Fixed some more example files (see list below)...

Export As (nbconvert).ipynb
File Upload Widget.ipynb
Nonblocking Console.ipynb
index.ipynb

examples/widgets/Export As (nbconvert).ipynb

@@ -1,194 +1,186
 {
  "metadata": {
   "name": ""
  },
  "nbformat": 3,
  "nbformat_minor": 0,
  "worksheets": [
   {
    "cells": [
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
+      "# Widget related imports\n",
       "from IPython.html import widgets\n",
-      "from IPython.display import display, Javascript, clear_output\n",
+      "from IPython.display import display, clear_output, Javascript\n",
+      "from IPython.utils.traitlets import Unicode\n",
+      "\n",
+      "# nbconvert related imports\n",
       "from IPython.nbconvert import get_export_names, export_by_name\n",
       "from IPython.nbconvert.writers import FilesWriter\n",
       "from IPython.nbformat import current"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [],
      "prompt_number": 1
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
-      "Create and *display* a StringWidget without a view.  The StringWidget will be used to store the notebook name which is otherwise only available in the front-end."
+      "Create a textbox Widget without displaying it.  The widget will be used to store the notebook's name which is otherwise only available in the front-end."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
-      "notebook_name = widgets.StringWidget(default_view_name='')\n",
-      "display(notebook_name)"
+      "notebook_name = widgets.TextBoxWidget()"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [],
      "prompt_number": 2
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "Get the current notebook's name by pushing JavaScript to the browser that sets the notebook name in a string widget."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
-      "js = \"\"\"var model = IPython.notebook.kernel.comm_manager.comms['{comm_id}'].model;\n",
+      "js = \"\"\"var model = IPython.notebook.kernel.widget_manager.get_model('{model_id}');\n",
       "model.set('value', IPython.notebook.notebook_name);\n",
-      "model.save();\"\"\".format(comm_id=notebook_name._comm.comm_id)\n",
+      "model.save();\"\"\".format(model_id=notebook_name.model_id)\n",
       "display(Javascript(data=js))"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [
       {
        "javascript": [
-        "var model = IPython.notebook.kernel.comm_manager.comms['af0fadc224134034af6141995abf625a'].model;\n",
+        "var model = IPython.notebook.kernel.widget_manager.get_model('8c6583524eb3422c99491730a3e1ce6c');\n",
         "model.set('value', IPython.notebook.notebook_name);\n",
         "model.save();"
        ],
        "metadata": {},
        "output_type": "display_data",
        "text": [
-        "<IPython.core.display.Javascript at 0x3756790>"
+        "<IPython.core.display.Javascript at 0x164ea50>"
        ]
       }
      ],
      "prompt_number": 3
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "filename = notebook_name.value\n",
       "filename"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [
       {
        "metadata": {},
        "output_type": "pyout",
        "prompt_number": 4,
        "text": [
         "u'Export As (nbconvert).ipynb'"
        ]
       }
      ],
      "prompt_number": 4
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "Create the widget that will allow the user to Export the current notebook."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
-      "container = widgets.ContainerWidget()\n",
-      "container.vbox()\n",
-      "container.align_center()\n",
-      "\n",
-      "options = widgets.ContainerWidget(parent=container)\n",
-      "options.hbox()\n",
-      "options.align_center()\n",
-      "exporter_names = widgets.SelectionWidget(parent=options, values=get_export_names(), value='html')\n",
-      "export_button = widgets.ButtonWidget(parent=options, description=\"Export\")\n",
-      "\n",
-      "download_link = widgets.StringWidget(parent=container, default_view_name=\"HTMLView\", visible=False)"
+      "exporter_names = widgets.DropdownWidget(values=get_export_names(), value='html')\n",
+      "export_button = widgets.ButtonWidget(description=\"Export\")\n",
+      "download_link = widgets.HTMLWidget(visible=False)"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [],
      "prompt_number": 5
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "Export the notebook when the export button is clicked."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "file_writer = FilesWriter()\n",
       "\n",
       "def export(name, nb):\n",
       "    \n",
       "    # Get a unique key for the notebook and set it in the resources object.\n",
       "    notebook_name = name[:name.rfind('.')]\n",
       "    resources = {}\n",
       "    resources['unique_key'] = notebook_name\n",
       "    resources['output_files_dir'] = '%s_files' % notebook_name\n",
       "\n",
       "    # Try to export\n",
       "    try:\n",
       "        output, resources = export_by_name(exporter_names.value, nb)\n",
       "    except ConversionException as e:\n",
       "        download_link.value = \"<br>Could not export notebook!\"\n",
       "    else:\n",
       "        write_results = file_writer.write(output, resources, notebook_name=notebook_name)\n",
       "    \n",
       "        download_link.value = \"<br>Results: <a href='files/{filename}'><i>\\\"{filename}\\\"</i></a>\".format(filename=write_results)\n",
-      "        download_link.visible = True"
-     ],
-     "language": "python",
-     "metadata": {},
-     "outputs": [],
-     "prompt_number": 6
-    },
-    {
-     "cell_type": "code",
-     "collapsed": false,
-     "input": [
+      "        download_link.visible = True\n",
+      "        \n",
       "def handle_export():\n",
       "    with open(filename, 'r') as f:\n",
       "        export(filename, current.read(f, 'json'))\n",
       "export_button.on_click(handle_export)"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 7
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Display the controls."
+     ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
-      "download_link.visible = False\n",
-      "display(container)"
+      "display(exporter_names, export_button, download_link)"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 8
+     "prompt_number": 7
     }
    ],
    "metadata": {}
   }
  ]
 }
  No newline at end of file

