Display / Restore the Tool Settings dialog

Background

Sometiems the Tool Settings dialog can be closed by chance or moved outside of the accessible screen area and cannot be easily resotred or movedback into the working screen area.

Steps to Accomplish

Option 1: Toggle the Tool Settings option

1. Open the "Settings" menu

2. Make sure that "Tool Settings" is enabled / ticked.

3. If Tool Settings is still not displayed try untoggling / re-toggling the above menu option

Option 2: Reset the User Preference File

Sometiems the Tool Settings dialog can disappear or get located outside the viewable and accesible screen area when the user preference file (.upf file) becomes corrupted.

In this cases we can create a new MicroStation User from MicroStation Manager or force MicroStation to recreate a new .upf file for an existing MicroStation user.

Please bear in mind that resetting the .upf file will restire all User preferences to factory defaults and should be done only when no other option works or is available or where loosing current user prefences is not an issue.

It is imperative that you close all open instances of MicroStation, when required by the procedure here below, in order
for them to work.

To re-create a new clean user preferences file for the active MicroStation User:

1. Open MicroStation with any file and open MicroStation’s Key-in panel (Utilities->key-in)

2. Type the following string in MicroStation’s key-in panel and press enter: 

$ % explorer $(_USTN_HOMEPREFS)

3. This will open your user preferences folder in windows explorer

4. Close MicroStation but keep the windows explorer window open.

5. MOVE (not just copy) the whole content of this folder - including all subfolders - into some other safe folder for backup.

6 . Restart MicroStation

Borehole Magnetometer survey

In this section, we will walk through how to use these tools by debugging the Google Closure hovercard demo and other dynamic examples in this page.

Note: If you are a Web Developer and want to get the latest version of DevTools, you should use Chrome Canary.

Contents

• The Sources Panel
• Debugging With Breakpoints
  • Breakpoints in Dynamic JavaScript
  • Pause on Next JavaScript Statement
  • Pause on Exceptions
  • Pause on Uncaught Exceptions
• Breakpoints on DOM Mutation Events
• Breakpoints on XHR
• Breakpoints on JavaScript Event Listeners

• Live Editing
• Handling Exceptions
  • Tracking exceptions
    • Viewing exception stack trace
    • Pause on exceptions
  • Printing stack traces
    • Error.stack
    • console.trace()
    • console.assert()
  • Handling exceptions at runtime using window.onerror
• Pretty Print
• Working With Source Maps

The Sources Panel

The Sources panel lets you debug your JavaScript code. It provides a graphical interface to the V8 debugger. Follow the steps below to explore the Sources panel:

• Open a site such as the Google Closure hovercard demo page or the TodoMVCAngular app.
• Open the DevTools window.
• If it is not already selected, select Sources.

The Sources panel lets you see all the scripts that are part of the inspected page. Standard controls to pause, resume, and step through code are provided below the panel selection icons. A button to force a pause at exceptions is located at the bottom of the window. Sources are visible in separate tabs and clicking  opens the file navigator which will display all open scripts.

Execution control

The execution control buttons are located at the top of the side panels and allow you to step through code. The buttons available are:

 Continue: continues code execution until we encounter another breakpoint.

 Step over: step through code line-by-line to get insights into how each line affects the variables being updated. Should your code call another function, the debugger won't jump into its code, instead stepping over so that the focus remains on the current function.

 Step into: like Step over, however clicking Step into at the function call will cause the debugger to move its execution to the first line in the functions definition.

Step out: having stepped into a function, clicking this will cause the remainder of the function definition to be run and the debugger will move its execution to the parent function.

Toggle breakpoints: toggles breakpoints on/off while leaving their enabled states intact.

There are also several related keyboard shortcuts available in the Sources panel:

