Merge pull request #5936 from jdfreder/i5821

Change widget css dict to a list,

IPython/html/static/widgets/js/widget.js

@@ -1,452 +1,452 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.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // Base Widget Model and View classes
 //============================================================================
 
 /**
  * @module IPython
  * @namespace IPython
  **/
 
 define(["widgets/js/manager",
         "underscore",
         "backbone"], 
 function(WidgetManager, _, Backbone){
 
     var WidgetModel = Backbone.Model.extend({
         constructor: function (widget_manager, model_id, comm) {
             // Constructor
             //
             // Creates a WidgetModel instance.
             //
             // Parameters
             // ----------
             // widget_manager : WidgetManager instance
             // model_id : string
             //      An ID unique to this model.
             // comm : Comm instance (optional)
             this.widget_manager = widget_manager;
             this._buffered_state_diff = {};
             this.pending_msgs = 0;
             this.msg_buffer = null;
             this.key_value_lock = null;
             this.id = model_id;
             this.views = [];
 
             if (comm !== undefined) {
                 // Remember comm associated with the model.
                 this.comm = comm;
                 comm.model = this;
 
                 // Hook comm messages up to model.
                 comm.on_close($.proxy(this._handle_comm_closed, this));
                 comm.on_msg($.proxy(this._handle_comm_msg, this));
             }
             return Backbone.Model.apply(this);
         },
 
         send: function (content, callbacks) {
             // Send a custom msg over the comm.
             if (this.comm !== undefined) {
                 var data = {method: 'custom', content: content};
                 this.comm.send(data, callbacks);
                 this.pending_msgs++;
             }
         },
 
         _handle_comm_closed: function (msg) {
             // Handle when a widget is closed.
             this.trigger('comm:close');
             delete this.comm.model; // Delete ref so GC will collect widget model.
             delete this.comm;
             delete this.model_id; // Delete id from model so widget manager cleans up.
             _.each(this.views, function(view, i) {
                 view.remove();
             });
         },
 
         _handle_comm_msg: function (msg) {
             // Handle incoming comm msg.
             var method = msg.content.data.method;
             switch (method) {
                 case 'update':
                     this.apply_update(msg.content.data.state);
                     break;
                 case 'custom':
                     this.trigger('msg:custom', msg.content.data.content);
                     break;
                 case 'display':
                     this.widget_manager.display_view(msg, this);
                     this.trigger('displayed');
                     break;
             }
         },
 
         apply_update: function (state) {
             // Handle when a widget is updated via the python side.
             var that = this;
             _.each(state, function(value, key) {
                 that.key_value_lock = [key, value];
                 try {
                     WidgetModel.__super__.set.apply(that, [key, that._unpack_models(value)]);
                 } finally {
                     that.key_value_lock = null;
                 }
             });
         },
 
         _handle_status: function (msg, callbacks) {
             // Handle status msgs.
 
             // execution_state : ('busy', 'idle', 'starting')
             if (this.comm !== undefined) {
                 if (msg.content.execution_state ==='idle') {
                     // Send buffer if this message caused another message to be
                     // throttled.
                     if (this.msg_buffer !== null &&
                         (this.get('msg_throttle') || 3) === this.pending_msgs) {
                         var data = {method: 'backbone', sync_method: 'update', sync_data: this.msg_buffer};
                         this.comm.send(data, callbacks);
                         this.msg_buffer = null;
                     } else {
                         --this.pending_msgs;
                     }
                 }
             }
         },
 
         callbacks: function(view) {
             // Create msg callbacks for a comm msg.
             var callbacks = this.widget_manager.callbacks(view);
 
             if (callbacks.iopub === undefined) {
                 callbacks.iopub = {};
             }
 
             var that = this;
             callbacks.iopub.status = function (msg) {
                 that._handle_status(msg, callbacks);
             };
             return callbacks;
         },
 
         set: function(key, val, options) {
             // Set a value.
             var return_value = WidgetModel.__super__.set.apply(this, arguments);
 
             // Backbone only remembers the diff of the most recent set()
             // operation.  Calling set multiple times in a row results in a 
             // loss of diff information.  Here we keep our own running diff.
             this._buffered_state_diff = $.extend(this._buffered_state_diff, this.changedAttributes() || {});
             return return_value;
         },
 
         sync: function (method, model, options) {
             // Handle sync to the back-end.  Called when a model.save() is called.
 
             // Make sure a comm exists.
             var error = options.error || function() {
                 console.error('Backbone sync error:', arguments);
             };
             if (this.comm === undefined) {
                 error();
                 return false;
             }
 
             // Delete any key value pairs that the back-end already knows about.
             var attrs = (method === 'patch') ? options.attrs : model.toJSON(options);
             if (this.key_value_lock !== null) {
                 var key = this.key_value_lock[0];
                 var value = this.key_value_lock[1];
                 if (attrs[key] === value) {
                     delete attrs[key];
                 }
             }
 
             // Only sync if there are attributes to send to the back-end.
             attrs = this._pack_models(attrs);
             if (_.size(attrs) > 0) {
 
                 // If this message was sent via backbone itself, it will not
                 // have any callbacks.  It's important that we create callbacks
                 // so we can listen for status messages, etc...
                 var callbacks = options.callbacks || this.callbacks();
 
                 // Check throttle.
                 if (this.pending_msgs >= (this.get('msg_throttle') || 3)) {
                     // The throttle has been exceeded, buffer the current msg so
                     // it can be sent once the kernel has finished processing 
                     // some of the existing messages.
                     
                     // Combine updates if it is a 'patch' sync, otherwise replace updates
                     switch (method) {
                         case 'patch':
                             this.msg_buffer = $.extend(this.msg_buffer || {}, attrs);
                             break;
                         case 'update':
                         case 'create':
                             this.msg_buffer = attrs;
                             break;
                         default:
                             error();
                             return false;
                     }
                     this.msg_buffer_callbacks = callbacks;
 
                 } else {
                     // We haven't exceeded the throttle, send the message like 
                     // normal.
                     var data = {method: 'backbone', sync_data: attrs};
                     this.comm.send(data, callbacks);
                     this.pending_msgs++;
                 }
             }
             // Since the comm is a one-way communication, assume the message 
             // arrived.  Don't call success since we don't have a model back from the server
             // this means we miss out on the 'sync' event.
             this._buffered_state_diff = {};
         },
 
         save_changes: function(callbacks) {
             // Push this model's state to the back-end
             //
             // This invokes a Backbone.Sync.
             this.save(this._buffered_state_diff, {patch: true, callbacks: callbacks});
         },
 
         _pack_models: function(value) {
             // Replace models with model ids recursively.
             if (value instanceof Backbone.Model) {
                 return value.id;
 
             } else if ($.isArray(value)) {
                 var packed = [];
                 var that = this;
                 _.each(value, function(sub_value, key) {
                     packed.push(that._pack_models(sub_value));
                 });
                 return packed;
 
             } else if (value instanceof Object) {
                 var packed = {};
                 var that = this;
                 _.each(value, function(sub_value, key) {
                     packed[key] = that._pack_models(sub_value);
                 });
                 return packed;
 
             } else {
                 return value;
             }
         },
 
         _unpack_models: function(value) {
             // Replace model ids with models recursively.
             if ($.isArray(value)) {
                 var unpacked = [];
                 var that = this;
                 _.each(value, function(sub_value, key) {
                     unpacked.push(that._unpack_models(sub_value));
                 });
                 return unpacked;
 
             } else if (value instanceof Object) {
                 var unpacked = {};
                 var that = this;
                 _.each(value, function(sub_value, key) {
                     unpacked[key] = that._unpack_models(sub_value);
                 });
                 return unpacked;
 
             } else {
                 var model = this.widget_manager.get_model(value);
                 if (model) {
                     return model;
                 } else {
                     return value;
                 }
             }
         },
 
     });
     WidgetManager.register_widget_model('WidgetModel', WidgetModel);
 
 
     var WidgetView = Backbone.View.extend({
         initialize: function(parameters) {
             // Public constructor.
             this.model.on('change',this.update,this);
             this.options = parameters.options;
             this.child_views = [];
             this.model.views.push(this);
         },
 
         update: function(){
             // Triggered on model change.
             //
             // Update view to be consistent with this.model
         },
 
         create_child_view: function(child_model, options) {
             // Create and return a child view.
             //
             // -given a model and (optionally) a view name if the view name is 
             // not given, it defaults to the model's default view attribute.
         
             // TODO: this is hacky, and makes the view depend on this cell attribute and widget manager behavior
             // it would be great to have the widget manager add the cell metadata
             // to the subview without having to add it here.
             var child_view = this.model.widget_manager.create_view(child_model, options || {}, this);
             this.child_views[child_model.id] = child_view;
             return child_view;
         },
 
         delete_child_view: function(child_model, options) {
             // Delete a child view that was previously created using create_child_view.
             var view = this.child_views[child_model.id];
             if (view !== undefined) {
                 delete this.child_views[child_model.id];
                 view.remove();
                 child_model.views.pop(view);
             }
         },
 
         do_diff: function(old_list, new_list, removed_callback, added_callback) {
             // Difference a changed list and call remove and add callbacks for 
             // each removed and added item in the new list.
             //
             // Parameters
             // ----------
             // old_list : array
             // new_list : array
             // removed_callback : Callback(item)
             //      Callback that is called for each item removed.
             // added_callback : Callback(item)
             //      Callback that is called for each item added.
 
 
             // removed items
             _.each(_.difference(old_list, new_list), function(item, index, list) {
                 removed_callback(item);
             }, this);
 
             // added items
             _.each(_.difference(new_list, old_list), function(item, index, list) {
                 added_callback(item);
             }, this);
         },
 
         callbacks: function(){
             // Create msg callbacks for a comm msg.
             return this.model.callbacks(this);
         },
 
         render: function(){
             // Render the view.
             //
             // By default, this is only called the first time the view is created
         },
 
         send: function (content) {
             // Send a custom msg associated with this view.
             this.model.send(content, this.callbacks());
         },
 
         touch: function () {
             this.model.save_changes(this.callbacks());
         },
     });
 
 
     var DOMWidgetView = WidgetView.extend({
         initialize: function (options) {
             // Public constructor
 
             // In the future we may want to make changes more granular 
             // (e.g., trigger on visible:change).
             this.model.on('change', this.update, this);
             this.model.on('msg:custom', this.on_msg, this);
             DOMWidgetView.__super__.initialize.apply(this, arguments);
         },
         
         on_msg: function(msg) {
             // Handle DOM specific msgs.
             switch(msg.msg_type) {
                 case 'add_class':
                     this.add_class(msg.selector, msg.class_list);
                     break;
                 case 'remove_class':
                     this.remove_class(msg.selector, msg.class_list);
                     break;
             }
         },
 
         add_class: function (selector, class_list) {
             // Add a DOM class to an element.
             this._get_selector_element(selector).addClass(class_list);
         },
         
         remove_class: function (selector, class_list) {
             // Remove a DOM class from an element.
             this._get_selector_element(selector).removeClass(class_list);
         },
     
         update: function () {
             // 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.
             //      The very first update seems to happen before the element is 
             // finished rendering so we use setTimeout to give the element time 
             // to render
             var e = this.$el;
             var visible = this.model.get('visible');
             setTimeout(function() {e.toggle(visible);},0);
      
             var css = this.model.get('_css');
             if (css === undefined) {return;}
-            var that = this;
-            _.each(css, function(css_traits, selector){
+            for (var i = 0; i < css.length; i++) {
                 // Apply the css traits to all elements that match the selector.
-                var elements = that._get_selector_element(selector);
+                var selector = css[i][0];
+                var elements = this._get_selector_element(selector);
                 if (elements.length > 0) {
-                    _.each(css_traits, function(css_value, css_key){
-                        elements.css(css_key, css_value);
-                    });
+                    var trait_key = css[i][1];
+                    var trait_value = css[i][2];
+                    elements.css(trait_key ,trait_value);
                 }
-            });
+            }
         },
 
         _get_selector_element: function (selector) {
             // Get the elements via the css selector.
 
             // If the selector is blank, apply the style to the $el_to_style 
             // element.  If the $el_to_style element is not defined, use apply 
             // the style to the view's element.
             var elements;
             if (!selector) {
                 if (this.$el_to_style === undefined) {
                     elements = this.$el;
                 } else {
                     elements = this.$el_to_style;
                 }
             } else {
                 elements = this.$el.find(selector);
             }
             return elements;
         },
     });
 
     IPython.WidgetModel = WidgetModel;
     IPython.WidgetView = WidgetView;
     IPython.DOMWidgetView = DOMWidgetView;
 
     // Pass through WidgetManager namespace.
     return WidgetManager;
 });

