Proxy console.error calls

IPython/html/static/services/kernels/comm.js

@@ -1,189 +1,189 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
 ], function(IPython, $, utils) {
     "use strict";
 
     //-----------------------------------------------------------------------
     // CommManager class
     //-----------------------------------------------------------------------
     
     var CommManager = function (kernel) {
         this.comms = {};
         this.targets = {};
         if (kernel !== undefined) {
             this.init_kernel(kernel);
         }
     };
     
     CommManager.prototype.init_kernel = function (kernel) {
         // connect the kernel, and register message handlers
         this.kernel = kernel;
         var msg_types = ['comm_open', 'comm_msg', 'comm_close'];
         for (var i = 0; i < msg_types.length; i++) {
             var msg_type = msg_types[i];
             kernel.register_iopub_handler(msg_type, $.proxy(this[msg_type], this));
         }
     };
     
     CommManager.prototype.new_comm = function (target_name, data, callbacks, metadata) {
         // Create a new Comm, register it, and open its Kernel-side counterpart
         // Mimics the auto-registration in `Comm.__init__` in the IPython Comm
         var comm = new Comm(target_name);
         this.register_comm(comm);
         comm.open(data, callbacks, metadata);
         return comm;
     };
     
     CommManager.prototype.register_target = function (target_name, f) {
         // Register a target function for a given target name
         this.targets[target_name] = f;
     };
     
     CommManager.prototype.unregister_target = function (target_name, f) {
         // Unregister a target function for a given target name
         delete this.targets[target_name];
     };
     
     CommManager.prototype.register_comm = function (comm) {
         // Register a comm in the mapping
         this.comms[comm.comm_id] = comm;
         comm.kernel = this.kernel;
         return comm.comm_id;
     };
     
     CommManager.prototype.unregister_comm = function (comm) {
         // Remove a comm from the mapping
         delete this.comms[comm.comm_id];
     };
     
     // comm message handlers
     
     CommManager.prototype.comm_open = function (msg) {
         var content = msg.content;
         var that = this;
         
         utils.load_class(content.target_name, content.target_module, this.targets)
         .then(function(target) {
             var comm = new Comm(content.target_name, content.comm_id);
             that.register_comm(comm);
             try {
                 target(comm, msg);
             } catch (e) {
                 console.log("Exception opening new comm:", e, e.stack, msg);
                 comm.close();
                 that.unregister_comm(comm);
             }
-        }, console.error);
+        }, $.proxy(console.error, console));
     };
     
     CommManager.prototype.comm_close = function (msg) {
         var content = msg.content;
         var comm = this.comms[content.comm_id];
         if (comm === undefined) {
             return;
         }
         this.unregister_comm(comm);
         try {
             comm.handle_close(msg);
         } catch (e) {
             console.log("Exception closing comm: ", e, e.stack, msg);
         }
     };
     
     CommManager.prototype.comm_msg = function (msg) {
         var content = msg.content;
         var comm = this.comms[content.comm_id];
         if (comm === undefined) {
             return;
         }
         try {
             comm.handle_msg(msg);
         } catch (e) {
             console.log("Exception handling comm msg: ", e, e.stack, msg);
         }
     };
     
     //-----------------------------------------------------------------------
     // Comm base class
     //-----------------------------------------------------------------------
     
     var Comm = function (target_name, comm_id) {
         this.target_name = target_name;
         this.comm_id = comm_id || utils.uuid();
         this._msg_callback = this._close_callback = null;
     };
     
     // methods for sending messages
     Comm.prototype.open = function (data, callbacks, metadata) {
         var content = {
             comm_id : this.comm_id,
             target_name : this.target_name,
             data : data || {},
         };
         return this.kernel.send_shell_message("comm_open", content, callbacks, metadata);
     };
     
     Comm.prototype.send = function (data, callbacks, metadata, buffers) {
         var content = {
             comm_id : this.comm_id,
             data : data || {},
         };
         return this.kernel.send_shell_message("comm_msg", content, callbacks, metadata, buffers);
     };
     
     Comm.prototype.close = function (data, callbacks, metadata) {
         var content = {
             comm_id : this.comm_id,
             data : data || {},
         };
         return this.kernel.send_shell_message("comm_close", content, callbacks, metadata);
     };
     
     // methods for registering callbacks for incoming messages
     Comm.prototype._register_callback = function (key, callback) {
         this['_' + key + '_callback'] = callback;
     };
     
     Comm.prototype.on_msg = function (callback) {
         this._register_callback('msg', callback);
     };
     
     Comm.prototype.on_close = function (callback) {
         this._register_callback('close', callback);
     };
     
     // methods for handling incoming messages
     
     Comm.prototype._maybe_callback = function (key, msg) {
         var callback = this['_' + key + '_callback'];
         if (callback) {
             try {
                 callback(msg);
             } catch (e) {
                 console.log("Exception in Comm callback", e, e.stack, msg);
             }
         }
     };
     
     Comm.prototype.handle_msg = function (msg) {
         this._maybe_callback('msg', msg);
     };
     
     Comm.prototype.handle_close = function (msg) {
         this._maybe_callback('close', msg);
     };
     
     // For backwards compatability.
     IPython.CommManager = CommManager;
     IPython.Comm = Comm;
 
     return {
         'CommManager': CommManager,
         'Comm': Comm
     };
 });