examples/widgets/File Upload Widget.ipynb

@@ -1,223 +1,248
 {
  "metadata": {
   "cell_tags": [
    [
     "<None>",
     null
    ]
   ],
   "name": ""
  },
  "nbformat": 3,
  "nbformat_minor": 0,
  "worksheets": [
   {
    "cells": [
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
-      "from __future__ import print_function # py 2.7 compat\n",
-      "\n",
       "import base64\n",
-      "from IPython.html import widgets # Widget definitions\n",
-      "from IPython.display import display # Used to display widgets in the notebook"
+      "from __future__ import print_function # py 2.7 compat.\n",
+      "from IPython.html import widgets # Widget definitions.\n",
+      "from IPython.utils.traitlets import Unicode # Traitlet needed to add synced attributes to the widget."
      ],
      "language": "python",
      "metadata": {},
      "outputs": [],
      "prompt_number": 1
     },
     {
-     "cell_type": "heading",
-     "level": 1,
+     "cell_type": "markdown",
      "metadata": {},
      "source": [
-      "Custom Widget"
+      "This is a custom widget that allows the user to upload file data to the notebook server.  The file data is sent via a statefull `value` attribute of the widget.  The widget has an upload failed event that fires in the front-end and is echoed to the back-end using a custom msg."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
-      "# Import the base Widget class and the traitlets Unicode class.\n",
-      "from IPython.html.widgets import Widget\n",
-      "from IPython.utils.traitlets import Unicode, Int\n",
-      "\n",
-      "# Define our FileWidget and its target model and default view.\n",
-      "class FileWidget(Widget):\n",
-      "    target_name = Unicode('FileWidgetModel')\n",
-      "    default_view_name = Unicode('FilePickerView')\n",
+      "class FileWidget(widgets.DOMWidget):\n",
+      "    _view_name = Unicode('FilePickerView', sync=True)\n",
+      "    value = Unicode(sync=True)\n",
+      "    filename = Unicode(sync=True)\n",
       "    \n",
-      "    # Define the custom state properties to sync with the front-end\n",
-      "    _keys = ['value', 'filename']\n",
-      "    value = Unicode('')\n",
-      "    filename = Unicode('')\n",
-      "    on_failed = Int(0)"
+      "    def __init__(self, **kwargs):\n",
+      "        \"\"\"Constructor\"\"\"\n",
+      "        widgets.DOMWidget.__init__(self, **kwargs) # Call the base.\n",
+      "        \n",
+      "        # Allow the user to register error callbacks with the following signatures:\n",
+      "        #    callback()\n",
+      "        #    callback(sender)\n",
+      "        self.errors = widgets.CallbackDispatcher(accepted_nargs=[0, 1])\n",
+      "        \n",
+      "        # Listen for custom msgs\n",
+      "        self.on_msg(self._handle_custom_msg)\n",
+      "\n",
+      "    def _handle_custom_msg(self, content):\n",
+      "        \"\"\"Handle a msg from the front-end.\n",
+      "\n",
+      "        Parameters\n",
+      "        ----------\n",
+      "        content: dict\n",
+      "            Content of the msg.\"\"\"\n",
+      "        if 'event' in content and content['event'] == 'error':\n",
+      "            self.errors()\n",
+      "            self.errors(self)\n",
+      "    "
      ],
      "language": "python",
      "metadata": {},
      "outputs": [],
      "prompt_number": 2
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "%%javascript\n",
       "\n",
-      "require([\"notebook/js/widget\"], function(){\n",
-      "    \n",
-      "    // Define the FileModel and register it with the widget manager.\n",
-      "    var FileModel = IPython.WidgetModel.extend({});\n",
-      "    IPython.widget_manager.register_widget_model('FileWidgetModel', FileModel);\n",
-      "    \n",
-      "    // Define the FilePickerView\n",
+      "require([\"notebook/js/widgets/widget\"], function(WidgetManager){\n",
+      "\n",
       "    var FilePickerView = IPython.WidgetView.extend({\n",
-      "        \n",
       "        render: function(){\n",
-      "            var that = this;\n",
-      "            this.$el = $('<input />')\n",
-      "                .attr('type', 'file')\n",
-      "                .change(function(evt){ that.handleFileChange(evt) });\n",
+      "            // Render the view.\n",
+      "            this.setElement($('<input />')\n",
+      "                .attr('type', 'file'));\n",
       "        },\n",
       "        \n",
-      "        // Handles: User input\n",
-      "        handleFileChange: function(evt) { \n",
+      "        events: {\n",
+      "            // List of events and their handlers.\n",
+      "            'change': 'handle_file_change',\n",
+      "        },\n",
+      "       \n",
+      "        handle_file_change: function(evt) { \n",
+      "            // Handle when the user has changed the file.\n",
       "            \n",
-      "            //Retrieve the first (and only!) File from the FileList object\n",
-      "            var that = this;\n",
-      "            var f = evt.target.files[0];\n",
-      "            if (f) {\n",
-      "                var r = new FileReader();\n",
-      "                r.onload = function(e) {\n",
+      "            // Retrieve the first (and only!) File from the FileList object\n",
+      "            var file = evt.target.files[0];\n",
+      "            if (file) {\n",
+      "\n",
+      "                // Read the file's textual content and set value to those contents.\n",
+      "                var that = this;\n",
+      "                var file_reader = new FileReader();\n",
+      "                file_reader.onload = function(e) {\n",
       "                    that.model.set('value', e.target.result);\n",
-      "                    that.model.update_other_views(that);\n",
+      "                    that.touch();\n",
       "                }\n",
-      "                r.readAsText(f);\n",
+      "                file_reader.readAsText(file);\n",
       "            } else {\n",
-      "                this.model.set('on_failed', this.model.get('on_failed') + 1);\n",
-      "                this.model.update_other_views(this);\n",
+      "\n",
+      "                // The file couldn't be opened.  Send an error msg to the\n",
+      "                // back-end.\n",
+      "                this.send({ 'event': 'error' });\n",
       "            }\n",
-      "            this.model.set('filename', f.name);\n",
-      "            this.model.update_other_views(this);\n",
+      "\n",
+      "            // Set the filename of the file.\n",
+      "            this.model.set('filename', file.name);\n",
+      "            this.touch();\n",
       "        },\n",
       "    });\n",
       "        \n",
       "    // Register the DatePickerView with the widget manager.\n",
-      "    IPython.widget_manager.register_widget_view('FilePickerView', FilePickerView);\n",
+      "    WidgetManager.register_widget_view('FilePickerView', FilePickerView);\n",
       "});"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [
       {
        "javascript": [
         "\n",
-        "require([\"notebook/js/widget\"], function(){\n",
-        "    \n",
-        "    // Define the FileModel and register it with the widget manager.\n",
-        "    var FileModel = IPython.WidgetModel.extend({});\n",
-        "    IPython.widget_manager.register_widget_model('FileWidgetModel', FileModel);\n",
-        "    \n",
-        "    // Define the FilePickerView\n",
+        "require([\"notebook/js/widgets/widget\"], function(WidgetManager){\n",
+        "\n",
         "    var FilePickerView = IPython.WidgetView.extend({\n",
-        "        \n",
         "        render: function(){\n",
-        "            var that = this;\n",
-        "            this.$el = $('<input />')\n",
-        "                .attr('type', 'file')\n",
-        "                .change(function(evt){ that.handleFileChange(evt) });\n",
+        "            // Render the view.\n",
+        "            this.setElement($('<input />')\n",
+        "                .attr('type', 'file'));\n",
         "        },\n",
         "        \n",
-        "        // Handles: User input\n",
-        "        handleFileChange: function(evt) { \n",
+        "        events: {\n",
+        "            // List of events and their handlers.\n",
+        "            'change': 'handle_file_change',\n",
+        "        },\n",
+        "       \n",
+        "        handle_file_change: function(evt) { \n",
+        "            // Handle when the user has changed the file.\n",
         "            \n",
-        "            //Retrieve the first (and only!) File from the FileList object\n",
-        "            var that = this;\n",
-        "            var f = evt.target.files[0];\n",
-        "            if (f) {\n",
-        "                var r = new FileReader();\n",
-        "                r.onload = function(e) {\n",
+        "            // Retrieve the first (and only!) File from the FileList object\n",
+        "            var file = evt.target.files[0];\n",
+        "            if (file) {\n",
+        "\n",
+        "                // Read the file's textual content and set value to those contents.\n",
+        "                var that = this;\n",
+        "                var file_reader = new FileReader();\n",
+        "                file_reader.onload = function(e) {\n",
         "                    that.model.set('value', e.target.result);\n",
-        "                    that.model.update_other_views(that);\n",
+        "                    that.touch();\n",
         "                }\n",
-        "                r.readAsText(f);\n",
+        "                file_reader.readAsText(file);\n",
         "            } else {\n",
-        "                this.model.set('on_failed', this.model.get('on_failed') + 1);\n",
-        "                this.model.update_other_views(this);\n",
+        "\n",
+        "                // The file couldn't be opened.  Send an error msg to the\n",
+        "                // back-end.\n",
+        "                this.send({ 'event': 'error' });\n",
         "            }\n",
-        "            this.model.set('filename', f.name);\n",
-        "            this.model.update_other_views(this);\n",
+        "\n",
+        "            // Set the filename of the file.\n",
+        "            this.model.set('filename', file.name);\n",
+        "            this.touch();\n",
         "        },\n",
         "    });\n",
         "        \n",
         "    // Register the DatePickerView with the widget manager.\n",
-        "    IPython.widget_manager.register_widget_view('FilePickerView', FilePickerView);\n",
+        "    WidgetManager.register_widget_view('FilePickerView', FilePickerView);\n",
         "});"
        ],
        "metadata": {},
        "output_type": "display_data",
        "text": [
-        "<IPython.core.display.Javascript at 0x7f14f1c78cd0>"
+        "<IPython.core.display.Javascript at 0x22870d0>"
        ]
       }
      ],
      "prompt_number": 3
     },
     {
-     "cell_type": "heading",
-     "level": 1,
+     "cell_type": "markdown",
      "metadata": {},
      "source": [
-      "Usage"
+      "The following shows how the file widget can be used."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "file_widget = FileWidget()\n",
-      "display(file_widget)\n",
       "\n",
+      "# Register an event to echo the filename when it has been changed.\n",
       "def file_loading():\n",
       "    print(\"Loading %s\" % file_widget.filename)\n",
+      "file_widget.on_trait_change(file_loading, 'filename')\n",
       "\n",
+      "# Register an event to echo the filename and contents when a file\n",
+      "# has been uploaded.\n",
       "def file_loaded():\n",
       "    print(\"Loaded, file contents: %s\" % file_widget.value)\n",
+      "file_widget.on_trait_change(file_loaded, 'value')\n",
       "\n",
-      "def file_failed(name, old_value, new_value):\n",
-      "    if new_value > old_value:\n",
-      "        print(\"Could not load file contents of %s\" % file_widget.filename)\n",
-      "\n",
+      "# Register an event to print an error message when a file could not\n",
+      "# be opened.  Since the error messages are not handled through\n",
+      "# traitlets but instead handled through custom msgs, the registration\n",
+      "# of the handler is different than the two examples above.  Instead\n",
+      "# the API provided by the CallbackDispatcher must be used.\n",
+      "def file_failed():\n",
+      "    print(\"Could not load file contents of %s\" % file_widget.filename)\n",
+      "file_widget.errors.register_callback(file_failed)\n",
       "\n",
-      "file_widget.on_trait_change(file_loading, 'filename')\n",
-      "file_widget.on_trait_change(file_loaded, 'value')\n",
-      "file_widget.on_trait_change(file_failed, 'on_failed')"
+      "file_widget"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "Loading test.txt\n"
        ]
       },
       {
        "output_type": "stream",
        "stream": "stdout",
        "text": [
         "Loaded, file contents: Hello World!\n",
         "\n"
        ]
       }
      ],
      "prompt_number": 4
     }
    ],
    "metadata": {}
   }
  ]
 }
  No newline at end of file

