Added system that allows js to be required by widgets.

IPython/html/widgets/base.py

@@ -1,157 +1,175 b''
 
 from copy import copy
 from glob import glob
 import uuid
 import sys
 import os
 
 import IPython
 from IPython.kernel.comm import Comm
 from IPython.config import LoggingConfigurable
-from IPython.utils.traitlets import Unicode, Dict
+from IPython.utils.traitlets import Unicode, Dict, List
 from IPython.display import Javascript, display
 from IPython.utils.py3compat import string_types
 
 
 class Widget(LoggingConfigurable):
 
     ### Public declarations
     target_name = Unicode('widget')
     default_view_name = Unicode()
+    js_requirements = List()
     
     
     ### Private/protected declarations
     _keys = []
     _property_lock = False
     _parent = None
     _children = []
     _css = Dict()
     
     
     ### Public constructor
     def __init__(self, parent=None, **kwargs):
         super(Widget, self).__init__(**kwargs)
         
         self._children = []
         if parent is not None:
             parent._children.append(self)
         self._parent = parent
         self.comm = None
         
         # Register after init to allow default values to be specified
         self.on_trait_change(self._handle_property_changed, self.keys)
         
         
     def __del__(self):
         self.close()
     
     def close(self):
         self.comm.close()
         del self.comm
     
     
     ### Properties
     def _get_parent(self):
         return self._parent
     parent = property(_get_parent)
     
     
     def _get_children(self):
         return copy(self._children)
     children = property(_get_children)
     
     
     def _get_keys(self):
         keys = ['_css']
         keys.extend(self._keys)
         return keys
     keys = property(_get_keys)
     
     def _get_css(self, key, selector=""):
         if selector in self._css and key in self._css[selector]:
             return self._css[selector][key]
         else:
             return None
     def _set_css(self, value, key, selector=""):
         if selector not in self._css:
             self._css[selector] = {}
             
         # Only update the property if it has changed.
         if not (key in self._css[selector] and value in self._css[selector][key]):
             self._css[selector][key] = value
             self.send_state() # Send new state to client.
             
     css = property(_get_css, _set_css)
     
     
     ### Event handlers
     def _handle_msg(self, msg):
         
         # Handle backbone sync methods
         sync_method = msg['content']['data']['sync_method']
         sync_data = msg['content']['data']['sync_data']
         if sync_method.lower() in ['create', 'update']:
             self._handle_recieve_state(sync_data)
     
     
     def _handle_recieve_state(self, sync_data):
         self._property_lock = True
         try:
             
             # Use _keys instead of keys - Don't get retrieve the css from the client side.
             for name in self._keys:
                 if name in sync_data:
                     setattr(self, name, sync_data[name])
         finally:
             self._property_lock = False
     
     
     def _handle_property_changed(self, name, old, new):
         if not self._property_lock and self.comm is not None:
             # TODO: Validate properties.
             # Send new state to frontend
             self.send_state()
 
 
     def _handle_close(self):
         self.comm = None
     
     
     ### Public methods
     def _repr_widget_(self, view_name=None):
         if not view_name:
             view_name = self.default_view_name
         
+        # Require traitlet specified widget js
+        for requirement in self.js_requirements:
+            self._require_js(requirement)
+
         # Create a comm.
         if self.comm is None:
             self.comm = Comm(target_name=self.target_name)
             self.comm.on_msg(self._handle_msg)
             self.comm.on_close(self._handle_close)
         
         # Make sure model is syncronized
         self.send_state()
             
         # Show view.
         if self.parent is None:
             self.comm.send({"method": "show", "view_name": view_name})
         else:
             self.comm.send({"method": "show", 
                             "view_name": view_name,
                             "parent": self.parent.comm.comm_id})
         
         # Now show children if any.
         for child in self.children:
             child._repr_widget_()
         return None
 
 
     def send_state(self):
         state = {}
         for key in self.keys:
             try:
                 state[key] = getattr(self, key)
             except Exception as e:
                 pass # Eat errors, nom nom nom
         self.comm.send({"method": "update",
                         "state": state})
