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_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 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
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 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)
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
