def test_observe_trait(self): # Given @observe(trait("value"), post_init=True, dispatch="ui") @observe("name") def handler(event): pass class_name = "MyClass" bases = (object,) class_dict = {"attr": "something", "my_listener": handler} # When update_traits_class_dict(class_name, bases, class_dict) # Then self.assertEqual( class_dict[ObserverTraits], { "my_listener": [ { "expression": [trait("name")], "post_init": False, "dispatch": "same", "handler_getter": getattr, }, { "expression": [trait("value")], "post_init": True, "dispatch": "ui", "handler_getter": getattr, }, ], }, )
class ClassWithPropertyMultipleObserves(PersonInfo): """ Dummy class to test observing multiple values. """ computed_value = Property(observe=[trait("age"), trait("gender")]) computed_value_n_calculations = Int() def _get_computed_value(self): self.computed_value_n_calculations += 1 return len(self.gender) + self.age
def test_nested_list_reassigned_value_compared_equally(self): container = ClassWithListOfListOfInstance() events = [] handler = events.append container.observe( expression=(trait( "list_of_list_of_instances", notify=False).list_items( notify=False).list_items(notify=False).trait("value")), handler=handler, ) inner_list = [SingleValue()] container.list_of_list_of_instances = [inner_list] # sanity check self.assertEqual(len(events), 0) # assignment of a list that compares equally should be handled # correctly. # This relies on TraitList not trying to suppress notifications # when new values compared equally to old values. container.list_of_list_of_instances[0] = inner_list second_instance = SingleValue() container.list_of_list_of_instances[0].append(second_instance) self.assertEqual(len(events), 0) # when second_instance.value += 1 # then event, = events self.assertEqual(event.object, second_instance) self.assertEqual(event.name, "value") self.assertEqual(event.old, 0) self.assertEqual(event.new, 1)
class Album(HasTraits): records = List(Instance(Record)) records_default_call_count = Int() record_number_change_events = List() name_to_records = Dict(Str, Record) name_to_records_default_call_count = Int() name_to_records_clicked_events = List() def _records_default(self): self.records_default_call_count += 1 return [Record()] @observe(trait("records").list_items().trait("number")) def handle_record_number_changed(self, event): self.record_number_change_events.append(event) def _name_to_records_default(self): self.name_to_records_default_call_count += 1 return {"Record": Record()} @observe("name_to_records:items:clicked") def handle_event(self, event): self.name_to_records_clicked_events.append(event)
def test_observe_instance_in_nested_list(self): container = ClassWithListOfListOfInstance() events = [] handler = events.append container.observe( expression=( trait("list_of_list_of_instances", notify=False) .list_items(notify=False) .list_items(notify=False) .trait("value") ), handler=handler, ) # sanity check single_value_instance = SingleValue() inner_list = [single_value_instance] container.list_of_list_of_instances.append(inner_list) self.assertEqual(len(events), 0) # when single_value_instance.value += 1 # then event, = events self.assertEqual(event.object, single_value_instance) self.assertEqual(event.name, "value") self.assertEqual(event.old, 0) self.assertEqual(event.new, 1)
def test_observe_instance_in_set(self): container = ClassWithSetOfInstance() events = [] handler = events.append container.observe( handler=handler, expression=( trait("instances", notify=False) .set_items(notify=False) .trait("value") ), ) single_value_instance = SingleValue() container.instances = set([single_value_instance]) # sanity check self.assertEqual(len(events), 0) # when single_value_instance.value += 1 # then event, = events self.assertEqual(event.object, single_value_instance) self.assertEqual(event.name, "value") self.assertEqual(event.old, 0) self.assertEqual(event.new, 1)
def _get_items(self): """Gets the current list of InstanceChoiceItem items.""" if self._items is not None: return self._items factory = self.factory if self._value is not None: values = self._value() + factory.values else: values = factory.values items = [] adapter = factory.adapter for value in values: if not isinstance(value, InstanceChoiceItem): value = adapter(object=value) # rebuild_items when an item's name changes so it is reflected by # combobox. This change was added to fix enthought/traitsui#1641 value.object.observe( self.rebuild_items, trait(value.name_trait, optional=True), dispatch="ui", ) items.append(value) self._items = items return items
def test_observe_dispatch_ui(self): # Test to ensure "ui" is one of the allowed value # Not testing the actual effect as it requires GUI event loop # as well as assumption on the local thread identity while running # the test. person = Person() person.observe(repr, trait("age"), dispatch="ui")
def test_no_new_trait_added(self): # Test enthought/traits#447 can be avoided with observe team = Team() team.observe(lambda e: None, trait("leader").trait("does_not_exist")) with self.assertRaises(ValueError): team.leader = Person() self.assertNotIn("does_not_exist", team.leader.trait_names())
def test_extended_trait_on_any_value(self): team = Team() team.any_value = 123 with self.assertRaises(ValueError) as exception_cm: team.observe(lambda e: None, trait("any_value").trait("does_not_exist")) self.assertEqual(str(exception_cm.exception), "Trait named 'does_not_exist' not found on 123.")
class ClassWithPropertyObservesItems(ClassWithInstanceDefaultInit): """ Dummy class to test property observing container items""" discounted = Property( Bool(), observe=trait("list_of_infos").list_items().trait("age")) discounted_n_calculations = Int() def _get_discounted(self): self.discounted_n_calculations += 1 return any(info.age > 70 for info in self.list_of_infos)
def test_overloaded_signature_expression(self): # Test the overloaded signature for expression expressions = [ trait("age"), "age", [trait("age")], ["age"], ] for expression in expressions: class NewPerson(Person): events = List() @observe(expression) def handler(self, event): self.events.append(event) person = NewPerson() person.age += 1 self.assertEqual(len(person.events), 1)
class Teacher(HasTraits): """ Model for testing list + post_init (enthought/traits#275) """ students = List(Instance(Student)) student_graduate_events = List() @observe(trait("students", notify=True).list_items(notify=False).trait("graduate"), post_init=True) def _student_graduate(self, event): self.student_graduate_events.append(event)
class Person(HasTraits): scores = List(Int) @observe("scores") def notify_scores_change(self, event): print("{event.name} changed from {event.old} to {event.new}. " "(Event type: {event.__class__.__name__})".format(event=event)) @observe(trait("scores", notify=False).list_items()) def notify_scores_content_change(self, event): print("scores added: {event.added}. scores removed: {event.removed} " "(Event type: {event.__class__.__name__})".format(event=event))
def test_items_on_a_list_not_observable_by_named_trait(self): # The member_names is a list of str, attempt to observe extended # trait on them should fail. team = Team() team.observe( lambda e: None, trait("member_names").list_items().trait("does_not_exist")) with self.assertRaises(ValueError) as exception_cm: team.member_names = ["Paul"] self.assertEqual(str(exception_cm.exception), "Trait named 'does_not_exist' not found on 'Paul'.")
def test_trait_is_not_list(self): team = Team() # The `list_items` should not be used here. # Error is not emitted now as leader is not defined so there is no # way to check. team.observe(lambda e: None, trait("leader").list_items()) person = Person() with self.assertRaises(ValueError) as exception_cm: team.leader = person self.assertIn( "Expected a TraitList to be observed", str(exception_cm.exception), )
def test_duplicated_items_tracked(self): # test for enthought/traits#237 container = ClassWithListOfInstance() events = [] handler = events.append container.observe( expression=( trait("list_of_instances", notify=False) .list_items(notify=False) .trait("value") ), handler=handler, ) instance = SingleValue() # The item is repeated. container.list_of_instances.append(instance) container.list_of_instances.append(instance) self.assertEqual(len(events), 0) # when instance.value += 1 # then self.assertEqual(len(events), 1) events.clear() # when container.list_of_instances.pop() instance.value += 1 # then self.assertEqual(len(events), 1) events.clear() # when container.list_of_instances.pop() instance.value += 1 # then self.assertEqual(len(events), 0)
class Person(HasTraits): @observe(trait("age", optional=True)) def notify_age_change(self, event): print("age changed")
class TasksApplication(GUIApplication): """ A base class for Pyface tasks applications. """ # ------------------------------------------------------------------------- # 'TaskApplication' interface # ------------------------------------------------------------------------- # Task management -------------------------------------------------------- #: List of all running tasks tasks = List(Instance("pyface.tasks.task.Task")) #: Currently active Task if any. active_task = Property( observe=trait("active_window").trait("active_task", optional=True) ) #: List of all application task factories. task_factories = List() #: The default layout for the application. If not specified, a single #: window will be created with the first available task factory. default_layout = List( Instance("pyface.tasks.task_window_layout.TaskWindowLayout") ) #: Hook to add global schema additions to tasks/windows extra_actions = List( Instance("pyface.action.schema.schema_addition.SchemaAddition") ) #: Hook to add global dock pane additions to tasks/windows extra_dock_pane_factories = List(Callable) # Window lifecycle methods ----------------------------------------------- def create_task(self, id): """ Creates the Task with the specified ID. Parameters ---------- id : str The id of the task factory to use. Returns ------- The new Task, or None if there is not a suitable TaskFactory. """ factory = self._get_task_factory(id) if factory is None: logger.warning("Could not find task factory {}".format(id)) return None task = factory.create(id=factory.id) task.extra_actions.extend(self.extra_actions) task.extra_dock_pane_factories.extend(self.extra_dock_pane_factories) return task def create_window(self, layout=None, **kwargs): """ Connect task to application and open task in a new window. Parameters ---------- layout : TaskLayout instance or None The pane layout for the window. **kwargs : dict Additional keyword arguments to pass to the window factory. Returns ------- window : ITaskWindow instance or None The new TaskWindow. """ from pyface.tasks.task_window_layout import TaskWindowLayout window = super().create_window(**kwargs) if layout is not None: for task_id in layout.get_tasks(): task = self.create_task(task_id) if task is not None: window.add_task(task) else: msg = "Missing factory for task with ID %r" logger.error(msg, task_id) else: # Create an empty layout to set default size and position only layout = TaskWindowLayout() window.set_window_layout(layout) return window def _create_windows(self): """ Create the initial windows to display from the default layout. """ for layout in self.default_layout: window = self.create_window(layout) self.add_window(window) self.active_window = window # ------------------------------------------------------------------------- # Private interface # ------------------------------------------------------------------------- def _get_task_factory(self, id): """ Returns the TaskFactory with the specified ID, or None. """ for factory in self.task_factories: if factory.id == id: return factory return None # Destruction utilities --------------------------------------------------- @observe("windows:items:closed") def _on_window_closed(self, event): """ Listener that ensures window handles are released when closed. """ window = event.object if getattr(window, "active_task", None) in self.tasks: self.tasks.remove(window.active_task) super()._on_window_closed(event) # Trait initializers and property getters --------------------------------- def _window_factory_default(self): """ Default to TaskWindow. This will be sufficient in many cases as customized behaviour comes from the Task and the TaskWindow is just a shell. """ from pyface.tasks.task_window import TaskWindow return TaskWindow def _default_layout_default(self): from pyface.tasks.task_window_layout import TaskWindowLayout window_layout = TaskWindowLayout() if self.task_factories: window_layout.items = [self.task_factories[0].id] return [window_layout] def _extra_actions_default(self): """ Extra application-wide menu items This adds a collection of standard Tasks application menu items and groups to a Task's set of menus. Whether or not they actually appear depends on whether the appropriate menus are provided by the Task. These default additions assume that the window will hold an editor pane so that Ctrl-N and Ctrl-W will be bound to creating/closing new editors rather than new task windows. """ from pyface.action.api import ( AboutAction, CloseActiveWindowAction, ExitAction, ) from pyface.action.schema.api import SMenu, SchemaAddition from pyface.tasks.action.api import ( CreateTaskWindowAction, TaskWindowToggleGroup, ) return [ SchemaAddition( factory=CreateTaskWindowAction.factory( application=self, accelerator="Ctrl+Shift+N" ), path="MenuBar/File/new_group", ), SchemaAddition( id="close_action", factory=CloseActiveWindowAction.factory( application=self, accelerator="Ctrl+Shift+W" ), path="MenuBar/File/close_group", ), SchemaAddition( id="exit_action", factory=ExitAction.factory(application=self), path="MenuBar/File/close_group", absolute_position="last", ), SchemaAddition( # id='Window', factory=lambda: SMenu( TaskWindowToggleGroup(application=self), id="Window", name="&Window", ), path="MenuBar", after="View", before="Help", ), SchemaAddition( id="about_action", factory=AboutAction.factory(application=self), path="MenuBar/Help", absolute_position="first", ), ] @cached_property def _get_active_task(self): if self.active_window is not None: return getattr(self.active_window, "active_task", None) else: return None
class Mayavi3DScene(Editor): # pylint: disable=too-many-instance-attributes """ A Pyface Tasks Editor for holding a Mayavi scene """ #: The model object to view. If not specified, the editor is used instead. model = Instance(HasTraits) #: The UI object associated with the Traits view, if it has been #: constructed. ui = Instance("traitsui.ui.UI") #: The editor's user-visible name. name = Str('3D View') #: Configuration parser. configuration = Instance(ConfigParser) #: Current participant ID. participant_id = Str() #: The :py:class:`EMFields` instance containing the field data. fields_model = Instance(EMFields) #: Normal vector of the cut plane normal = Array() #: Origin point of the cut plane origin = Array() #: The :py:class:`mayavi.core.ui.api.MlabSceneModel` instance #: containing the 3D plot. scene = Instance(MlabSceneModel, ()) #: The mayavi pipeline object containing the cut plane. data_set_clipper = Instance(DataSetClipper) #: The list of points describing the line for the line figure. points = List(ArrayClass, value=[ ArrayClass(value=np.array([0, 0, -1])), ArrayClass(value=np.array([0, 0, 1])) ]) #: The 3D surface object for the line. line = Instance(Surface) #: The field data source. src = Instance(ArraySource) #: The field cut plane. cut = Instance(CutPlane) #: The 3D surface for the field data. surf = Instance(Surface) #: The path to the spinal cord model file. csf_model = File() #: The mayavi file reader object to read the spinal cord model file. csf_model_reader = Any() #: The 3D surface object for the cut spinal cord model. csf_surface = Instance(Surface) #: Show the full spinal cord model? show_full_model = Bool() #: The 3D surface object for the full spinal cord model. full_csf_surface = Instance(Surface) #: Use a logarithmic scale for the field data? log_scale = Bool() #: Current participant ID. participant_id = Str() def default_traits_view(self): # pylint: disable=no-self-use """ Create the default traits View object for the model Returns ------- default_traits_view : :py:class:`traitsui.view.View` The default traits View object for the model """ return View( Item('scene', show_label=False, editor=SceneEditor(scene_class=MayaviScene))) def create(self, parent): """ Create and set the widget(s) for the Editor. Parameters ---------- parent : toolkit-specific widget The parent widget for the Editor """ self.ui = self.edit_traits(kind='subpanel', parent=parent) # pylint: disable=invalid-name self.control = self.ui.control # pylint: disable=attribute-defined-outside-init def destroy(self): """ Destroy the Editor and clean up after """ self.control = None # pylint: disable=attribute-defined-outside-init if self.ui is not None: self.ui.dispose() self.ui = None @observe('log_scale', post_init=True) def toggle_log_scale(self, event): """ Toggle between using a logarithmic scale and a linear scale Parameters ---------- event : A :py:class:`traits.observation.events.TraitChangeEvent` instance The trait change event for log_scale """ if event.new: self.surf.parent.scalar_lut_manager.lut.scale = 'log10' else: self.surf.parent.scalar_lut_manager.lut.scale = 'linear' self.scene.mlab.draw() @observe('origin', post_init=True) def update_origin(self, event): """ Update objects when the cut plane origin is changed. Parameters ---------- event : A :py:class:`traits.observation.events.TraitChangeEvent` instance The trait change event for origin """ if hasattr(self.data_set_clipper, 'widget'): self.data_set_clipper.widget.widget.origin = event.new self.cut.filters[0].widget.origin = event.new self.scene.mlab.draw() @observe('normal', post_init=True) def update_normal(self, event): """ Update objects when the cut plane normal is changed. Parameters ---------- event : A :py:class:`traits.observation.events.TraitChangeEvent` instance The trait change event for normal """ if hasattr(self.data_set_clipper, 'widget'): self.data_set_clipper.widget.widget.normal = event.new self.cut.filters[0].widget.normal = event.new self.scene.mlab.draw() @observe('show_full_model', post_init=True) def toggle_full_model(self, event): """ Toggle between showing the full spinal cord model and showing only below the cut plane. Parameters ---------- event : A :py:class:`traits.observation.events.TraitChangeEvent` instance The trait change event for show_full_model. """ self.csf_surface.visible = not event.new self.full_csf_surface.visible = event.new self.scene.mlab.draw() def reset_participant_defaults(self): self.reset_traits(traits=[ 'csf_model', 'show_full_model', 'log_scale', 'normal', 'origin' ]) @observe('csf_model', post_init=True) def change_cord_model(self, event): """ Change the spinal cord model file used for the 3D display. Parameters ---------- event : A :py:class:`traits.observation.events.TraitChangeEvent` instance The trait change event for csf_model """ if self.csf_model_reader is not None: self.csf_model_reader.initialize(event.new) @observe('scene.activated') def initialize_camera(self, event=None): # pylint: disable=unused-argument """ Set the camera for the Mayavi scene to a pre-determined perspective. Parameters ---------- event : A :py:class:`traits.observation.events.TraitChangeEvent` instance The trait change event for scene.activated """ if self.csf_surface is not None: self.scene.engine.current_object = self.csf_surface self.scene.mlab.view(azimuth=-35, elevation=75) self.scene.mlab.draw() def create_plot(self): """ Create the 3D objects to be shown. """ normal = self.normal max_ind = np.unravel_index( np.nanargmax(self.fields_model.masked_grid_data), self.fields_model.masked_grid_data.shape) self.origin = np.array([ self.fields_model.masked_gr_x[max_ind], self.fields_model.masked_gr_y[max_ind], self.fields_model.masked_gr_z[max_ind] ]) self.csf_model_reader = self.scene.engine.open(self.csf_model) self.csf_surface = Surface() self.data_set_clipper = DataSetClipper() self.scene.engine.add_filter(self.data_set_clipper, self.csf_model_reader) self.data_set_clipper.widget.widget_mode = 'ImplicitPlane' self.data_set_clipper.widget.widget.normal = normal self.data_set_clipper.widget.widget.origin = self.origin self.data_set_clipper.widget.widget.enabled = False self.data_set_clipper.widget.widget.key_press_activation = False self.data_set_clipper.filter.inside_out = True self.csf_surface.actor.property.opacity = 0.3 self.csf_surface.actor.property.specular_color = (0.0, 0.0, 1.0) self.csf_surface.actor.property.specular = 1.0 self.csf_surface.actor.actor.use_bounds = False self.scene.engine.add_filter(self.csf_surface, self.data_set_clipper) self.full_csf_surface = Surface() self.full_csf_surface.actor.property.opacity = 0.3 self.full_csf_surface.actor.property.specular_color = (0.0, 0.0, 1.0) self.full_csf_surface.actor.property.specular = 1.0 self.full_csf_surface.actor.actor.use_bounds = False self.full_csf_surface.visible = False self.scene.engine.add_filter(self.full_csf_surface, self.csf_model_reader) self.src = self.scene.mlab.pipeline.scalar_field( self.fields_model.masked_gr_x, self.fields_model.masked_gr_y, self.fields_model.masked_gr_z, self.fields_model.masked_grid_data) self.cut = self.scene.mlab.pipeline.cut_plane(self.src) self.cut.filters[0].widget.normal = normal self.cut.filters[0].widget.origin = self.origin self.cut.filters[0].widget.enabled = False self.surf = self.scene.mlab.pipeline.surface(self.cut, colormap='jet') self.surf.actor.actor.use_bounds = False self.surf.parent.scalar_lut_manager.lut.nan_color = np.array( [0, 0, 0, 0]) self.scene.mlab.draw() @observe(ob.trait('points').list_items().trait( 'value', optional=True).list_items(optional=True), post_init=True) def draw_line(self, event): """ Create or update the line described by the points in :ref:`line-attributes`. Parameters ---------- event : A :py:class:`traits.observation.events.TraitChangeEvent` instance The trait change event for points. """ if None in event.new and len(event.old) == len( event.new) and None not in event.old: self.points = event.old return points = np.array([ val.value if val is not None else np.array([0, 0, 0]) for val in self.points ]) x_positions = [] y_positions = [] z_positions = [] for point in points: x_positions.append(point[0]) y_positions.append(point[1]) z_positions.append(point[2]) if not hasattr(self.line, 'mlab_source'): self.line = self.scene.mlab.plot3d(x_positions, y_positions, z_positions, tube_radius=0.2, color=(1, 0, 0), figure=self.scene.mayavi_scene) else: self.line.mlab_source.reset(x=x_positions, y=y_positions, z=z_positions) self.scene.mlab.draw() def disable_widgets(self): """ Disable widgets to be hidden and set up color properties. """ if self.data_set_clipper.widget.widget.enabled: self.cut.filters[0].widget.enabled = False self.data_set_clipper.widget.widget.enabled = False if self.log_scale: self.surf.parent.scalar_lut_manager.lut.scale = 'log10' else: self.surf.parent.scalar_lut_manager.lut.scale = 'linear' self.surf.parent.scalar_lut_manager.show_legend = True self.surf.parent.scalar_lut_manager.use_default_name = False self.surf.parent.scalar_lut_manager.data_name = 'J (A/m^2)' self.surf.parent.scalar_lut_manager.shadow = True self.surf.parent.scalar_lut_manager.use_default_range = False self.surf.parent.scalar_lut_manager.data_range = np.array([ np.nanmin(self.fields_model.masked_grid_data), np.nanmax(self.fields_model.masked_grid_data) ]) self.surf.parent.scalar_lut_manager.lut.nan_color = np.array( [0, 0, 0, 0]) def _csf_model_default(self): try: model = self._get_default_value('csf_model') except KeyError: model = os.path.join(os.getcwd(), 'CSF.vtk') return model def _show_full_model_default(self): full_model = self.configuration.BOOLEAN_STATES[self._get_default_value( 'full_model').lower()] return full_model def _log_scale_default(self): log_scale = self.configuration.BOOLEAN_STATES[self._get_default_value( 'log_scale').lower()] return log_scale def _normal_default(self): normal = self._get_default_value('normal') return np.fromstring(normal.strip('()'), sep=',') def _origin_default(self): origin = self._get_default_value('origin') return np.fromstring(origin.strip('()'), sep=',') def _get_default_value(self, option): if self.participant_id is not None: if self.participant_id not in self.configuration: self.configuration[self.participant_id] = {} val = self.configuration[self.participant_id][option] else: val = self.configuration[self.participant_id][option] return val
class RowTableDataModel(AbstractDataModel): """ A data model that presents a sequence of objects as rows. The data is expected to be a sequence of row objects, each object providing values for the columns via an AbstractDataAccessor subclass. Concrete implementations can be found in the data_accessors module that get data from attributes, indices of sequences, and keys of mappings, but for more complex situations, custom accessors can be defined. """ #: A sequence of objects to display as rows. data = Instance( Sequence, comparison_mode=ComparisonMode.identity, allow_none=False, ) #: An object which describes how to map data for the row headers. row_header_data = Instance(AbstractDataAccessor, allow_none=False) #: An object which describes how to map data for each column. column_data = List( Instance(AbstractDataAccessor, allow_none=False), comparison_mode=ComparisonMode.identity, ) #: The index manager that helps convert toolkit indices to data view #: indices. index_manager = Instance(IntIndexManager, args=(), allow_none=False) # Data structure methods def get_column_count(self): """ How many columns in the data view model. Returns ------- column_count : non-negative int The number of columns that the data view provides. """ return len(self.column_data) def can_have_children(self, row): """ Whether or not a row can have child rows. Only the root has children. Parameters ---------- row : sequence of int The indices of the row as a sequence from root to leaf. Returns ------- can_have_children : bool Whether or not the row can ever have child rows. """ return len(row) == 0 def get_row_count(self, row): """ How many child rows the row currently has. Parameters ---------- row : sequence of int The indices of the row as a sequence from root to leaf. Returns ------- row_count : non-negative int The number of child rows that the row has. """ if len(row) == 0: return len(self.data) else: return 0 # Data value methods def get_value(self, row, column): """ Return the Python value for the row and column. This uses the row_header_data and column_data accessors to extract values for the row and column. Parameters ---------- row : sequence of int The indices of the row as a sequence from root to leaf. column : sequence of int The indices of the column as a sequence of length 0 or 1. Returns ------- value : any The value represented by the given row and column. """ if len(column) == 0: column_data = self.row_header_data else: column_data = self.column_data[column[0]] if len(row) == 0: return column_data.title obj = self.data[row[0]] return column_data.get_value(obj) def can_set_value(self, row, column): """ Whether the value in the indicated row and column can be set. This uses the row_header_data and column_data accessors to determine if the value may be changed. Parameters ---------- row : sequence of int The indices of the row as a sequence from root to leaf. column : sequence of int The indices of the column as a sequence of length 0 or 1. Returns ------- can_set_value : bool Whether or not the value can be set. """ if len(row) == 0: return False if len(column) == 0: column_data = self.row_header_data else: column_data = self.column_data[column[0]] obj = self.data[row[0]] return column_data.can_set_value(obj) def set_value(self, row, column, value): """ Set the Python value for the row and column. This uses the row_header_data and column_data accessors to set the value. Parameters ---------- row : sequence of int The indices of the row as a sequence from root to leaf. column : sequence of int The indices of the column as a sequence of length 0 or 1. value : any The new value for the given row and column. Raises ------- DataViewSetError If the value cannot be set. """ if len(row) == 0: raise DataViewSetError("Can't set column titles.") if len(column) == 0: column_data = self.row_header_data else: column_data = self.column_data[column[0]] obj = self.data[row[0]] column_data.set_value(obj, value) self.values_changed = (row, column, row, column) def get_value_type(self, row, column): """ Return the value type of the given row and column. This uses the row_header_data and column_data accessors to get the value type. Parameters ---------- row : sequence of int The indices of the row as a sequence from root to leaf. column : sequence of int The indices of the column as a sequence of length 0 or 1. Returns ------- value_type : AbstractValueType or None The value type of the given row and column, or None if no value should be displayed. """ if len(column) == 0: column_data = self.row_header_data else: column_data = self.column_data[column[0]] if len(row) == 0: return column_data.title_type return column_data.value_type # data update methods @observe("data") def _update_data(self, event): self.structure_changed = True @observe(trait("data", notify=False).list_items(optional=True)) def _update_data_items(self, event): if len(event.added) != len(event.removed): # number of rows has changed self.structure_changed = True else: if isinstance(event.index, int): start = event.index stop = min(event.index + len(event.added), len(self.data)) - 1 else: start = event.index.start stop = min(event.index.stop, len(self.data)) - 1 self.values_changed = ((start, ), (), (stop, ), ()) @observe('row_header_data') def _update_row_header_data(self, event): self.values_changed = ((), (), (), ()) @observe('row_header_data:updated') def _update_row_header_data_event(self, event): if event.new[1] == 'value': if len(self.data) > 0: self.values_changed = ((0, ), (), (len(self.data) - 1, ), ()) else: self.values_changed = ((), (), (), ()) @observe('column_data.items') def _update_all_column_data_items(self, event): self.structure_changed = True @observe('column_data:items:updated') def _update_column_data(self, event): index = self.column_data.index(event.new[0]) if event.new[1] == 'value': if len(self.data) > 0: self.values_changed = ((0, ), (index, ), (len(self.data) - 1, ), (index, )) else: self.values_changed = ((), (index, ), (), (index, )) # default data value def _data_default(self): return []
class SliceFigureModel(Editor): """ A Pyface Tasks Editor to hold the slice figure. """ #: The model object to view. If not specified, the editor is used instead. model = Instance(HasTraits) #: The UI object associated with the Traits view, if it has been #: constructed. ui = Instance("traitsui.ui.UI") #: The editor's user-visible name. name = Str("Slice Plane") #: Configuration parser. configuration = Instance(ConfigParser) #: Current participant ID. participant_id = Str() #: The :py:class:`EMFields` instance containing the field data. fields_model = Instance(EMFields) #: The :py:class:`Mayavi3DScene` instance containing the 3D plot. mayavi_scene = Instance(Mayavi3DScene) #: The :py:class:`matplotlib.figure.Figure` containing the slice figure. figure = Instance(Figure, ()) #: Use a logarithmic scale for the field data? log_scale = Bool() #: Matplotlib colormap. mycmap = Any() #: :py:class:`matplotlib.colors.Normalize` instance for the #: field data. norm = Any() #: :py:class:`matplotlib.collections.QuadMesh` containing the plot data. pcm = Any() #: :py:class:`matplotlib.colorbar.Colorbar` containing the figure's #: colorbar. clb = Any() #: Draw the line cross marker? draw_cross = Bool() #: The list of points describing the line for the line figure. points = DelegatesTo('mayavi_scene') #: List of :py:class:`matplotlib.lines.Line2D` representing the line #: cross marker line_cross = Any() #: The slice figure title. figure_title = Str() #: Data label. data_label = Str() #: Use user-input labels? use_custom_label = Bool(False) def default_traits_view(self): # pylint: disable=no-self-use """ Create the default traits View object for the model Returns ------- default_traits_view : :py:class:`traitsui.view.View` The default traits View object for the model """ return View( Group(Item('figure', editor=MPLFigureEditor(), show_label=False), )) def create(self, parent): """ Create and set the widget(s) for the Editor. Parameters ---------- parent : toolkit-specific widget The parent widget for the Editor """ self.ui = self.edit_traits(kind='subpanel', parent=parent) # pylint: disable=invalid-name self.control = self.ui.control # pylint: disable=attribute-defined-outside-init def destroy(self): """ Destroy the Editor and clean up after """ self.control = None # pylint: disable=attribute-defined-outside-init if self.ui is not None: self.ui.dispose() self.ui = None def export_slice(self, file_path): """ Export data for slice to Excel or CSV file. Parameters ---------- file_path : os.PathLike Path to output file """ x_positions, y_positions, data = self._calculate_plane() out_df = pd.DataFrame(data=data, index=y_positions, columns=x_positions) if file_path.endswith('.xlsx'): out_df.to_excel(file_path) elif file_path.endswith('.csv') or file_path.endswith('.txt'): out_df.to_csv(file_path) @observe('log_scale', post_init=True) def toggle_log_scale(self, event): """ Toggle between using a logarithmic scale and a linear scale Parameters ---------- event : A :py:class:`traits.observation.events.TraitChangeEvent` instance The trait change event for log_scale """ if event.new: self.norm = LogNorm( vmin=np.nanmin(self.fields_model.masked_grid_data), vmax=np.nanmax(self.fields_model.masked_grid_data)) else: self.norm = Normalize( vmin=np.nanmin(self.fields_model.masked_grid_data), vmax=np.nanmax(self.fields_model.masked_grid_data)) self.clb.update_normal( cm.ScalarMappable(norm=self.norm, cmap=self.mycmap)) self.update_plot(event) def create_plot(self): """ Create the slice figure plot. """ true_x, true_y, true_data = self._calculate_plane() self.mycmap = copy.copy(cm.get_cmap('jet')) self.figure.clear() axes = self.figure.add_subplot(111) self.figure.subplots_adjust(right=0.75, bottom=0.15) if self.log_scale: self.norm = LogNorm( vmin=np.nanmin(self.fields_model.masked_grid_data), vmax=np.nanmax(self.fields_model.masked_grid_data)) else: self.norm = Normalize( vmin=np.nanmin(self.fields_model.masked_grid_data), vmax=np.nanmax(self.fields_model.masked_grid_data)) self.pcm = axes.pcolormesh(true_x, true_y, true_data, shading='nearest', cmap=self.mycmap, norm=self.norm) if self.draw_cross: self.line_cross = axes.plot([0], [0], 'rx') else: self.line_cross = axes.plot([0], [0], '') axes.set_ylim( bottom=np.nanmin(self.fields_model.masked_gr_y[0, :, 0]) - 2, top=np.nanmax(self.fields_model.masked_gr_y[0, :, 0]) + 2) axes.set_xlim( left=np.nanmin(self.fields_model.masked_gr_x[:, 0, 0]) - 2, right=np.nanmax(self.fields_model.masked_gr_x[:, 0, 0]) + 2) axes.set_xlabel('X (mm)') axes.set_ylabel('Y (mm)') axes.set_title(self.figure_title) self.clb = self.figure.colorbar(cm.ScalarMappable(norm=self.norm, cmap=self.mycmap), ax=axes) self.clb.set_label(self.data_label, rotation=270, labelpad=15) self.figure.canvas.draw() @observe('fields_model.selected_field_key') def _set_figure_labels(self, event): if not self.use_custom_label: if self.fields_model.selected_field_key.startswith('J'): self.figure_title = 'Current Density Magnitude' self.data_label = 'Current Density ($A/m^2$)' elif self.fields_model.selected_field_key.startswith('EM_E'): self.figure_title = 'Electric Field Magnitude' self.data_label = 'Electric Field ($V/m$)' elif self.fields_model.selected_field_key.startswith('D'): self.figure_title = 'Displacement Flux Density Magnitude' self.data_label = 'Displacement Flux Density ($C/m^2$)' if self.line_cross is not None: self.update_line_cross(event=event) if self.pcm is not None: self.update_plot(event=event) def _calculate_plane(self): dataset = self.mayavi_scene.cut.outputs[0].output datax, datay, dataz = dataset.points.to_array().T # pylint: disable=unused-variable scalar_data = dataset.point_data.scalars.to_array() true_x = np.unique(np.floor( datax / SCALE_FACTOR).astype(int)) * SCALE_FACTOR true_y = np.unique(np.floor( datay / SCALE_FACTOR).astype(int)) * SCALE_FACTOR true_data = np.empty((true_y.size, true_x.size)) true_data[:] = np.nan for i in range(scalar_data.size): true_data[arg_find_nearest(true_y, datay[i]), arg_find_nearest(true_x, datax[i])] =\ scalar_data[i] return true_x, true_y, true_data @observe('mayavi_scene:origin') @observe('mayavi_scene:normal') def update_plot(self, event): # pylint: disable=unused-argument """ Update the slice figure when the cut plane origin or normal are changed. Parameters ---------- event : A :py:class:`traits.observation.events.TraitChangeEvent` instance The trait change event for the cut plane origin or normal """ true_x, true_y, true_data = self._calculate_plane() self.update_line_cross() axes = self.figure.axes[0] self.pcm.remove() self.pcm = axes.pcolormesh(true_x, true_y, true_data, shading='nearest', cmap=self.mycmap, norm=self.norm) axes.set_title(self.figure_title) self.clb.set_label(self.data_label, rotation=270, labelpad=15) canvas = self.figure.canvas if canvas is not None: canvas.draw() @observe('draw_cross', post_init=True) @observe( ob.trait('points').list_items().trait( 'value', optional=True).list_items(optional=True)) def update_line_cross(self, event=None): # pylint: disable=too-many-locals, unused-argument """ Update the location of the line cross marker when draw_cross is changed or when the points are changed. Parameters ---------- event : A :py:class:`traits.observation.events.TraitChangeEvent` instance The trait change event for draw_cross or points """ if not self.draw_cross and self.line_cross is not None: self.line_cross[0].set_marker('') elif self.line_cross is not None: normal_x, normal_y, normal_z = self.mayavi_scene.normal origin_x, origin_y, origin_z = self.mayavi_scene.origin plane_z_0 = -1 * (normal_x * origin_x + normal_y * origin_y) / normal_z + origin_z points = [ val.value if val is not None else np.array([0, 0, 0]) for val in self.points ] p_under = [val for val in points if val[2] <= plane_z_0] p_over = [val for val in points if val[2] > plane_z_0] if len(p_under) > 0 and len(p_over) > 0: point_1 = p_under[-1] point_2 = p_over[0] parametric_t = (-1 * normal_x * point_1[0] - normal_y * point_1[1] - normal_z * point_1[2] + normal_x * origin_x + normal_y * origin_y + normal_z * origin_z) /\ (normal_x * (point_2[0] - point_1[0]) + normal_y * (point_2[1] - point_1[1]) + normal_z * (point_2[2] - point_1[2])) x_position = point_1[0] + parametric_t * (point_2[0] - point_1[0]) y_position = point_1[1] + parametric_t * (point_2[1] - point_1[1]) self.line_cross[0].set_data([x_position], [y_position]) self.line_cross[0].set_marker('x') self.figure.canvas.draw() def _log_scale_default(self): log_scale = self.configuration.BOOLEAN_STATES[self._get_default_value( 'log_scale').lower()] return log_scale def _draw_cross_default(self): line_cross = self.configuration.BOOLEAN_STATES[self._get_default_value( 'line_cross_marker').lower()] return line_cross def _get_default_value(self, option): if self.participant_id is not None: if self.participant_id not in self.configuration: self.configuration[self.participant_id] = {} val = self.configuration[self.participant_id][option] else: val = self.configuration[self.participant_id][option] return val
class LineFigureModel(Editor): """ A Pyface Traits Editor to hold the line figure. """ #: The model object to view. If not specified, the editor is used instead. model = Instance(HasTraits) #: The UI object associated with the Traits view, if it has been #: constructed. ui = Instance("traitsui.ui.UI") #: The editor's user-visible name. name = Str("Line Plot") #: The :py:class:`EMFields` instance containing the field data. fields_model = Instance(EMFields) #: The :py:class:`matplotlib.figure.Figure` containing the line figure. figure = Instance(Figure, ()) #: The list of points describing the line for the line figure. points = List(ArrayClass, value=[ ArrayClass(value=np.array([0, 0, -1])), ArrayClass(value=np.array([0, 0, 1])) ]) #: The interpolation function to sample the field data for the line #: figure. interp_func = Instance(RegularGridInterpolator) #: The line figure title. figure_title = Str() #: The line figure x-axis label. x_axis_label = Str('Distance Along Line (mm)') #: The line figure y-axis label. y_axis_label = Str() #: Use user-input labels? use_custom_label = Bool(False) def default_traits_view(self): # pylint: disable=no-self-use """ Create the default traits View object for the model Returns ------- default_traits_view : :py:class:`traitsui.view.View` The default traits View object for the model """ return View( Group(Item('figure', editor=MPLFigureEditor(), show_label=False), )) def create(self, parent): """ Create and set the widget(s) for the Editor. Parameters ---------- parent : toolkit-specific widget The parent widget for the Editor """ self.ui = self.edit_traits(kind='subpanel', parent=parent) # pylint: disable=invalid-name self.control = self.ui.control def destroy(self): """ Destroy the Editor and clean up after """ self.control = None if self.ui is not None: self.ui.dispose() self.ui = None def export_line(self, file_path): """ Export data for line to Excel or CSV file. Parameters ---------- file_path : os.PathLike Path to output file """ line_pos, line_data = self._fill_data() out_df = pd.DataFrame(data=line_data, index=line_pos, columns=['y']) if file_path.endswith('.xlsx'): out_df.to_excel(file_path) elif file_path.endswith('.csv') or file_path.endswith('.txt'): out_df.to_csv(file_path) def _calculate_between_pair(self, point_1, point_2, prev_line_pos=0): x_positions = np.linspace(point_1[0], point_2[0], 1000) y_positions = np.linspace(point_1[1], point_2[1], 1000) z_positions = np.linspace(point_1[2], point_2[2], 1000) line_pos = np.linspace(0, np.linalg.norm(point_2 - point_1), 1000) + prev_line_pos line_data = self.interp_func((x_positions, y_positions, z_positions)) return line_pos, line_data def _interp_func_default(self): func = RegularGridInterpolator( (self.fields_model.x_vals, self.fields_model.y_vals, self.fields_model.z_vals), np.nan_to_num(self.fields_model.data_arr), bounds_error=False, fill_value=None) return func def _fill_data(self): points = [ val.value if val is not None else np.array([0, 0, 0]) for val in self.points ] line_pos = np.array([]) line_data = np.array([]) last_pos = 0 for i, point in enumerate(points[:-1]): pos, data = self._calculate_between_pair(point, points[i + 1], prev_line_pos=last_pos) line_pos = np.append(line_pos, pos) line_data = np.append(line_data, data) last_pos = line_pos[-1] return line_pos, line_data @observe(ob.trait('points').list_items().trait( 'value', optional=True).list_items(optional=True), post_init=True) def create_plot(self, event): """ Create or update the line figure. Parameters ---------- event : A :py:class:`traits.observation.events.TraitChangeEvent` instance The trait change event for points """ line_pos, line_data = self._fill_data() self.figure.clear() axes = self.figure.add_subplot(111) axes.plot(line_pos, line_data) axes.set_ylabel(self.y_axis_label) axes.set_xlabel(self.x_axis_label) self.figure.suptitle(self.figure_title) self.figure.canvas.draw() @observe('fields_model.selected_field_key') def _set_figure_labels(self, event): if not self.use_custom_label: if self.fields_model.selected_field_key.startswith('J'): self.figure_title = 'Current Density Magnitude' self.y_axis_label = 'Current Density ($A/m^2$)' elif self.fields_model.selected_field_key.startswith('EM_E'): self.figure_title = 'Electric Field Magnitude' self.y_axis_label = 'Electric Field ($V/m$)' elif self.fields_model.selected_field_key.startswith('D'): self.figure_title = 'Displacement Flux Density Magnitude' self.y_axis_label = 'Displacement Flux Density ($C/m^2$)' self.create_plot(event)
class PersonWithObserve(Person): events = List() @observe(trait("age")) def handler(self, event): self.events.append(event)
class TableModel(GridModel): """Model for table data.""" # ------------------------------------------------------------------------- # Trait definitions: # ------------------------------------------------------------------------- #: The editor that created this model editor = Instance(Editor) #: The current filter filter = Instance(TableFilter, allow_none=True) #: Current filter summary message filter_summary = Str("All items") #: Display the table items in reverse order? reverse = Bool(False) #: Event fired when the table has been sorted sorted = Event() #: The current 'auto_add' row auto_add_row = Any() def __init__(self, **traits): """Initializes the object.""" super().__init__(**traits) # Attach trait handlers to the list object: editor = self.editor object = editor.context_object name = " " + editor.extended_name # Set up listeners for any of the model data changing: object.on_trait_change(self._on_data_changed, name, dispatch="ui") object.on_trait_change(self.fire_content_changed, name + ".-", dispatch="ui") # Set up listeners for any column definitions changing: editor.on_trait_change(self.update_columns, "columns", dispatch="ui") editor.on_trait_change(self.update_columns, "columns_items", dispatch="ui") # Initialize the current filter from the editor's default filter: self.filter = editor.filter # If we are using 'auto_add' mode, create the first 'auto_add' row: if editor.auto_add: self.auto_add_row = row = editor.create_new_row() if row is not None: row.on_trait_change(self.on_auto_add_row, dispatch="ui") # -- TableModel Interface ------------------------------------------------- def dispose(self): """Disposes of the model when it is no longer needed.""" editor = self.editor object = editor.context_object name = " " + editor.extended_name # Remove listeners for any of the model data changing: object.on_trait_change(self._on_data_changed, name, remove=True) object.on_trait_change(self.fire_content_changed, name + ".-", remove=True) # Remove listeners for any column definitions changing: editor.on_trait_change(self.update_columns, "columns", remove=True) editor.on_trait_change(self.update_columns, "columns_items", remove=True) # Make sure we have removed listeners from the current filter also: if self.filter is not None: self.filter.on_trait_change(self._filter_modified, remove=True) # Clean-up any links that should be broken: self.editor = None def get_filtered_items(self): """Returns all model items matching the current filter.""" return self.__filtered_items() def get_filtered_item(self, index=0): """Returns a single specified item from those items matching the current filter. """ try: return self.__filtered_items()[index] except Exception: logger.exception( "TableModel error: Request for invalid row %d out of %d", index, len(self.__filtered_items()), ) return None def raw_index_of(self, row): """Returns the raw, unfiltered index corresponding to a specified filtered index. """ if self._filtered_cache is None: return row return self.editor.filtered_indices[row] def insert_filtered_item_after(self, index, item): """Inserts an object after a specified filtered index.""" mapped_index = 0 n = len(self.editor.filtered_indices) if index >= n: if (index != 0) or (n != 0): raise IndexError elif index >= 0: mapped_index = self.editor.filtered_indices[index] + 1 self.__items().insert(mapped_index, item) sorted = self._sort_model() if sorted: mapped_index = self.__items().index(item) self._filtered_cache = None return (mapped_index, sorted) def delete_filtered_item_at(self, index): """Deletes the object at the specified filtered index.""" if index >= len(self.editor.filtered_indices): raise IndexError mapped_index = self.editor.filtered_indices[index] items = self.__items() object = items[mapped_index] del items[mapped_index] self._filtered_cache = None return (mapped_index, object) def update_columns(self): """Updates the table view when columns have been changed.""" self._columns = None self.fire_structure_changed() self.editor.refresh() def no_column_sort(self): """Resets any sorting being performed on the underlying model.""" self._sorter = self._filtered_cache = None self.column_sorted = GridSortEvent(index=-1) # self.fire_structure_changed() # -- Event Handlers ------------------------------------------------------- @observe(trait("filter").match(lambda name, ctrait: True)) def _filter_modified(self, event): """Handles the contents of the filter being changed.""" self._filtered_cache = None self.fire_structure_changed() self.editor.filter_modified() def _click_changed(self, event): """Handles the grid firing a 'click' event.""" row, col = event # Fire the same event on the editor after mapping it to a model object # and column name: object = self.get_filtered_item(row) column = self.__get_column(col) self.editor.click = (object, column) # Check to see if the column has a view to display: view = column.get_view(object) if view is not None: column.get_object(object).edit_traits(view=view, parent=self._bounds_for( row, col)) # Invoke the column's click handler: column.on_click(object) def _dclick_changed(self, event): """Handles the grid firing a 'dclick' event.""" row, col = event # Fire the same event on the editor after mapping it to a model object # and column name: object = self.get_filtered_item(row) column = self.__get_column(col) self.editor.dclick = (object, column) # Invoke the column's double-click handler: column.on_dclick(object) def on_auto_add_row(self): """Handles the user modifying the current 'auto_add' mode row.""" object = self.auto_add_row object.on_trait_change(self.on_auto_add_row, remove=True) self.auto_add_row = row = self.editor.create_new_row() if row is not None: row.on_trait_change(self.on_auto_add_row, dispatch="ui") do_later(self.editor.add_row, object, len(self.get_filtered_items()) - 2) # -- GridModel Interface -------------------------------------------------- def get_column_count(self): """Returns the number of columns for this table.""" return len(self.__get_columns()) def get_column_name(self, index): """Returns the label of the column specified by the (zero-based) index.""" return self.__get_column(index).get_label() def get_column_size(self, index): """Returns the size in pixels of the column indexed by *index*. A value of -1 or None means to use the default. """ return self.__get_column(index).get_width() def get_cols_drag_value(self, cols): """Returns the value to use when the specified columns are dragged or copied and pasted. The parameter *cols* is a list of column indexes. """ return [self.__get_data_column(col) for col in cols] def get_cols_selection_value(self, cols): """Returns a list of TraitGridSelection objects containing the objects corresponding to the grid rows and the traits corresponding to the specified columns. """ values = [] for obj in self.__items(False): values.extend([ TraitGridSelection(obj=obj, name=self.__get_column_name(col)) for col in cols ]) return values def sort_by_column(self, col, reverse=False): """Sorts the model data by the column indexed by *col*.""" # Make sure we allow sorts by column: factory = self.editor.factory if not factory.sortable: return # Flush the object cache: self._filtered_cache = None # Cache the sorting information for later: self._sorter = self.__get_column(col).key self._reverse = reverse # If model sorting is requested, do it now: self._sort_model() # Indicate the we have been sorted: self.sorted = True self.column_sorted = GridSortEvent(index=col, reversed=reverse) def is_column_read_only(self, index): """Returns True if the column specified by the zero-based *index* is read-only. """ return not self.__get_column(index).editable def get_row_count(self): """Return the number of rows for this table.""" return len(self.__filtered_items()) def get_row_name(self, index): """Return the name of the row specified by the (zero-based) *index*.""" return "<undefined>" def get_rows_drag_value(self, rows): """Returns the value to use when the specified rows are dragged or copied and pasted. The parameter *rows* is a list of row indexes. If there is only one row listed, then return the corresponding trait object. If more than one row is listed, then return a list of objects. """ items = self.__filtered_items() return [items[row] for row in rows] def get_rows_selection_value(self, rows): """Returns a list of TraitGridSelection objects containing the object corresponding to the selected rows. """ items = self.__filtered_items() return [TraitGridSelection(obj=items[row]) for row in rows] def is_row_read_only(self, index): """Returns True if the row specified by the zero-based *index* is read-only. """ return False def get_cell_editor(self, row, col): """Returns the editor for the specified cell.""" if self.editor is None: return None column = self.__get_column(col) object = self.get_filtered_item(row) editor = column.get_editor(object) if editor is None: return None editor._ui = self.editor.ui target, name = column.target_name(object) return TraitGridCellAdapter( editor, target, name, "", context=self.editor.ui.context, style=column.get_style(object), width=column.get_edit_width(object), height=column.get_edit_height(object), ) def get_cell_renderer(self, row, col): """Returns the renderer for the specified cell.""" return self.__get_column(col).get_renderer(self.get_filtered_item(row)) def get_cell_drag_value(self, row, col): """Returns the value to use when the specified cell is dragged or copied and pasted. """ return self.__get_column(col).get_drag_value( self.get_filtered_item(row)) def get_cell_selection_value(self, row, col): """Returns a TraitGridSelection object specifying the data stored in the table at (*row*, *col*). """ return TraitGridSelection(obj=self.get_filtered_item(row), name=self.__get_column_name(col)) def resolve_selection(self, selection_list): """Returns a list of (row, col) grid-cell coordinates that correspond to the objects in *selection_list*. For each coordinate, if the row is -1, it indicates that the entire column is selected. Likewise coordinates with a column of -1 indicate an entire row that is selected. For the TableModel, the objects in *selection_list* must be TraitGridSelection objects. """ items = self.__filtered_items() cells = [] for selection in selection_list: row = -1 if selection.obj is not None: try: row = items.index(selection.obj) except ValueError: continue column = -1 if selection.name != "": column = self._get_column_index_by_trait(selection.name) if column is None: continue cells.append((row, column)) return cells def get_cell_context_menu(self, row, col): """Returns a Menu object that generates the appropriate context menu for this cell. """ column = self.__get_column(col) menu = column.get_menu(self.get_filtered_item(row)) editor = self.editor if menu is None: menu = editor.factory.menu if menu is None: menu_name = editor.factory.menu_name if menu_name: menu = getattr(self.editor.object, menu_name, None) if menu is not None: editor.prepare_menu(row, column) return (menu, editor) return None def get_value(self, row, col): """Returns the value stored in the table at (*row*, *col*).""" object = self.get_filtered_item(row) if object is self.auto_add_row: return "" value = self.__get_column(col).get_value(object) formats = self.__get_column_formats(col) if (value is not None) and (formats is not None): format = formats.get(type(value)) if format is not None: try: if callable(format): value = format(value) else: value = format % value except: pass return value def is_valid_cell_value(self, row, col, value): """Tests whether *value* is valid for the cell at (*row*, *col*). Returns True if value is acceptable, and False otherwise.""" return self.__get_column(col).is_droppable(self.get_filtered_item(row), value) def is_cell_empty(self, row, col): """Returns True if the cell at (*row*, *col*) has a None value, and False otherwise. """ return self.get_value(row, col) is None def is_cell_read_only(self, row, col): """Returns True if the cell at (*row*, *col*) is read-only, and False otherwise. """ return not self.__get_column(col).is_editable( self.get_filtered_item(row)) def get_cell_bg_color(self, row, col): """Returns a wxColour object specifying the background color of the specified cell. """ return self.__get_column(col).get_cell_color( self.get_filtered_item(row)) def get_cell_text_color(self, row, col): """Returns a wxColour object specifying the text color of the specified cell. """ column = self.__get_column(col) item = self.get_filtered_item(row) return column.get_text_color(item) def get_cell_font(self, row, col): """Returns a wxFont object specifying the font of the specified cell.""" return self.__get_column(col).get_text_font( self.get_filtered_item(row)) def get_cell_halignment(self, row, col): """Returns a string specifying the horizontal alignment of the specified cell. Returns 'left' for left alignment, 'right' for right alignment, or 'center' for center alignment. """ return self.__get_column(col).get_horizontal_alignment( self.get_filtered_item(row)) def get_cell_valignment(self, row, col): """Returns a string specifying the vertical alignment of the specified cell. Returns 'top' for top alignment, 'bottom' for bottom alignment, or 'center' for center alignment. """ return self.__get_column(col).get_vertical_alignment( self.get_filtered_item(row)) def _insert_rows(self, pos, num_rows): """Inserts *num_rows* at *pos*; fires an event only if a factory method for new rows is defined or the model is not empty. Otherwise, it returns 0. """ count = 0 factory = self.editor.factory.row_factory if factory is None: items = self.__items(False) if len(items) > 0: factory = items[0].__class__ if factory is not None: new_data = [ x for x in [factory() for i in range(num_rows)] if x is not None ] if len(new_data) > 0: count = self._insert_rows_into_model(pos, new_data) self.rows_added = ("added", pos, new_data) return count def _delete_rows(self, pos, num_rows): """Removes rows *pos* through *pos* + *num_rows* from the model.""" row_count = self.get_rows_count() if (pos + num_rows) > row_count: num_rows = row_count - pos return self._delete_rows_from_model(pos, num_rows) def _set_value(self, row, col, value): """Sets the value of the cell at (*row*, *col*) to *value*. Raises a ValueError if the value is vetoed or the cell at the specified position does not exist. """ new_rows = 0 column = self.__get_column(col) obj = None try: obj = self.get_filtered_item(row) except: # Add a new row: new_rows = self._insert_rows(self.get_row_count(), 1) if new_rows > 0: # Now set the value on the new object: try: obj = self.get_filtered_item(self.get_row_count() - 1) except: # fixme: what do we do in this case? veto the set somehow? # raise an exception? pass if obj is not None: self._set_data_on_row(obj, column, value) return new_rows def _move_column(self, frm, to): """Moves a specified **frm** column to before the specified **to** column. Returns **True** if successful; **False** otherwise. """ to_column = None if to < len(self.__get_columns()): to_column = self.__get_column(to) return self.editor.move_column(self.__get_column(frm), to_column) def _set_data_on_row(self, row, column, value): """Sets the cell specified by (*row*, *col*) to *value, which can be either a member of the row object, or a no-argument method on that object. """ column.set_value(row, value) def _insert_rows_into_model(self, pos, new_data): """Inserts the given new rows into the model.""" raw_pos = self.raw_index_of(pos) self.__items()[raw_pos:raw_pos] = new_data def _delete_rows_from_model(self, pos, num_rows): """Deletes the specified rows from the model.""" raw_rows = sorted( [self.raw_index_of(i) for i in range(pos, pos + num_rows)]) raw_rows.reverse() items = self.__items() for row in raw_rows: del items[row] return num_rows def _on_data_changed(self): """Forces the grid to refresh when the underlying list changes.""" # Invalidate the current cache (if any): self._filtered_cache = None self.fire_structure_changed() def _mouse_cell_changed(self, new): """Handles the user mousing over a specified cell.""" row, col = new column = self.__get_column(col) object = self.get_filtered_item(row) # Update the tooltip if necessary: tooltip = column.get_tooltip(object) if tooltip != self._tooltip: self._tooltip = tooltip self.editor.grid._grid_window.SetToolTip(wx.ToolTip(tooltip)) if column.is_auto_editable(object): x, y, dx, dy = self._bounds_for(row, col) if column.is_editable(object): view = View( Item( name=column.name, editor=column.get_editor(object), style=column.get_style(object), show_label=False, padding=-4, ), kind="info", width=dx, height=dy, ) else: view = column.get_view(object) if view is None: return column.get_object(object).edit_traits(view=view, parent=(x, y, dx, dy)) def _bounds_for(self, row, col): """Returns the coordinates and size of the specified cell in the form: ( x, y, dx, dy ). """ grid = self.editor.grid coords = wxg.GridCellCoords(row, col) x, y, dx, dy = grid._grid.BlockToDeviceRect(coords, coords) x, y = grid._grid_window.ClientToScreen(x, y) return (x, y, dx, dy) def _sort_model(self): """Sorts the underlying model if that is what the user requested.""" editor = self.editor sorted = editor.factory.sort_model and (self._sorter is not None) if sorted: items = self.__items(False)[:] items.sort(key=self._sorter) if self.reverse ^ self._reverse: items.reverse() editor.value = items return sorted def __items(self, ordered=True): """Returns the raw list of model objects.""" result = self.editor.value if not isinstance(result, SequenceTypes): return [result] if ordered and self.reverse: return ReversedList(result) return result def __filtered_items(self): """Returns the list of all model objects that pass the current filter.""" fc = self._filtered_cache if fc is None: items = self.__items() filter = self.filter if filter is None: nitems = [nitem for nitem in enumerate(items)] self.filter_summary = "All %s items" % len(nitems) else: if not callable(filter): filter = filter.filter nitems = [ nitem for nitem in enumerate(items) if filter(nitem[1]) ] self.filter_summary = "%s of %s items" % ( len(nitems), len(items), ) sorter = self._sorter if sorter is not None: nitems.sort(key=lambda x: sorter(x[1])) if self._reverse: nitems.reverse() self.editor.filtered_indices = [x[0] for x in nitems] self._filtered_cache = fc = [x[1] for x in nitems] if self.auto_add_row is not None: self._filtered_cache.append(self.auto_add_row) return fc def __get_data_column(self, col): """Returns a list of model data from the column indexed by *col*.""" column = self.__get_column(col) return [column.get_value(item) for item in self.__filtered_items()] def __get_columns(self): columns = self._columns if columns is None: self._columns = columns = [ c for c in self.editor.columns if c.visible ] return columns def __get_column(self, col): try: return self.__get_columns()[col] except: return self.__get_columns()[0] def __get_column_name(self, col): return self.__get_column(col).name def __get_column_formats(self, col): return None # Not used/implemented currently def _get_column_index_by_trait(self, name): for i, col in enumerate(self.__get_columns()): if name == col.name: return i