-    
  No newline at end of file
+    
+    ### Private methods
+
+    def _require_js(self, js_path):
+        # Since we are loading requirements that must be loaded before this call
+        # returns, preform async js load.
+        display(Javascript(data="""
+$.ajax({
+    url: '{0}',
+    async: false,
+    dataType: "script",
+    timeout: 1000, // Wait a maximum of one second for the script to load.
+});
+        """.format(js_path)))
  No newline at end of file

IPython/html/widgets/container.py

@@ -1,11 +1,12 b''
 import os
 
 from base import Widget
-from IPython.utils.traitlets import Unicode
+from IPython.utils.traitlets import Unicode, List
 from IPython.utils.javascript import display_all_js
 
 class ContainerWidget(Widget):
     target_name = Unicode('container_widget')
     default_view_name = Unicode('ContainerView')
+    js_requirements = List(["notebook/js/widgets/container.js"])
     
     _keys = []

IPython/html/widgets/float_range.py

@@ -1,17 +1,18 b''
 import os
 
 from base import Widget
-from IPython.utils.traitlets import Unicode, Float, Bool
+from IPython.utils.traitlets import Unicode, Float, Bool, List
 from IPython.utils.javascript import display_all_js
 
 class FloatRangeWidget(Widget):
     target_name = Unicode('FloatRangeWidgetModel')
     default_view_name = Unicode('FloatSliderView')
+    js_requirements = List(["notebook/js/widgets/float_range.js"])
     _keys = ['value', 'step', 'max', 'min', 'disabled', 'orientation']
     
     value = Float(0.0) 
     max = Float(100.0) # Max value
     min = Float(0.0) # Min value
     disabled = Bool(False) # Enable or disable user changes
     step = Float(0.1) # Minimum step that the value can take (ignored by some views)
     orientation = Unicode(u'horizontal') # Vertical or horizontal (ignored by some views)

IPython/html/widgets/int_range.py

@@ -1,17 +1,18 b''
 import os
 
 from base import Widget
-from IPython.utils.traitlets import Unicode, Int, Bool
+from IPython.utils.traitlets import Unicode, Int, Bool, List
 from IPython.utils.javascript import display_all_js
 
 class IntRangeWidget(Widget):
     target_name = Unicode('IntRangeWidgetModel')
     default_view_name = Unicode('IntSliderView')
+    js_requirements = List(["notebook/js/widgets/int_range.js"])
     _keys = ['value', 'step', 'max', 'min', 'disabled', 'orientation']
 
     value = Int(0) 
     max = Int(100) # Max value
     min = Int(0) # Min value
     disabled = Bool(False) # Enable or disable user changes
     step = Int(1) # Minimum step that the value can take (ignored by some views)
     orientation = Unicode(u'horizontal') # Vertical or horizontal (ignored by some views)

IPython/html/widgets/selection.py

@@ -1,15 +1,16 b''
 import os
 
 from base import Widget
 from IPython.utils.traitlets import Unicode, List, Bool
 from IPython.utils.javascript import display_all_js
 
 class SelectionWidget(Widget):
     target_name = Unicode('SelectionWidgetModel')
     default_view_name = Unicode('DropdownView')
+    js_requirements = List(["notebook/js/widgets/selection.js"])
     _keys = ['value', 'values', 'disabled']
 
     value = Unicode()
     values = List() # List of values the user can select
     disabled = Bool(False) # Enable or disable user changes
  
  No newline at end of file

IPython/html/widgets/string.py

@@ -1,14 +1,15 b''
 import os
 
 from base import Widget
-from IPython.utils.traitlets import Unicode, Bool
+from IPython.utils.traitlets import Unicode, Bool, List
 from IPython.utils.javascript import display_all_js
 
 class StringWidget(Widget):
     target_name = Unicode('StringWidgetModel')
     default_view_name = Unicode('TextboxView')
+    js_requirements = List(["notebook/js/widgets/string.js"])
     _keys = ['value', 'row_count', 'disabled']
     
     value = Unicode()
     disabled = Bool(False) # Enable or disable user changes
     
  No newline at end of file