• Continue: F8 or Command-/ (forward slash) on Mac or Control-/ (forward slash) on other platforms.
• Step over: F10 or Command-' (apostrophe) on Mac or Control-' (apostrophe) on other platforms.
• Step into: F11 or Command-; (semi-colon) on Mac or Control-; (semi-colon); on other platforms.
• Step out: Shift-F11 or Shift-Command-; (semi-colon) on Mac or Shift-Control-; (semi-colon) on other platforms.
• Next call frame: Control-. (period) on all platforms.
• Previous call frame: Control-, (comma) on all platforms.

For a walkthrough of other keyboard shortcuts supported, see Shortcuts.

Back to top

Debugging With Breakpoints

A breakpoint is an intentional stopping or pausing place in a script, put in place for debugging purposes. Let's look at debuggingJavaScript using breakpoints set on JavaScript code and breakpoints targeted at UI and network aspects of an application.

Workflow

First, open the DevTools by hitting the Control-Shift-I shortcut. Click the line gutter to set a breakpoint for that line of code, select another script and set another breakpoint.

All the breakpoints you have set appear under Breakpoints in the right-hand sidebar. Breakpoints can be enabled or disabled using the checkboxes in this sidebar.

Clicking on the entry jumps to the highlighted line in the source file. You can set one or more breakpoints in one or more scripts.

Delete a breakpoint by clicking the blue tag breakpoint indicator. The breakpoint indicator menu has several options including "Continue to here", "Edit Breakpoint", "Disable Breakpoint" and "Save As", which will save the file locally.

Once you have set a breakpoint, you can right-click on the blue arrow tag indicator in the gutter line to set a conditional statement for that specific breakpoint. Type any expression and the breakpoint will pause only if the condition is true. The tag cycles through its three states of active, inactive, and removed.

Click the Pause button then interact with your page.

While a script is paused, you can see the current call stack and in-scope variables in the right-hand side bar. The call stack displays the complete execution path that led to the point where code was paused, giving us insights into the code flaws that caused the error.

You may also open up the console to experiment while paused. Hit the Esc key to bring the console into view.

Remember, if your code happens to be using a loop which fires every 20ms, you likely won't want the debugger to halt on each iteration. Using conditional statements/breakpoints can assist with this. In the below example, code execution will only break if the minLevel variable is greater than 2004, helping us avoid a number of additional clicks in the debugger.

Note: It may not be desirable to set breakpoints from the DevTools interface. Should you wish to launch the debugger from your code, you may use the debugger keywordto achieve this.

Using Breakpoints

Make sure the Sources panel is open and select "script.js" from scripts drop-down

• Set a breakpoint on line 8 by clicking the line gutter (you can use the Control-Gshortcut to reveal a line in a large file)
• Move your mouse over this page
• You should stop on the breakpoint
• Hover over the source code to inspect local and global variables, function arguments etc.
• Delete the breakpoint by clicking the blue tag breakpoint indicator
• Click the Continue  button or hit F8 in DevTools window to resume

Back to top

Breakpoints in Dynamic JavaScript

Note: Notice the "//# sourceURL=dynamicScript.js" line at the end of dynamicScript.js file. This technique gives a name to a script created with eval, and will be discussed in more detail in the Source Maps section. Breakpoints can be set in dynamic JavaScript only if it has a user supplied name.

Back to top

Pause on Next JavaScript Statement

Back to top

Pause on Exceptions

Back to top

Pause on Uncaught Exceptions

Back to top

Breakpoints on DOM Mutation Events

Back to top

Breakpoints on XHR

Note: To edit URL filter, double click on the XHR breakpoint entry in XHR Breakpointssidebar pane. XHR breakpoint with empty URL filter will match any XHR.

Back to top

Breakpoints on JavaScript Event Listeners

