##// END OF EJS Templates
upstream » ipython
RSS

Clone from https://github.com/ipython/ipython.git

Fix: added inspect import to widget.py
Fix: added inspect import to widget.py
Jonathan Frederic - - Load All Authors

File last commit:

r14327:af45ffd0
r14341:c0c9ab2c
Show More
Part 2 - Events.ipynb
309 lines | 8.8 KiB | text/plain | TextLexer
/ examples / widgets / Part 2 - Events.ipynb
History | Annotation | Raw |Copy content |Copy permalink
In [1]:
from IPython.html import widgets # Widget definitions
from IPython.display import display # Used to display widgets in the notebook

# Enable widgets in this notebook
widgets.init_widget_js()

SandBoxed(IPython.core.display.Javascript object)
SandBoxed(IPython.core.display.Javascript object)
SandBoxed(IPython.core.display.Javascript object)
SandBoxed(IPython.core.display.Javascript object)
SandBoxed(IPython.core.display.Javascript object)
SandBoxed(IPython.core.display.Javascript object)
SandBoxed(IPython.core.display.Javascript object)
SandBoxed(IPython.core.display.Javascript object)
SandBoxed(IPython.core.display.Javascript object)
SandBoxed(IPython.core.display.Javascript object)

Traitlet Events

The widget properties are IPython traitlets. Traitlets are eventful. To handle property value changes, the on_trait_change method of the widget can be used to register an event handling callback. The doc string for on_trait_change can be seen below. Both the name and remove properties are optional.

In [2]:
print(widgets.Widget.on_trait_change.__doc__)

Setup a handler to be called when a trait changes.

        This is used to setup dynamic notifications of trait changes.

        Static handlers can be created by creating methods on a HasTraits
        subclass with the naming convention '_[traitname]_changed'.  Thus,
        to create static handler for the trait 'a', create the method
        _a_changed(self, name, old, new) (fewer arguments can be used, see
        below).

        Parameters
        ----------
        handler : callable
            A callable that is called when a trait changes.  Its
            signature can be handler(), handler(name), handler(name, new)
            or handler(name, old, new).
        name : list, str, None
            If None, the handler will apply to all traits.  If a list
            of str, handler will apply to all names in the list.  If a
            str, the handler will apply just to that name.
        remove : bool
            If False (the default), then install the handler.  If True
            then unintall it.

Mentioned in the doc string, the callback registered can have 4 possible signatures:

  • callback()
  • callback(trait_name)
  • callback(trait_name, new_value)
  • callback(trait_name, old_value, new_value)

An example of how to output an IntRangeWiget's value as it is changed can be seen below.

In [3]:
intrange = widgets.IntRangeWidget()
display(intrange)

def on_value_change(name, value):
    print value

intrange.on_trait_change(on_value_change, 'value')

Specialized Events

Button On Click Event

The ButtonWidget is a special widget, like the ContainerWidget and MulticontainerWidget, that isn't used to represent a data type. Instead the button widget is used to handle mouse clicks. The on_click method of the ButtonWidget can be used to register a click even handler. The doc string of the on_click can be seen below.

In [4]:
print(widgets.ButtonWidget.on_click.__doc__)

Register a callback to execute when the button is clicked.  The
        callback can either accept no parameters or one sender parameter:
        - callback()
        - callback(sender)
        If the callback has a sender parameter, the ButtonWidget instance that
        called the callback will be passed into the method as the sender.

        Parameters
        ----------
        remove : bool (optional)
            Set to true to remove the callback from the list of callbacks.

Button clicks are tracked by the clicks property of the button widget. By using the on_click method and the clicks property, a button that outputs how many times it has been clicked is shown below.

In [5]:
button = widgets.ButtonWidget(description="Click Me!")
display(button)

def on_button_clicked(sender):
    print("Button clicked %d times." % sender.clicks)

button.on_click(on_button_clicked)

Button clicked 1 times.

Button clicked 2 times.

Button clicked 3 times.

Event handlers can also be used to create widgets. In the example below, clicking a button spawns another button with a description equal to how many times the parent button had been clicked at the time.

In [6]:
def show_button(sender=None):
    button = widgets.ButtonWidget()
    button.description = "%d" % (sender.clicks if sender is not None else 0)
    display(button)
    button.on_click(show_button)
show_button()