IPython/html/static/widgets/js/manager.js

@@ -1,256 +1,256 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     "underscore",
     "backbone",
     "jquery",
     "base/js/utils",
     "base/js/namespace"
 ], function (_, Backbone, $, utils, IPython) {
     "use strict";
     //--------------------------------------------------------------------
     // WidgetManager class
     //--------------------------------------------------------------------
     var WidgetManager = function (comm_manager, notebook) {
         // Public constructor
         WidgetManager._managers.push(this);
 
         // Attach a comm manager to the 
         this.keyboard_manager = notebook.keyboard_manager;
         this.notebook = notebook;
         this.comm_manager = comm_manager;
         this._models = {}; /* Dictionary of model ids and model instances */
 
         // Register with the comm manager.
         this.comm_manager.register_target('ipython.widget', $.proxy(this._handle_comm_open, this));
     };
 
     //--------------------------------------------------------------------
     // Class level
     //--------------------------------------------------------------------
     WidgetManager._model_types = {}; /* Dictionary of model type names (target_name) and model types. */
     WidgetManager._view_types = {}; /* Dictionary of view names and view types. */
     WidgetManager._managers = []; /* List of widget managers */
 
     WidgetManager.register_widget_model = function (model_name, model_type) {
         // Registers a widget model by name.
         WidgetManager._model_types[model_name] = model_type;
     };
 
     WidgetManager.register_widget_view = function (view_name, view_type) {
         // Registers a widget view by name.
         WidgetManager._view_types[view_name] = view_type;
     };
 
     //--------------------------------------------------------------------
     // Instance level
     //--------------------------------------------------------------------
     WidgetManager.prototype.display_view = function(msg, model) {
         // Displays a view for a particular model.
         var cell = this.get_msg_cell(msg.parent_header.msg_id);
         if (cell === null) {
             console.log("Could not determine where the display" + 
                 " message was from.  Widget will not be displayed");
         } else {
             var dummy = null;
             if (cell.widget_subarea) {
                 dummy = $('<div />');
                 cell.widget_subarea.append(dummy);
             }
 
             var that = this;
             this.create_view(model, {cell: cell}).then(function(view) {
                 that._handle_display_view(view);
                 if (dummy) {
                     dummy.replaceWith(view.$el);
                 }
                 view.trigger('displayed');
-            }, console.error);
+            }, $.proxy(console.error, console));
         }
     };
 
     WidgetManager.prototype._handle_display_view = function (view) {
         // Have the IPython keyboard manager disable its event
         // handling so the widget can capture keyboard input.
         // Note, this is only done on the outer most widgets.
         if (this.keyboard_manager) {
             this.keyboard_manager.register_events(view.$el);
         
             if (view.additional_elements) {
                 for (var i = 0; i < view.additional_elements.length; i++) {
                         this.keyboard_manager.register_events(view.additional_elements[i]);
                 }
             } 
         }
     };
     
 
     WidgetManager.prototype.create_view = function(model, options) {
         // Creates a view for a particular model.
         return new Promise(function(resolve, reject) {
             var view_name = model.get('_view_name');
             var view_module = model.get('_view_module');
             utils.try_load(view_name, view_module, WidgetManager._view_types).then(function(ViewType){
 
                 // If a view is passed into the method, use that view's cell as
                 // the cell for the view that is created.
                 options = options || {};
                 if (options.parent !== undefined) {
                     options.cell = options.parent.options.cell;
                 }
 
                 // Create and render the view...
                 var parameters = {model: model, options: options};
                 var view = new ViewType(parameters);
                 view.render();
                 model.on('destroy', view.remove, view);
                 resolve(view);
             }, reject);
         });
     };
 
     WidgetManager.prototype.get_msg_cell = function (msg_id) {
         var cell = null;
         // First, check to see if the msg was triggered by cell execution.
         if (this.notebook) {
             cell = this.notebook.get_msg_cell(msg_id);
         }
         if (cell !== null) {
             return cell;
         }
         // Second, check to see if a get_cell callback was defined
         // for the message.  get_cell callbacks are registered for
         // widget messages, so this block is actually checking to see if the
         // message was triggered by a widget.
         var kernel = this.comm_manager.kernel;
         if (kernel) {
             var callbacks = kernel.get_callbacks_for_msg(msg_id);
             if (callbacks && callbacks.iopub &&
                 callbacks.iopub.get_cell !== undefined) {
                 return callbacks.iopub.get_cell();
             }
         }
         
         // Not triggered by a cell or widget (no get_cell callback 
         // exists).
         return null;
     };
 
     WidgetManager.prototype.callbacks = function (view) {
         // callback handlers specific a view
         var callbacks = {};
         if (view && view.options.cell) {
 
             // Try to get output handlers
             var cell = view.options.cell;
             var handle_output = null;
             var handle_clear_output = null;
             if (cell.output_area) {
                 handle_output = $.proxy(cell.output_area.handle_output, cell.output_area);
                 handle_clear_output = $.proxy(cell.output_area.handle_clear_output, cell.output_area);
             }
 
             // Create callback dictionary using what is known
             var that = this;
             callbacks = {
                 iopub : {
                     output : handle_output,
                     clear_output : handle_clear_output,
 
                     // Special function only registered by widget messages.
                     // Allows us to get the cell for a message so we know
                     // where to add widgets if the code requires it.
                     get_cell : function () {
                         return cell;
                     },
                 },
             };
         }
         return callbacks;
     };
 
     WidgetManager.prototype.get_model = function (model_id) {
         // Look-up a model instance by its id.
         var that = this;
         var model = that._models[model_id];
         if (model !== undefined) {
             return new Promise(function(resolve, reject){
                 if (model instanceof Promise) {
                     model.then(resolve, reject);
                 } else {
                     resolve(model);
                 }
             });
         } else {
             return undefined;
         }
     };
 
     WidgetManager.prototype._handle_comm_open = function (comm, msg) {
         // Handle when a comm is opened.
         this.create_model({
             model_name: msg.content.data.model_name, 
             model_module: msg.content.data.model_module, 
             comm: comm});
     };
 
     WidgetManager.prototype.create_model = function (options) {
         // Create and return a promise to create a new widget model.
         //
         // Minimally, one must provide the model_name and widget_class
         // parameters to create a model from Javascript.
         //
         // Example
         // --------
         // JS:
         // IPython.notebook.kernel.widget_manager.create_model({
         //      model_name: 'WidgetModel', 
         //      widget_class: 'IPython.html.widgets.widget_int.IntSlider'})
         //      .then(function(model) { console.log('Create success!', model); },
-        //      console.error);
+        //      $.proxy(console.error, console));
         //
         // Parameters
         // ----------
         // options: dictionary
         //  Dictionary of options with the following contents:
         //      model_name: string
         //          Target name of the widget model to create.
         //      model_module: (optional) string
         //          Module name of the widget model to create.
         //      widget_class: (optional) string
         //          Target name of the widget in the back-end.
         //      comm: (optional) Comm
         
         // Create a comm if it wasn't provided.
         var comm = options.comm;
         if (!comm) {
             comm = this.comm_manager.new_comm('ipython.widget', {'widget_class': options.widget_class});
         }
 
         var that = this;
         var model_id = comm.comm_id;
         var promise = new Promise(function(resolve, reject) {
 
             // Get the model type using require or through the registry.
             var widget_type_name = options.model_name;
             var widget_module = options.model_module;
             utils.try_load(widget_type_name, widget_module, WidgetManager._model_types)
                 .then(function(ModelType) {
                     var widget_model = new ModelType(that, model_id, comm);
                     widget_model.on('comm:close', function () {
                       delete that._models[model_id];
                     });
                     that._models[model_id] = widget_model;
                     resolve(widget_model);
                 }, reject);
         });
         this._models[model_id] = promise;
         return promise;
     };
 
     // Backwards compatibility.
     IPython.WidgetManager = WidgetManager;
 
     return {'WidgetManager': WidgetManager};
 });

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

