Source code for highcharts_core.utility_classes.events

from typing import Optional

from validator_collection import validators

from highcharts_core.decorators import class_sensitive
from highcharts_core.metaclasses import HighchartsMeta
from highcharts_core.utility_classes.javascript_functions import CallbackFunction


[docs]class ChartEvents(HighchartsMeta): """Event listeners for the chart.""" def __init__(self, **kwargs): self._add_series = None self._after_print = None self._before_print = None self._click = None self._drilldown = None self._drillup = None self._drillupall = None self._export_data = None self._fullscreen_close = None self._fullscreen_open = None self._load = None self._redraw = None self._render = None self._selection = None for attribute in dir(self): if attribute.startswith('_') and not attribute.startswith('__'): non_private_name = attribute[1:] setattr(self, non_private_name, kwargs.get(non_private_name, None)) @property def add_series(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when a series is added to the chart after load time, using the JavaScript ``.addSeries()`` method. One parameter, ``event``, is passed to the JavaScript function, containing common event information. Through ``event.options`` you can access the series options that were passed to the ``.addSeries()`` method. Returning ``false`` prevents the series from being added. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._add_series @add_series.setter @class_sensitive(CallbackFunction) def add_series(self, value): self._add_series = value @property def after_print(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires after a chart has been printed through the context menu or the ``Chart.print()`` JavaScript method. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._after_print @after_print.setter @class_sensitive(CallbackFunction) def after_print(self, value): self._after_print = value @property def before_print(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires before a chart is printed through the context menu or the ``Chart.print()`` JavaScript method. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._before_print @before_print.setter @class_sensitive(CallbackFunction) def before_print(self, value): self._before_print = value @property def click(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when the user clicks on the plot background. One parameter, ``event``, is passed to the JavaScript function, containing common event information. .. hint:: Information on the clicked spot can be found in your JavaScript function through ``event.xAxis`` and ``event.yAxis``, which are arrays containing the axes of each dimension and each axis' value at the clicked spot. The primary axes are ``event.xAxis[0]`` and ``event.yAxis[0]``. Remember the unit of a datetime axis is milliseconds since 1970-01-01 00:00:00. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._click @click.setter @class_sensitive(CallbackFunction) def click(self, value): self._click = value @property def drilldown(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when a drilldown point is clicked, before the new series is added. This callback function is also used for asynchronous drilldown, where the JavaScript ``seriesOptions`` are not added using the configuration options, but are instead loaded asynchronously. .. warning:: When the user clicks a category label to triggle multiple series drilldowns, one ``drilldown`` event is triggered per point in the category. One parameter, ``event``, is passed to the JavaScript function, containing common event information plus certain specific properties: * ``category``: if a category label was clicked, this will contain its index * ``originalEvent``: the original browser event (typically a click) that triggered the drilldown * ``point``: the originating point * ``points``: if a category label was clicked, this will be an array that holds all points corresponding to the category * ``seriesOptions``: options for the new series :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._drilldown @drilldown.setter @class_sensitive(CallbackFunction) def drilldown(self, value): self._drilldown = value @property def drillup(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when the user drills up from a drilldown series. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._drillup @drillup.setter @class_sensitive(CallbackFunction) def drillup(self, value): self._drillup = value @property def drillupall(self) -> Optional[CallbackFunction]: """In a chart with multiple drilldown series, this JavaScript callback function fires after all the series have been drilled up. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._drillupall @drillupall.setter @class_sensitive(CallbackFunction) def drillupall(self, value): self._drillupall = value @property def export_data(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires while exporting data. This enables the modification of data rows before they are processed into their final format. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._export_data @export_data.setter @class_sensitive(CallbackFunction) def export_data(self, value): self._export_data = value @property def fullscreen_close(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when a fullscreen view is closed, either through a context menu item, the ``Esc`` key, or the JavaScript ``Chart.fullscreen.close()`` method. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._fullscreen_close @fullscreen_close.setter @class_sensitive(CallbackFunction) def fullscreen_close(self, value): self._fullscreen_close = value @property def fullscreen_open(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when a fullscreen view is opened, either through a context menu item or the JavaScript ``Chart.fullscreen.open()`` method. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._fullscreen_open @fullscreen_open.setter @class_sensitive(CallbackFunction) def fullscreen_open(self, value): self._fullscreen_open = value @property def load(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when the chart has finished loading (including images, for example in point markers). One parameter, ``event``, is passed to the JavaScript function, containing common event information. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._load @load.setter @class_sensitive(CallbackFunction) def load(self, value): self._load = value @property def redraw(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when the chart is redrawn, either after a JavaScript call to ``chart.redraw()`` or after an axis, series, or point is modified in JavaScript with the ``redraw`` option set to ``true``. One parameter, ``event``, is passed to the JavaScript function, containing common event information. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._redraw @redraw.setter @class_sensitive(CallbackFunction) def redraw(self, value): self._redraw = value @property def selection(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when an area of the chart has been selected (selection is enabled by setting :class:`Chart.zoom_type`). One parameter, ``event``, is passed to the JavaScript function, containing common event information. .. hint:: The default action for the selection event is to zoom the chart to the selected area, however this can be prevented by calling ``event.preventDefault()`` or returning ``false`` from your JavaScript callback function. .. hint:: Information on the selected area can be found in your JavaScript function through ``event.xAxis`` and ``event.yAxis``, which are arrays containing the axes of each dimension and each axis' minimum and maximum value within the selected area. The primary axes are ``event.xAxis[0]`` and ``event.yAxis[0]``. Remember the unit of a datetime axis is milliseconds since 1970-01-01 00:00:00. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._selection @selection.setter @class_sensitive(CallbackFunction) def selection(self, value): self._selection = value @classmethod def _get_kwargs_from_dict(cls, as_dict): kwargs = { 'add_series': as_dict.get('addSeries', None), 'after_print': as_dict.get('afterPrint', None), 'before_print': as_dict.get('beforePrint', None), 'click': as_dict.get('click', None), 'drilldown': as_dict.get('drilldown', None), 'drillup': as_dict.get('drillup', None), 'drillupall': as_dict.get('drillupall', None), 'export_data': as_dict.get('exportData', None), 'fullscreen_close': as_dict.get('fullscreenClose', None), 'fullscreen_open': as_dict.get('fullscreenOpen', None), 'load': as_dict.get('load', None), 'redraw': as_dict.get('redraw', None), 'selection': as_dict.get('selection', None) } return kwargs def _to_untrimmed_dict(self, in_cls = None) -> dict: untrimmed = { 'addSeries': self.add_series, 'afterPrint': self.after_print, 'beforePrint': self.before_print, 'click': self.click, 'drilldown': self.drilldown, 'drillup': self.drillup, 'drillupall': self.drillupall, 'exportData': self.export_data, 'fullscreenClose': self.fullscreen_close, 'fullscreenOpen': self.fullscreen_open, 'load': self.load, 'redraw': self.redraw, 'selection': self.selection } return untrimmed
[docs]class PointEvents(HighchartsMeta): """Event listeners for Points.""" def __init__(self, **kwargs): self._click = None self._drag = None self._drag_start = None self._drop = None self._mouse_out = None self._mouse_over = None self._remove = None self._select = None self._unselect = None self._update = None self.click = kwargs.get('click', None) self.drag = kwargs.get('drag', None) self.drag_start = kwargs.get('drag_start', None) self.drop = kwargs.get('drop', None) self.mouse_out = kwargs.get('mouse_out', None) self.mouse_over = kwargs.get('mouse_over', None) self.remove = kwargs.get('remove', None) self.select = kwargs.get('select', None) self.unselect = kwargs.get('unselect', None) self.update = kwargs.get('update', None) @property def click(self) -> Optional[CallbackFunction]: """JavaScript function that fires when a point is clicked. One parameter, ``event``, is passed to the function, containing common event information. If the :meth:`Series.allow_point_select` option is ``True``, the default action for the point's click event is to toggle the point's select state. Returning ``False`` from the JavaScript event handler function cancels this action. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._click @click.setter @class_sensitive(CallbackFunction) def click(self, value): self._click = value @property def drag(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires while dragging a point. The mouse event is passed in as parameter. The original data can be accessed from ``e.origin``, and the new point values can be accessed from ``e.newPoints``. If there is only a single point being updated, it can be accessed from ``e.newPoint`` for simplicity, and its ID can be accessed from ``e.newPointId``. The this context is the point being dragged. To stop the default drag action, return ``false``. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._drag @drag.setter @class_sensitive(CallbackFunction) def drag(self, value): self._drag = value @property def drag_start(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when starting to drag a point. In JavaScript, the mouse event object is passed in as an argument. If a drag handle is used, ``e.updateProp`` is set to the data property being dragged. The ``this`` context is the point. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._drag_start @drag_start.setter @class_sensitive(CallbackFunction) def drag_start(self, value): self._drag_start = value @property def drop(self) -> Optional[CallbackFunction]: """JavaScript function that fires when a point is droped (when dragging ends). The mouse event is passed in as parameter. The original data can be accessed from ``e.origin``, and the new point values can be accessed from ``e.newPoints``. If there is only a single point being updated, it can be accessed from ``e.newPoint`` for simplicity, and its ID can be accessed from ``e.newPointId``. The this context is the point being dragged. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._drop @drop.setter @class_sensitive(CallbackFunction) def drop(self, value): self._drop = value @property def mouse_out(self) -> Optional[CallbackFunction]: """JavaScript function which fires when the mouse leaves the area close to the point. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._mouse_out @mouse_out.setter @class_sensitive(CallbackFunction) def mouse_out(self, value): self._mouse_out = value @property def mouse_over(self) -> Optional[CallbackFunction]: """JavaScript function which fires when the mouse enters the area close to the point. One parameter, ``event``, is passed to the function, containing common event information. Returning ``false`` cancels the default behavior, which is to show a tooltip for the point. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._mouse_over @mouse_over.setter @class_sensitive(CallbackFunction) def mouse_over(self, value): self._mouse_over = value @property def remove(self) -> Optional[CallbackFunction]: """JavaScript function which fires when the point is removed using the (JavaScript) ``.remove()`` method. One parameter, ``event``, is passed to the function. Returning ``false`` cancels the operation. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._remove @remove.setter @class_sensitive(CallbackFunction) def remove(self, value): self._remove = value @property def select(self) -> Optional[CallbackFunction]: """JavaScript function which fires when the point is selected either programmatically or following a click on the point. One parameter, ``event``, is passed to the function. Returning ``false`` cancels the operation. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._select @select.setter @class_sensitive(CallbackFunction) def select(self, value): self._select = value @property def unselect(self) -> Optional[CallbackFunction]: """JavaScript function that fires when the point is unselected either programmatically or following a click on the point. One parameter, ``event``, is passed to the function. Returning ``false`` cancels the operation. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._unselect @unselect.setter @class_sensitive(CallbackFunction) def unselect(self, value): self._unselect = value @property def update(self) -> Optional[CallbackFunction]: """JavaScript function that fires when the point is updated programmatically through the (JavaScript) ``.update()`` method. One parameter, ``event``, is passed to the function. The new point options can be accessed through ``event.options``. Returning ``false`` cancels the operation. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._update @update.setter def update(self, value): self._update = value @classmethod def _get_kwargs_from_dict(cls, as_dict): kwargs = { 'click': as_dict.get('click', None), 'drag': as_dict.get('drag', None), 'drag_start': as_dict.get('dragStart', None), 'drop': as_dict.get('drop', None), 'mouse_out': as_dict.get('mouseOut', None), 'mouse_over': as_dict.get('mouseOver', None), 'remove': as_dict.get('remove', None), 'select': as_dict.get('select', None), 'unselect': as_dict.get('unselect', None), 'update': as_dict.get('update', None) } return kwargs def _to_untrimmed_dict(self, in_cls = None) -> dict: untrimmed = { 'click': self.click, 'drag': self.drag, 'dragStart': self.drag_start, 'drop': self.drop, 'mouseOut': self.mouse_out, 'mouseOver': self.mouse_over, 'remove': self.remove, 'select': self.select, 'unselect': self.unselect, 'update': self.update } return untrimmed
[docs]class SeriesEvents(HighchartsMeta): """Event listeners for Series.""" def __init__(self, **kwargs): self._after_animate = None self._checkbox_click = None self._click = None self._hide = None self._legend_item_click = None self._mouse_out = None self._mouse_over = None self._show = None self.after_animate = kwargs.get('after_animate', None) self.checkbox_click = kwargs.get('checkbox_click', None) self.click = kwargs.get('click', None) self.hide = kwargs.get('hide', None) self.legend_item_click = kwargs.get('legend_item_click', None) self.mouse_out = kwargs.get('mouse_out', None) self.mouse_over = kwargs.get('mouse_over', None) self.show = kwargs.get('show', None) @property def after_animate(self) -> Optional[CallbackFunction]: """JavaScript function that fires after the series has finished its initial animation, or if animation is disabled, immediately as the series is displayed. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._after_animate @after_animate.setter @class_sensitive(CallbackFunction) def after_animate(self, value): self._after_animate = value @property def checkbox_click(self) -> Optional[CallbackFunction]: """JavaScript function that fires when the checkbox next to the series' name in the legend is clicked. One parameter, ``event``, is passed to the (JavaScript) function. The state of the checkbox is found by ``event.checked``. The checked item is found by ``event.item``. Return ``false`` to prevent the default action which is to toggle the select state of the series. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._checkbox_click @checkbox_click.setter @class_sensitive(CallbackFunction) def checkbox_click(self, value): self._checkbox_click = value @property def click(self) -> Optional[CallbackFunction]: """JavaScript function that fires when when the series is clicked. One parameter, ``event``, is passed to the (JavaScript) function, containing common event information. Additionally, ``event.point`` holds a pointer to the nearest point on the graph. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._click @click.setter @class_sensitive(CallbackFunction) def click(self, value): self._click = value @property def hide(self) -> Optional[CallbackFunction]: """JavaScript function that fires when the series is hidden after chart generation time, either by clicking the legend item or by calling (in JavaScript) ``.hide()``. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._hide @hide.setter @class_sensitive(CallbackFunction) def hide(self, value): self._hide = value @property def legend_item_click(self) -> Optional[CallbackFunction]: """JavaScript function that fires when the legend item belonging to the series is clicked. One parameter, ``event``, is passed to the (JavaScript) function. The default action is to toggle the visibility of the series. This can be prevented by returning ``false`` or calling (in JavaScript) ``event.preventDefault()``. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._legend_item_click @legend_item_click.setter @class_sensitive(CallbackFunction) def legend_item_click(self, value): self._legend_item_click = value @property def mouse_out(self) -> Optional[CallbackFunction]: """JavaScript function which fires when the mouse leaves the graph. One parameter, ``event``, is passed to the (JavaScript) function, containing common event information. If the ``stickyTracking`` option is ``true``, the ``mouse_out`` event doesn't happen before the mouse enters another graph or leaves the plot area. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._mouse_out @mouse_out.setter @class_sensitive(CallbackFunction) def mouse_out(self, value): self._mouse_out = value @property def mouse_over(self) -> Optional[CallbackFunction]: """JavaScript function which fires when the mouse enters the graph. One parameter, ``event``, is passed to the function, containing common event information. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._mouse_over @mouse_over.setter @class_sensitive(CallbackFunction) def mouse_over(self, value): self._mouse_over = value @property def show(self) -> Optional[CallbackFunction]: """JavaScript function which fires when the series is shown after chart generation time, either by clicking the legend item or by calling (in JavaScript) ``.show()``. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._show @show.setter @class_sensitive(CallbackFunction) def show(self, value): self._show = value @classmethod def _get_kwargs_from_dict(cls, as_dict): kwargs = { 'after_animate': as_dict.get('afterAnimate', None), 'checkbox_click': as_dict.get('checkboxClick', None), 'click': as_dict.get('click', None), 'hide': as_dict.get('hide', None), 'legend_item_click': as_dict.get('legendItemClick', None), 'mouse_out': as_dict.get('mouseOut', None), 'mouse_over': as_dict.get('mouseOver', None), 'show': as_dict.get('show', None) } return kwargs def _to_untrimmed_dict(self, in_cls = None) -> dict: untrimmed = { 'afterAnimate': self.after_animate, 'checkboxClick': self.checkbox_click, 'click': self.click, 'hide': self.hide, 'legendItemClick': self.legend_item_click, 'mouseOut': self.mouse_out, 'mouseOver': self.mouse_over, 'show': self.show } return untrimmed
[docs]class ClusterEvents(HighchartsMeta): """General event handlers for marker clusters.""" def __init__(self, **kwargs): self._drill_to_cluster = None self.drill_to_cluster = kwargs.get('drill_to_cluster', None) @property def drill_to_cluster(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when the cluster point is clicked and :meth:`Cluster.drill_to_cluster` is ``True``. One parameter, ``event``, is passed to the function. The default action is to zoom to the cluster points range. This can be prevented by calling (in JavaScript) ``event.preventDefault()``. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._drill_to_cluster @drill_to_cluster.setter @class_sensitive(CallbackFunction) def drill_to_cluster(self, value): self._drill_to_cluster = value @classmethod def _get_kwargs_from_dict(cls, as_dict): return { 'drill_to_cluster': as_dict.get('drillToCluster', None) } def _to_untrimmed_dict(self, in_cls = None) -> dict: untrimmed = { 'drillToCluster': self.drill_to_cluster } return untrimmed
[docs]class AxisEvents(HighchartsMeta): """Event listeners for axes.""" def __init__(self, **kwargs): self._after_breaks = None self._after_set_extremes = None self._point_break = None self._point_in_break = None self._set_extremes = None self.after_breaks = kwargs.get('after_breaks', None) self.after_set_extremes = kwargs.get('after_set_extremes', None) self.point_break = kwargs.get('point_break', None) self.point_in_break = kwargs.get('point_in_break', None) self.set_extremes = kwargs.get('set_extremes', None) @property def after_breaks(self) -> Optional[CallbackFunction]: """A JavaScript event function fired after breaks have rendered. Defaults to :obj:`None <python:None>`. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._after_breaks @after_breaks.setter @class_sensitive(CallbackFunction) def after_breaks(self, value): self._after_breaks = value @property def after_set_extremes(self) -> Optional[CallbackFunction]: """As opposed to :meth:`AxisEvent.set_extremes`, this JavaScript event fires after the final min and max values are computed and corrected for :meth:`GenericAxis.min_range`. Defaults to :obj:`None <python:None>`. Fires when the minimum and maximum is set for the axis, either by calling the (JavaScript) ``.setExtremes()`` method or by selecting an area in the chart. One parameter, ``event``, is passed to the function, containing common event information. The new user-set minimum and maximum values can be found (in JavaScript) by ``event.min`` and ``event.max``. These reflect the axis minimum and maximum in axis values. The actual data extremes are found in ``event.dataMin`` and ``event.dataMax``. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._after_set_extremes @after_set_extremes.setter @class_sensitive(CallbackFunction) def after_set_extremes(self, value): self._after_set_extremes = value @property def point_break(self) -> Optional[CallbackFunction]: """A JavaScript event fired when a break from this axis occurs on a point. Defaults to :obj:`None <python:None>`. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._point_break @point_break.setter @class_sensitive(CallbackFunction) def point_break(self, value): self._point_break = value @property def point_in_break(self) -> Optional[CallbackFunction]: """A JavaScript event fired when a point falls inside a break from this axis. Defaults to :obj:`None <python:None>`. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._point_in_break @point_in_break.setter @class_sensitive(CallbackFunction) def point_in_break(self, value): self._point_in_break = value @property def set_extremes(self) -> Optional[CallbackFunction]: """JavaScript function which fires when the minimum and maximum is set for the axis, either by calling the (JavaScript) ``.setExtremes()`` method or by selecting an area in the chart. One parameter, ``event``, is passed to the function, containing common event information. The new user-set minimum and maximum values can be found by ``event.min`` and ``event.max``. These reflect the axis minimum and maximum in data values. When an axis is zoomed all the way out from the "Reset zoom" button, ``event.min`` and ``event.max`` are ``null``, and the new extremes are set based on ``this.dataMin`` and ``this.dataMax``. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._set_extremes @set_extremes.setter @class_sensitive(CallbackFunction) def set_extremes(self, value): self._set_extremes = value @classmethod def _get_kwargs_from_dict(cls, as_dict): kwargs = { 'after_breaks': as_dict.get('afterBreaks', None), 'after_set_extremes': as_dict.get('afterSetExtremes', None), 'point_break': as_dict.get('pointBreak', None), 'point_in_break': as_dict.get('pointInBreak', None), 'set_extremes': as_dict.get('setExtremes', None) } return kwargs def _to_untrimmed_dict(self, in_cls = None) -> dict: untrimmed = { 'afterBreaks': self.after_breaks, 'afterSetExtremes': self.after_set_extremes, 'pointBreak': self.point_break, 'pointInBreak': self.point_in_break, 'setExtremes': self.set_extremes } return untrimmed
[docs]class MouseEvents(HighchartsMeta): """Collection of basic / standard event handlers for mouse interactions.""" def __init__(self, **kwargs): self._click = None self._mousemove = None self._mouseout = None self._mouseover = None self.click = kwargs.get('click', None) self.mousemove = kwargs.get('mousemove', None) self.mouseout = kwargs.get('mouseout', None) self.mouseover = kwargs.get('mouseover', None) @property def click(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when the user clicks on the plot band. One parameter, ``event``, is passed to the JavaScript function, containing common event information. Defaults to :obj:`None <python:None>`. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._click @click.setter @class_sensitive(CallbackFunction) def click(self, value): self._click = value @property def mousemove(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires on the mousemove event within the plot band. Defaults to :obj:`None <python:None>`. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._mousemove @mousemove.setter @class_sensitive(CallbackFunction) def mousemove(self, value): self._mousemove = value @property def mouseout(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when the mouse moves away from the corner of the plot band. Defaults to :obj:`None <python:None>`. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._mouseout @mouseout.setter @class_sensitive(CallbackFunction) def mouseout(self, value): self._mouseout = value @property def mouseover(self) -> Optional[CallbackFunction]: """JavaScript callback function that fires when the user moves their mouse over the plot band. One parameter, ``event``, is passed to the JavaScript function, containing common event information. Defaults to :obj:`None <python:None>`. :rtype: :class:`CallbackFunction` or :obj:`None <python:None>` """ return self._mouseover @mouseover.setter @class_sensitive(CallbackFunction) def mouseover(self, value): self._mouseover = value @classmethod def _get_kwargs_from_dict(cls, as_dict): kwargs = { 'click': as_dict.get('click', None), 'mousemove': as_dict.get('mousemove', None), 'mouseout': as_dict.get('mouseout', None), 'mouseover': as_dict.get('mouseover', None) } return kwargs def _to_untrimmed_dict(self, in_cls = None) -> dict: untrimmed = { 'click': self.click, 'mousemove': self.mousemove, 'mouseout': self.mouseout, 'mouseover': self.mouseover } return untrimmed