Got containers and mutlicontainers working! Yay

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

@@ -1,379 +1,366 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(["notebook/js/widgetmanager",
         "underscore",
         "backbone"], 
 function(widget_manager, underscore, backbone){
     
     //--------------------------------------------------------------------
     // WidgetModel class
     //--------------------------------------------------------------------
     var WidgetModel = Backbone.Model.extend({
         constructor: function (widget_manager, model_id, comm) {
             // Construcctor
             //
             // 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.pending_msgs = 0;
             this.msg_throttle = 2;
             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) {
             if (this.comm !== undefined) {
                 var data = {method: 'custom', custom_content: content};
                 this.comm.send(data, callbacks);
             }
         },
 
         // Handle when a widget is closed.
         _handle_comm_closed: function (msg) {
             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.
             // TODO: Handle deletion, like this.destroy(), and delete views, etc.
         },
 
 
         // Handle incoming comm msg.
         _handle_comm_msg: function (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.custom_content);
                     break;
                 case 'display':
                     this.widget_manager.display_view(msg.parent_header.msg_id, this);
                     break;
             }
         },
 
 
         // Handle when a widget is updated via the python side.
         apply_update: function (state) {
             for (var key in state) {
                 if (state.hasOwnProperty(key)) {
                     var value = state[key];
                     this.key_value_lock = [key, value];
                     try {
                         this.set(key, this._unpack_models(value));
                     } finally {
                         this.key_value_lock = null;
                     }
                 }
             }
             //TODO: are there callbacks that make sense in this case?  If so, attach them here as an option
             this.save();
         },
 
 
         _handle_status: function (msg, callbacks) {
             //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.msg_throttle === 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;
                     }
                 }
             }
         },
 
 
         // Custom syncronization logic.
         _handle_sync: function (method, options) {
             var model_json = this.toJSON();
             var attr;
 
             // Only send updated state if the state hasn't been changed 
             // during an update.
             if (this.comm !== undefined) {    
                 if (this.pending_msgs >= this.msg_throttle) {
                     // 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.
                     if (this.msg_buffer === null) {
                         this.msg_buffer = $.extend({}, model_json); // Copy
                     }
                     for (attr in options.attrs) {
                         var value = this._pack_models(options.attrs[attr]);
                         if (this.key_value_lock === null || attr !== this.key_value_lock[0] || value !== this.key_value_lock[1]) {
                             this.msg_buffer[attr] = value;
                         }
                     }
 
                 } else {
                     // We haven't exceeded the throttle, send the message like 
                     // normal.  If this is a patch operation, just send the 
                     // changes.
                     var send_json = model_json;
                     send_json = {};
                     for (attr in options.attrs) {
                         var value = this._pack_models(options.attrs[attr]);
                         if (this.key_value_lock === null || attr !== this.key_value_lock[0] || value !== this.key_value_lock[1]) {
                             send_json[attr] = value;
                         }
                     }
                     
                     var is_empty = true;
                     for (var prop in send_json) if (send_json.hasOwnProperty(prop)) is_empty = false;
                     if (!is_empty) {
                         ++this.pending_msgs;
                         var data = {method: 'backbone', sync_data: send_json};
                         this.comm.send(data, options.callbacks);
                     }
                 }
             }
             
             // Since the comm is a one-way communication, assume the message 
             // arrived.
             return model_json;
         },
 
         _pack_models: function(value) {
             if (value instanceof Backbone.Model) {
                 return value.id;
             } else if (value instanceof Object) {
                 var packed = {};
                 for (var key in value) {
                     packed[key] = this._pack_models(value[key]);
                 }
                 return packed;
             } else {
                 return value;
             }
         },
 
         _unpack_models: function(value) {
             if (value instanceof Object) {
                 var unpacked = {};
                 for (var key in value) {
                     unpacked[key] = this._unpack_models(value[key]);
                 }
                 return unpacked;
             } else {
                 var model = this.widget_manager.get_model(value);
                 if (model !== null) {
                     return model;
                 } else {
                     return value;
                 }
             }
         },
 
     });
     widget_manager.register_widget_model('WidgetModel', WidgetModel);
 
 
     //--------------------------------------------------------------------
     // WidgetView class
     //--------------------------------------------------------------------
     var WidgetView = Backbone.View.extend({
         initialize: function(parameters) {
             this.model.on('change',this.update,this);
             this.options = parameters.options;
             this.child_views = [];
             this.model.views.push(this);
         },
 
         update: function(){
             // update view to be consistent with this.model
             // triggered on model change
         },
 
-        child_view: function(child_model, options) {
+        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
             var child_view = this.model.widget_manager.create_view(child_model, options);
             this.child_views[child_model.id] = child_view;
             return child_view;
         },
-        
-        update_child_views: function(old_list, new_list) {
-            // this function takes an old list and new list of models
-            // views in child_views that correspond to deleted ids are deleted
-            // views corresponding to added ids are added child_views
-        
-            // delete old views
-            _.each(_.difference(old_list, new_list), function(element, index, list) {
-                var view = this.child_views[element.id];
-                delete this.child_views[element.id];
-                view.remove();
-            }, this);
-            
-            // add new views
-            _.each(_.difference(new_list, old_list), function(element, index, list) {
-                // this function adds the view to the child_views dictionary
-                this.child_view(element);
-            }, this);
+
+        delete_child_view: function(child_model, options) {
+            var view = this.child_views[child_model.id];
+            delete this.child_views[child_model.id];
+            view.remove();
         },
 
         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(){
             return this.model.widget_manager.callbacks(this);
         },
 
         render: function(){
             // render the view.  By default, this is only called the first time the view is created
         },
         send: function (content) {
             this.model.send(content, this.callbacks());
         },
 
         touch: function () {
             this.model.save(this.model.changedAttributes(), {patch: true, callbacks: this.callbacks()});
         },
 
     });
 
     var DOMWidgetView = WidgetView.extend({
         initialize: function (options) {
             // TODO: 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) {
             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) {
             this._get_selector_element(selector).addClass(class_list);
         },
         
         remove_class: function (selector, class_list) {
             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;}
             for (var selector in css) {
                 if (css.hasOwnProperty(selector)) {
                     // Apply the css traits to all elements that match the selector.
                     var elements = this._get_selector_element(selector);
                     if (elements.length > 0) {
                         var css_traits = css[selector];    
                         for (var css_key in css_traits) {
                             if (css_traits.hasOwnProperty(css_key)) {
                                 elements.css(css_key, css_traits[css_key]);
                             }
                         }
                     }
                 }
             }
         },
 
         _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 === undefined || selector === null || 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;
 
     return widget_manager;
 });

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