Note: Following events are supported   Keyboard: keydown, keypress, keyup, textInput
  Mouse: click, dblclick, mousedown, mouseup, mouseover, mousemove, mouseout, mousewheel
  Control: resize, scroll, zoom, focus, blur, select, change, submit, reset
  Clipboard: copy, cut, paste, beforecopy, beforecut, beforepaste
  Load: load, unload, abort, error
  DOM Mutation: DOMActivate, DOMFocusIn, DOMFocusOut, DOMAttrModified, DOMCharacterDataModified, DOMNodeInserted, DOMNodeInsertedIntoDocument, DOMNodeRemoved, DOMNodeRemovedFromDocument, DOMSubtreeModified, DOMContentLoaded
  Device: deviceorientation, devicemotion

Back to top

Live Editing

In Authoring And Workflow, we discussed how to make changes to scripts in theSources panel. While at a breakpoint, it's also possible to live edit scripts by clicking into the main editor panel and making modifications.

• Navigate to the Google Closure hovercard demo
• In the Sources panel, open up "mouse.js" and use the Ctrl/Cmd + Shift + O to navigate to the onMouseOut() function

• Click the pause button to pause debugging
• Modify the function, adding a console.log('Moused out') to the end
• Using the Cmd +S or Ctrl + S shortcuts will save these modifications. Make sure to Save As.
• Click the pause/resume button to resume execution
• When you now hover out, the new message will be logged to the console

This allows you to saved changes from within the DevTools without having to leave your browser.

Back to top

Exceptions

Let's now look at how to deal with exceptions and stack traces using Chrome DevTools.
Exception handling is the process of responding to the occurrence of exceptions - exceptional situations that require special processing - often changing the normal flow of your JavaScript code's execution.

Note: If you are a Web Developer and want to get the latest version of DevTools, you should use Chrome Canary.

Tracking exceptions

When something goes wrong, you can open the DevTools console (Ctrl+Shift+J / Cmd+Option+J) and find a number of JavaScript error messages there. Each message has a link to the file name with the line number you can navigate to.

Back to top

Viewing exception stack trace

There might be several execution paths that lead to the error and it's not always obvious which one of them has happened. Once DevTools window is opened, exceptions in the console are accompanied with the complete JavaScript call stacks. You can expand these console messages to see the stack frames and navigate to the corresponding locations in the code:

Back to top

Pause on JavaScript exceptions

You may also want to pause JavaScript execution next time exception is thrown and inspect its call stack, scope variables and state of your app. A tri-state stop button (  ) at the bottom of the Scripts panel enables you to switch between different exception handling modes: you can choose to either pause on all exception or only on the uncaught ones or you can ignore exceptions altogether.

Back to top

Printing stack traces

Printing log messages to the DevTools console may be very helpful in understanding how your application behaves. You can make the log entries even more informative by including associated stack traces. There are several ways of doing that.

Back to top

Error.stack

Each Error object has a string property named stack that contains the stack trace:

Back to top

console.trace()

You can instrument your code with console.trace() calls that would print current JavaScript call stacks:

Back to top

console.assert()

There is also a way to place assertion in your JavaScript code. Just call console.assert() with the error condition as the first parameter. Whenever this expression evaluates to false you will see a corresponding console record:

Back to top

Handling exceptions at runtime using window.onerror

Chrome supports setting a handler function to window.onerror. Whenever a JavaScript exception is thrown in the window context and is not caught by any try/catch block, the function will be invoked with the exception's message, the URL of the file where the exception was thrown and the line number in that file passed as three arguments in that order. You may find it convenient to set an error handler that would collect information about uncaught exceptions and report it back to your server.

Back to top

Pretty Print

If you have trouble trying to read and debug minified JavaScript in the DevTools, a pretty printing option is available to make life easier. Here is how a minified script displayed in the tools might look prior to being displayed in the DevTools:

And by clicking on the curly brace  ("Pretty Print") icon in the bottom left corner, the JavaScript is transformed into a more human readable form. This is also more easy for debugging and setting breakpoints.

Back to top

Source Maps

Have you ever found yourself wishing you could keep your client-side code readable and more importantly debuggable even after you've combined and minified it, without impacting performance? Well now you can through the magic of source maps.