examples/widgets/Nonblocking Console.ipynb

@@ -1,223 +1,227
 {
  "metadata": {
   "name": ""
  },
  "nbformat": 3,
  "nbformat_minor": 0,
  "worksheets": [
   {
    "cells": [
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
+      "# Console related imports.\n",
       "from subprocess import Popen, PIPE\n",
       "import fcntl\n",
       "import os\n",
+      "from IPython.utils.py3compat import bytes_to_str, string_types\n",
       "\n",
+      "# Widget related imports.\n",
       "from IPython.html import  widgets\n",
-      "from IPython.display import display\n",
-      "from IPython.utils.py3compat import bytes_to_str, string_types"
+      "from IPython.display import display"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 1
-    },
-    {
-     "cell_type": "markdown",
-     "metadata": {},
-     "source": [
-      "Create the output, input, and console toggle widgets."
-     ]
-    },
-    {
-     "cell_type": "code",
-     "collapsed": false,
-     "input": [
-      "console_container = widgets.ContainerWidget(visible=False)\n",
-      "console_container.set_css('padding', '10px')\n",
-      "\n",
-      "console_style = {\n",
-      "    'font-family': 'monospace',\n",
-      "    'color': '#AAAAAA',\n",
-      "    'background': 'black',\n",
-      "    'width': '800px',\n",
-      "}\n",
-      "\n",
-      "output_box = widgets.StringWidget(parent=console_container, default_view_name='TextAreaView')\n",
-      "output_box.set_css(console_style)\n",
-      "output_box.set_css('height', '400px')\n",
-      "\n",
-      "input_box = widgets.StringWidget(parent=console_container)\n",
-      "input_box.set_css(console_style)\n",
-      "\n",
-      "toggle_button = widgets.ButtonWidget(description=\"Start Console\")\n",
-      "def toggle_console():\n",
-      "    console_container.visible = not console_container.visible\n",
-      "    if console_container.visible:\n",
-      "        toggle_button.description=\"Stop Console\"\n",
-      "        input_box.disabled = False\n",
-      "    else:\n",
-      "        toggle_button.description=\"Start Console\"\n",
-      "toggle_button.on_click(toggle_console)\n"
-     ],
-     "language": "python",
-     "metadata": {},
-     "outputs": [],
-     "prompt_number": 2
+     "prompt_number": 6
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "Define function to run a process without blocking the input."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "def read_process(process, append_output):\n",
       "    \"\"\" Try to read the stdout and stderr of a process and render it using \n",
       "    the append_output method provided\n",
       "    \n",
       "    Parameters\n",
       "    ----------\n",
       "    process: Popen handle\n",
       "    append_output: method handle\n",
       "        Callback to render output.  Signature of\n",
       "        append_output(output, [prefix=])\"\"\"\n",
       "    \n",
       "    try:\n",
       "        stdout = process.stdout.read()\n",
       "        if stdout is not None and len(stdout) > 0:\n",
       "            append_output(stdout, prefix='    ')\n",
       "    except:\n",
       "        pass\n",
       "        \n",
       "    try:\n",
       "        stderr = process.stderr.read()\n",
       "        if stderr is not None and len(stderr) > 0:\n",
       "            append_output(stderr, prefix='ERR ')\n",
       "    except:\n",
       "        pass\n",
       "\n",
       "\n",
       "def set_pipe_nonblocking(pipe):\n",
       "    \"\"\"Set a pipe as non-blocking\"\"\"\n",
       "    fl = fcntl.fcntl(pipe, fcntl.F_GETFL)\n",
       "    fcntl.fcntl(pipe, fcntl.F_SETFL, fl | os.O_NONBLOCK)\n",
       "\n",
       "\n",
       "kernel = get_ipython().kernel\n",
       "def run_command(command, append_output, has_user_exited=None):\n",
       "    \"\"\"Run a command asyncronously\n",
       "    \n",
       "    Parameters\n",
       "    ----------\n",
       "    command: str\n",
       "        Shell command to launch a process with.\n",
       "    append_output: method handle\n",
       "        Callback to render output.  Signature of\n",
       "        append_output(output, [prefix=])\n",
       "    has_user_exited: method handle\n",
       "        Check to see if the user wants to stop the command.\n",
       "        Must return a boolean.\"\"\"\n",
       "    \n",
       "    # Echo input.\n",
       "    append_output(command, prefix='>>> ')\n",
       "    \n",
       "    # Create the process.  Make sure the pipes are set as non-blocking.\n",
       "    process = Popen(command, shell=True, stdout=PIPE, stderr=PIPE)\n",
       "    set_pipe_nonblocking(process.stdout)\n",
       "    set_pipe_nonblocking(process.stderr)\n",
       "    \n",
       "    # Only continue to read from the command \n",
       "    while (has_user_exited is None or not has_user_exited()) and process.poll() is None:\n",
       "        read_process(process, append_output)\n",
       "        kernel.do_one_iteration() # Run IPython iteration.  This is the code that\n",
       "                                  # makes this operation non-blocking.  This will\n",
       "                                  # allow widget messages and callbacks to be \n",
       "                                  # processed.\n",
       "        \n",
       "    # If the process is still running, the user must have exited.\n",
       "    if process.poll() is None:\n",
       "        process.kill()\n",
       "    else:\n",
       "        read_process(process, append_output) # Read remainer\n",
       "        \n",
       "    \n",
       "        \n",
       "        "
      ],
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 3
+     "prompt_number": 7
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Create the console widgets without displaying them."
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "console_container = widgets.ContainerWidget(visible=False)\n",
+      "console_container.set_css('padding', '10px')\n",
+      "\n",
+      "console_style = {\n",
+      "    'font-family': 'monospace',\n",
+      "    'color': '#AAAAAA',\n",
+      "    'background': 'black',\n",
+      "    'width': '800px',\n",
+      "}\n",
+      "\n",
+      "output_box = widgets.TextAreaWidget()\n",
+      "output_box.set_css(console_style)\n",
+      "output_box.set_css('height', '400px')\n",
+      "\n",
+      "input_box = widgets.TextBoxWidget()\n",
+      "input_box.set_css(console_style)\n",
+      "\n",
+      "console_container.children = [output_box, input_box]"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 8
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "Hook the process execution methods up to our console widgets."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
       "\n",
       "def append_output(output, prefix):\n",
       "    if isinstance(output, string_types):\n",
       "        output_str = output\n",
       "    else:\n",
       "        output_str = bytes_to_str(output)\n",
       "    output_lines = output_str.split('\\n')\n",
       "    formatted_output = '\\n'.join([prefix + line for line in output_lines if len(line) > 0]) + '\\n'\n",
       "    output_box.value += formatted_output\n",
       "    output_box.scroll_to_bottom()\n",
       "    \n",
       "def has_user_exited():\n",
       "    return not console_container.visible\n",
       "\n",
       "def handle_input(sender):\n",
       "    sender.disabled = True\n",
       "    try:\n",
       "        command = sender.value\n",
       "        sender.value = ''\n",
       "        run_command(command, append_output=append_output, has_user_exited=has_user_exited)\n",
       "    finally:\n",
       "        sender.disabled = False\n",
       "        \n",
       "input_box.on_submit(handle_input)"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 4
+     "prompt_number": 9
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
-      "Show the console"
+      "Create the button that will be used to display and hide the console.  Display both the console container and the new button used to toggle it."
      ]
     },
     {
      "cell_type": "code",
      "collapsed": false,
      "input": [
+      "toggle_button = widgets.ButtonWidget(description=\"Start Console\")\n",
+      "def toggle_console():\n",
+      "    console_container.visible = not console_container.visible\n",
+      "    if console_container.visible:\n",
+      "        toggle_button.description=\"Stop Console\"\n",
+      "        input_box.disabled = False\n",
+      "    else:\n",
+      "        toggle_button.description=\"Start Console\"\n",
+      "toggle_button.on_click(toggle_console)\n",
+      "\n",
       "display(toggle_button)\n",
       "display(console_container)"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 5
+     "prompt_number": 10
     }
    ],
    "metadata": {}
   }
  ]
 }
  No newline at end of file

