Pulling in content and rewriting from ipython-in-depth.

examples/Notebook/Custom Keyboard Shortcuts.ipynb

@@ -1,9 +1,149 b''
 {
  "metadata": {
-  "name": "",
-  "signature": "sha256:0abf067a20ebda26a671db997ac954770350d292dff7b7d6a4ace8808f70aca1"
+  "name": ""
  },
  "nbformat": 3,
  "nbformat_minor": 0,
- "worksheets": []
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Keyboard Shortcut Customization"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Starting with IPython 2.0 keyboard shortcuts in command and edit mode are fully customizable. These customizations are made using the IPython JavaScript API. Here is an example that makes the `r` key available for running a cell:"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "%%javascript\n",
+      "\n",
+      "IPython.keyboard_manager.command_shortcuts.add_shortcut('r', {\n",
+      "    help : 'run cell',\n",
+      "    help_index : 'zz',\n",
+      "    handler : function (event) {\n",
+      "        IPython.notebook.execute_cell();\n",
+      "        return false;\n",
+      "    }}\n",
+      ");"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "javascript": [
+        "\n",
+        "IPython.keyboard_manager.command_shortcuts.add_shortcut('r', {\n",
+        "    help : 'run cell',\n",
+        "    help_index : 'zz',\n",
+        "    handler : function (event) {\n",
+        "        IPython.notebook.execute_cell();\n",
+        "        return false;\n",
+        "    }}\n",
+        ");"
+       ],
+       "metadata": {},
+       "output_type": "display_data",
+       "text": [
+        "<IPython.core.display.Javascript at 0x10e8d1890>"
+       ]
+      }
+     ],
+     "prompt_number": 7
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "There are a couple of points to mention about this API:\n",
+      "\n",
+      "* The `help_index` field is used to sort the shortcuts in the Keyboard Shortcuts help dialog. It defaults to `zz`.\n",
+      "* When a handler returns `false` it indicates that the event should stop propagating and the default action should not be performed. For further details about the `event` object or event handling, see the jQuery docs.\n",
+      "* If you don't need a `help` or `help_index` field, you can simply pass a function as the second argument to `add_shortcut`."
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "%%javascript\n",
+      "\n",
+      "IPython.keyboard_manager.command_shortcuts.add_shortcut('r', function (event) {\n",
+      "    IPython.notebook.execute_cell();\n",
+      "    return false;\n",
+      "});"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "javascript": [
+        "\n",
+        "IPython.keyboard_manager.command_shortcuts.add_shortcut('r', function (event) {\n",
+        "    IPython.notebook.execute_cell();\n",
+        "    return false;\n",
+        "});"
+       ],
+       "metadata": {},
+       "output_type": "display_data",
+       "text": [
+        "<IPython.core.display.Javascript at 0x1019baf90>"
+       ]
+      }
+     ],
+     "prompt_number": 11
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Likewise, to remove a shortcut, use `remove_shortcut`:"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "%%javascript\n",
+      "\n",
+      "IPython.keyboard_manager.command_shortcuts.remove_shortcut('r');"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "javascript": [
+        "\n",
+        "IPython.keyboard_manager.command_shortcuts.remove_shortcut('r');"
+       ],
+       "metadata": {},
+       "output_type": "display_data",
+       "text": [
+        "<IPython.core.display.Javascript at 0x10e8d1950>"
+       ]
+      }
+     ],
+     "prompt_number": 8
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "If you want your keyboard shortcuts to be active for all of your notebooks, put the above API calls into your `<profile>/static/custom/custom.js` file."
+     ]
+    }
+   ],
+   "metadata": {}
+  }
+ ]
 }
  No newline at end of file

examples/Notebook/Index.ipynb