Source Maps are a generic mapping format (that are JSON-based) which can be used by any processed file to create relations between files that are pre-processed and those that are post-processed. Of most relevance to us is that they can be used to map combined/minified scripts back to an unbuilt state for debugging.

A source map itself can look as simple as the following:

  {
    version : 3,
    file: "out.js",
    sourceRoot : "",
    sources: ["foo.js", "bar.js"],
    names: ["src", "maps", "are", "fun"],
    mappings: "AAgBC,SAAQ,CAAEA"
}

The idea is when you build for production, along with minifying and combining your JavaScript files, you generate a source map which holds information about your original files. When you query a certain line and column number in your generated JavaScript you can do a lookup in the source map which returns the original location. The DevTools can parse the source map automatically and make it appear as though you're running unminified and uncombined files.

Before you view the following real world implementation of Source Maps make sure you've enabled the Source Maps feature by clicking the settings cog in the dev tools panel and checking the "Enable source maps" option.

Take a look at the special build of the font dragr tool in Chrome, with source mapping enabled, and you'll notice that the JavaScript isn't compiled and you can see all the individual JavaScript files it references. This is using source mapping, but behind the scenes actually running the compiled code. Any errors, logs and breakpoints will map to the dev code for awesome debugging! So in effect it gives you the illusion that you're running a dev site in production.

How do Source Maps work?

Once you've combined and minified your JavaScript with a tool that supports outputting Source Maps, alongside it will exist a sourcemap file. At present, Closure Compiler and UglifyJS 2.0 are two such tools for achieving this but there are also tools available that support outputting Source Maps for CoffeeScript and SASS. A special comment is placed at the end of the file, signifying to the DevTools that a source map is available.

//# sourceMappingURL=/path/to/file.js.map

This enables DevTools to map calls back to their location in original source files. If you don't like the idea of the weird comment you can alternatively set a special header on your compiled JavaScript file:

X-SourceMap: /path/to/file.js.map

Like the comment this will tell your source map consumer where to look for the source map associated with a JavaScript file. This header also gets around the issue of referencing Source Maps in languages that don't support single-line comments.

@sourceURL and displayName in action

While not part of the source map spec the following convention allows you to make development much easier when working with evals.

This helper looks very similar to the //# sourceMappingURL property and is actually mentioned in the source map V3 specifications. By including the following special comment in your code, which will be evaled, you can name evals so they appear as more logical names in your dev tools.

//# sourceURL=source.coffee

Working with sourceURL

• Navigate to the demo
• Open the DevTools and go to the Sources panel.
• Enter in a filename into the Name your code: input field.
• Click on the compile button.
• An alert will appear with the evaluated sum from the CoffeeScript source
• If you expand the Sources sub-panel you will now see a new file with the custom filename you entered earlier. If you double-click to view this file it will contain the compiled JavaScript for our original source. On the last line however will be a // @sourceURL comment indicating what the original source file was. This can greatly help with debugging when working with language abstractions.

To run Windows Script Host samples

How to Source a Script in R

When you want to tell R to perform several commands one after the other without waiting for additional instructions, you use the source() function. R users refer to this process as sourcing a script.

To prepare your script to be sourced, you first write the entire script in an editor window. In RStudio, for example, the editor window is in the top-left corner of the screen. Whenever you press Enter in the editor window, the cursor moves to the next line, as in any text editor.

Type the following lines of code in the editor window. (Remember that in RStudio the source editor is in the top-left corner, by default.) Notice that the last line contains a small addition to the code you saw earlier: the print()function.

h <- "Hello"
yourname <- readline("What is your name?")
print(paste(h, yourname))

Remember to type the print() function as part of your script. Sourced scripts behave differently from interactive code in printing results. In interactive mode, a result is printed even without aprint() function. But when you source a script, output is printed only if you have an explicit print() function.

You can type multiple lines of code into the source editor without having each line evaluated by R. Then, when you’re ready, you can send the instructions to R — in other words, source the script.