@@ -1,252 +1,270 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.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // ContainerWidget
 //============================================================================
 
 /**
  * @module IPython
  * @namespace IPython
  **/
 
 define(["notebook/js/widgets/widget"], function(widget_manager) {
     var ContainerView = IPython.DOMWidgetView.extend({
         
         render: function(){
             this.$el
                 .addClass('widget-container');
             this.children={};
             this.update_children([], this.model.get('children'));
             this.model.on('change:children', function(model, value, options) {
                 this.update_children(model.previous('children'), value);
             }, this);
             this.update()
         },
         
         update_children: function(old_list, new_list) {
-            this.$el.empty();
-            this.update_child_views(old_list, new_list);
-            _.each(new_list, function(element, index, list) {
-                this.$el.append(this.child_views[element.id].$el);
-            }, this)
+            this.do_diff(old_list, 
+                new_list, 
+                $.proxy(this.remove_child_model, this),
+                $.proxy(this.add_child_model, this));
+        },
+
+        remove_child_model: function(model) {
+            this.child_views[model.id].remove();
+            this.delete_child_view(model);
+        },
+
+        add_child_model: function(model) {
+            var view = this.create_child_view(model);
+            this.$el.append(view.$el);
         },
         
         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.
             return ContainerView.__super__.update.apply(this);
         },
     });
 
     widget_manager.register_widget_view('ContainerView', ContainerView);
 
 
     var ModalView = IPython.DOMWidgetView.extend({
         
         render: function(){
             var that = this;
             this.children={};
             this.update_children([], this.model.get('children'));
             this.model.on('change:children', function(model, value, options) {
                 this.update_children(model.previous('children'), value);
             }, this);
             
             this.$el
                 .html('')
                 .on("remove", function(){
                     that.$window.remove();
                 });
             this.$window = $('<div />')
                 .addClass('modal widget-modal')
                 .appendTo($('#notebook-container'))
                 .mousedown(function(){
                     that.bring_to_front();
                 });
             this.$title_bar = $('<div />')
                 .addClass('popover-title')
                 .appendTo(this.$window)
                 .mousedown(function(){
                     that.bring_to_front();
                 });
             this.$close = $('<button />')
                 .addClass('close icon-remove')
                 .css('margin-left', '5px')
                 .appendTo(this.$title_bar)
                 .click(function(){
                     that.hide();
                     event.stopPropagation();
                 });
             this.$minimize = $('<button />')
                 .addClass('close icon-arrow-down')
                 .appendTo(this.$title_bar)
                 .click(function(){
                     that.popped_out = !that.popped_out;
                     if (!that.popped_out) {
                         that.$minimize
                             .removeClass('icon-arrow-down')
                             .addClass('icon-arrow-up');
                             
                         that.$window
                             .draggable('destroy')
                             .resizable('destroy')
                             .removeClass('widget-modal modal')
                             .addClass('docked-widget-modal')
                             .detach()
                             .insertBefore(that.$show_button);
                         that.$show_button.hide();
                         that.$close.hide();
                     } else {
                         that.$minimize
                             .addClass('icon-arrow-down')
                             .removeClass('icon-arrow-up');
 
                         that.$window
                             .removeClass('docked-widget-modal')
                             .addClass('widget-modal modal')
                             .detach()
                             .appendTo($('#notebook-container'))
                             .draggable({handle: '.popover-title', snap: '#notebook, .modal', snapMode: 'both'})
                             .resizable()
                             .children('.ui-resizable-handle').show();
                         that.show();
                         that.$show_button.show();
                         that.$close.show();
                     }
                     event.stopPropagation();
                 });
             this.$title = $('<div />')
                 .addClass('widget-modal-title')
                 .html('&nbsp;')
                 .appendTo(this.$title_bar);
             this.$body = $('<div />')
                 .addClass('modal-body')
                 .addClass('widget-modal-body')
                 .addClass('widget-container')
                 .appendTo(this.$window);
             
             this.$show_button = $('<button />')
                 .html('&nbsp;')
                 .addClass('btn btn-info widget-modal-show')
                 .appendTo(this.$el)
                 .click(function(){
                     that.show();
                 });
             
             this.$window.draggable({handle: '.popover-title', snap: '#notebook, .modal', snapMode: 'both'});
             this.$window.resizable();
             this.$window.on('resize', function(){
                 that.$body.outerHeight(that.$window.innerHeight() - that.$title_bar.outerHeight());
             });
 
             this.$el_to_style = this.$body;
             this._shown_once = false;
             this.popped_out = true;
         },
         
         hide: function() {
             this.$window.hide();
             this.$show_button.removeClass('btn-info');
         },
         
         show: function() {
             this.$show_button.addClass('btn-info');
 
             this.$window.show();
             if (this.popped_out) {
                 this.$window.css("positon", "absolute");
                 this.$window.css("top", "0px");
                 this.$window.css("left", Math.max(0, (($('body').outerWidth() - this.$window.outerWidth()) / 2) + 
                     $(window).scrollLeft()) + "px");
                 this.bring_to_front();
             }
         },
         
         bring_to_front: function() {
             var $widget_modals = $(".widget-modal");
             var max_zindex = 0;
             $widget_modals.each(function (index, el){
                 max_zindex = Math.max(max_zindex, parseInt($(el).css('z-index')));
             });
             
             // Start z-index of widget modals at 2000
             max_zindex = Math.max(max_zindex, 2000);
 
             $widget_modals.each(function (index, el){
                 $el = $(el);
                 if (max_zindex == parseInt($el.css('z-index'))) {
                     $el.css('z-index', max_zindex - 1);
                 }
             });
             this.$window.css('z-index', max_zindex);
         },
         
         update_children: function(old_list, new_list) {
-            this.$el.empty();
-            this.update_child_views(old_list, new_list);
-            _.each(new_list, function(element, index, list) {
-                this.$body.append(this.child_views[element].$el);
-            }, this)
+            this.do_diff(old_list, 
+                new_list, 
+                $.proxy(this.remove_child_model, this),
+                $.proxy(this.add_child_model, this));
+        },
+
+        remove_child_model: function(model) {
+            this.child_views[model.id].remove();
+            this.delete_child_view(model);
+        },
+
+        add_child_model: function(model) {
+            var view = this.create_child_view(model);
+            this.$body.append(view.$el);
         },
         
         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.
             var description = this.model.get('description');
             description = description.replace(/ /g, '&nbsp;', 'm');
             description = description.replace(/\n/g, '<br>\n', 'm');
             if (description.length === 0) {
                 this.$title.html('&nbsp;'); // Preserve title height
             } else {
                 this.$title.html(description);
             }
             
             var button_text = this.model.get('button_text');
             button_text = button_text.replace(/ /g, '&nbsp;', 'm');
             button_text = button_text.replace(/\n/g, '<br>\n', 'm');
             if (button_text.length === 0) {
                 this.$show_button.html('&nbsp;'); // Preserve button height
             } else {
                 this.$show_button.html(button_text);
             }
             
             if (!this._shown_once) {
                 this._shown_once = true;
                 this.show();
             }
             
             return ModalView.__super__.update.apply(this);
         },
         
         _get_selector_element: function(selector) {
 
             // Since the modal actually isn't within the $el in the DOM, we need to extend
             // the selector logic to allow the user to set css on the modal if need be.
             // The convention used is:
             // "modal" - select the modal div
             // "modal [selector]" - select element(s) within the modal div.
             // "[selector]" - select elements within $el
             // "" - select the $el_to_style
             if (selector.substring(0, 5) == 'modal') {
                 if (selector == 'modal') {
                     return this.$window;
                 } else {
                     return this.$window.find(selector.substring(6));
                 }
             } else {
                 return ModalView.__super__._get_selector_element.apply(this, [selector]);
             }
         },
         
     });
 
     widget_manager.register_widget_view('ModalView', ModalView);
 });

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