@@ -1,645 +1,645 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define(["widgets/js/manager",
         "underscore",
         "backbone", 
         "jquery",   
         "base/js/namespace",
 ], function(widgetmanager, _, Backbone, $, IPython){
 
     var WidgetModel = Backbone.Model.extend({
         constructor: function (widget_manager, model_id, comm, init_state_callback) {
             // Constructor
             //
             // Creates a WidgetModel instance.
             //
             // Parameters
             // ----------
             // widget_manager : WidgetManager instance
             // model_id : string
             //      An ID unique to this model.
             // comm : Comm instance (optional)
             // init_state_callback : callback (optional)
             //      Called once when the first state message is recieved from 
             //      the back-end.
             this.widget_manager = widget_manager;
             this.init_state_callback = init_state_callback;
             this._buffered_state_diff = {};
             this.pending_msgs = 0;
             this.msg_buffer = null;
             this.state_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');
             this.stopListening();
             this.trigger('destroy', this);
             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.
             for (var id in this.views) {
                 if (this.views.hasOwnProperty(id)) {
                     this.views[id].remove();
                 }
             }
         },
 
         _handle_comm_msg: function (msg) {
             // Handle incoming comm msg.
             var method = msg.content.data.method;
             switch (method) {
                 case 'update':
                     this.set_state(msg.content.data.state);
                     if (this.init_state_callback) {
                         this.init_state_callback.apply(this, [this]);
                         delete this.init_state_callback;
                     }
                     break;
                 case 'custom':
                     this.trigger('msg:custom', msg.content.data.content);
                     break;
                 case 'display':
                     this.widget_manager.display_view(msg, this);
                     break;
             }
         },
 
         set_state: function (state) {
             // Handle when a widget is updated via the python side.
             this.state_lock = state;
             try {
                 var state_keys = [];
                 var state_values = [];
                 for (var state_key in Object.keys(state)) {
                     if (state.hasOwnProperty(state_key)) {
                         state_keys.push(state_key);
                         state_values.push(this._unpack_models(state[state_key]));
                     }
                 }
 
                 Promise.all(state_values).then(function(promise_values){
                     var unpacked_state = {};
                     for (var i = 0; i < state_keys.length; i++) {
                         unpacked_state[state_keys[i]] = promise_values[i];
                     }
                     WidgetModel.__super__.set.apply(this, [unpacked_state]);
-                }, console.error);
+                }, $.proxy(console.error, console));
             } finally {
                this.state_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.state_lock !== null) {
                 var keys = Object.keys(this.state_lock);
                 for (var i=0; i<keys.length; i++) {
                     var key = keys[i];
                     if (attrs[key] === this.state_lock[key]) {
                         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.
             var that = this;
             var packed;
             if (value instanceof Backbone.Model) {
                 return "IPY_MODEL_" + value.id;
 
             } else if ($.isArray(value)) {
                 packed = [];
                 _.each(value, function(sub_value, key) {
                     packed.push(that._pack_models(sub_value));
                 });
                 return packed;
             } else if (value instanceof Date || value instanceof String) {
                 return value;
             } else if (value instanceof Object) {
                 packed = {};
                 _.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.
             var that = this;
             var unpacked;
             return new Promise(function(resolve, reject) {
 
                 if ($.isArray(value)) {
                     unpacked = [];
                     _.each(value, function(sub_value, key) {
                         unpacked.push(that._unpack_models(sub_value));
                     });
                     Promise.all(unpacked).then(resolve, reject);
 
                 } else if (value instanceof Object) {
                     unpacked_values = [];
                     unpacked_keys = [];
                     _.each(value, function(sub_value, key) {
                         unpacked_keys.push(key);
                         unpacked_values.push(that._unpack_models(sub_value));
                     });
 
                     Promise.all(unpacked_values).then(function(promise_values) {
                         unpacked = {};
                         for (var i = 0; i < unpacked_keys.length; i++) {
                             unpacked[unpacked_keys[i]] = promise_values[i];
                         }
                         resolve(unpacked);
                     }, reject);    
 
                 } else if (typeof value === 'string' && value.slice(0,10) === "IPY_MODEL_") {
                     var model = this.widget_manager.get_model(value.slice(10, value.length));
                     if (model) {
                         model.then(resolve, reject);
                     } else {
                         resolve(value);
                     }    
                 } else {
                     resolve(value);
                 }  
             });
         },
 
         on_some_change: function(keys, callback, context) {
             // on_some_change(["key1", "key2"], foo, context) differs from
             // on("change:key1 change:key2", foo, context).
             // If the widget attributes key1 and key2 are both modified, 
             // the second form will result in foo being called twice
             // while the first will call foo only once.
             this.on('change', function() {
                 if (keys.some(this.hasChanged, this)) {
                     callback.apply(context);
                 }
             }, this);
 
        },
     });
     widgetmanager.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_model_views = {};
             this.child_views = {};
             this.id = this.id || IPython.utils.uuid();
             this.model.views[this.id] = this;
             this.on('displayed', function() { 
                 this.is_displayed = true; 
             }, 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.
             var that = this;
             return new Promise(function(resolve, reject) {
                 // 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.
                 options = $.extend({ parent: this }, options || {});
                 
                 this.model.widget_manager.create_view(child_model, options).then(function(child_view) {
                     // Associate the view id with the model id.
                     if (that.child_model_views[child_model.id] === undefined) {
                         that.child_model_views[child_model.id] = [];
                     }
                     that.child_model_views[child_model.id].push(child_view.id);
 
                     // Remember the view by id.
                     that.child_views[child_view.id] = child_view;
                     resolve(child_view);
                  }, reject);
             });
         },
 
         pop_child_view: function(child_model) {
             // Delete a child view that was previously created using create_child_view.
             var view_ids = this.child_model_views[child_model.id];
             if (view_ids !== undefined) {
 
                 // Only delete the first view in the list.
                 var view_id = view_ids[0];
                 var view = this.child_views[view_id];
                 delete this.child_views[view_id];
                 view_ids.splice(0,1);
                 delete child_model.views[view_id];
             
                 // Remove the view list specific to this model if it is empty.
                 if (view_ids.length === 0) {
                     delete this.child_model_views[child_model.id];
                 }
                 return view;
             }
             return null;
         },
 
         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.
 
             // Walk the lists until an unequal entry is found.
             var i;
             for (i = 0; i < new_list.length; i++) {
                 if (i >= old_list.length || new_list[i] !== old_list[i]) {
                     break;
                 }
             }
 
             // Remove the non-matching items from the old list.
             for (var j = i; j < old_list.length; j++) {
                 removed_callback(old_list[j]);
             }
 
             // Add the rest of the new list items.
             for (; i < new_list.length; i++) {
                 added_callback(new_list[i]);
             }
         },
 
         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
         },
 
         show: function(){
             // Show the widget-area
             if (this.options && this.options.cell &&
                 this.options.cell.widget_area !== undefined) {
                 this.options.cell.widget_area.show();
             }
         },
 
         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());
         },
 
         after_displayed: function (callback, context) {
             // Calls the callback right away is the view is already displayed
             // otherwise, register the callback to the 'displayed' event.
             if (this.is_displayed) {
                 callback.apply(context);
             } else {
                 this.on('displayed', callback, context);
             }
         },
     });
 
 
     var DOMWidgetView = WidgetView.extend({
         initialize: function (parameters) {
             // Public constructor
             DOMWidgetView.__super__.initialize.apply(this, [parameters]);
             this.on('displayed', this.show, this);
             this.model.on('change:visible', this.update_visible, this);
             this.model.on('change:_css', this.update_css, this);
 
             this.model.on('change:_dom_classes', function(model, new_classes) {
                 var old_classes = model.previous('_dom_classes');
                 this.update_classes(old_classes, new_classes);
             }, this);
 
             this.model.on('change:color', function (model, value) { 
                 this.update_attr('color', value); }, this);
 
             this.model.on('change:background_color', function (model, value) { 
                 this.update_attr('background', value); }, this);
 
             this.model.on('change:width', function (model, value) { 
                 this.update_attr('width', value); }, this);
 
             this.model.on('change:height', function (model, value) { 
                 this.update_attr('height', value); }, this);
 
             this.model.on('change:border_color', function (model, value) { 
                 this.update_attr('border-color', value); }, this);
 
             this.model.on('change:border_width', function (model, value) { 
                 this.update_attr('border-width', value); }, this);
 
             this.model.on('change:border_style', function (model, value) { 
                 this.update_attr('border-style', value); }, this);
 
             this.model.on('change:font_style', function (model, value) { 
                 this.update_attr('font-style', value); }, this);
 
             this.model.on('change:font_weight', function (model, value) { 
                 this.update_attr('font-weight', value); }, this);
 
             this.model.on('change:font_size', function (model, value) { 
                 this.update_attr('font-size', this._default_px(value)); }, this);
 
             this.model.on('change:font_family', function (model, value) { 
                 this.update_attr('font-family', value); }, this);
 
             this.model.on('change:padding', function (model, value) { 
                 this.update_attr('padding', value); }, this);
 
             this.model.on('change:margin', function (model, value) { 
                 this.update_attr('margin', this._default_px(value)); }, this);
 
             this.model.on('change:border_radius', function (model, value) { 
                 this.update_attr('border-radius', this._default_px(value)); }, this);
 
             this.after_displayed(function() {
                 this.update_visible(this.model, this.model.get("visible"));
                 this.update_classes([], this.model.get('_dom_classes'));
                 
                 this.update_attr('color', this.model.get('color'));
                 this.update_attr('background', this.model.get('background_color'));
                 this.update_attr('width', this.model.get('width'));
                 this.update_attr('height', this.model.get('height'));
                 this.update_attr('border-color', this.model.get('border_color'));
                 this.update_attr('border-width', this.model.get('border_width'));
                 this.update_attr('border-style', this.model.get('border_style'));
                 this.update_attr('font-style', this.model.get('font_style'));
                 this.update_attr('font-weight', this.model.get('font_weight'));
                 this.update_attr('font-size', this.model.get('font_size'));
                 this.update_attr('font-family', this.model.get('font_family'));
                 this.update_attr('padding', this.model.get('padding'));
                 this.update_attr('margin', this.model.get('margin'));
                 this.update_attr('border-radius', this.model.get('border_radius'));
 
                 this.update_css(this.model, this.model.get("_css"));
             }, this);
         },
 
         _default_px: function(value) {
             // Makes browser interpret a numerical string as a pixel value.
             if (/^\d+\.?(\d+)?$/.test(value.trim())) {
                 return value.trim() + 'px';
             }
             return value;
         },
 
         update_attr: function(name, value) {
             // Set a css attr of the widget view.
             this.$el.css(name, value);
         },
 
         update_visible: function(model, value) {
             // Update visibility
             this.$el.toggle(value);
          },
 
         update_css: function (model, css) {
             // Update the css styling of this view.
             var e = this.$el;
             if (css === undefined) {return;}
             for (var i = 0; i < css.length; i++) {
                 // Apply the css traits to all elements that match the selector.
                 var selector = css[i][0];
                 var elements = this._get_selector_element(selector);
                 if (elements.length > 0) {
                     var trait_key = css[i][1];
                     var trait_value = css[i][2];
                     elements.css(trait_key ,trait_value);
                 }
             }
         },
 
         update_classes: function (old_classes, new_classes, $el) {
             // Update the DOM classes applied to an element, default to this.$el.
             if ($el===undefined) {
                 $el = this.$el;
             }
             this.do_diff(old_classes, new_classes, function(removed) {
                 $el.removeClass(removed);
             }, function(added) {
                 $el.addClass(added);
             });
         },
 
         update_mapped_classes: function(class_map, trait_name, previous_trait_value, $el) {
             // Update the DOM classes applied to the widget based on a single
             // trait's value.
             //
             // Given a trait value classes map, this function automatically
             // handles applying the appropriate classes to the widget element
             // and removing classes that are no longer valid.
             //
             // Parameters
             // ----------
             // class_map: dictionary
             //  Dictionary of trait values to class lists.
             //  Example:
             //      {
             //          success: ['alert', 'alert-success'],
             //          info: ['alert', 'alert-info'],
             //          warning: ['alert', 'alert-warning'],
             //          danger: ['alert', 'alert-danger']
             //      };
             // trait_name: string
             //  Name of the trait to check the value of.
             // previous_trait_value: optional string, default ''
             //  Last trait value
             // $el: optional jQuery element handle, defaults to this.$el
             //  Element that the classes are applied to.
             var key = previous_trait_value;
             if (key === undefined) {
                 key = this.model.previous(trait_name);
             }
             var old_classes = class_map[key] ? class_map[key] : [];
             key = this.model.get(trait_name);
             var new_classes = class_map[key] ? class_map[key] : [];
 
             this.update_classes(old_classes, new_classes, $el || this.$el);
         },
         
         _get_selector_element: function (selector) {
             // Get the elements via the css selector.
             var elements;
             if (!selector) {
                 elements = this.$el;
             } else {
                 elements = this.$el.find(selector).addBack(selector);
             }
             return elements;
         },
     });
 
     
     var widget = {
         'WidgetModel': WidgetModel,
         'WidgetView': WidgetView,
         'DOMWidgetView': DOMWidgetView,
     };
 
     // For backwards compatability.
     $.extend(IPython, widget);
 
     return widget;
 });