When you use RGui or RStudio, you can do this in one of three ways:

• Send an individual line of code from the editor to the console. Click the line of code you want to run, and then press Ctrl+R in RGui. In RStudio, you can press Ctrl+Enter or click the Run button.

• Send a block of highlighted code to the console. Select the block of code you want to run, and then press Ctrl+R (in RGui) or Ctrl+Enter (in RStudio).

• Send the entire script to the console (which is called sourcing a script). In RGui, click anywhere in your script window, and then choose Edit→Run all. In RStudio, click anywhere in the source editor and press Ctrl+Shift+Enter. Alternatively, you can click the Source button.

These keyboard shortcuts are defined only in RStudio. If you use a different source editor, you may not have the same options.

Now you can send the entire script to the R console. To do this, click the Source button in the top-right corner of the editor window or choose Edit→Source. The script starts, reaches the point where it asks for input, and then waits for you to enter your name in the console window. Notice that the Workspace window now lists the two objects you created: h and yourname.

When you click the Source button, source('~/.active-rstudio-document') appears in the console. What RStudio actually does here is save your script in a temporary file and then use the R function source() to call that script in the console. Remember this function; you’ll meet it again.

By Edwin Prakoso, published on November 5, 2009

草蛉科的昆虫翼展从6毫米到超过65毫米，其中最大的昆虫在热带。它们的特点在于翅脉上的宽肋脉区域，上面有跨脉。身体通常为亮绿色到绿褐色，很多物种的复眼是显著的景色。翅膀通常为半透明，上面有淡淡的彩虹色．有些具有绿色的翅脉或亮褐色图案。草蛉属（Chrysopa）和其他属的物种能从前胸释放出气体。

成虫的前翅基部有鼓膜器，使它们能听得更清楚。有些物种在听到蝙蝠的超声波时有逃避行为－在飞行时它们关闭翅膀并降落到地上。草蛉也采用底部或者身体振动的方式来互相沟通，尤其是在求偶时。几乎相同形态的草蛉有时更容易通过求偶信号来区别。比如，南欧的Chrysoperla mediterranea与北欧Chrysoperla carnea看起来几乎完全一样，但是它们求偶声音差别非常大，一个物种的生物不会对另一个物种的振动有反应。 ^[1]幼虫的背部更细，胸部有显著的拱起，两侧有硬毛。

成虫在拂晓或夜间出没。它们吃花粉，花蜜和蜂蜜，并辅以螨虫，蚜虫和其他小型节肢动物。有些物种主要是掠食者，另一些只吃花蜜，在其消化道有帮助其分解食物为营养素的共生酵母菌。^[2]

草蛉卵有細長的莖，形似花朵

它们于夜间产卵，单独产或成小群公共产卵，搭起约1厘米长的细茎，一只雌性可产100-200枚卵。卵产于植物上，通常附近有大量蚜虫。在卵孵化后，幼虫立刻蜕化,开始觅食。它们是贪婪的掠食者，袭击大部分形状适合的昆虫，尤其是软体动物如蚜虫，毛毛虫和其他昆虫幼虫和卵，在密度高的时候甚至互相捕食。因此，幼虫又被称为“蚜狮”或者“蚜狼”。除了触觉敏感外，它们的其他感官没有发育。它们行动杂乱无章，头从一边摇到另一边，当它们发现合适的捕食对象，就抓住猎物。它们的上颌空心，可以使消化液注射到猎物上，蚜虫的器官可以在90秒内溶解。根据环境条件不同，幼虫需要1–3周时间化蛹，温带的物种通常以蛹的形式度过冬天。

用于生物害虫控制[编辑]

根据物种和环境的不同，有些草蛉科的生物一生只吃掉大约150只蚜虫，另一些一周就可以吃掉100只蚜虫。因此，在一些国家，养育了几百万只这样的昆虫用于农业和园艺上的生物害虫控制。它们以虫卵的形式销售，卵在田野裡孵化。效果是多样化的，因此有待更进一步的研究来更好地使用它们。

