def test_add_custom_emitter(self): class Emitter(EventEmitter): def _prepare_event(self, *args, **kwds): ev = super(Emitter, self)._prepare_event(*args, **kwds) ev.test_key = 1 return ev class Source: pass src = Source() grp = EmitterGroup(source=src, em1=Emitter(type='test_event1')) grp.em1.connect(self.record_event) self.result = None ev = grp.em1() self.assert_result( event=ev, test_key=1, type='test_event1', source=src) grp.add(em2=Emitter(type='test_event2')) grp.em2.connect(self.record_event) self.result = None ev = grp.em2() self.assert_result( event=ev, test_key=1, type='test_event2', source=src)
class Config(object): """ Container for global settings used application-wide in vispy. Events: ------- Config.events.changed - Emits ConfigEvent whenever the configuration changes. """ def __init__(self): self.events = EmitterGroup(source=self) self.events['changed'] = EventEmitter(event_class=ConfigEvent, source=self) self._config = {} def __getitem__(self, item): return self._config[item] def __setitem__(self, item, val): self._config[item] = val # inform any listeners that a configuration option has changed self.events.changed(changes={item:val}) def update(self, **kwds): self._config.update(kwds) self.events.changed(changes=kwds) def __repr__(self): return repr(self._config)
class Config(object): """ Container for global settings used application-wide in vispy. Events: ------- Config.events.changed - Emits ConfigEvent whenever the configuration changes. """ def __init__(self): self.events = EmitterGroup(source=self) self.events['changed'] = EventEmitter(event_class=ConfigEvent, source=self) self._config = {} def __getitem__(self, item): return self._config[item] def __setitem__(self, item, val): self._config[item] = val # inform any listeners that a configuration option has changed self.events.changed(changes={item: val}) def update(self, **kwds): self._config.update(kwds) self.events.changed(changes=kwds) def __repr__(self): return repr(self._config)
def __init__(self, central_node): super().__init__(central_node) self._selected = False self._viewer = None self.events = EmitterGroup(source=self, auto_connect=True, select=Event, deselect=Event)
def test_group_connect(self): grp = EmitterGroup(source=self, em1=Event) grp.connect(self.record_event) self.result = None ev = grp.em1(test_key=1) self.assert_result(event=ev, source=self, sources=[self, self], test_key=1)
def test_group_connect(self): grp = EmitterGroup(source=self, em1=Event) grp.connect(self.record_event) self.result = None ev = grp.em1(test_key=1) self.assert_result( event=ev, source=self, sources=[ self, self], test_key=1)
def test_group_construction(self): """EmitterGroup basic construction""" grp = EmitterGroup(em1=Event, em2=BasicEvent, em3=TypedEvent) grp.em1.connect(self.record_event) grp.em2.connect(self.record_event) grp.em3.connect(self.record_event) self.result = None ev = grp.em1() self.assert_result(event=ev, type="em1", event_class=Event) ev = grp.em2() self.assert_result(event=ev, type="em2", event_class=BasicEvent) ev = grp.em3() self.assert_result(event=ev, type="typed_event", event_class=TypedEvent)
def __init__(self, viewer=None): self._list = [] self._viewer = None self.events = EmitterGroup(source=self, auto_connect=True, add_item=ItemEvent, remove_item=ItemEvent, reorder=Event) self.events.add_item.connect(self._add) self.events.remove_item.connect(self._remove) self.events.reorder.connect(self._reorder) # property setting - happens last self.viewer = viewer
def test_group_construction(self): """EmitterGroup basic construction""" grp = EmitterGroup(em1=Event, em2=BasicEvent, em3=TypedEvent) grp.em1.connect(self.record_event) grp.em2.connect(self.record_event) grp.em3.connect(self.record_event) self.result = None ev = grp.em1() self.assert_result(event=ev, type='em1', event_class=Event) ev = grp.em2() self.assert_result(event=ev, type='em2', event_class=BasicEvent) ev = grp.em3() self.assert_result(event=ev, type='typed_event', event_class=TypedEvent)
def test_group_disconnect(self): """EmitterGroup.disconnect""" grp = EmitterGroup(em1=Event) assert len(grp.em1.callbacks) == 0, grp.em1.callbacks grp.connect(self.record_event) assert len(grp.em1.callbacks) == 1 grp.add(em2=Event) assert len(grp.em2.callbacks) == 1 grp.disconnect() assert len(grp.em1.callbacks) == 0 assert len(grp.em2.callbacks) == 0
def __init__(self, connect=None, start=True, app=None): self.events = EmitterGroup(source=self, start=Event, stop=Event, midiIn=Event) if app is None: self._app = use_app(call_reuse=False) elif isinstance(app, Application): self._app = app elif isinstance(app, string_types): self._app = Application(app) else: raise ValueError('Invalid value for app %r' % app) self._running = False if connect is not None: self.connect(connect) if start: self.start()
def test_group_ignore(self): """EmitterGroup.block_all""" grp = EmitterGroup(em1=Event) grp.em1.connect(self.error_event) with use_log_level('warning', record=True, print_msg=False) as l: grp.em1() assert_true(len(l) >= 1) grp.ignore_callback_errors = False assert_raises(RuntimeError, grp.em1) grp.ignore_callback_errors = True with use_log_level('warning', record=True, print_msg=False) as l: grp.em1() assert_true(len(l) >= 1)
def test_add_custom_emitter(self): class Emitter(EventEmitter): def _prepare_event(self, *args, **kwds): ev = super(Emitter, self)._prepare_event(*args, **kwds) ev.test_key = 1 return ev class Source: pass src = Source() grp = EmitterGroup(source=src, em1=Emitter(type='test_event1')) grp.em1.connect(self.record_event) self.result = None ev = grp.em1() self.assert_result(event=ev, test_key=1, type='test_event1', source=src) grp.add(em2=Emitter(type='test_event2')) grp.em2.connect(self.record_event) self.result = None ev = grp.em2() self.assert_result(event=ev, test_key=1, type='test_event2', source=src)
class MidiMonitor(object): def __init__(self, connect=None, start=True, app=None): self.events = EmitterGroup(source=self, start=Event, stop=Event, midiIn=Event) if app is None: self._app = use_app(call_reuse=False) elif isinstance(app, Application): self._app = app elif isinstance(app, string_types): self._app = Application(app) else: raise ValueError('Invalid value for app %r' % app) self._running = False if connect is not None: self.connect(connect) if start: self.start() @property def running(self): return self._running def start(self): if self.running: return # don't do anything if already running port = sys.argv[1] if len(sys.argv) > 1 else None try: self.midiin = rtmidi.MidiIn(name="game") available_ports = self.midiin.get_ports() if available_ports: self.midiin.open_port(0) else: self.midiin.open_virtual_port("My virtual output") except (EOFError, KeyboardInterrupt): sys.exit() self.midiInputHandler = MidiInputHandler(self, port) self.midiin.set_callback(self.midiInputHandler) self._running = True self.events.start(type='midi_start') print(self.midiin) def stop(self): self.events.stop(type='midi_stop') def _midiIn(self, message): if not self.running: return if message[0] == 144: print(message) self.events.midiIn(type='midi_in', message=message) def connect(self, callback): return self.events.midiIn.connect(callback) def disconnect(self, callback=None): return self.events.midiIn.disconnect(callback)
def test_group_ignore(self): """EmitterGroup.block_all""" grp = EmitterGroup(em1=Event) grp.em1.connect(self.error_event) with use_log_level("warning", record=True, print_msg=False) as l: grp.em1() assert_true(len(l) >= 1) grp.ignore_callback_errors = False assert_raises(RuntimeError, grp.em1) grp.ignore_callback_errors = True with use_log_level("warning", record=True, print_msg=False) as l: grp.em1() assert_true(len(l) >= 1)
def __init__(self, interval=0.0, connect=None, iterations=-1, start=False, app=None): self.events = EmitterGroup(source=self, start=Event, stop=Event, timeout=Event) #self.connect = self.events.timeout.connect #self.disconnect = self.events.timeout.disconnect # Get app instance and make sure that it has an associated backend self._app = vispy.app.default_app if app is None else app self._app.use() # Instantiate the backed with the right class self._backend = self._app.backend_module.TimerBackend(self) self._interval = interval self._running = False self._last_emit_time = None self.iter_count = 0 self.max_iterations = iterations if connect is not None: self.connect(connect) if start: self.start()
def __init__(self, *args, **kwargs): self.events = EmitterGroup( source=self, initialize=Event, resize=ResizeEvent, paint=PaintEvent, mouse_press=MouseEvent, mouse_release=MouseEvent, mouse_move=MouseEvent, mouse_wheel=MouseEvent, key_press=KeyEvent, key_release=KeyEvent, stylus=Event, touch=Event, close=Event, ) # Store input and initialize backend attribute self._args = args self._kwargs = kwargs self._backend = None # Extract kwargs that are for us # Most are used in _set_backend self._our_kwargs = {} self._our_kwargs['title'] = kwargs.pop('title', 'Vispy canvas') self._our_kwargs['show'] = kwargs.pop('show', False) self._our_kwargs['autoswap'] = kwargs.pop('autoswap', True) self._our_kwargs['size'] = kwargs.pop('size', (800, 600)) self._our_kwargs['position'] = kwargs.pop('position', None) # Initialise some values self._title = '' # Get app instance self._app = kwargs.pop('app', vispy.app.default_app) # Create widget now if 'native' in kwargs: self._set_backend(kwargs.pop('native')) else: self.create_native()
def __init__(self, bgcolor): self._bgcolor = bgcolor self.events = EmitterGroup(source=self, resize=app.canvas.ResizeEvent, mouse_press=app.canvas.MouseEvent, mouse_release=app.canvas.MouseEvent, mouse_move=app.canvas.MouseEvent, mouse_wheel=app.canvas.MouseEvent, ) # Create program self.program = gloo.Program(VERT_SHADER, FRAG_SHADER) self.program['u_size'] = 20.0 self.program['u_color'] = bgcolor # Create position self.vbo = gloo.VertexBuffer(('', 'float32', 3)) self.program['a_position'] = self.vbo # Init self._pos = 25, 25 self._size = 1, 1
def test_group_autoconnect(self): """EmitterGroup auto-connect""" class Source: def on_em1(self, ev): self.result = 1 def em2_event(self, ev): self.result = 2 def em3_event(self, ev): self.result = 3 src = Source() grp = EmitterGroup(source=src, em1=Event, auto_connect=False) src.result = None grp.em1() assert src.result is None grp = EmitterGroup(source=src, em1=Event, auto_connect=True) src.result = None grp.em1() assert src.result == 1 grp.auto_connect_format = "%s_event" grp.add(em2=Event) src.result = None grp.em2() assert src.result == 2 grp.add(em3=Event, auto_connect=False) src.result = None grp.em3() assert src.result is None
def __init__(self): self.events = EmitterGroup(source=self) self.events['changed'] = EventEmitter(event_class=ConfigEvent, source=self) self._config = {}
class Timer(object): """Timer used to schedule events in the future or on a repeating schedule. """ def __init__(self, interval=0.0, connect=None, iterations=-1, start=False, app=None): self.events = EmitterGroup(source=self, start=Event, stop=Event, timeout=Event) #self.connect = self.events.timeout.connect #self.disconnect = self.events.timeout.disconnect # Get app instance and make sure that it has an associated backend self._app = vispy.app.default_app if app is None else app self._app.use() # Instantiate the backed with the right class self._backend = self._app.backend_module.TimerBackend(self) self._interval = interval self._running = False self._last_emit_time = None self.iter_count = 0 self.max_iterations = iterations if connect is not None: self.connect(connect) if start: self.start() @property def app(self): """ The vispy Application instance on which this Timer is based. """ return self._app @property def interval(self): return self._interval @interval.setter def interval(self, val): self._interval = val if self.running: self.stop() self.start() @property def running(self): return self._running def start(self, interval=None, iterations=None): """Start the timer. A timeout event will be generated every *interval* seconds. If *interval* is None, then self.interval will be used. If *iterations* is specified, the timer will stop after emitting that number of events. If unspecified, then the previous value of self.iterations will be used. If the value is negative, then the timer will continue running until stop() is called. """ self.iter_count = 0 if interval is not None: self.interval = interval if iterations is not None: self.max_iterations = iterations self._backend._vispy_start(self.interval) self._running = True self._last_emit_time = None self.events.start(type='timer_start') def stop(self): """Stop the timer.""" self._backend._vispy_stop() self._running = False self.events.stop(type='timer_stop') # use timer.app.run() and .quit() instead. #def run_event_loop(self): #"""Execute the event loop for this Timer's backend. #""" #return self._backend._vispy_run() #def quit_event_loop(self): #"""Exit the event loop for this Timer's backend. #""" #return self._backend._vispy_quit() @property def native(self): """ The native timer on which this Timer is based. """ return self._backend._vispy_get_native_timer() def _timeout(self, *args): # called when the backend timer has triggered. if not self.running: return if self.max_iterations >= 0 and self.iter_count >= self.max_iterations: self.stop() return # compute dt since last event now = precision_time() if self._last_emit_time is None: dt = None else: dt = now - self._last_emit_time self._last_emit_time = now self.events.timeout(type='timer_timeout', iteration=self.iter_count, dt=dt) self.iter_count += 1 def connect(self, callback): """ Alias for self.events.timeout.connect() """ return self.events.timeout.connect(callback) def disconnect(self, callback=None): """ Alias for self.events.timeout.disconnect() """ return self.events.timeout.disconnect(callback)
class Layer(VisualWrapper, ABC): """Base layer class. Must define the following: * ``_get_shape()``: called by ``shape`` property * ``_refresh()``: called by ``refresh`` method * ``data`` property (setter & getter) May define the following: * ``_set_view_slice(indices)``: called to set currently viewed slice * ``_after_set_viewer()``: called after the viewer is set * ``_qt``: QtWidget inserted into the layer list GUI Attributes ---------- ndim shape selected viewer Methods ------- refresh() Refresh the current view. """ def __init__(self, central_node): super().__init__(central_node) self._selected = False self._viewer = None self._qt = None self.name = 'layer' self.events = EmitterGroup(source=self, auto_connect=True, select=Event, deselect=Event) @property @abstractmethod def data(self): # user writes own docstring raise NotImplementedError() @data.setter @abstractmethod def data(self, data): raise NotImplementedError() @abstractmethod def _get_shape(self): raise NotImplementedError() @abstractmethod def _refresh(self): raise NotImplementedError() @property def ndim(self): """int: Number of dimensions in the data. """ return len(self.shape) @property def shape(self): """tuple of int: Shape of the data. """ return self._get_shape() @property def selected(self): """boolean: Whether this layer is selected or not. """ return self._selected @selected.setter def selected(self, selected): if selected == self.selected: return self._selected = selected if selected: self.events.select() else: self.events.deselect() @property def viewer(self): """Viewer: Parent viewer widget. """ if self._viewer is not None: return self._viewer() @viewer.setter def viewer(self, viewer): prev = self.viewer if viewer == prev: return if viewer is None: self._viewer = None parent = None else: self._viewer = weakref.ref(viewer) parent = viewer._view.scene self._parent = parent self._after_set_viewer(prev) def _after_set_viewer(self, prev): """Triggered after a new viewer is set. Parameters ---------- prev : Viewer Previous viewer. """ if self.viewer is not None: self.refresh() def _set_view_slice(self, indices): """Called whenever the sliders change. Sets the current view given a specific slice to view. Parameters ---------- indices : sequence of int or slice Indices that make up the slice. """ def refresh(self): """Fully refreshes the layer. """ self._refresh()
def test_group_add_emitter(self): """EmitterGroup.add""" grp = EmitterGroup(em1=Event) grp.em1.connect(self.record_event) self.result = None ev = grp.em1() self.assert_result(event=ev, type='em1') grp.add(em2=BasicEvent) grp.em2.connect(self.record_event) ev = grp.em2() self.assert_result(event=ev, type='em2', event_class=BasicEvent) grp.add(em3=TypedEvent) grp.em3.connect(self.record_event) ev = grp.em3(test_key=2) self.assert_result(event=ev, type='typed_event', event_class=TypedEvent, test_key=2) try: grp.add(em3=Event) assert False, "Double-added emitter" except ValueError: pass try: grp.add(add=Event) assert False, "Added event with invalid name" except ValueError: pass
class Layer(VisualWrapper, ABC): def __init__(self, central_node): super().__init__(central_node) self._selected = False self._viewer = None self._qt = None self.name = 'layer' self.events = EmitterGroup(source=self, auto_connect=True, select=Event, deselect=Event) @property @abstractmethod def data(self): # user writes own docstring raise NotImplementedError() @data.setter @abstractmethod def data(self, data): raise NotImplementedError() @abstractmethod def _get_shape(self): raise NotImplementedError() @abstractmethod def _refresh(self): raise NotImplementedError() @property def ndim(self): """int: Number of dimensions in the data. """ return len(self.shape) @property def shape(self): """tuple of int: Shape of the data. """ return self._get_shape() @property def selected(self): """boolean: Whether this layer is selected or not. """ return self._selected @selected.setter def selected(self, selected): if selected == self.selected: return self._selected = selected if selected: self.events.select() else: self.events.deselect() # @property # def _qt(self): # """PyQt5.QWidget or None: Widget, if any, inserted when # solely this layer is selected. # """ # # TODO: actually insert said widget # return None @property def viewer(self): """Viewer: Parent viewer widget. """ if self._viewer is not None: return self._viewer() @viewer.setter def viewer(self, viewer): prev = self.viewer if viewer == prev: return if viewer is None: self._viewer = None parent = None else: self._viewer = weakref.ref(viewer) parent = viewer._view.scene self._parent = parent self._after_set_viewer(prev) def _after_set_viewer(self, prev): """Triggered after a new viewer is set. Parameters ---------- prev : Viewer Previous viewer. """ if self.viewer is not None: self.refresh() def _set_view_slice(self, indices): """Called whenever the sliders change. Sets the current view given a specific slice to view. Parameters ---------- indices : sequence of int or slice Indices that make up the slice. """ def refresh(self): """Fully refreshes the layer. """ self._refresh()
def test_group_block(self): """EmitterGroup.block_all""" grp = EmitterGroup(em1=Event, em2=Event) def cb(ev): self.result = 1 grp.em1.connect(self.record_event) grp.em2.connect(self.record_event) grp.connect(cb) self.result = None grp.block_all() try: grp.em1() grp.em2() grp(type='test_event') finally: grp.unblock_all() assert self.result is None
def test_group_add_emitter(self): """EmitterGroup.add""" grp = EmitterGroup(em1=Event) grp.em1.connect(self.record_event) self.result = None ev = grp.em1() self.assert_result(event=ev, type='em1') grp.add(em2=BasicEvent) grp.em2.connect(self.record_event) ev = grp.em2() self.assert_result(event=ev, type='em2', event_class=BasicEvent) grp.add(em3=TypedEvent) grp.em3.connect(self.record_event) ev = grp.em3(test_key=2) self.assert_result( event=ev, type='typed_event', event_class=TypedEvent, test_key=2) try: grp.add(em3=Event) assert False, "Double-added emitter" except ValueError: pass try: grp.add(add=Event) assert False, "Added event with invalid name" except ValueError: pass
class LayerList: """List-like layer collection with built-in reordering and callback hooks. Parameters ---------- viewer : Viewer, optional Parent viewer. Attributes ---------- viewer : Viewer Parent viewer. events : vispy.util.event.EmitterGroup Event hooks: * add_item(item): whenever an item is added * remove_item(item): whenever an item is removed * reorder(): whenever the list is reordered """ __slots__ = ('__weakref__', '_list', '_qt', '_viewer', 'total', 'events') def __init__(self, viewer=None): self._list = [] self._qt = QtLayerPanel(self) self._viewer = None self.total = 0 self.events = EmitterGroup(source=self, auto_connect=True, add_item=ItemEvent, remove_item=ItemEvent, reorder=Event) self.events.add_item.connect(self._add) self.events.remove_item.connect(self._remove) self.events.reorder.connect(self._reorder) # property setting - happens last self.viewer = viewer def __str__(self): return str(self._list) def __repr__(self): return repr(self._list) def __iter__(self): return iter(self._list) def __contains__(self, item): return item in self._list def __len__(self): return len(self._list) def __getitem__(self, i): return self._list[i] @property def viewer(self): """Viewer: Parent viewer. """ if self._viewer is None: return self._viewer return self._viewer() @viewer.setter def viewer(self, viewer): prev = self.viewer if viewer == prev: return if prev is not None: self.events.add_item.disconnect(prev._on_layers_change) self.events.remove_item.disconnect(prev._on_layers_change) for layer in self: layer.viewer = viewer if viewer is not None: self.events.add_item.connect(viewer._on_layers_change) self.events.remove_item.connect(viewer._on_layers_change) viewer = weakref.ref(viewer) self._viewer = viewer def _to_index(self, obj): """Ensures that an object is a proper integer index. Parameters ---------- obj : int or Layer Object to be converted. Returns ------- index : int Index of the object if it is not already an int. """ if _check_layer(obj): return self.index(obj) if not isinstance(obj, int): raise TypeError(f'expected {obj} to be int or Layer; ' f'got {type(obj)}') from None return obj def _reordered_list(self, ordering): """Generates the reordered list given an ordering. Parameters ---------- ordering : iterable of int Ordering of the indices to use. Yields ------ item : Layer Next layer in the ordered list. Raises ------ ValueError When the improper indices are used. """ expected = list(range(len(self))) for o in ordering: if not isinstance(o, int): raise TypeError(f'expected {o} to be int; ' f'got {type(o)}') from None try: expected.remove(o) except ValueError: raise ValueError(f'duplicate index: {o}') from None yield self._list[o] if expected: raise ValueError(f'indices {tuple(expected)} not provided') def append(self, item): """Appends a layer to the list. Parameters ---------- item : Layer Layer to append. """ _check_layer(item, error=True) self._list.append(item) self.events.add_item(item=item, index=len(self)-1) self.total = self.total+1 def insert(self, index, item): """Inserts an item before an index. Parameters ---------- index : int Index to insert before. item : Layer Layer to insert. """ _check_layer(item, error=True) self._list.insert(index, item) self.events.add_item(item=item, index=index-1) self.total = self.total+1 def pop(self, index=-1): """Removes and returns an item given an index. Parameters ---------- index : int, optional Index to remove. Returns ------- item : Layer Removed item. """ item = self._list.pop(index) self.events.remove_item(item=item) def remove(self, item): """Removes an item from the list. Parameters ---------- item : Layer Item to remove. """ self._list.remove(item) self.events.remove_item(item=item) def __delitem__(self, index): """Removes an item given its index. Parameters ---------- index : int Index of the item to remove. """ self.pop(index) def swap(self, a, b): """Swaps the ordering of two elements in the list. Parameters ---------- a : Layer or int Layer to swap or its index. b : Layer or int Layer to swap or its index. """ i = self._to_index(a) j = self._to_index(b) self._list[i], self._list[j] = self._list[j], self._list[i] self.events.reorder() def reorder(self, *ordering): """Reorders the list given an iterable of its elements or their indices. Parameters ---------- ordering : iterable of Layer or int Ordering of the items. Can also be used as *args. Notes ----- LayerList.reorder(i, j, k, ...) LayerList.reorder([i, j, k, ...]) """ if not isinstance(ordering[0], (int, Layer)): ordering = ordering[0] if not isinstance(ordering, Sequence): raise TypeError(f'expected {ordering} to be Sequence; ' f'got {type(ordering)}') from None self._list[:] = self._reordered_list(self._to_index(o) for o in ordering) self.events.reorder() def index(self, item, start=None, stop=None): """Finds the index of an item in the list. Parameters ---------- item : object Querying item.. start : int, optional Start of slice index to look. stop : int, optional Stop of slice index to look. Returns ------- index : int Index of the item. Raises ------ ValueError When the item is not in the list. """ args = (item,) if stop is not None and start is None: start = 0 if start is not None: args += (start,) if stop is not None: args += (stop,) return self._list.index(*args) def _add(self, event): """Callback when an item is added to set its order and viewer. """ layer = event.item self._qt.layersList.insert(event.index, len(self), layer) layer._order = -len(self) layer.viewer = self.viewer def _remove(self, event): """Callback when an item is removed to remove its viewer and reset its order. """ layer = event.item self._qt.layersList.remove(layer) layer.viewer = None layer._order = 0 def _reorder(self, event): """Callback when the list is reordered to propagate those changes to the node draw order. """ for i in range(len(self)): self[i]._order = -i self._qt.layersList.reorder() canvas = self.viewer._canvas canvas._draw_order.clear() canvas.update() def remove_selected(self): """Removes selected items from list. """ to_delete = [] for i in range(len(self)): if self[i].selected: to_delete.append(i) to_delete.reverse() for i in to_delete: self.pop(i)