examples/widgets/index.ipynb

@@ -1,70 +1,69
 {
  "metadata": {
   "name": ""
  },
  "nbformat": 3,
  "nbformat_minor": 0,
  "worksheets": [
   {
    "cells": [
     {
      "cell_type": "heading",
      "level": 1,
      "metadata": {},
      "source": [
       "Widgets"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "This directory includes a tutorial and collection of examples related to the IPython notebook widget framework."
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
       "Tutorial"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "- [Part 1 - Basics](Part 1 - Basics.ipynb)  \n",
       "- [Part 2 - Events](Part 2 - Events.ipynb)  \n",
       "- [Part 3 - Placement](Part 3 - Placement.ipynb)  \n",
       "- [Part 4 - Styles](Part 4 - Styles.ipynb)  \n",
       "- [Part 5 - Alignment](Part 5 - Alignment.ipynb)  \n",
       "- [Part 6 - Custom Widget](Part 6 - Custom Widget.ipynb)  "
      ]
     },
     {
      "cell_type": "heading",
      "level": 2,
      "metadata": {},
      "source": [
       "Examples"
      ]
     },
     {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
       "- [Widget Tester](Widget Tester.ipynb)  \n",
       "- [Variable Inspector](Variable Inspector.ipynb)  \n",
       "- [Export As (nbconvert)](Export As (nbconvert%29.ipynb)  \n",
       "- [Nonblocking Console](Nonblocking Console.ipynb)  \n",
       "- [D3](D3.ipynb)  \n",
-      "- [File Upload Widget](File Upload Widget.ipynb)  \n",
-      "- [Dialogs](Dialogs.ipynb)  "
+      "- [File Upload Widget](File Upload Widget.ipynb)  "
      ]
     }
    ],
    "metadata": {}
   }
  ]
 }
  No newline at end of file