IPython/html/static/widgets/js/widget_box.js

@@ -1,348 +1,348 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     "widgets/js/widget",
     "jqueryui",
     "bootstrap",
 ], function(widget, $){
 
     var BoxView = widget.DOMWidgetView.extend({
         initialize: function(){
             // Public constructor
             BoxView.__super__.initialize.apply(this, arguments);
             this.model.on('change:children', function(model, value) {
                 this.update_children(model.previous('children'), value);
             }, this);
             this.model.on('change:overflow_x', function(model, value) {
                 this.update_overflow_x();
             }, this);
             this.model.on('change:overflow_y', function(model, value) {
                 this.update_overflow_y();
             }, this);
             this.model.on('change:box_style', function(model, value) {
                 this.update_box_style();
             }, this);
         },
 
         update_attr: function(name, value) {
             // Set a css attr of the widget view.
             this.$box.css(name, value);
         },
 
         render: function(){
             // Called when view is rendered.
             this.$box = this.$el;
             this.$box.addClass('widget-box');
             this.update_children([], this.model.get('children'));
             this.update_overflow_x();
             this.update_overflow_y();
             this.update_box_style('');
         },
 
         update_overflow_x: function() {
             // Called when the x-axis overflow setting is changed.
             this.$box.css('overflow-x', this.model.get('overflow_x'));
         },
 
         update_overflow_y: function() {
             // Called when the y-axis overflow setting is changed.
             this.$box.css('overflow-y', this.model.get('overflow_y'));
         },
 
         update_box_style: function(previous_trait_value) {
             var class_map = {
                 success: ['alert', 'alert-success'],
                 info: ['alert', 'alert-info'],
                 warning: ['alert', 'alert-warning'],
                 danger: ['alert', 'alert-danger']
             };
             this.update_mapped_classes(class_map, 'box_style', previous_trait_value, this.$box);
         },
         
         update_children: function(old_list, new_list) {
             // Called when the children list changes.
             this.do_diff(old_list, new_list, 
                 $.proxy(this.remove_child_model, this),
                 $.proxy(this.add_child_model, this));
         },
 
         remove_child_model: function(model) {
             // Called when a model is removed from the children list.
             this.pop_child_view(model).remove();
         },
 
         add_child_model: function(model) {
             // Called when a model is added to the children list.
             var that = this;
             var dummy = $('<div/>');
             that.$box.append(dummy);
             this.create_child_view(model).then(function(view) {
                 dummy.replaceWith(view.$el);
 
                 // Trigger the displayed event of the child view.
                 that.after_displayed(function() {
                     view.trigger('displayed');
                 });
-            }, console.error);
+            }, $.proxy(console.error, console));
         },
     });
 
 
     var FlexBoxView = BoxView.extend({
         render: function(){
             FlexBoxView.__super__.render.apply(this);
             this.model.on('change:orientation', this.update_orientation, this);
             this.model.on('change:flex', this._flex_changed, this);
             this.model.on('change:pack', this._pack_changed, this);
             this.model.on('change:align', this._align_changed, this);
             this._flex_changed();
             this._pack_changed();
             this._align_changed();
             this.update_orientation();
         },
 
         update_orientation: function(){
             var orientation = this.model.get("orientation");
             if (orientation == "vertical") {
                 this.$box.removeClass("hbox").addClass("vbox");
             } else {
                 this.$box.removeClass("vbox").addClass("hbox");
             }
         },
 
         _flex_changed: function(){
             if (this.model.previous('flex')) {
                 this.$box.removeClass('box-flex' + this.model.previous('flex'));
             }
             this.$box.addClass('box-flex' + this.model.get('flex'));
         },
 
         _pack_changed: function(){
             if (this.model.previous('pack')) {
                 this.$box.removeClass(this.model.previous('pack'));
             }
             this.$box.addClass(this.model.get('pack'));
         },
 
         _align_changed: function(){
             if (this.model.previous('align')) {
                 this.$box.removeClass('align-' + this.model.previous('align'));
             }
             this.$box.addClass('align-' + this.model.get('align'));
         },
     });
 
     var PopupView = BoxView.extend({
 
         render: function(){
             // Called when view is rendered.
             var that = this;
             
             this.$el.on("remove", function(){
                     that.$backdrop.remove();
                 });
             this.$backdrop = $('<div />')
                 .appendTo($('#notebook-container'))
                 .addClass('modal-dialog')
                 .css('position', 'absolute')
                 .css('left', '0px')
                 .css('top', '0px');
             this.$window = $('<div />')
                 .appendTo(this.$backdrop)
                 .addClass('modal-content widget-modal')
                 .mousedown(function(){
                     that.bring_to_front();
                 });
 
             // Set the elements array since the this.$window element is not child
             // of this.$el and the parent widget manager or other widgets may
             // need to know about all of the top-level widgets.  The IPython
             // widget manager uses this to register the elements with the
             // keyboard manager.
             this.additional_elements = [this.$window];
 
             this.$title_bar = $('<div />')
                 .addClass('popover-title')
                 .appendTo(this.$window)
                 .mousedown(function(){
                     that.bring_to_front();
                 });
             this.$close = $('<button />')
                 .addClass('close fa fa-remove')
                 .css('margin-left', '5px')
                 .appendTo(this.$title_bar)
                 .click(function(){
                     that.hide();
                     event.stopPropagation();
                 });
             this.$minimize = $('<button />')
                 .addClass('close fa fa-arrow-down')
                 .appendTo(this.$title_bar)
                 .click(function(){
                     that.popped_out = !that.popped_out;
                     if (!that.popped_out) {
                         that.$minimize
                             .removeClass('fa-arrow-down')
                             .addClass('fa-arrow-up');
                             
                         that.$window
                             .draggable('destroy')
                             .resizable('destroy')
                             .removeClass('widget-modal modal-content')
                             .addClass('docked-widget-modal')
                             .detach()
                             .insertBefore(that.$show_button);
                         that.$show_button.hide();
                         that.$close.hide();
                     } else {
                         that.$minimize
                             .addClass('fa-arrow-down')
                             .removeClass('fa-arrow-up');
 
                         that.$window
                             .removeClass('docked-widget-modal')
                             .addClass('widget-modal modal-content')
                             .detach()
                             .appendTo(that.$backdrop)
                             .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.$box = $('<div />')
                 .addClass('modal-body')
                 .addClass('widget-modal-body')
                 .addClass('widget-box')
                 .addClass('vbox')
                 .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.$box.outerHeight(that.$window.innerHeight() - that.$title_bar.outerHeight());
             });
 
             this._shown_once = false;
             this.popped_out = true;
 
             this.update_children([], this.model.get('children'));
             this.model.on('change:children', function(model, value) {
                 this.update_children(model.previous('children'), value);
             }, this);
         },
         
         hide: function() {
             // Called when the modal hide button is clicked.
             this.$window.hide();
             this.$show_button.removeClass('btn-info');
         },
         
         show: function() {
             // Called when the modal show button is clicked.
             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() {
             // Make the modal top-most, z-ordered about the other modals.
             var $widget_modals = $(".widget-modal");
             var max_zindex = 0;
             $widget_modals.each(function (index, el){
                 var zindex = parseInt($(el).css('z-index'));
                 if (!isNaN(zindex)) {
                     max_zindex = Math.max(max_zindex, zindex);
                 }
             });
             
             // 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: 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');
             if (description.trim().length === 0) {
                 this.$title.html("&nbsp;"); // Preserve title height
             } else {
                 this.$title.text(description);
                 MathJax.Hub.Queue(["Typeset",MathJax.Hub,this.$title.get(0)]);
             }
             
             var button_text = this.model.get('button_text');
             if (button_text.trim().length === 0) {
                 this.$show_button.html("&nbsp;"); // Preserve button height
             } else {
                 this.$show_button.text(button_text);
             }
             
             if (!this._shown_once) {
                 this._shown_once = true;
                 this.show();
             }
             
             return PopupView.__super__.update.apply(this);
         },
         
         _get_selector_element: function(selector) {
             // Get an element view a 'special' jquery selector.  (see widget.js)
             //
             // 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
             if (selector.substring(0, 5) == 'modal') {
                 if (selector == 'modal') {
                     return this.$window;
                 } else {
                     return this.$window.find(selector.substring(6));
                 }
             } else {
                 return PopupView.__super__._get_selector_element.apply(this, [selector]);
             }
         },
     });
 
     return {
         'BoxView': BoxView,
         'PopupView': PopupView,
         'FlexBoxView': FlexBoxView,
     };
 });

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