Green lacewings
Chrysopa perla
Scientific classification
Kingdom:	Animalia
Phylum:	Arthropoda
Class:	Insecta
Order:	Neuroptera
Suborder:	Hemerobiiformia
Superfamily:	Chrysopoidea
Family:	Chrysopidae
Subfamilies
Apochrysinae Chrysopinae Nothochrysinae and see text

Your complete guide to the Android camera

Smartphone photography keeps getting better. The Camera and Gallery apps that come with Android 4.2 (still called Jelly Bean) have evolved into powerful tools for taking, viewing, editing, and sharing photos.

Before you take a picture, you can fine-tune the exposure, set the white balance, and tell the camera where to focus. You can photograph the entire world around you, 360 degrees horizontally and vertically. Afterward, you can add filters, tweak the exposure some more, fiddle with the colors (or remove them), crop the image, straighten it in both 90- and 1-degree increments, and put a frame around it. And when you're happy with the result, you can upload it to whatever social media sites you choose.

I spent some quality time with a Google Nexus 4 smartphone to find out just what Android 4.2's photography apps can do. This is a pure Android phone, with no manufacturer additions or alterations to the operating system. In other words, anything I could do here should be available on other smartphones running Android 4.2.

(A personal note: You might think, looking at the photos ahead, that I'm obsessed with my cats. Not so. It's just that, unlike people, they never object to having their photos appear on the Internet.)

[See also: Smartphone photo tips for the holidays]

The Camera app

The main camera screen.

Get to the camera right away