@@ -1,92 +1,85 b''
 {
  "metadata": {
   "name": "",
-  "signature": "sha256:f3479d16d8a60d0aa82e5fbffd52552e5649074a7a660730ddca9d5b286692b2"
+  "signature": "sha256:33a14f36e4dad22b2fc23c59ce0e0ed96719007a09f616f240ed5f665e1b871f"
  },
  "nbformat": 3,
  "nbformat_minor": 0,
  "worksheets": [
   {
    "cells": [
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "<img src=\"../images/ipython_logo.png\">"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "Back to the main [Index](../Index.ipynb)"
      ]
     },
     {
      "cell_type": "heading",
      "level": 1,
      "metadata": {},
      "source": [
       "Notebook"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "The IPython Notebook is a web-based interactive computing system that enables users to author documents that include live code, narrative text, LaTeX equations, HTML, images and video. These documents contain a full record of a computation and its results and can be shared on email, [Dropbox](http://dropbox.com), version control systems (like git/[GitHub](http://github.com)) or [nbviewer.ipython.org](http://nbviewer.ipython.org)."
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
       "Tutorials"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "* [What is the IPython Notebook?](What is the IPython Notebook%3F.ipynb)\n",
       "* [Running the Notebook Server](Running the Notebook Server.ipynb)\n",
       "* [Notebook Dashboard](Notebook Dashboard.ipynb)\n",
       "* [Notebook User Interface](Notebook User Interface.ipynb)\n",
-      "* [Notebook Cell Types](Notebook Cell Types.ipynb)\n",
+      "* [Custom Keyboard Shortcuts](Custom Keyboard Shortcuts.ipynb)\n",
       "* [Working With Code Cells](Working With Code Cells.ipynb)\n",
+      "* [Basic Output](Basic Output.ipynb)\n",
       "* [Working With Markdown Cells](Working With Markdown Cells.ipynb)\n",
+      "* [JavaScript Notebook Extensions](JavaScript Notebook Extensions.ipynb)\n",
       "* [Notebook Security](Notebook Security.ipynb)"
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
       "Examples"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
-      "* [Custom Keyboard Shortcuts](Custom Keyboard Shortcuts.ipynb)\n",
       "* [Importing Notebooks](Importing Notebooks.ipynb)\n",
       "* [Connecting with the Qt Console](Connecting with the Qt Console.ipynb)\n",
       "* [Typesetting Equations](Typesetting Equations.ipynb)"
      ]
-    },
-    {
-     "cell_type": "code",
-     "collapsed": false,
-     "input": [],
-     "language": "python",
-     "metadata": {},
-     "outputs": []
     }
    ],
    "metadata": {}
   }
  ]
 }
  No newline at end of file

examples/Notebook/Notebook User Interface.ipynb