@@ -1,222 +1,248 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.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // SelectionContainerWidget
 //============================================================================
 
 /**
  * @module IPython
  * @namespace IPython
  **/
 
 define(["notebook/js/widgets/widget"], function(widget_manager){
     var AccordionView = IPython.DOMWidgetView.extend({
         
         render: function(){
             var guid = 'accordion' + IPython.utils.uuid();
             this.$el
                 .attr('id', guid)
                 .addClass('accordion');
             this.containers = [];
+            this.model_containers = {};
             this.update_children([], this.model.get('children'));
             this.model.on('change:children', function(model, value, options) {
                 this.update_children(model.previous('children'), value);
             }, this);
         },
         
-        update_children: function(old_list, new_list) {
-            _.each(this.containers, function(element, index, list) {
-                element.remove();
-            }, this);
-            this.containers = [];
-            this.update_child_views(old_list, new_list);
-            _.each(new_list, function(element, index, list) {
-                this.add_child_view(this.child_views[element]);
-            }, this)
-        },
-        
-
         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) {
                 // Set tab titles
                 var titles = this.model.get('_titles');
                 for (var page_index in titles) {
 
                     var accordian = this.containers[page_index];
                     if (accordian !== undefined) {
                         accordian
                             .find('.accordion-heading')
                             .find('.accordion-toggle')
                             .html(titles[page_index]);
                     }
                 }
 
                 // Set selected page
                 var selected_index = this.model.get("selected_index");
                 if (0 <= selected_index && selected_index < this.containers.length) {
                     for (var index in this.containers) {
                         if (index==selected_index) {
                             this.containers[index].find('.accordion-body').collapse('show');    
                         } else {
                             this.containers[index].find('.accordion-body').collapse('hide');    
                         }
                         
                     }
                 }
             }
             return AccordionView.__super__.update.apply(this);
         },
+        
+        update_children: function(old_list, new_list) {
+            this.do_diff(old_list, 
+                new_list, 
+                $.proxy(this.remove_child_model, this),
+                $.proxy(this.add_child_model, this));
+        },
 
-        add_child_view: function(view) {
+        remove_child_model: function(model) {
+            var accordion_group = this.model_containers[model.id];
+            this.containers.splice(accordion_group.container_index, 1);
+            delete this.model_containers[model.id];
+            accordion_group.remove();
+            this.delete_child_view(model);
+        },
 
+        add_child_model: function(model) {
+            var view = this.create_child_view(model);
             var index = this.containers.length;
             var uuid = IPython.utils.uuid();
             var accordion_group = $('<div />')
                 .addClass('accordion-group')
                 .appendTo(this.$el);
             var accordion_heading = $('<div />')
                 .addClass('accordion-heading')
                 .appendTo(accordion_group);
             var that = this;
             var accordion_toggle = $('<a />')
                 .addClass('accordion-toggle')
                 .attr('data-toggle', 'collapse')
                 .attr('data-parent', '#' + this.$el.attr('id'))
                 .attr('href', '#' + uuid)
                 .click(function(evt){ 
             
                     // Calling model.set will trigger all of the other views of the 
                     // model to update.
                     that.model.set("selected_index", index, {updated_view: this});
                     that.touch();
                  })
                 .html('Page ' + index)
                 .appendTo(accordion_heading);
             var accordion_body = $('<div />', {id: uuid})
                 .addClass('accordion-body collapse')
                 .appendTo(accordion_group);
             var accordion_inner = $('<div />')
                 .addClass('accordion-inner')
                 .appendTo(accordion_body);
-            this.containers.push(accordion_group);
+            var container_index = this.containers.push(accordion_group) - 1;
+            accordion_group.container_index = container_index;
+            this.model_containers[model.id] = accordion_group;
             accordion_inner.append(view.$el);
 
             this.update();
 
             // Stupid workaround to close the bootstrap accordion tabs which
             // open by default even though they don't have the `in` class
             // attached to them.  For some reason a delay is required.  
             // TODO: Better fix.
             setTimeout(function(){ that.update(); }, 500);
         },
     });
 
     widget_manager.register_widget_view('AccordionView', AccordionView);
     
     var TabView = IPython.DOMWidgetView.extend({
         
         initialize: function() {
             this.containers = [];
             TabView.__super__.initialize.apply(this, arguments);
         },
 
         render: function(){
             var uuid = 'tabs'+IPython.utils.uuid();
             var that = this;
             this.$tabs = $('<div />', {id: uuid})
                 .addClass('nav')
                 .addClass('nav-tabs')
                 .appendTo(this.$el);
             this.$tab_contents = $('<div />', {id: uuid + 'Content'})
                 .addClass('tab-content')
                 .appendTo(this.$el);
             this.containers = [];
             this.update_children([], this.model.get('children'));
             this.model.on('change:children', function(model, value, options) {
                 this.update_children(model.previous('children'), value);
             }, this);
         },
         
         update_children: function(old_list, new_list) {
             _.each(this.containers, function(element, index, list) {
                 element.remove();
             }, this);
             this.containers = [];
             this.update_child_views(old_list, new_list);
             _.each(new_list, function(element, index, list) {
                 this.add_child_view(this.child_views[element]);
             }, this)
         },
+        
+        update_children: function(old_list, new_list) {
+            this.do_diff(old_list, 
+                new_list, 
+                $.proxy(this.remove_child_model, this),
+                $.proxy(this.add_child_model, this));
+        },
 
-        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) {
-                // Set tab titles
-                var titles = this.model.get('_titles');
-                for (var page_index in titles) {
-                    var tab_text = this.containers[page_index];
-                    if (tab_text !== undefined) {
-                        tab_text.html(titles[page_index]);
-                    }
-                }
-
-                var selected_index = this.model.get('selected_index');
-                if (0 <= selected_index && selected_index < this.containers.length) {
-                    this.select_page(selected_index);
-                }
-            }
-            return TabView.__super__.update.apply(this);
+        remove_child_model: function(model) {
+            var view = this.child_views[model.id];
+            this.containers.splice(view.parent_tab.tab_text_index, 1);
+            view.parent_tab.remove();
+            view.parent_container.remove();
+            view.remove();
+            this.delete_child_view(model);
         },
 
-        add_child_view: function(view) {
+        add_child_model: function(model) {
+            var view = this.create_child_view(model);
             var index = this.containers.length;
             var uuid = IPython.utils.uuid();
 
             var that = this;
             var tab = $('<li />')
                 .css('list-style-type', 'none')
                 .appendTo(this.$tabs);
+            view.parent_tab = tab;
+
             var tab_text = $('<a />')
                 .attr('href', '#' + uuid)
                 .attr('data-toggle', 'tab') 
                 .html('Page ' + index)
                 .appendTo(tab)
                 .click(function (e) {
             
                     // Calling model.set will trigger all of the other views of the 
                     // model to update.
                     that.model.set("selected_index", index, {updated_view: this});
                     that.touch();
                     that.select_page(index);
                 });
-            this.containers.push(tab_text);
+            tab.tab_text_index = this.containers.push(tab_text) - 1;
 
             var contents_div = $('<div />', {id: uuid})
                 .addClass('tab-pane')
                 .addClass('fade')
                 .append(view.$el)
                 .appendTo(this.$tab_contents);
+            view.parent_container = contents_div;
+        },
+
+        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) {
+                // Set tab titles
+                var titles = this.model.get('_titles');
+                for (var page_index in titles) {
+                    var tab_text = this.containers[page_index];
+                    if (tab_text !== undefined) {
+                        tab_text.html(titles[page_index]);
+                    }
+                }
+
+                var selected_index = this.model.get('selected_index');
+                if (0 <= selected_index && selected_index < this.containers.length) {
+                    this.select_page(selected_index);
+                }
+            }
+            return TabView.__super__.update.apply(this);
         },
 
         select_page: function(index) {
             this.$tabs.find('li')
                 .removeClass('active');
             this.containers[index].tab('show');
         },
     });
 
     widget_manager.register_widget_view('TabView', TabView);
 });

IPython/html/widgets/widget_selectioncontainer.py

@@ -1,60 +1,60 b''
 """SelectionContainerWidget class.  
 
 Represents a multipage container that can be used to group other widgets into
 pages.
 """
 #-----------------------------------------------------------------------------
 # 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 .widget import DOMWidget
 from IPython.utils.traitlets import Unicode, Dict, Int, List, Instance
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class AccordionWidget(DOMWidget):
     view_name = Unicode('AccordionView', sync=True)
 
     # Keys
     _titles = Dict(help="Titles of the pages", sync=True)
     selected_index = Int(0, sync=True)
 
-    children = List(Instance(DOMWidget))
+    children = List(Instance(DOMWidget), sync=True)
 
     # Public methods
     def set_title(self, index, title):
         """Sets the title of a container page
 
         Parameters
         ----------
         index : int
             Index of the container page
         title : unicode
             New title"""
         self._titles[index] = title
         self.send_state('_titles')
 
 
     def get_title(self, index):
         """Gets the title of a container pages
 
         Parameters
         ----------
         index : int
             Index of the container page"""
         if index in self._titles:
             return self._titles[index]
         else:
             return None
 
 
 class TabWidget(AccordionWidget):
     view_name = Unicode('TabView', sync=True)