@@ -1,261 +1,261 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     "widgets/js/widget",
     "base/js/utils",
     "jquery",
     "bootstrap",
 ], function(widget, utils, $){
 
     var AccordionView = widget.DOMWidgetView.extend({
         render: function(){
             // Called when view is rendered.
             var guid = 'panel-group' + utils.uuid();
             this.$el
                 .attr('id', guid)
                 .addClass('panel-group');
             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);
             this.model.on('change:selected_index', function(model, value, options) {
                 this.update_selected_index(model.previous('selected_index'), value, options);
             }, this);
             this.model.on('change:_titles', function(model, value, options) {
                 this.update_titles(value);
             }, this);
             var that = this;
             this.on('displayed', function() {
                 this.update_titles();
             }, this);
         },
 
         update_titles: function(titles) {
             // Set tab titles
             if (!titles) {
                 titles = this.model.get('_titles');
             }
 
             var that = this;
             _.each(titles, function(title, page_index) {
                 var accordian = that.containers[page_index];
                 if (accordian !== undefined) {
                     accordian
                         .find('.panel-heading')
                         .find('.accordion-toggle')
                         .text(title);
                 }
             });
         },
 
         update_selected_index: function(old_index, new_index, options) {
             // Only update the selection if the selection wasn't triggered
             // by the front-end.  It must be triggered by the back-end.
             if (options === undefined || options.updated_view != this) {
                 this.containers[old_index].find('.panel-collapse').collapse('hide');
                 if (0 <= new_index && new_index < this.containers.length) {
                     this.containers[new_index].find('.panel-collapse').collapse('show');
                 }
             }
         },
         
         update_children: function(old_list, new_list) {
             // Called when the children list is modified.
             this.do_diff(old_list, 
                 new_list, 
                 $.proxy(this.remove_child_model, this),
                 $.proxy(this.add_child_model, this));
         },
 
         remove_child_model: function(model) {
             // Called when a child is removed from children list.
             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.pop_child_view(model);
         },
 
         add_child_model: function(model) {
             // Called when a child is added to children list.
             var index = this.containers.length;
             var uuid = utils.uuid();
             var accordion_group = $('<div />')
                 .addClass('panel panel-default')
                 .appendTo(this.$el);
             var accordion_heading = $('<div />')
                 .addClass('panel-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: that});
                     that.touch();
                  })
                 .text('Page ' + index)
                 .appendTo(accordion_heading);
             var accordion_body = $('<div />', {id: uuid})
                 .addClass('panel-collapse collapse')
                 .appendTo(accordion_group);
             var accordion_inner = $('<div />')
                 .addClass('panel-body')
                 .appendTo(accordion_body);
             var container_index = this.containers.push(accordion_group) - 1;
             accordion_group.container_index = container_index;
             this.model_containers[model.id] = accordion_group;
             
             var dummy = $('<div/>');
             accordion_inner.append(dummy);
             this.create_child_view(model).then(function(view) {
                 dummy.replaceWith(view.$el);
                 that.update();
                 that.update_titles();
 
                 // Trigger the displayed event of the child view.
                 that.after_displayed(function() {
                     view.trigger('displayed');
                 });
-            }, console.error);
+            }, $.proxy(console.error, console));
         },
     });
     
 
     var TabView = widget.DOMWidgetView.extend({    
         initialize: function() {
             // Public constructor.
             this.containers = [];
             TabView.__super__.initialize.apply(this, arguments);
         },
 
         render: function(){
             // Called when view is rendered.
             var uuid = 'tabs'+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_attr: function(name, value) {
             // Set a css attr of the widget view.
             this.$tabs.css(name, value);
         },
 
         update_children: function(old_list, new_list) {
             // Called when the children list is modified.
             this.do_diff(old_list, 
                 new_list, 
                 $.proxy(this.remove_child_model, this),
                 $.proxy(this.add_child_model, this));
         },
 
         remove_child_model: function(model) {
             // Called when a child is removed from children list.
             var view = this.pop_child_view(model);
             this.containers.splice(view.parent_tab.tab_text_index, 1);
             view.parent_tab.remove();
             view.parent_container.remove();
             view.remove();
         },
 
         add_child_model: function(model) {
             // Called when a child is added to children list.
             var index = this.containers.length;
             var uuid = utils.uuid();
 
             var that = this;
             var tab = $('<li />')
                 .css('list-style-type', 'none')
                 .appendTo(this.$tabs);
             
 
             var tab_text = $('<a />')
                 .attr('href', '#' + uuid)
                 .attr('data-toggle', 'tab') 
                 .text('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: that});
                     that.touch();
                     that.select_page(index);
                 });
             tab.tab_text_index = that.containers.push(tab_text) - 1;
 
             var dummy = $('<div />');
             var contents_div = $('<div />', {id: uuid})
                 .addClass('tab-pane')
                 .addClass('fade')
                 .append(dummy)
                 .appendTo(that.$tab_contents);
 
             this.create_child_view(model).then(function(view) {
                 dummy.replaceWith(view.$el);
                 view.parent_tab = tab;
                 view.parent_container = contents_div;
 
                 // Trigger the displayed event of the child view.
                 that.after_displayed(function() {
                     view.trigger('displayed');
                 });
-            }, console.error);
+            }, $.proxy(console.error, console));
         },
 
         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');
                 var that = this;
                 _.each(titles, function(title, page_index) {
                    var tab_text = that.containers[page_index];
                     if (tab_text !== undefined) {
                         tab_text.text(title);
                     } 
                 });
 
                 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) {
             // Select a page.
             this.$tabs.find('li')
                 .removeClass('active');
             this.containers[index].tab('show');
         },
     });
 
     return {
         'AccordionView': AccordionView,
         'TabView': TabView,
     };
 });