More fixes

IPython/html/static/notebook/js/widgets/widget_bool.js

@@ -1,121 +1,126 b''
 //----------------------------------------------------------------------------
 //  Copyright (C) 2013 The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // BoolWidget
 //============================================================================
 
 /**
  * @module IPython
  * @namespace IPython
  **/
 
 define(["notebook/js/widgets/widget"], function(widget_manager){
     var CheckBoxView = IPython.DOMWidgetView.extend({
       
         // Called when view is rendered.
         render : function(){
             this.$el
                 .addClass('widget-hbox-single');
             this.$label = $('<div />')
                 .addClass('widget-hlabel')
                 .appendTo(this.$el)
                 .hide();
-            var that = this;
             this.$checkbox = $('<input />')
                 .attr('type', 'checkbox')
-                .click(function(el) {
-            
-                    // Calling model.set will trigger all of the other views of the 
-                    // model to update.
-                    that.model.set('value', that.$checkbox.prop('checked'), {updated_view: this});
-                    that.touch();
-                })
-                .appendTo(this.$el);
+                .appendTo(this.$el)
+                .click($.proxy(this.handle_click, this));
 
             this.$el_to_style = this.$checkbox; // Set default element to style
             this.update(); // Set defaults.
         },
+
+        handle_click: function() {
+            // Calling model.set will trigger all of the other views of the 
+            // model to update.
+            var value = this.model.get('value');
+            this.model.set('value', ! value, {updated_view: this});
+            this.touch();
+        },
         
         update : function(options){
             // Update the contents of this view
             //
             // Called when the model is changed.  The model may have been 
             // changed by another view or by a state update from the back-end.
-            if (options === undefined || options.updated_view != this) {
-                this.$checkbox.prop('checked', this.model.get('value'));
+            this.$checkbox.prop('checked', this.model.get('value'));
 
+            if (options === undefined || options.updated_view != this) {
                 var disabled = this.model.get('disabled');
                 this.$checkbox.prop('disabled', disabled);
 
                 var description = this.model.get('description');
                 if (description.length === 0) {
                     this.$label.hide();
                 } else {
                     this.$label.html(description);
                     this.$label.show();
                 }
             }
             return CheckBoxView.__super__.update.apply(this);
         },
         
     });
 
     widget_manager.register_widget_view('CheckBoxView', CheckBoxView);
 
     var ToggleButtonView = IPython.DOMWidgetView.extend({
       
         // Called when view is rendered.
-        render : function(){
+        render : function() {
+            var that = this;
             this.setElement($('<button />')
                 .addClass('btn')
                 .attr('type', 'button')
-                .attr('data-toggle', 'button'));
+                .on('click', function (e) {
+                    e.preventDefault();
+                    that.handle_click();
+                }));
 
             this.update(); // Set defaults.
         },
         
         update : function(options){
             // Update the contents of this view
             //
             // Called when the model is changed.  The model may have been 
             // changed by another view or by a state update from the back-end.
             if (this.model.get('value')) {
                 this.$el.addClass('active');
             } else {
                 this.$el.removeClass('active');
             }
 
             if (options === undefined || options.updated_view != this) {
+
                 var disabled = this.model.get('disabled');
                 this.$el.prop('disabled', disabled);
 
                 var description = this.model.get('description');
                 if (description.length === 0) {
                     this.$el.html(' '); // Preserve button height
                 } else {
                     this.$el.html(description);
                 }
             }
             return ToggleButtonView.__super__.update.apply(this);
         },
         
-        events: {"click" : "handleClick"},
-        
         // Handles and validates user input.
-        handleClick: function(e) { 
+        handle_click: function(e) { 
 
             // Calling model.set will trigger all of the other views of the 
             // model to update.
-            this.model.set('value', ! $(this.$el).hasClass('active'), {updated_view: this});
+            var value = this.model.get('value');
+            this.model.set('value', ! value, {updated_view: this});
             this.touch();
         },
     });
 
     widget_manager.register_widget_view('ToggleButtonView', ToggleButtonView);
 
 });

IPython/html/tests/casperjs/test_cases/widgets.js

@@ -1,126 +1,76 b''
 // Test the widget framework.
 casper.notebook_test(function () {
     var index;
     
     this.then(function () {
     
         // Check if the WidgetManager class is defined.
         this.test.assert(this.evaluate(function() {
             return IPython.WidgetManager != undefined; 
         }), 'WidgetManager class is defined');
     });
 
     index = this.append_cell(
         'from IPython.html import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'print("Success")');
     this.execute_cell_then(index);
 
     this.wait(500); // Wait for require.js async callbacks to load dependencies.
 
     this.then(function () {
         // Check if the widget manager has been instanciated.
         this.test.assert(this.evaluate(function() {
             return IPython.widget_manager != undefined; 
         }), 'Notebook widget manager instanciated');
     });
 
-    index = this.append_cell(
-        'names = [name for name in dir(widgets)' + 
-        ' if name.endswith("Widget") and name!= "Widget" and name!= "DOMWidget"]\n' +
-        'for name in names:\n' +
-        '    print(name)\n');
-    this.execute_cell_then(index, function(index){
-
-        // Get the widget names that are registered with the widget manager.  Assume
-        // a 1 to 1 mapping of model and widgets names (model names just have 'model'
-        // suffixed).
-        var javascript_names = this.evaluate(function () {
-            names = [];
-            for (var name in IPython.widget_manager._model_types) {
-                names.push(name.replace('Model',''));
-            }
-            return names;
-        });
-
-        // Get the widget names registered in python.
-        var python_names = this.get_output_cell(index).text.split('\n');
-
-        // Make sure the two lists have the same items.
-        for (var i in javascript_names) {
-            var javascript_name = javascript_names[i];
-            var found = false;
-            for (var j in python_names) {
-                var python_name = python_names[j];
-                if (python_name==javascript_name) {
-                    found = true;
-                    break;
-                }
-            }
-            this.test.assert(found, javascript_name + ' exists in python');
-        }
-        for (var i in python_names) {
-            var python_name = python_names[i];
-            if (python_name.length > 0) {
-                var found = false;
-                for (var j in javascript_names) {
-                    var javascript_name = javascript_names[j];
-                    if (python_name==javascript_name) {
-                        found = true;
-                        break;
-                    }
-                }
-                this.test.assert(found, python_name + ' exists in javascript');
-            }
-        }
-    });
-    
     throttle_index = this.append_cell(
         'import time\n' +
-        'textbox = widgets.StringWidget()\n' +
+        'textbox = widgets.TextBoxWidget()\n' +
         'display(textbox)\n'+
         'textbox.add_class("my-throttle-textbox")\n' +
         'def handle_change(name, old, new):\n' +
         '    print(len(new))\n' +
         '    time.sleep(0.5)\n' +
         'textbox.on_trait_change(handle_change)\n' +
         'print("Success")');
     this.execute_cell_then(throttle_index, function(index){
         this.test.assert(this.get_output_cell(index).text == 'Success\n', 
             'Test throttling cell executed with correct output');
 
         this.test.assert(this.cell_element_exists(index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(index, 
             '.my-throttle-textbox'), 'Textbox exists.');
 
         // Send 20 characters
         this.sendKeys('.my-throttle-textbox', '....................');
     });
 
     this.wait(2000); // Wait for clicks to execute in kernel
 
     this.then(function(){
         var resume = true;
         var i = 0;
         while (resume) {
             i++;
             var output = this.get_output_cell(throttle_index, i);  
             if (output === undefined || output === null) {
                 resume = false;
                 i--;
             }
         }
 
         // Only 4 outputs should have printed, but because of timing, sometimes
         // 5 outputs will print.  All we need to do is verify num outputs <= 5
         // because that is much less than 20.
         this.test.assert(i <= 5, 'Messages throttled.');
 
         // We also need to verify that the last state sent was correct.
         var last_state = this.get_output_cell(throttle_index, i).text;
         this.test.assert(last_state == "20\n", "Last state sent when throttling.");
     })
 });

IPython/html/tests/casperjs/test_cases/widgets_bool.js

@@ -1,98 +1,86 b''
 // Test widget bool class
 casper.notebook_test(function () {
     index = this.append_cell(
         'from IPython.html import widgets\n' + 
         'from IPython.display import display, clear_output\n' +
         'print("Success")');
     this.execute_cell_then(index);
 
     var bool_index = this.append_cell(
-        'bool_widgets = [widgets.BoolWidget(description="Title", value=True) for i in range(2)]\n' +
+        'bool_widgets = [widgets.CheckBoxWidget(description="Title", value=True),\n' +
+        '    widgets.ToggleButtonWidget(description="Title", value=True)]\n' +
         'display(bool_widgets[0])\n' +
-        'bool_widgets[1].view_name = "ToggleButtonView"\n' +
         'display(bool_widgets[1])\n' +
-        'for widget in bool_widgets:\n' +
-        '    def handle_change(name,old,new):\n' +
-        '        for other_widget in bool_widgets:\n' +
-        '            other_widget.value = new\n' +
-        '    widget.on_trait_change(handle_change, "value")\n' +
         'print("Success")');
     this.execute_cell_then(bool_index, function(index){
 
         this.test.assert(this.get_output_cell(index).text == 'Success\n', 
             'Create bool widget cell executed with correct output.');
 
         this.test.assert(this.cell_element_exists(index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(index, 
             '.widget-area .widget-subarea .widget-hbox-single input'),
             'Checkbox exists.');
 
         this.test.assert(this.cell_element_function(index, 
             '.widget-area .widget-subarea .widget-hbox-single input', 'prop', ['checked']),
             'Checkbox is checked.');
 
         this.test.assert(this.cell_element_exists(index, 
             '.widget-area .widget-subarea .widget-hbox-single .widget-hlabel'),
             'Checkbox label exists.');
 
         this.test.assert(this.cell_element_function(index, 
             '.widget-area .widget-subarea .widget-hbox-single .widget-hlabel', 'html')=="Title",
             'Checkbox labeled correctly.');
 
         this.test.assert(this.cell_element_exists(index, 
             '.widget-area .widget-subarea button'),
             'Toggle button exists.');
 
         this.test.assert(this.cell_element_function(index, 
             '.widget-area .widget-subarea button', 'html')=="Title",
             'Toggle button labeled correctly.');
 
         this.test.assert(this.cell_element_function(index, 
             '.widget-area .widget-subarea button', 'hasClass', ['active']),
             'Toggle button is toggled.');
 
     });
 
     index = this.append_cell(
         'bool_widgets[0].value = False\n' +
+        'bool_widgets[1].value = False\n' +
         'print("Success")');
     this.execute_cell_then(index, function(index){
 
         this.test.assert(this.get_output_cell(index).text == 'Success\n', 
             'Change bool widget value cell executed with correct output.');
 
         this.test.assert(! this.cell_element_function(bool_index, 
             '.widget-area .widget-subarea .widget-hbox-single input', 'prop', ['checked']),
             'Checkbox is not checked. (1)');
 
         this.test.assert(! this.cell_element_function(bool_index, 
             '.widget-area .widget-subarea button', 'hasClass', ['active']),
             'Toggle button is not toggled. (1)');
-
-        // Try toggling the bool by clicking on the toggle button.
-        this.cell_element_function(bool_index, '.widget-area .widget-subarea button', 'click');
-
-        this.test.assert(this.cell_element_function(bool_index, 
-            '.widget-area .widget-subarea .widget-hbox-single input', 'prop', ['checked']),
-            'Checkbox is checked. (2)');
-
-        this.test.assert(this.cell_element_function(bool_index, 
-            '.widget-area .widget-subarea button', 'hasClass', ['active']),
-            'Toggle button is toggled. (2)');
  
         // Try toggling the bool by clicking on the checkbox.
         this.cell_element_function(bool_index, '.widget-area .widget-subarea .widget-hbox-single input', 'click');
 
-        this.test.assert(! this.cell_element_function(bool_index, 
+        this.test.assert(this.cell_element_function(bool_index, 
             '.widget-area .widget-subarea .widget-hbox-single input', 'prop', ['checked']),
-            'Checkbox is not checked. (3)');
+            'Checkbox is checked. (2)');
 
-        this.test.assert(! this.cell_element_function(bool_index, 
+        // Try toggling the bool by clicking on the toggle button.
+        this.cell_element_function(bool_index, '.widget-area .widget-subarea button', 'click');
+
+        this.test.assert(this.cell_element_function(bool_index, 
             '.widget-area .widget-subarea button', 'hasClass', ['active']),
-            'Toggle button is not toggled. (3)');
+            'Toggle button is toggled. (3)');
 
     });
 });
  No newline at end of file

IPython/html/widgets/widget.py

@@ -1,447 +1,447 b''
 """Base Widget class.  Allows user to create widgets in the back-end that render
 in the IPython notebook front-end.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from contextlib import contextmanager
 import inspect
 import types
 
 from IPython.kernel.comm import Comm
 from IPython.config import LoggingConfigurable
 from IPython.utils.traitlets import Unicode, Dict, Instance, Bool
 from IPython.utils.py3compat import string_types
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class Widget(LoggingConfigurable):
 
     # Shared declarations (Class level)
     widget_construction_callback = None
     widgets = {}
 
     def on_widget_constructed(callback):
         """Class method, registers a callback to be called when a widget is
         constructed.  The callback must have the following signature:
         callback(widget)"""
         Widget.widget_construction_callback = callback
 
     def _call_widget_constructed(widget):
         """Class method, called when a widget is constructed."""
         if Widget.widget_construction_callback is not None and callable(Widget.widget_construction_callback):
             Widget.widget_construction_callback(widget)
 
     
 
     # Public declarations (Instance level)
     model_name = Unicode('WidgetModel', help="""Name of the backbone model 
         registered in the front-end to create and sync this widget with.""")
     view_name = Unicode(help="""Default view registered in the front-end
         to use to represent the widget.""", sync=True)
 
     @contextmanager
     def property_lock(self, key, value):
         """Lock a property-value pair.
 
         NOTE: This, in addition to the single lock for all state changes, is 
         flawed.  In the future we may want to look into buffering state changes 
         back to the front-end."""
         self._property_lock = (key, value)
         try:
             yield
         finally:
             self._property_lock = (None, None)
 
     def should_send_property(self, key, value):
         """Check the property lock (property_lock)"""
         return key != self._property_lock[0] or \
         value != self._property_lock[1]
 
     @property
     def keys(self):
         if self._keys is None:
             self._keys = []
             for trait_name in self.trait_names():
                 if self.trait_metadata(trait_name, 'sync'):
                     self._keys.append(trait_name)
         return self._keys
 
     # Private/protected declarations
     _comm = Instance('IPython.kernel.comm.Comm')
     
     def __init__(self, **kwargs):
         """Public constructor
         """
         self.closed = False
         self._property_lock = (None, None)
         self._display_callbacks = []
         self._msg_callbacks = []
         self._keys = None
         super(Widget, self).__init__(**kwargs)
 
         self.on_trait_change(self._handle_property_changed, self.keys)
         Widget._call_widget_constructed(self)
 
     def __del__(self):
         """Object disposal"""
         self.close()
 
     def close(self):
         """Close method.  Closes the widget which closes the underlying comm.
         When the comm is closed, all of the widget views are automatically
         removed from the front-end."""
         if not self.closed:
             self._comm.close() 
             self._close()
 
 
     def _close(self):
         """Unsafe close"""
         del Widget.widgets[self.model_id]
         self._comm = None
         self.closed = True
 
 
     @property
     def comm(self):
         if self._comm is None:
             # Create a comm.
             self._comm = Comm(target_name=self.model_name)
             self._comm.on_msg(self._handle_msg)
             self._comm.on_close(self._close)
             Widget.widgets[self.model_id] = self
 
             # first update
             self.send_state()
         return self._comm
     
     @property
     def model_id(self):
         return self.comm.comm_id
 
     # Event handlers
     def _handle_msg(self, msg):
         """Called when a msg is received from the front-end"""
         data = msg['content']['data']
         method = data['method']
         if not method in ['backbone', 'custom']:
             self.log.error('Unknown front-end to back-end widget msg with method "%s"' % method)
 
         # Handle backbone sync methods CREATE, PATCH, and UPDATE all in one.
         if method == 'backbone' and 'sync_data' in data:
             sync_data = data['sync_data']
             self._handle_receive_state(sync_data) # handles all methods
 
         # Handle a custom msg from the front-end
         elif method == 'custom':
             if 'custom_content' in data:
                 self._handle_custom_msg(data['custom_content'])
 
 
     def _handle_receive_state(self, sync_data):
         """Called when a state is received from the front-end."""
         for name in self.keys:
             if name in sync_data:
                 value = self._unpack_widgets(sync_data[name])
                 with self.property_lock(name, value):
                     setattr(self, name, value)
 
 
     def _handle_custom_msg(self, content):
         """Called when a custom msg is received."""
         for handler in self._msg_callbacks:
             handler(self, content)
 
 
     def _handle_property_changed(self, name, old, new):
         """Called when a property has been changed."""
         # Make sure this isn't information that the front-end just sent us.
         if self.should_send_property(name, new):
             # Send new state to front-end
             self.send_state(key=name)
 
     def _handle_displayed(self, **kwargs):
         """Called when a view has been displayed for this widget instance"""
         for handler in self._display_callbacks:
             handler(self, **kwargs)
 
     # Public methods
     def send_state(self, key=None):
         """Sends the widget state, or a piece of it, to the front-end.
 
         Parameters
         ----------
         key : unicode (optional)
             A single property's name to sync with the front-end.
         """
         self._send({"method": "update",
             "state": self.get_state()})
 
     def get_state(self, key=None):
         """Gets the widget state, or a piece of it.
 
         Parameters
         ----------
         key : unicode (optional)
             A single property's name to get.
         """
         keys = self.keys if key is None else [key]
         return {k: self._pack_widgets(getattr(self, k)) for k in keys} 
 
 
     def _pack_widgets(self, values):
         """This function recursively converts all widget instances to model id
         strings.
 
         Children widgets will be stored and transmitted to the front-end by 
         their model ids."""
         if isinstance(values, dict):
             new_dict = {}
             for key, value in values.items():
                 new_dict[key] = self._pack_widgets(value)
             return new_dict
         elif isinstance(values, list):
             new_list = []
             for value in values:
                 new_list.append(self._pack_widgets(value))
             return new_list
         elif isinstance(values, Widget):
             return values.model_id
         else:
             return values
 
 
     def _unpack_widgets(self, values):
         """This function recursively converts all model id strings to widget 
         instances.
 
         Children widgets will be stored and transmitted to the front-end by 
         their model ids."""
         if isinstance(values, dict):
             new_dict = {}
             for key, values in values.items():
                 new_dict[key] = self._unpack_widgets(values[key])
             return new_dict
         elif isinstance(values, list):
             new_list = []
             for value in values:
                 new_list.append(self._unpack_widgets(value))
             return new_list
         elif isinstance(values, string_types):
-            if widget.model_id in Widget.widgets:
-                return Widget.widgets[widget.model_id]
+            if values in Widget.widgets:
+                return Widget.widgets[values]
             else:
                 return values
         else:
             return values
 
 
     def send(self, content):
         """Sends a custom msg to the widget model in the front-end.
 
         Parameters
         ----------
         content : dict
             Content of the message to send.
         """
         self._send({"method": "custom", "custom_content": content})
 
 
     def on_msg(self, callback, remove=False):
         """Register or unregister a callback for when a custom msg is recieved 
         from the front-end.
 
         Parameters
         ----------
         callback: method handler
             Can have a signature of:
             - callback(content)
             - callback(sender, content)
         remove: bool
             True if the callback should be unregistered."""
         if remove and callback in self._msg_callbacks:
             self._msg_callbacks.remove(callback)
         elif not remove and not callback in self._msg_callbacks:
             if callable(callback):
                 argspec = inspect.getargspec(callback)
                 nargs = len(argspec[0])
 
                 # Bound methods have an additional 'self' argument
                 if isinstance(callback, types.MethodType):
                     nargs -= 1
 
                 # Call the callback
                 if nargs == 1:
                     self._msg_callbacks.append(lambda sender, content: callback(content))
                 elif nargs == 2:
                     self._msg_callbacks.append(callback)
                 else:
                     raise TypeError('Widget msg callback must ' \
                         'accept 1 or 2 arguments, not %d.' % nargs)
             else:
                 raise Exception('Callback must be callable.')
 
 
     def on_displayed(self, callback, remove=False):
         """Register or unregister a callback to be called when the widget has 
         been displayed.
 
         Parameters
         ----------
         callback: method handler
             Can have a signature of:
             - callback(sender, **kwargs)
               kwargs from display call passed through without modification.
         remove: bool
             True if the callback should be unregistered."""
         if remove and callback in self._display_callbacks:
             self._display_callbacks.remove(callback)
         elif not remove and not callback in self._display_callbacks:
             if callable(handler):
                 self._display_callbacks.append(callback)
             else:
                 raise Exception('Callback must be callable.')
 
 
     # Support methods
     def _ipython_display_(self, **kwargs):
         """Function that is called when `IPython.display.display` is called on
         the widget."""
             
         # Show view.  By sending a display message, the comm is opened and the
         # initial state is sent.
         self._send({"method": "display"})
         self._handle_displayed(**kwargs)
 
 
     def _send(self, msg):
         """Sends a message to the model in the front-end"""
         self.comm.send(msg)
 
 
 class DOMWidget(Widget):
     visible = Bool(True, help="Whether or not the widget is visible.", sync=True)
 
     # Private/protected declarations
     _css = Dict(sync=True) # Internal CSS property dict
 
     def get_css(self, key, selector=""):
         """Get a CSS property of the widget.
 
         Note: This function does not actually request the CSS from the 
         front-end;  Only properties that have been set with set_css can be read.
 
         Parameters
         ----------
         key: unicode
             CSS key
         selector: unicode (optional)
             JQuery selector used when the CSS key/value was set.
         """
         if selector in self._css and key in self._css[selector]:
             return self._css[selector][key]
         else:
             return None
 
     def set_css(self, *args, **kwargs):
         """Set one or more CSS properties of the widget.
 
         This function has two signatures:
         - set_css(css_dict, selector='')
         - set_css(key, value, selector='')
 
         Parameters
         ----------
         css_dict : dict
             CSS key/value pairs to apply
         key: unicode
             CSS key
         value
             CSS value
         selector: unicode (optional)
             JQuery selector to use to apply the CSS key/value.  If no selector 
             is provided, an empty selector is used.  An empty selector makes the 
             front-end try to apply the css to a default element.  The default
             element is an attribute unique to each view, which is a DOM element
             of the view that should be styled with common CSS (see 
             `$el_to_style` in the Javascript code).
         """
         selector = kwargs.get('selector', '')
 
         # Signature 1: set_css(css_dict, selector='')
         if len(args) == 1:
             if isinstance(args[0], dict):
                 for (key, value) in args[0].items():
                     if not (key in self._css[selector] and value == self._css[selector][key]):
                         self._css[selector][key] = value
                 self.send_state('_css')
             else:
                 raise Exception('css_dict must be a dict.')
 
         # Signature 2: set_css(key, value, selector='')
         elif len(args) == 2 or len(args) == 3:
 
             # Selector can be a positional arg if it's the 3rd value
             if len(args) == 3:
                 selector = args[2]
             if selector not in self._css:
                 self._css[selector] = {}
 
             # Only update the property if it has changed.
             key = args[0]
             value = args[1]
             if not (key in self._css[selector] and value == self._css[selector][key]):
                 self._css[selector][key] = value
                 self.send_state('_css') # Send new state to client.
         else:
             raise Exception('set_css only accepts 1-3 arguments')
 
 
     def add_class(self, class_names, selector=""):
         """Add class[es] to a DOM element
 
         Parameters
         ----------
         class_names: unicode or list
             Class name(s) to add to the DOM element(s).
         selector: unicode (optional)
             JQuery selector to select the DOM element(s) that the class(es) will
             be added to.
         """
         class_list = class_names
         if isinstance(class_list, list):
             class_list = ' '.join(class_list)
 
         self.send({"msg_type": "add_class",
             "class_list": class_list,
             "selector": selector})
 
 
     def remove_class(self, class_names, selector=""):
         """Remove class[es] from a DOM element
 
         Parameters
         ----------
         class_names: unicode or list
             Class name(s) to remove from  the DOM element(s).
         selector: unicode (optional)
             JQuery selector to select the DOM element(s) that the class(es) will
             be removed from.
         """
         class_list = class_names
         if isinstance(class_list, list):
             class_list = ' '.join(class_list)
 
         self.send({"msg_type": "remove_class",
             "class_list": class_list,
             "selector": selector})

IPython/html/widgets/widget_string.py

@@ -1,94 +1,94 b''
 """StringWidget class.  
 
 Represents a unicode string using a widget.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 import inspect
 import types
 
 from .widget import DOMWidget
 from IPython.utils.traitlets import Unicode, Bool, List, Int
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class HTMLWidget(DOMWidget):
     view_name = Unicode('HTMLView', sync=True)
 
     # Keys
     value = Unicode(help="String value", sync=True)
     disabled = Bool(False, help="Enable or disable user changes", sync=True)
     description = Unicode(help="Description of the value this widget represents", sync=True)
 
 
 class LatexWidget(HTMLWidget):
     view_name = Unicode('LatexView', sync=True)
 
 
 class TextAreaWidget(HTMLWidget):
     view_name = Unicode('TextAreaView', sync=True)
 
     def scroll_to_bottom(self):
         self.send({"method": "scroll_to_bottom"})
 
 
 class TextBoxWidget(HTMLWidget):
     view_name = Unicode('TextBoxView', sync=True)
 
     def __init__(self, **kwargs):
-        super(StringWidget, self).__init__(**kwargs)
+        super(TextBoxWidget, self).__init__(**kwargs)
         self._submission_callbacks = []        
         self.on_msg(self._handle_string_msg)
 
     def _handle_string_msg(self, content):
         """Handle a msg from the front-end
 
         Parameters
         ----------
         content: dict
             Content of the msg."""
         if 'event' in content and content['event'] == 'submit':
             for handler in self._submission_callbacks:
                 handler(self)
 
     def on_submit(self, callback, remove=False):
         """Register a callback to handle text submission (triggered when the 
         user clicks enter).
 
         Parameters
         callback: Method handle
             Function to be called when the text has been submitted.  Function
             can have two possible signatures:
             callback()
             callback(sender)
         remove: bool (optional)
             Whether or not to unregister the callback"""
         if remove and callback in self._submission_callbacks:
             self._submission_callbacks.remove(callback)
         elif not remove and not callback in self._submission_callbacks:
             if callable(callback):
                 argspec = inspect.getargspec(callback)
                 nargs = len(argspec[0])
 
                 # Bound methods have an additional 'self' argument
                 if isinstance(callback, types.MethodType):
                     nargs -= 1
 
                 # Call the callback
                 if nargs == 0:
                     self._submission_callbacks.append(lambda sender: callback())
                 elif nargs == 1:
                     self._submission_callbacks.append(callback)
                 else:
-                    raise TypeError('StringWidget submit callback must ' \
+                    raise TypeError('TextBoxWidget submit callback must ' \
                         'accept 0 or 1 arguments.')