@@ -1,445 +1,244 b''
 {
  "metadata": {
-  "name": ""
+  "name": "",
+  "signature": "sha256:fdeb47a733910a12406e6a2e4f13c2c76fe50b19428feb6ba77c06652fb1d6af"
  },
  "nbformat": 3,
  "nbformat_minor": 0,
  "worksheets": [
   {
    "cells": [
     {
      "cell_type": "heading",
      "level": 1,
      "metadata": {},
      "source": [
-      "User Interface"
+      "Notebook User Interface"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
-      "This notebook describes the user interface of the IPython Notebook. This includes both mouse and keyboard based navigation and interaction.\n",
-      "\n",
-      "<div class=\"alert\" style=\"margin: 10px\">\n",
+      "This notebook describes the user interface of the IPython Notebook. This includes both mouse and keyboard based navigation and interaction."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "<div class=\"alert\">\n",
       "As of IPython 2.0, the user interface has changed significantly. Because of this we highly recommend existing users to review this information after upgrading to IPython 2.0. All new users of IPython should review this information as well.\n",
       "</div>"
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
+      "Overview of the UI"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "The notebook UI has the following main areas:\n",
+      "\n",
+      "* Menu\n",
+      "* Toolbar\n",
+      "* Notebook area and cells\n",
+      "\n",
+      "IPython 2.0 has an interactive tour of these elements that can be started in the \"Help:User Interface Tour\" menu item."
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
       "Modal editor"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "Starting with IPython 2.0, the IPython Notebook has a modal user interface. This means that the keyboard does different things depending on which mode the Notebook is in. There are two modes: edit mode and command mode."
      ]
     },
     {
      "cell_type": "heading",
      "level": 3,
      "metadata": {},
      "source": [
       "Edit mode"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "Edit mode is indicated by a green cell border and a prompt showing in the editor area:\n",
       "\n",
       "<img src=\"images/edit_mode.png\">\n",
       "\n",
-      "When a cell is in edit mode, you can type into the cell, like a normal text editor.\n",
-      "\n",
-      "<div class=\"alert alert-success\" style=\"margin: 10px\">\n",
-      "Enter edit mode by pressing `enter` or using the mouse to click on a cell's editor area.\n",
+      "When a cell is in edit mode, you can type into the cell, like a normal text editor."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "<div class=\"alert alert-success\">\n",
+      "Enter edit mode by pressing `Enter` or using the mouse to click on a cell's editor area.\n",
       "</div>"
      ]
     },
     {
      "cell_type": "heading",
      "level": 3,
      "metadata": {},
      "source": [
       "Command mode"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "Command mode is indicated by a grey cell border:\n",
       "\n",
       "<img src=\"images/command_mode.png\">\n",
       "\n",
-      "When you are in command mode, you are able to edit the notebook as a whole, but not type into individual cells. Most importantly, in command mode, the keyboard is mapped to a set of shortcuts that let you perform notebook and cell actions efficiently. For example, if you are in command mode and you press `c`, you will copy the current cell - no modifier is needed.\n",
-      "\n",
-      "<div class=\"alert alert-error\" style=\"margin: 10px\">\n",
+      "When you are in command mode, you are able to edit the notebook as a whole, but not type into individual cells. Most importantly, in command mode, the keyboard is mapped to a set of shortcuts that let you perform notebook and cell actions efficiently. For example, if you are in command mode and you press `c`, you will copy the current cell - no modifier is needed."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "<div class=\"alert alert-error\">\n",
       "Don't try to type into a cell in command mode; unexpected things will happen!\n",
-      "</div>\n",
-      "\n",
-      "<div class=\"alert alert-success\" style=\"margin: 10px\">\n",
-      "Enter command mode by pressing `esc` or using the mouse to click *outside* a cell's editor area.\n",
+      "</div>"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "<div class=\"alert alert-success\">\n",
+      "Enter command mode by pressing `Esc` or using the mouse to click *outside* a cell's editor area.\n",
       "</div>"
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
       "Mouse navigation"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "All navigation and actions in the Notebook are available using the mouse through the menubar and toolbar, which are both above the main Notebook area:\n",
       "\n",
       "<img src=\"images/menubar_toolbar.png\">"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "The first idea of mouse based navigation is that **cells can be selected by clicking on them.** The currently selected cell gets a grey or green border depending on whether the notebook is in edit or command mode. If you click inside a cell's editor area, you will enter edit mode. If you click on the prompt or output area of a cell you will enter command mode.\n",
       "\n",
       "If you are running this notebook in a live session (not on http://nbviewer.ipython.org) try selecting different cells and going between edit and command mode. Try typing into a cell."
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
-      "The second idea of mouse based navigation is that **cell actions usually apply to the currently selected cell**. Thus if you want to run the code in a cell, you would select it and click the \"Play\" button in the toolbar or the \"Cell:Run\" menu item. Similarly, to copy a cell you would select it and click the \"Copy\" button in the toolbar or the \"Edit:Copy\" menu item. With this simple pattern, you should be able to do most everything you need with the mouse.\n",
+      "The second idea of mouse based navigation is that **cell actions usually apply to the currently selected cell**. Thus if you want to run the code in a cell, you would select it and click the <button><i class=\"icon-play\"></i></button> button in the toolbar or the \"Cell:Run\" menu item. Similarly, to copy a cell you would select it and click the <button><i class=\"icon-copy\"></i></button> button in the toolbar or the \"Edit:Copy\" menu item. With this simple pattern, you should be able to do most everything you need with the mouse.\n",
       "\n",
-      "Markdown and heading cells have one other state that can be modified with the mouse. These cells can either be rendered or unrendered. When they are rendered, you will see a nice formatted representation of the cell's contents. When they are unrendered, you will see the raw text source of the cell. To render the selected cell with the mouse, click the \"Play\" button in the toolbar or the \"Cell:Run\" menu item. To unrender the selected cell, double click on the cell."
+      "Markdown and heading cells have one other state that can be modified with the mouse. These cells can either be rendered or unrendered. When they are rendered, you will see a nice formatted representation of the cell's contents. When they are unrendered, you will see the raw text source of the cell. To render the selected cell with the mouse, click the <button><i class=\"icon-play\"></i></button> button in the toolbar or the \"Cell:Run\" menu item. To unrender the selected cell, double click on the cell."
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
       "Keyboard Navigation"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "The modal user interface of the IPython Notebook has been optimized for efficient keyboard usage. This is made possible by having two different sets of keyboard shortcuts: one set that is active in edit mode and another in command mode.\n",
       "\n",
-      "The most important keyboard shortcuts are `enter`, which enters edit mode, and `esc`, which enters command mode.\n",
+      "The most important keyboard shortcuts are `Enter`, which enters edit mode, and `Esc`, which enters command mode.\n",
       "\n",
-      "In edit mode, most of the keyboard is dedicated to typing into the cell's editor. Thus, in edit mode there are relatively few shortcuts:"
-     ]
-    },
-    {
-     "cell_type": "markdown",
-     "metadata": {},
-     "source": [
-      "The `display_edit_shortcuts()` function used here is defined in the [Utilities section](#Utilities) at the bottom of this notebook."
-     ]
-    },
-    {
-     "cell_type": "code",
-     "collapsed": false,
-     "input": [
-      "display_edit_shortcuts()"
-     ],
-     "language": "python",
-     "metadata": {},
-     "outputs": [
-      {
-       "html": [
-        "<div class=\"hbox\"><div class=\"box-flex0\"><div class=\"quickhelp\"><span class=\"shortcut_key\">esc</span><span class=\"shortcut_descr\"> : command mode</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">ctrl+m</span><span class=\"shortcut_descr\"> : command mode</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">shift+enter</span><span class=\"shortcut_descr\"> : run cell</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">ctrl+enter</span><span class=\"shortcut_descr\"> : run cell, select below</span></div></div><div class=\"box-flex0\"><div class=\"quickhelp\"><span class=\"shortcut_key\">alt+enter</span><span class=\"shortcut_descr\"> : run cell, insert below</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">alt+-</span><span class=\"shortcut_descr\"> : split cell</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">meta+s</span><span class=\"shortcut_descr\"> : save notebook</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">ctrl+s</span><span class=\"shortcut_descr\"> : save notebook</span></div></div></div>"
-       ],
-       "output_type": "display_data"
-      },
-      {
-       "javascript": [
-        "var help = IPython.quick_help.build_edit_help();\n",
-        "help.children().first().remove();\n",
-        "this.append_output({output_type: 'display_data', html: help.html()});"
-       ],
-       "metadata": {},
-       "output_type": "display_data",
-       "text": [
-        "<IPython.core.display.Javascript at 0x10e8d1a50>"
-       ]
-      }
-     ],
-     "prompt_number": 17
-    },
-    {
-     "cell_type": "markdown",
-     "metadata": {},
-     "source": [
-      "There are two other keyboard shortcuts in edit mode that are not listed here:\n",
+      "In edit mode, most of the keyboard is dedicated to typing into the cell's editor. Thus, in edit mode there are relatively few shortcuts:\n",
       "\n",
-      "* `tab`: trigger \"tab\" completion\n",
-      "* `shift+tab`: open the tooltip"
+      "<img src=\"images/edit_shortcuts.png\">"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
-      "In command mode, the entire keyboard is available for shortcuts:"
+      "In command mode, the entire keyboard is available for shortcuts, so there are many more:\n",
+      "\n",
+      "<img src=\"images/command_shortcuts.png\">"
      ]
     },
     {
-     "cell_type": "code",
-     "collapsed": false,
-     "input": [
-      "display_command_shortcuts()"
-     ],
-     "language": "python",
-     "metadata": {},
-     "outputs": [
-      {
-       "html": [
-        "<div class=\"hbox\"><div class=\"box-flex0\"><div class=\"quickhelp\"><span class=\"shortcut_key\">enter</span><span class=\"shortcut_descr\"> : edit mode</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">shift+enter</span><span class=\"shortcut_descr\"> : run cell</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">ctrl+enter</span><span class=\"shortcut_descr\"> : run cell, select below</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">alt+enter</span><span class=\"shortcut_descr\"> : run cell, insert below</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">y</span><span class=\"shortcut_descr\"> : to code</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">m</span><span class=\"shortcut_descr\"> : to markdown</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">t</span><span class=\"shortcut_descr\"> : to raw</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">1</span><span class=\"shortcut_descr\"> : to heading 1</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">2</span><span class=\"shortcut_descr\"> : to heading 2</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">3</span><span class=\"shortcut_descr\"> : to heading 3</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">4</span><span class=\"shortcut_descr\"> : to heading 4</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">5</span><span class=\"shortcut_descr\"> : to heading 5</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">6</span><span class=\"shortcut_descr\"> : to heading 6</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">up</span><span class=\"shortcut_descr\"> : select previous cell</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">down</span><span class=\"shortcut_descr\"> : select next cell</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">k</span><span class=\"shortcut_descr\"> : select previous cell</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">j</span><span class=\"shortcut_descr\"> : select next cell</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">ctrl+k</span><span class=\"shortcut_descr\"> : move cell up</span></div></div><div class=\"box-flex0\"><div class=\"quickhelp\"><span class=\"shortcut_key\">ctrl+j</span><span class=\"shortcut_descr\"> : move cell down</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">a</span><span class=\"shortcut_descr\"> : insert cell above</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">b</span><span class=\"shortcut_descr\"> : insert cell below</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">x</span><span class=\"shortcut_descr\"> : cut cell</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">c</span><span class=\"shortcut_descr\"> : copy cell</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">v</span><span class=\"shortcut_descr\"> : paste cell below</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">z</span><span class=\"shortcut_descr\"> : undo last delete</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">d</span><span class=\"shortcut_descr\"> : delete cell (press twice)</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">shift+=</span><span class=\"shortcut_descr\"> : merge cell below</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">s</span><span class=\"shortcut_descr\"> : save notebook</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">meta+s</span><span class=\"shortcut_descr\"> : save notebook</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">ctrl+s</span><span class=\"shortcut_descr\"> : save notebook</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">l</span><span class=\"shortcut_descr\"> : toggle line numbers</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">o</span><span class=\"shortcut_descr\"> : toggle output</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">shift+o</span><span class=\"shortcut_descr\"> : toggle output</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">h</span><span class=\"shortcut_descr\"> : keyboard shortcuts</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">i</span><span class=\"shortcut_descr\"> : interrupt kernel</span></div><div class=\"quickhelp\"><span class=\"shortcut_key\">.</span><span class=\"shortcut_descr\"> : restart kernel</span></div></div></div>"
-       ],
-       "output_type": "display_data"
-      },
-      {
-       "javascript": [
-        "var help = IPython.quick_help.build_command_help();\n",
-        "help.children().first().remove();\n",
-        "this.append_output({output_type: 'display_data', html: help.html()});"
-       ],
-       "metadata": {},
-       "output_type": "display_data",
-       "text": [
-        "<IPython.core.display.Javascript at 0x10e8d1650>"
-       ]
-      }
-     ],
-     "prompt_number": 18
-    },
-    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
-      "Here the rough order in which we recommend learning the command mode shortcuts:\n",
+      "We recommend learning the command mode shortcuts in the following rough order:\n",
       "\n",
       "1. Basic navigation: `enter`, `shift-enter`, `up/k`, `down/j`\n",
       "2. Saving the notebook: `s`\n",
       "2. Cell types: `y`, `m`, `1-6`, `t`\n",
       "3. Cell creation and movement: `a`, `b`, `ctrl+k`, `ctrl+j`\n",
       "4. Cell editing: `x`, `c`, `v`, `d`, `z`, `shift+=`\n",
       "5. Kernel operations: `i`, `.`"
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
-      "Keyboard shortcut customization"
+      "Cell types"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
-      "Starting with IPython 2.0 keyboard shortcuts in command and edit mode are fully customizable. These customizations are made using the IPython JavaScript API. Here is an example that makes the `r` key available for running a cell:"
-     ]
-    },
-    {
-     "cell_type": "code",
-     "collapsed": false,
-     "input": [
-      "%%javascript\n",
+      "The notebook UI and notebook documents are a linear sequence of cells. There are four cell types:\n",
       "\n",
-      "IPython.keyboard_manager.command_shortcuts.add_shortcut('r', {\n",
-      "    help : 'run cell',\n",
-      "    help_index : 'zz',\n",
-      "    handler : function (event) {\n",
-      "        IPython.notebook.execute_cell();\n",
-      "        return false;\n",
-      "    }}\n",
-      ");"
-     ],
-     "language": "python",
-     "metadata": {},
-     "outputs": [
-      {
-       "javascript": [
-        "\n",
-        "IPython.keyboard_manager.command_shortcuts.add_shortcut('r', {\n",
-        "    help : 'run cell',\n",
-        "    help_index : 'zz',\n",
-        "    handler : function (event) {\n",
-        "        IPython.notebook.execute_cell();\n",
-        "        return false;\n",
-        "    }}\n",
-        ");"
-       ],
-       "metadata": {},
-       "output_type": "display_data",
-       "text": [
-        "<IPython.core.display.Javascript at 0x10e8d1890>"
-       ]
-      }
-     ],
-     "prompt_number": 7
-    },
-    {
-     "cell_type": "markdown",
-     "metadata": {},
-     "source": [
-      "There are a couple of points to mention about this API:\n",
+      "* **Code cells:** Input and output of live code that is run in the kernel\n",
+      "* **Markdown cells:** Narrative text with embedded LaTeX equations\n",
+      "* **Heading cells:** 6 levels of hierarchical organization and formatting\n",
+      "* **Raw cells:** Unformatted text that is included, without modification, when notebooks are converted to different formats using nbconvert\n",
       "\n",
-      "* The `help_index` field is used to sort the shortcuts in the Keyboard Shortcuts help dialog. It defaults to `zz`.\n",
-      "* When a handler returns `false` it indicates that the event should stop propagating and the default action should not be performed. For further details about the `event` object or event handling, see the jQuery docs.\n",
-      "* If you don't need a `help` or `help_index` field, you can simply pass a function as the second argument to `add_shortcut`."
-     ]
-    },
-    {
-     "cell_type": "code",
-     "collapsed": false,
-     "input": [
-      "%%javascript\n",
+      "More information about code and Markdown cell can be found in these tutorials:\n",
       "\n",
-      "IPython.keyboard_manager.command_shortcuts.add_shortcut('r', function (event) {\n",
-      "    IPython.notebook.execute_cell();\n",
-      "    return false;\n",
-      "});"
-     ],
-     "language": "python",
-     "metadata": {},
-     "outputs": [
-      {
-       "javascript": [
-        "\n",
-        "IPython.keyboard_manager.command_shortcuts.add_shortcut('r', function (event) {\n",
-        "    IPython.notebook.execute_cell();\n",
-        "    return false;\n",
-        "});"
-       ],
-       "metadata": {},
-       "output_type": "display_data",
-       "text": [
-        "<IPython.core.display.Javascript at 0x1019baf90>"
-       ]
-      }
-     ],
-     "prompt_number": 11
-    },
-    {
-     "cell_type": "markdown",
-     "metadata": {},
-     "source": [
-      "Likewise, to remove a shortcut, use `remove_shortcut`:"
+      "* [Working With Code Cells](Working With Code Cells.ipynb)\n",
+      "* [Working With Markdown Cells](Working With Markdown Cells.ipynb)"
      ]
-    },
-    {
-     "cell_type": "code",
-     "collapsed": false,
-     "input": [
-      "%%javascript\n",
-      "\n",
-      "IPython.keyboard_manager.command_shortcuts.remove_shortcut('r');"
-     ],
-     "language": "python",
-     "metadata": {},
-     "outputs": [
-      {
-       "javascript": [
-        "\n",
-        "IPython.keyboard_manager.command_shortcuts.remove_shortcut('r');"
-       ],
-       "metadata": {},
-       "output_type": "display_data",
-       "text": [
-        "<IPython.core.display.Javascript at 0x10e8d1950>"
-       ]
-      }
-     ],
-     "prompt_number": 8
-    },
-    {
-     "cell_type": "markdown",
-     "metadata": {},
-     "source": [
-      "If you want your keyboard shortcuts to be active for all of your notebooks, put the above API calls into your `<profile>/static/custom/custom.js` file."
-     ]
-    },
-    {
-     "cell_type": "heading",
-     "level": 2,
-     "metadata": {},
-     "source": [
-      "Utilities"
-     ]
-    },
-    {
-     "cell_type": "markdown",
-     "metadata": {},
-     "source": [
-      "We use the following functions to generate the keyboard shortcut listings above."
-     ]
-    },
-    {
-     "cell_type": "code",
-     "collapsed": false,
-     "input": [
-      "from IPython.display import Javascript, display, HTML\n",
-      "\n",
-      "t = \"\"\"var help = IPython.quick_help.build_{0}_help();\n",
-      "help.children().first().remove();\n",
-      "this.append_output({{output_type: 'display_data', html: help.html()}});\"\"\"\n",
-      "\n",
-      "def display_command_shortcuts():\n",
-      "    display(Javascript(t.format('command')))\n",
-      "\n",
-      "def display_edit_shortcuts():\n",
-      "    display(Javascript(t.format('edit')))\n",
-      "\n",
-      "display(HTML(\"\"\"\n",
-      "<style>\n",
-      ".shortcut_key {display: inline-block; width: 15ex; text-align: right; font-family: monospace;}\n",
-      ".shortcut_descr {display: inline-block;}\n",
-      "div.quickhelp {float: none; width: 100%;}\n",
-      "</style>\n",
-      "\"\"\"))"
-     ],
-     "language": "python",
-     "metadata": {},
-     "outputs": [
-      {
-       "html": [
-        "\n",
-        "<style>\n",
-        ".shortcut_key {display: inline-block; width: 15ex; text-align: right; font-family: monospace;}\n",
-        ".shortcut_descr {display: inline-block;}\n",
-        "div.quickhelp {float: none; width: 100%;}\n",
-        "</style>\n"
-       ],
-       "metadata": {},
-       "output_type": "display_data",
-       "text": [
-        "<IPython.core.display.HTML at 0x10e8b0710>"
-       ]
-      }
-     ],
-     "prompt_number": 16
     }
    ],
    "metadata": {}
   }
  ]
 }
  No newline at end of file