IPython/html/widgets/widget.py

@@ -1,441 +1,440 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
 
 from IPython.core.getipython import get_ipython
 from IPython.kernel.comm import Comm
 from IPython.config import LoggingConfigurable
 from IPython.utils.traitlets import Unicode, Dict, Instance, Bool, List, Tuple, Int
 from IPython.utils.py3compat import string_types
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class CallbackDispatcher(LoggingConfigurable):
     """A structure for registering and running callbacks"""
     callbacks = List()
     
     def __call__(self, *args, **kwargs):
         """Call all of the registered callbacks."""
         value = None
         for callback in self.callbacks:
             try:
                 local_value = callback(*args, **kwargs)
             except Exception as e:
                 ip = get_ipython()
                 if ip is None:
                     self.log.warn("Exception in callback %s: %s", callback, e, exc_info=True)
                 else:
                     ip.showtraceback()
             else:
                 value = local_value if local_value is not None else value
         return value
 
     def register_callback(self, callback, remove=False):
         """(Un)Register a callback
 
         Parameters
         ----------
         callback: method handle
             Method to be registered or unregistered.
         remove=False: bool
             Whether to unregister the callback."""
         
         # (Un)Register the callback.
         if remove and callback in self.callbacks:
             self.callbacks.remove(callback)
         elif not remove and callback not in self.callbacks:
             self.callbacks.append(callback)
 
 def _show_traceback(method):
     """decorator for showing tracebacks in IPython"""
     def m(self, *args, **kwargs):
         try:
             return(method(self, *args, **kwargs))
         except Exception as e:
             ip = get_ipython()
             if ip is None:
                 self.log.warn("Exception in widget method %s: %s", method, e, exc_info=True)
             else:
                 ip.showtraceback()
     return m
 
 class Widget(LoggingConfigurable):
     #-------------------------------------------------------------------------
     # Class attributes
     #-------------------------------------------------------------------------
     _widget_construction_callback = None
     widgets = {}
 
     @staticmethod
     def on_widget_constructed(callback):
         """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
 
     @staticmethod
     def _call_widget_constructed(widget):
         """Static 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)
 
     #-------------------------------------------------------------------------
     # Traits
     #-------------------------------------------------------------------------
     _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)
     _comm = Instance('IPython.kernel.comm.Comm')
     
     msg_throttle = Int(3, sync=True, help="""Maximum number of msgs the 
         front-end can send before receiving an idle msg from the back-end.""")
     
     keys = List()
     def _keys_default(self):
         return [name for name in self.traits(sync=True)]
     
     _property_lock = Tuple((None, None))
     
     _display_callbacks = Instance(CallbackDispatcher, ())
     _msg_callbacks = Instance(CallbackDispatcher, ())
     
     #-------------------------------------------------------------------------
     # (Con/de)structor
     #-------------------------------------------------------------------------
     def __init__(self, **kwargs):
         """Public constructor"""
         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()
 
     #-------------------------------------------------------------------------
     # Properties
     #-------------------------------------------------------------------------
 
     @property
     def comm(self):
         """Gets the Comm associated with this widget.
 
         If a Comm doesn't exist yet, a Comm will be created automagically."""
         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):
         """Gets the model id of this widget.
 
         If a Comm doesn't exist yet, a Comm will be created automagically."""
         return self.comm.comm_id
 
     #-------------------------------------------------------------------------
     # Methods
     #-------------------------------------------------------------------------
     def _close(self):
         """Private close - cleanup objects, registry entries"""
         del Widget.widgets[self.model_id]
         self._comm = None
 
     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 self._comm is not None:
             self._comm.close()
             self._close()
 
     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 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", "content": content})
 
     def on_msg(self, callback, remove=False):
         """(Un)Register a custom msg receive callback.
 
         Parameters
         ----------
         callback: callable
             callback will be passed two arguments when a message arrives::
             
                 callback(widget, content)
             
         remove: bool
             True if the callback should be unregistered."""
         self._msg_callbacks.register_callback(callback, remove=remove)
 
     def on_displayed(self, callback, remove=False):
         """(Un)Register a widget displayed callback.
 
         Parameters
         ----------
         callback: method handler
             Must have a signature of::
             
                 callback(widget, **kwargs)
             
             kwargs from display are passed through without modification.
         remove: bool
             True if the callback should be unregistered."""
         self._display_callbacks.register_callback(callback, remove=remove)
 
     #-------------------------------------------------------------------------
     # Support methods
     #-------------------------------------------------------------------------
     @contextmanager
     def _lock_property(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]
     
     # Event handlers
     @_show_traceback
     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 'content' in data:
                 self._handle_custom_msg(data['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._lock_property(name, value):
                     setattr(self, name, value)
 
     def _handle_custom_msg(self, content):
         """Called when a custom msg is received."""
         self._msg_callbacks(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"""
         self._display_callbacks(self, **kwargs)
 
     def _pack_widgets(self, x):
         """Recursively converts all widget instances to model id strings.
 
         Children widgets will be stored and transmitted to the front-end by 
         their model ids.  Return value must be JSON-able."""
         if isinstance(x, dict):
             return {k: self._pack_widgets(v) for k, v in x.items()}
         elif isinstance(x, (list, tuple)):
             return [self._pack_widgets(v) for v in x]
         elif isinstance(x, Widget):
             return x.model_id
         else:
             return x # Value must be JSON-able
 
     def _unpack_widgets(self, x):
         """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(x, dict):
             return {k: self._unpack_widgets(v) for k, v in x.items()}
         elif isinstance(x, (list, tuple)):
             return [self._unpack_widgets(v) for v in x]
         elif isinstance(x, string_types):
             return x if x not in Widget.widgets else Widget.widgets[x]
         else:
             return x
 
     def _ipython_display_(self, **kwargs):
         """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 the widget is visible.", sync=True)
-    _css = Dict(sync=True) # Internal CSS property dict
+    _css = List(sync=True) # Internal CSS property list: (selector, key, value)
 
     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, dict_or_key, value=None, selector=''):
         """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, kwarg only)
             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).
         """
-        if not selector in self._css:
-            self._css[selector] = {}
-        my_css = self._css[selector]
-        
         if value is None:
             css_dict = dict_or_key
         else:
             css_dict = {dict_or_key: value}
         
         for (key, value) in css_dict.items():
-            if not (key in my_css and value == my_css[key]):
-                my_css[key] = value
+            # First remove the selector/key pair from the css list if it exists.
+            # Then add the selector/key pair and new value to the bottom of the 
+            # list.
+            self._css = [x for x in self._css if not (x[0]==selector and x[1]==key)]
+            self._css += [(selector, key, value)]
         self.send_state('_css')
 
     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, tuple)):
             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, tuple)):
             class_list = ' '.join(class_list)
 
         self.send({
             "msg_type"   : "remove_class",
             "class_list" : class_list,
             "selector"   : selector,
         })