Has this ever happened to you? You see a perfect photo moment. So you whip out your phone, press the power button, enter the PIN, password, or pattern to unlock your phone (and if you haven't secured your smartphone with one of these, you should), wait for the home screen to appear, and launch the camera app.

And by that time, the perfect moment has passed.

Not an issue with Android 4.2—if you know the trick. First, press the power button. Then, instead of entering your PIN (or whatever), swipe the lock screen from right to left. The camera app will come up immediately.

Yes, if someone steals your phone, they will be able to take pictures. But that's not a real security issue. They won't even have full access to the gallery, let alone your private information.

Of course, you can also launch the Camera app the conventional way (after you've unlocked the phone), but by then your perfect shot will be no more.

Take a simple photo

Aim the camera, and a white circle will appear in the center. This circle shows the area on which the camera will focus and set exposure.

Tap the screen to focus on a specific area.

But your picture might not really be about what's in the center of the frame. Tap another part of the screen, and the circle will move. That way, you can focus the shot on something—or someone—off to the side.

If you're too far away from the subject, you can zoom in with the same two-finger gesture you use to zoom in on a webpage. Just remember that your Android device probably lacks a real zoom lens; the app can give you only an inferior digital zoom.

When the image is just right, press the big blue shutter button on the right side of the screen (which will be on the center-bottom if you're shooting in portrait mode).

Fine-tune via the camera menu

On the main screen of the Camera app, you'll find another, smaller, white circle in the upper-right corner (lower-right if you're in portrait mode). Tap that, and a radial menu will give you assorted options for controlling the look of your photo.

The camera menu.

Let's consider these options, clockwise from the top.

HDR: Digital cameras often have dynamic range problems. If the scene has a lot of bright light and dark shadows (a common problem on sunny days), either one part of the image will be too bright or another part will be too dark. A high dynamic range (HDR) mode helps fix this problem by sampling the light in multiple exposures and creating a composite photo. You can turn this feature on or off; the app gives you no other options.

Flash: You get the usual options, on, auto, and off. Auto—in which the camera decides whether it needs the flash—is a good default. But there will be times when you and the camera will disagree about that.

The various white balance options.

White balance: White light—the basic default of what we see—is seldom pure white. It changes depending on the dominant light source, namely incandescent light bulbs, fluorescent bulbs, sunlight, and so on. The Android Camera app offers five options for the different types of lighting you may encounter, but the Automatic setting (the one with the A/W icon) works well for most situations.

Settings: This isn't really an option, but a submenu with three additional options of its own.

• Scene mode lets you tell the camera about your environment. Are you shooting at night? At a party? If you're unsure, stick with the default, Auto(which doesn't mean you're in a car).
• Store location has nothing to do with where you bought your tablet or phone. It's about geotagging your pictures so that you create an automatic record of where you took them.
• Picture size lets you adjust how big of a photo you take (in terms of megapixels).

Exposure: At the default 0, you get the exposure that the camera selects. The other options let you cheat that up or down if you want an overexposed or underexposed image.

Switch camera: Your phone or tablet likely has a second, front-facing camera intended for video calls. But it also allows you to take photos of yourself. You may find it useful as a makeshift mirror, too.

Other camera modes

The camera app features different shooting modes.

Shoot videos

Below the shutter button is an icon shaped like a camera. Tap it, and up come three additional photography modes. Going from left to right, they're Photo Sphere, Panoramic, and Video.

Android 4.2 doesn't provide as much control over shooting video as it does with still photos. You have no way to tell the camera where to focus, and you can't set the exposure. But at least you can set the resolution and the white balance (using the same menus as with still photos).

You can also control the flash, although the word flash may not be appropriate (turn it on, and the light stays on until you turn it off). You get no Auto option.

When you visit the Settings submenu, you'll find a setting for time-lapse photography, allowing you to condense a very long period of time into a few seconds.

Turning on the time-lapse function can be a bit confusing.

Turning it on the first time can be a bit confusing, however. When you tap the time-lapse option, the app will tell you that the time-lapse feature is off, and that you have to turn it on if you want to use it. That's helpful.

To turn on time-lapse photography, tap the OFF button. This brings up a dialog box where you can set the time interval. The default, 0.5 seconds, will shoot only two frames a second, so an hour's worth of video will go by in 2 minutes.

With few exceptions (sitting in a moving car's passenger seat is one of them), there's little you can do with time lapse that doesn't require a tripod. Few phones or tablets can easily accommodate a tripod.

Whether you're shooting in time lapse or real time, you press the shutter button—which is red in video instead of blue—to start and stop capturing images.

One other interesting trick: Touch the screen while shooting video, and you'll also save a still image of your current frame.

Use Panoramic mode

A sample panoramic photo taken on the Google Nexus 4.

I'm sure you can guess that this mode allows you to capture very wide landscapes. Once in this mode, point your camera to the extreme left or right of the landscape you want to photograph. Then press the shutter button and start panning.

The camera screen while taking a panoramic photo.

The camera won't tell you when it snaps the individual sections of the photo, but an icon of a wide, curved screen will tell you how much of the photo you've captured so far.

No matter what camera or software you use, panoramas have their problems. Moving objects, including people, ruin the illusion. And objects too close to the camera will not blend well between images.

When you're done, don't tap the X that appears in the corner … unless you want to delete what you've just done. Instead, wait for the camera to stitch together the panorama.

Capture the environment with Photo Sphere

Photo Sphere lets you capture all of your surroundings in a single image. Like a panorama, Photo Sphere works best when you're standing in a single spot and capturing a stationary environment.

Photo Sphere lets you take pictures of your surroundings.

When you select Photo Sphere, a grid replaces the photographic image on your screen, except for a small window with a white circle in the center. You should also see a blue dot on the screen (if it's not present, move the camera until it appears). Move the camera until the blue dot is centered in the white circle. The camera will automatically take a picture.

Other dots will appear. Move the camera so that one of them is centered, and the camera takes another picture. Continue until you've covered as much area as you want to capture, or until you get bored.

Press the shutter button when you're done, and the Camera app will begin rendering your Photo Sphere.

[See also: 10 Android apps to take your smartphone's camera to the next level]