examples/Notebook/What is the IPython Notebook?.ipynb

@@ -1,129 +1,129 b''
 {
  "metadata": {
   "name": "",
-  "signature": "sha256:3676a017d63581291cf2d61ea56d09cb3e5480a4f222184d8216e3e829eb4871"
+  "signature": "sha256:1fd1c67d342de34c5edf43789ce56f80963eda3662752e7d9cbc97ac54848be8"
  },
  "nbformat": 3,
  "nbformat_minor": 0,
  "worksheets": [
   {
    "cells": [
     {
      "cell_type": "heading",
      "level": 1,
      "metadata": {},
      "source": [
       "What is the IPython Notebook?"
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
       "Introduction"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "The IPython Notebook is an interactive computing environment that enables users to author notebook documents that include live code, interactive widgets, plots, narrative text, equations, images and video. These documents provide a complete and self-contained record of a computation that can be converted to various formats and shared with others using email, [Dropbox](http://dropbox.com), version control systems (like git/[GitHub](http://github.com)) or [nbviewer.ipython.org](http://nbviewer.ipython.org).\n",
       "\n",
       "Through IPython's kernel and messaging architecture, the Notebook allows code to be run in a range of different programming languages, including Python, R, Julia, Ruby and many others.\n",
       "\n",
       "The IPython Notebook combines three components:\n",
       "\n",
       "* **The notebook web application**: An interactive web application for writing and running code interactively and authoring notebook documents.\n",
       "* **Kernels**: Separate processes started by the notebook web application that runs users' code in a given language and returns output back to the notebook web application. The kernel also handles things like computations for interactive widgets, tab completion and introspection. \n",
       "* **Notebook documents**: Self-contained documents that contain a representation of all content visible in the notebook web application, including inputs and outputs of the computations, narrative\n",
       "text, equations, images, and rich media representations of objects. Each notebook document has its own kernel."
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
       "Notebook web application"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "The notebook web application enables users to:\n",
       "\n",
       "* Edit code in the browser, with automatic syntax highlighting, indentation, and tab completion/introspection.\n",
       "* Run code from the browser, with the results of computations attached to the code which generated them.\n",
       "* See the results of computations with rich media representations, such as HTML, LaTeX, PNG, SVG, PDF, etc.\n",
       "* Create and use interactive JavaScript wigets, which bind interactive user interface controls and visualizations to reactive kernel side computations.\n",
       "* Author narrative text using the [Markdown](https://daringfireball.net/projects/markdown/) markup language.\n",
       "* Build hierarchical documents that are organized into sections with different levels of headings.\n",
       "* Include mathematical equations using LaTeX syntax in Markdown, which are rendered in-browser by [MathJax](http://www.mathjax.org/).\n",
       "* Start parallel computing clusters that work with IPython's interactive parallel computing libraries `IPython.parallel`."
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
       "Kernels"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "For each notebook document that a user opens, the web application starts a kernel that runs the code for that notebook. Each kernel is capable of running code in a single programming language and there are kernels available in the following languages:\n",
       "\n",
       "* Python(https://github.com/ipython/ipython)\n",
       "* Julia (https://github.com/JuliaLang/IJulia.jl)\n",
       "* R (https://github.com/takluyver/IRkernel)\n",
       "* Ruby (https://github.com/minrk/iruby)\n",
       "* Haskell (https://github.com/gibiansky/IHaskell)\n",
       "* Scala (https://github.com/Bridgewater/scala-notebook)\n",
       "* node.js (https://gist.github.com/Carreau/4279371)\n",
       "* Go (https://github.com/takluyver/igo)\n",
       "\n",
       "The default kernel runs Python code. When it is released in the Summer/Fall of 2014, IPython 3.0 will provide a simple way for users to pick which of these kernels is used for a given notebook. \n",
       "\n",
       "Each of these kernels communicate with the notebook web application and web browser using a JSON over ZeroMQ/WebSockets message protocol that is described [here](http://ipython.org/ipython-doc/dev/development/messaging.html). Most users don't need to know about these details, but it helps to understand that \"kernels run code.\""
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
       "Notebook documents"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "Notebook documents contain the inputs and outputs of an interactive session as well as narrative text that accompanies the code but is not meant for execution. Rich output generated by running code, including HTML, images, video, and plots, is embeddeed in the notebook, which makes it a complete and self-contained record of a computation. \n",
       "\n",
       "When you run the notebook web application on your computer, notebook documents are just files on your local filesystem with a `.ipynb` extension. This allows you to use familiar workflows for organizing your notebooks into folders and sharing them with others using email, Dropbox and version control systems.\n",
       "\n",
       "Notebooks consist of a linear sequence of cells. There are four basic cell types:\n",
       "\n",
       "* **Code cells:** Input and output of live code that is run in the kernel\n",
       "* **Markdown cells:** Narrative text with embedded LaTeX equations\n",
-      "* **Heading cells:** 6 levels of hierarchical organization\n",
+      "* **Heading cells:** 6 levels of hierarchical organization and formatting\n",
       "* **Raw cells:** Unformatted text that is included, without modification, when notebooks are converted to different formats using nbconvert\n",
       "\n",
       "Internally, notebook documents are [JSON](http://en.wikipedia.org/wiki/JSO) data with binary values [base64](http://en.wikipedia.org/wiki/Base64) encoded. This allows them to be read and manipulated programmatically by any programming language. Because JSON is a text format, notebook documents are version control friendly.\n",
       "\n",
       "Notebooks can be exported to different static formats including HTML, reStructeredText, LaTeX, PDF, and slide shows ([reveal.js](http://lab.hakim.se/reveal-js/#/)) using IPython's `nbconvert` utility.\n",
       "\n",
       "Furthermore, any notebook document available from a public URL on or GitHub can be shared via http://nbviewer.ipython.org. This service loads the notebook document from the URL and renders it as a static web page. The resulting web page may thus be shared with others without their needing to install IPython."
      ]
     }
    ],
    "metadata": {}
   }
  ]
 }
  No newline at end of file