#------------------------------------------------------------------------------ # # Copyright (c) 2005, Enthought, Inc. # All rights reserved. # # This software is provided without warranty under the terms of the BSD # license included in enthought/LICENSE.txt and may be redistributed only # under the conditions described in the aforementioned license. The license # is also available online at http://www.enthought.com/licenses/BSD.txt # # Thanks for using Enthought open source! # # Author: David C. Morrill # Date: 07/01/2005 # #------------------------------------------------------------------------------ """ Defines the table editor for the wxPython user interface toolkit. """ #------------------------------------------------------------------------------- # Imports: #------------------------------------------------------------------------------- import wx from traits.api \ import Int, List, Instance, Str, Any, Button, Tuple, \ HasPrivateTraits, Bool, Event, Property from traitsui.api \ import View, Item, UI, InstanceEditor, EnumEditor, Handler, SetEditor, \ ListUndoItem from traitsui.editors.table_editor \ import BaseTableEditor, customize_filter from traitsui.menu \ import Action, ToolBar from traitsui.table_column \ import TableColumn, ObjectColumn from traitsui.table_filter \ import TableFilter from traitsui.ui_traits \ import SequenceTypes from pyface.ui.wx.grid.api \ import Grid from pyface.dock.api \ import DockWindow, DockSizer, DockSection, DockRegion, DockControl from pyface.image_resource \ import ImageResource from pyface.timer.api \ import do_later from editor \ import Editor from table_model \ import TableModel, TraitGridSelection from helper import TraitsUIPanel #------------------------------------------------------------------------------- # Constants: #------------------------------------------------------------------------------- # Mapping from TableEditor selection modes to Grid selection modes: GridModes = { 'row': 'rows', 'rows': 'rows', 'column': 'cols', 'columns': 'cols', 'cell': 'cell', 'cells': 'cell' } #------------------------------------------------------------------------------- # 'TableEditor' class: #------------------------------------------------------------------------------- class TableEditor ( Editor, BaseTableEditor ): """ Editor that presents data in a table. Optionally, tables can have a set of filters that reduce the set of data displayed, according to their criteria. """ #--------------------------------------------------------------------------- # Trait definitions: #--------------------------------------------------------------------------- # The set of columns currently defined on the editor: columns = List( TableColumn ) # Index of currently edited (i.e., selected) table item(s): selected_row_index = Int( -1 ) selected_row_indices = List( Int ) selected_indices = Property selected_column_index = Int( -1 ) selected_column_indices = List( Int ) selected_cell_index = Tuple( Int, Int ) selected_cell_indices = List( Tuple( Int, Int ) ) # The currently selected table item(s): selected_row = Any selected_rows = List selected_items = Property selected_column = Any selected_columns = List selected_cell = Tuple( Any, Str ) selected_cells = List( Tuple( Any, Str ) ) selected_values = Property # The indices of the table items currently passing the table filter: filtered_indices = List( Int ) # The event fired when a cell is clicked on: click = Event # The event fired when a cell is double-clicked on: dclick = Event # Is the editor in row mode (i.e. not column or cell mode)? in_row_mode = Property # Is the editor in column mode (i.e. not row or cell mode)? in_column_mode = Property # Current filter object (should be a TableFilter or callable or None): filter = Any # The grid widget associated with the editor: grid = Instance( Grid ) # The table model associated with the editor: model = Instance( TableModel ) # TableEditorToolbar associated with the editor: toolbar = Any # The Traits UI associated with the table editor toolbar: toolbar_ui = Instance( UI ) # Is the table editor scrollable? This value overrides the default. scrollable = True # Is 'auto_add' mode in effect? (I.e., new rows are automatically added to # the end of the table when the user modifies current last row.) auto_add = Bool( False ) #--------------------------------------------------------------------------- # Finishes initializing the editor by creating the underlying toolkit # widget: #--------------------------------------------------------------------------- def init ( self, parent ): """ Finishes initializing the editor by creating the underlying toolkit widget. """ factory = self.factory self.filter = factory.filter self.auto_add = (factory.auto_add and (factory.row_factory is not None)) columns = factory.columns[:] if (len( columns ) == 0) and (len( self.value ) > 0): columns = [ ObjectColumn( name = name ) for name in self.value[0].editable_traits() ] self.columns = columns self.model = model = TableModel( editor = self, reverse = factory.reverse ) model.on_trait_change( self._model_sorted, 'sorted', dispatch = 'ui' ) mode = factory.selection_mode row_mode = mode in ( 'row', 'rows' ) selected = None items = model.get_filtered_items() if factory.editable and (len( items ) > 0): selected = items[0] if (factory.edit_view == ' ') or (not row_mode): self.control = panel = TraitsUIPanel( parent, -1 ) sizer = wx.BoxSizer( wx.VERTICAL ) self._create_toolbar( panel, sizer ) # Create the table (i.e. grid) control: hsizer = wx.BoxSizer( wx.HORIZONTAL ) self._create_grid( panel, hsizer ) sizer.Add( hsizer, 1, wx.EXPAND ) else: item = self.item name = item.get_label( self.ui ) theme = factory.dock_theme or item.container.dock_theme self.control = dw = DockWindow( parent, theme = theme ).control panel = TraitsUIPanel( dw, -1, size = ( 300, 300 ) ) sizer = wx.BoxSizer( wx.VERTICAL ) dc = DockControl( name = name + ' Table', id = 'table', control = panel, style = 'fixed' ) contents = [ DockRegion( contents = [ dc ] ) ] self._create_toolbar( panel, sizer ) selected = None items = model.get_filtered_items() if factory.editable and (len( items ) > 0): selected = items[0] # Create the table (i.e. grid) control: hsizer = wx.BoxSizer( wx.HORIZONTAL ) self._create_grid( panel, hsizer ) sizer.Add( hsizer, 1, wx.EXPAND ) # Assign the initial object here, so a valid editor will be built # when the 'edit_traits' call is made: self.selected_row = selected self._ui = ui = self.edit_traits( parent = dw, kind = 'subpanel', view = View( [ Item( 'selected_row', style = 'custom', editor = InstanceEditor( view = factory.edit_view, kind = 'subpanel' ), resizable = True, width = factory.edit_view_width, height = factory.edit_view_height ), '|<>' ], resizable = True, handler = factory.edit_view_handler ) ) # Set the parent UI of the new UI to our own UI: ui.parent = self.ui # Reset the object so that the sub-sub-view will pick up the # correct history also: self.selected_row = None self.selected_row = selected dc.style = item.dock contents.append( DockRegion( contents = [ DockControl( name = name + ' Editor', id = 'editor', control = ui.control, style = item.dock ) ] ) ) # Finish setting up the DockWindow: dw.SetSizer( DockSizer( contents = DockSection( contents = contents, is_row = (factory.orientation == 'horizontal') ) ) ) # Set up the required externally synchronized traits (if any): sv = self.sync_value is_list = (mode[-1] == 's') sv( factory.click, 'click', 'to' ) sv( factory.dclick, 'dclick', 'to' ) sv( factory.filter_name, 'filter', 'from' ) sv( factory.columns_name, 'columns', is_list = True ) sv( factory.filtered_indices, 'filtered_indices', 'to' ) sv( factory.selected, 'selected_%s' % mode, is_list = is_list ) if is_list: sv( factory.selected_indices, 'selected_%s_indices' % mode[:-1], is_list = True ) else: sv( factory.selected_indices, 'selected_%s_index' % mode ) # Listen for the selection changing on the grid: self.grid.on_trait_change( getattr( self, '_selection_%s_updated' % mode ), 'selection_changed', dispatch = 'ui' ) # Make sure the selection is initialized: if row_mode: self.set_selection( items[0:1] ) else: self.set_selection() # Set the min height of the grid panel to 0, this will provide # a scrollbar if the window is resized such that only the first row # is visible panel.SetMinSize((-1, 0)) # Finish the panel layout setup: panel.SetSizer( sizer ) #--------------------------------------------------------------------------- # Creates the associated grid control used to implement the table: #--------------------------------------------------------------------------- def _create_grid ( self, parent, sizer ): """ Creates the associated grid control used to implement the table. """ factory = self.factory selection_mode = GridModes[ factory.selection_mode ] if factory.selection_bg_color is None: selection_mode = '' self.grid = grid = Grid( parent, model = self.model, enable_lines = factory.show_lines, grid_line_color = factory.line_color, show_row_headers = factory.show_row_labels, show_column_headers = factory.show_column_labels, default_cell_font = factory.cell_font, default_cell_text_color = factory.cell_color, default_cell_bg_color = factory.cell_bg_color, default_cell_read_only_color = factory.cell_read_only_bg_color, default_label_font = factory.label_font, default_label_text_color = factory.label_color, default_label_bg_color = factory.label_bg_color, selection_bg_color = factory.selection_bg_color, selection_text_color = factory.selection_color, autosize = factory.auto_size, read_only = not factory.editable, edit_on_first_click = factory.edit_on_first_click, selection_mode = selection_mode, allow_column_sort = factory.sortable, allow_row_sort = False, column_label_height = factory.column_label_height, row_label_width = factory.row_label_width ) _grid = grid._grid _grid.SetScrollLineY( factory.scroll_dy ) # Set the default size for each table row: height = factory.row_height if height <= 0: height = _grid.GetTextExtent( 'My' )[1] + 9 _grid.SetDefaultRowSize( height ) # Allow the table to be resizable if the user did not explicitly # specify a number of rows to display: self.scrollable = (factory.rows == 0) # Calculate a reasonable default size for the table: if len( self.model.get_filtered_items() ) > 0: height = _grid.GetRowSize( 0 ) max_rows = factory.rows or 15 min_width = max( 150, 80 * len( self.columns ) ) if factory.show_column_labels: min_height = _grid.GetColLabelSize() + (max_rows * height) else: min_height = (max_rows * height) _grid.SetMinSize(wx.Size(min_width, min_height)) # On Linux, there is what appears to be a bug in wx in which the # vertical scrollbar will not be sized properly if the TableEditor is # sized to be shorter than the minimum height specified above. Since # this height is only set to ensure that the TableEditor is sized # correctly during the initial UI layout, we un-set it after this takes # place (addresses ticket 1810) def clear_minimum_height ( info ): min_size = _grid.GetMinSize() min_size.height = 0 _grid.SetMinSize ( min_size ) self.ui.add_defined ( clear_minimum_height ) sizer.Add( grid.control, 1, wx.EXPAND ) return grid.control #--------------------------------------------------------------------------- # Creates the table editing tool bar: #--------------------------------------------------------------------------- def _create_toolbar ( self, parent, sizer ): """ Creates the table editing toolbar. """ factory = self.factory if not factory.show_toolbar: return toolbar = TableEditorToolbar( parent = parent, editor = self ) if (toolbar.control is not None) or (len( factory.filters ) > 0): tb_sizer = wx.BoxSizer( wx.HORIZONTAL ) if len( factory.filters ) > 0: view = View( [ Item( 'filter<250>{View}', editor = factory._filter_editor ), '_', Item( 'filter_summary<100>{Results}~', object = 'model', resizable = False ), '_', '-' ], resizable = True ) self.toolbar_ui = ui = view.ui( context = { 'object': self, 'model': self.model }, parent = parent, kind = 'subpanel' ).set( parent = self.ui ) tb_sizer.Add( ui.control, 0 ) if toolbar.control is not None: self.toolbar = toolbar # add padding so the toolbar is right aligned tb_sizer.Add( ( 1, 1 ), 1, wx.EXPAND ) tb_sizer.Add( toolbar.control, 0 ) sizer.Add( tb_sizer, 0, wx.ALIGN_RIGHT | wx.EXPAND ) #--------------------------------------------------------------------------- # Disposes of the contents of an editor: #--------------------------------------------------------------------------- def dispose ( self ): """ Disposes of the contents of an editor. """ if self.toolbar_ui is not None: self.toolbar_ui.dispose() if self._ui is not None: self._ui.dispose() self.grid.on_trait_change( getattr( self, '_selection_%s_updated' % self.factory.selection_mode ), 'selection_changed', remove = True ) self.model.on_trait_change( self._model_sorted, 'sorted', remove = True ) self.grid.dispose() self.model.dispose() # Break any links needed to allow garbage collection: self.grid = self.model = self.toolbar = None super( TableEditor, self ).dispose() #--------------------------------------------------------------------------- # Updates the editor when the object trait changes external to the editor: #--------------------------------------------------------------------------- def update_editor ( self ): """ Updates the editor when the object trait changes externally to the editor. """ # fixme: Do we need to override this method? pass #--------------------------------------------------------------------------- # Refreshes the editor control: #--------------------------------------------------------------------------- def refresh ( self ): """ Refreshes the editor control. """ self.grid._grid.Refresh() #--------------------------------------------------------------------------- # Sets the current selection to a set of specified objects: #--------------------------------------------------------------------------- def set_selection ( self, objects = [], notify = True ): """ Sets the current selection to a set of specified objects. """ if not isinstance( objects, SequenceTypes ): objects = [ objects ] self.grid.set_selection( [ TraitGridSelection( obj = object ) for object in objects ], notify = notify ) #--------------------------------------------------------------------------- # Sets the current selection to a set of specified object/column pairs: #--------------------------------------------------------------------------- def set_extended_selection ( self, *pairs ): """ Sets the current selection to a set of specified object/column pairs. """ if (len( pairs ) == 1) and isinstance( pairs[0], list ): pairs = pairs[0] grid_selections = [TraitGridSelection(obj = object, name = name) for object, name in pairs] self.grid.set_selection(grid_selections) #--------------------------------------------------------------------------- # Creates a new row object using the provided factory: #--------------------------------------------------------------------------- def create_new_row ( self ): """ Creates a new row object using the provided factory. """ factory = self.factory kw = factory.row_factory_kw.copy() if '__table_editor__' in kw: kw[ '__table_editor__' ] = self return self.ui.evaluate( factory.row_factory, *factory.row_factory_args, **kw ) #--------------------------------------------------------------------------- # Adds a new object as a new row after the currently selected indices: #--------------------------------------------------------------------------- def add_row ( self, object = None, index = None ): """ Adds a specified object as a new row after the specified index. """ filtered_items = self.model.get_filtered_items if index is None: indices = self.selected_indices if len( indices ) == 0: indices = [ len( filtered_items() ) - 1 ] indices.reverse() else: indices = [ index ] if object is None: objects = [] for index in indices: object = self.create_new_row() if object is None: if self.in_row_mode: self.set_selection() return objects.append( object ) else: objects = [ object ] items = [] insert_item_after = self.model.insert_filtered_item_after in_row_mode = self.in_row_mode for i, index in enumerate( indices ): object = objects[i] index, extend = insert_item_after( index, object ) if in_row_mode and (object in filtered_items()): items.append( object ) self._add_undo( ListUndoItem( object = self.object, name = self.name, index = index, added = [ object ] ), extend ) if in_row_mode: self.set_selection( items ) #--------------------------------------------------------------------------- # Moves a column from one place to another: #--------------------------------------------------------------------------- def move_column ( self, from_column, to_column ): """ Moves the specified **from_column** from its current position to just preceding the specified **to_column**. """ columns = self.columns frm = columns.index( from_column ) if to_column is None: to = len( columns ) else: to = columns.index( to_column ) del columns[ frm ] columns.insert( to - (frm < to), from_column ) return True #-- Property Implementations ----------------------------------------------- def _get_selected_indices ( self ): sm = self.factory.selection_mode if sm == 'rows': return self.selected_row_indices elif sm == 'row': index = self.selected_row_index if index >= 0: return [ index ] elif sm == 'cells': return list( set( [ row_col[0] for row_col in self.selected_cell_indices ] ) ) elif sm == 'cell': index = self.selected_cell_index[0] if index >= 0: return [ index ] return [] def _get_selected_items ( self ): sm = self.factory.selection_mode if sm == 'rows': return self.selected_rows elif sm == 'row': item = self.selected_row if item is not None: return [ item ] elif sm == 'cells': return list( set( [ item_name[0] for item_name in self.selected_cells ] ) ) elif sm == 'cell': item = self.selected_cell[0] if item is not None: return [ item ] return [] def _get_selected_values ( self ): if self.in_row_mode: return [ ( item, '' ) for item in self.selected_items ] if self.in_column_mode: if self.factory.selection_mode == 'columns': return [ ( None, column ) for column in self.selected_columns ] column = self.selected_column if column != '': return [ ( None, column ) ] return [] if self.factory.selection_mode == 'cells': return self.selected_cells item = self.selected_cell if item[0] is not None: return [ item ] return [] def _get_in_row_mode ( self ): return (self.factory.selection_mode in ( 'row', 'rows' )) def _get_in_column_mode ( self ): return (self.factory.selection_mode in ( 'column', 'columns' )) #-- UI preference save/restore interface ----------------------------------- #--------------------------------------------------------------------------- # Restores any saved user preference information associated with the # editor: #--------------------------------------------------------------------------- def restore_prefs ( self, prefs ): """ Restores any saved user preference information associated with the editor. """ factory = self.factory try: filters = prefs.get( 'filters', None ) if filters is not None: factory.filters = ([ f for f in factory.filters if f.template ] + [ f for f in filters if not f.template ]) columns = prefs.get( 'columns' ) if columns is not None: new_columns = [] all_columns = self.columns + factory.other_columns for column in columns: for column2 in all_columns: if column == column2.get_label(): new_columns.append( column2 ) break self.columns = new_columns # Restore the column sizes if possible: if not factory.auto_size: widths = prefs.get( 'widths' ) if widths is not None: # fixme: Talk to Jason about a better way to do this: self.grid._user_col_size = True set_col_size = self.grid._grid.SetColSize for i, width in enumerate( widths ): if width >= 0: set_col_size( i, width ) structure = prefs.get( 'structure' ) if (structure is not None) and (factory.edit_view != ' '): self.control.GetSizer().SetStructure( self.control, structure ) except: pass #--------------------------------------------------------------------------- # Returns any user preference information associated with the editor: #--------------------------------------------------------------------------- def save_prefs ( self ): """ Returns any user preference information associated with the editor. """ get_col_size = self.grid._grid.GetColSize result = { 'filters': [ f for f in self.factory.filters if not f.template ], 'columns': [ c.get_label() for c in self.columns ], 'widths': [ get_col_size( i ) for i in range( len( self.columns ) ) ] } if self.factory.edit_view != ' ': result[ 'structure' ] = self.control.GetSizer().GetStructure() return result #-- Public Methods --------------------------------------------------------- def filter_modified ( self ): """ Handles updating the selection when some aspect of the current filter has changed. """ values = self.selected_values if len( values ) > 0: if self.in_column_mode: self.set_extended_selection( values ) else: items = self.model.get_filtered_items() self.set_extended_selection( [ item for item in values if item[0] in items ] ) #-- Event Handlers --------------------------------------------------------- #--------------------------------------------------------------------------- # Handles the user selecting items (rows, columns, cells) in the table: #--------------------------------------------------------------------------- def _selection_row_updated ( self, event ): """ Handles the user selecting items (rows, columns, cells) in the table. """ gfi = self.model.get_filtered_item rio = self.model.raw_index_of tl = self.grid._grid.GetSelectionBlockTopLeft() br = iter( self.grid._grid.GetSelectionBlockBottomRight() ) rows = len( self.model.get_filtered_items() ) if self.auto_add: rows -= 1 # Get the row items and indices in the selection: values = [] for row0, col0 in tl: row1, col1 = br.next() for row in xrange( row0, row1 + 1 ): if row < rows: values.append( ( rio( row ), gfi( row ) ) ) if len( values ) > 0: # Sort by increasing row index: values.sort( lambda l, r: cmp( l[0], r[0] ) ) index, row = values[0] else: index, row = -1, None # Save the new selection information: self.set( selected_row_index = index, trait_change_notify = False ) self.setx( selected_row = row ) # Update the toolbar status: self._update_toolbar( row is not None ) # Invoke the user 'on_select' handler: self.ui.evaluate( self.factory.on_select, row ) def _selection_rows_updated ( self, event ): """ Handles multiple row selection changes. """ gfi = self.model.get_filtered_item rio = self.model.raw_index_of tl = self.grid._grid.GetSelectionBlockTopLeft() br = iter( self.grid._grid.GetSelectionBlockBottomRight() ) rows = len( self.model.get_filtered_items() ) if self.auto_add: rows -= 1 # Get the row items and indices in the selection: values = [] for row0, col0 in tl: row1, col1 = br.next() for row in xrange( row0, row1 + 1 ): if row < rows: values.append( ( rio( row ), gfi( row ) ) ) # Sort by increasing row index: values.sort( lambda l, r: cmp( l[0], r[0] ) ) # Save the new selection information: self.trait_set( selected_row_indices = [ v[0] for v in values ], trait_change_notify = False ) rows = [ v[1] for v in values ] self.setx( selected_rows = rows ) # Update the toolbar status: self._update_toolbar( len( values ) > 0 ) # Invoke the user 'on_select' handler: self.ui.evaluate( self.factory.on_select, rows ) def _selection_column_updated ( self, event ): """ Handles single column selection changes. """ cols = self.columns tl = self.grid._grid.GetSelectionBlockTopLeft() br = iter( self.grid._grid.GetSelectionBlockBottomRight() ) # Get the column items and indices in the selection: values = [] for row0, col0 in tl: row1, col1 = br.next() for col in xrange( col0, col1 + 1 ): values.append( ( col, cols[ col ].name ) ) if len( values ) > 0: # Sort by increasing column index: values.sort( lambda l, r: cmp( l[0], r[0] ) ) index, column = values[0] else: index, column = -1, '' # Save the new selection information: self.set( selected_column_index = index, trait_change_notify = False ) self.setx( selected_column = column ) # Invoke the user 'on_select' handler: self.ui.evaluate( self.factory.on_select, column ) def _selection_columns_updated ( self, event ): """ Handles multiple column selection changes. """ cols = self.columns tl = self.grid._grid.GetSelectionBlockTopLeft() br = iter( self.grid._grid.GetSelectionBlockBottomRight() ) # Get the column items and indices in the selection: values = [] for row0, col0 in tl: row1, col1 = br.next() for col in xrange( col0, col1 + 1 ): values.append( ( col, cols[ col ].name ) ) # Sort by increasing row index: values.sort( lambda l, r: cmp( l[0], r[0] ) ) # Save the new selection information: self.set( selected_column_indices = [ v[0] for v in values ], trait_change_notify = False ) columns = [ v[1] for v in values ] self.setx( selected_columns = columns ) # Invoke the user 'on_select' handler: self.ui.evaluate( self.factory.on_select, columns ) def _selection_cell_updated ( self, event ): """ Handles single cell selection changes. """ tl = self.grid._grid.GetSelectionBlockTopLeft() if len( tl ) == 0: return gfi = self.model.get_filtered_item rio = self.model.raw_index_of cols = self.columns br = iter( self.grid._grid.GetSelectionBlockBottomRight() ) # Get the column items and indices in the selection: values = [] for row0, col0 in tl: row1, col1 = br.next() for row in xrange( row0, row1 + 1 ): item = gfi( row ) for col in xrange( col0, col1 + 1 ): values.append( ( ( rio( row ), col ), ( item, cols[ col ].name ) ) ) if len( values ) > 0: # Sort by increasing row, column index: values.sort( lambda l, r: cmp( l[0], r[0] ) ) index, cell = values[0] else: index, cell = ( -1, -1 ), ( None, '' ) # Save the new selection information: self.set( selected_cell_index = index, trait_change_notify = False ) self.setx( selected_cell = cell ) # Update the toolbar status: self._update_toolbar( len( values ) > 0 ) # Invoke the user 'on_select' handler: self.ui.evaluate( self.factory.on_select, cell ) def _selection_cells_updated ( self, event ): """ Handles multiple cell selection changes. """ gfi = self.model.get_filtered_item rio = self.model.raw_index_of cols = self.columns tl = self.grid._grid.GetSelectionBlockTopLeft() br = iter( self.grid._grid.GetSelectionBlockBottomRight() ) # Get the column items and indices in the selection: values = [] for row0, col0 in tl: row1, col1 = br.next() for row in xrange( row0, row1 + 1 ): item = gfi( row ) for col in xrange( col0, col1 + 1 ): values.append( ( ( rio( row ), col ), ( item, cols[ col ].name ) ) ) # Sort by increasing row, column index: values.sort( lambda l, r: cmp( l[0], r[0] ) ) # Save the new selection information: self.setx( selected_cell_indices = [ v[0] for v in values ]) cells = [ v[1] for v in values ] self.setx( selected_cells = cells ) # Update the toolbar status: self._update_toolbar( len( cells ) > 0 ) # Invoke the user 'on_select' handler: self.ui.evaluate( self.factory.on_select, cells ) def _selected_row_changed ( self, item ): if not self._no_notify: if item is None: self.set_selection( notify = False ) else: self.set_selection( item, notify = False ) def _selected_row_index_changed ( self, row ): if not self._no_notify: if row < 0: self.set_selection( notify = False ) else: self.set_selection( self.value[ row ], notify = False ) def _selected_rows_changed ( self, items ): if not self._no_notify: self.set_selection( items, notify = False ) def _selected_row_indices_changed ( self, indices ): if not self._no_notify: value = self.value self.set_selection( [ value[i] for i in indices ], notify = False ) def _selected_column_changed ( self, name ): if not self._no_notify: self.set_extended_selection( ( None, name ) ) def _selected_column_index_changed ( self, index ): if not self._no_notify: if index < 0: self.set_extended_selection() else: self.set_extended_selection( ( None, self.model.get_column_name[ index ] ) ) def _selected_columns_changed ( self, names ): if not self._no_notify: self.set_extended_selection( [ ( None, name ) for name in names ] ) def _selected_column_indices_changed ( self, indices ): if not self._no_notify: gcn = self.model.get_column_name self.set_extended_selection( [ ( None, gcn(i) ) for i in indices ] ) def _selected_cell_changed ( self, cell ): if not self._no_notify: self.set_extended_selection( [ cell ] ) def _selected_cell_index_changed ( self, pair ): if not self._no_notify: row, column = pair if (row < 0) or (column < 0): self.set_extended_selection() else: self.set_extended_selection( ( self.value[ row ], self.model.get_column_name[ column ] ) ) def _selected_cells_changed ( self, cells ): if not self._no_notify: self.set_extended_selection( cells ) def _selected_cell_indices_changed ( self, pairs ): if not self._no_notify: value = self.value gcn = self.model.get_column_name new_selection = [(value[row], gcn(col)) for row, col in pairs] self.set_extended_selection(new_selection) def _update_toolbar ( self, has_selection ): """ Updates the toolbar after a selection change. """ toolbar = self.toolbar if toolbar is not None: no_filter = (self.filter is None) if has_selection: indices = self.selected_indices start = indices[0] n = len( self.model.get_filtered_items() ) - 1 delete = toolbar.delete if self.auto_add: n -= 1 delete.enabled = (start <= n) else: delete.enabled = True deletable = self.factory.deletable if delete.enabled and callable( deletable ): delete.enabled = reduce( lambda l, r: l and r, [ deletable( item ) for item in self.selected_items ], True ) toolbar.search.enabled = toolbar.add.enabled = True toolbar.move_up.enabled = (no_filter and (start > 0)) toolbar.move_down.enabled = (no_filter and (indices[-1] < n)) else: toolbar.add.enabled = no_filter toolbar.search.enabled = toolbar.delete.enabled = \ toolbar.move_up.enabled = toolbar.move_down.enabled = False #--------------------------------------------------------------------------- # Handles the contents of the model being resorted: #--------------------------------------------------------------------------- def _model_sorted ( self ): """ Handles the contents of the model being resorted. """ if self.toolbar is not None: self.toolbar.no_sort.enabled = True values = self.selected_values if len( values ) > 0: do_later( self.set_extended_selection, values ) #--------------------------------------------------------------------------- # Handles the current filter being changed: #--------------------------------------------------------------------------- def _filter_changed ( self, old_filter, new_filter ): """ Handles the current filter being changed. """ if new_filter is customize_filter: do_later( self._customize_filters, old_filter ) elif self.model is not None: if ((new_filter is not None) and (not isinstance( new_filter, TableFilter ))): new_filter = TableFilter( allowed = new_filter ) self.model.filter = new_filter self.filter_modified() #--------------------------------------------------------------------------- # Refresh the list of available filters: #--------------------------------------------------------------------------- def _refresh_filters ( self, filters ): factory = self.factory # hack: The following line forces the 'filters' to be changed... factory.filters = [] factory.filters = filters #--------------------------------------------------------------------------- # Allows the user to customize the current set of table filters: #--------------------------------------------------------------------------- def _customize_filters ( self, filter ): """ Allows the user to customize the current set of table filters. """ factory = self.factory filter_editor = TableFilterEditor( editor = self, filter = filter ) enum_editor = EnumEditor( values = factory.filters[:], mode = 'list' ) ui = filter_editor.edit_traits( parent = self.control, view = View( [ [ Item( 'filter<200>@', editor = enum_editor, resizable = True ), '|<>' ], [ 'edit:edit', 'new', 'apply', 'delete:delete', '|<>' ], '-' ], title = 'Customize Filters', kind = 'livemodal', height = .25, buttons = [ 'OK', 'Cancel' ] ) ) if ui.result: self._refresh_filters( enum_editor.values ) self.filter = filter_editor.filter else: self.filter = filter #--------------------------------------------------------------------------- # Handles the user requesting that columns not be sorted: #--------------------------------------------------------------------------- def on_no_sort ( self ): """ Handles the user requesting that columns not be sorted. """ self.model.no_column_sort() self.toolbar.no_sort.enabled = False values = self.selected_values if len( values ) > 0: self.set_extended_selection( values ) #--------------------------------------------------------------------------- # Handles the user requesting to move the current item up one row: #--------------------------------------------------------------------------- def on_move_up ( self ): """ Handles the user requesting to move the current item up one row. """ model = self.model objects = [] for index in self.selected_indices: objects.append( model.get_filtered_item( index ) ) index -= 1 object = model.get_filtered_item( index ) model.delete_filtered_item_at( index ) model.insert_filtered_item_after( index, object ) if self.in_row_mode: self.set_selection( objects ) else: self.set_extended_selection( self.selected_values ) #--------------------------------------------------------------------------- # Handles the user requesting to move the current item down one row: #--------------------------------------------------------------------------- def on_move_down ( self ): """ Handles the user requesting to move the current item down one row. """ model = self.model objects = [] indices = self.selected_indices[:] indices.reverse() for index in indices: object = model.get_filtered_item( index ) objects.append( object ) model.delete_filtered_item_at( index ) model.insert_filtered_item_after( index, object ) if self.in_row_mode: self.set_selection( objects ) else: self.set_extended_selection( self.selected_values ) #--------------------------------------------------------------------------- # Handles the user requesting a table search: #--------------------------------------------------------------------------- def on_search ( self ): """ Handles the user requesting a table search. """ self.factory.search.edit_traits( parent = self.control, view = 'searchable_view', handler = TableSearchHandler( editor = self ) ) #--------------------------------------------------------------------------- # Handles the user requesting to add a new row to the table: #--------------------------------------------------------------------------- def on_add ( self ): """ Handles the user requesting to add a new row to the table. """ self.add_row() #--------------------------------------------------------------------------- # Handles the user requesting to delete the currently selected items of the # table: #--------------------------------------------------------------------------- def on_delete ( self ): """ Handles the user requesting to delete the currently selected items of the table. """ # Get the selected row indices: indices = self.selected_indices[:] values = self.selected_values[:] indices.reverse() # Make sure that we don't delete any rows while an editor is open in it self.grid.stop_editing_indices(indices) # Delete the selected rows: for i in indices: index, object = self.model.delete_filtered_item_at( i ) self._add_undo( ListUndoItem( object = self.object, name = self.name, index = index, removed = [ object ] ) ) # Compute the new selection and set it: items = self.model.get_filtered_items() n = len( items ) - 1 indices.reverse() for i in range( len( indices ) - 1, -1, -1 ): if indices[i] > n: indices[i] = n if indices[i] < 0: del indices[i] del values[i] n = len( indices ) if n > 0: if self.in_row_mode: self.set_selection( list( set( [ items[i] for i in indices ] ) ) ) else: self.set_extended_selection( list( set( [ ( items[ indices[i] ], values[i][1] ) for i in range( n ) ] ) ) ) else: self._update_toolbar( False ) #--------------------------------------------------------------------------- # Handles the user requesting to set the user preference items for the # table: #--------------------------------------------------------------------------- def on_prefs ( self ): """ Handles the user requesting to set the user preference items for the table. """ columns = self.columns[:] columns.extend( [ c for c in (self.factory.columns + self.factory.other_columns) if c not in columns ] ) self.edit_traits( parent = self.control, view = View( [ Item( 'columns', resizable = True, editor = SetEditor( values = columns, ordered = True, can_move_all = False ) ), '|<>' ], title = 'Select and Order Columns', width = 0.3, height = 0.3, resizable = True, buttons = [ 'Undo', 'OK', 'Cancel' ], kind = 'livemodal' ) ) #--------------------------------------------------------------------------- # Prepares to have a context menu action called: #--------------------------------------------------------------------------- def prepare_menu ( self, row, column ): """ Prepares to have a context menu action called. """ object = self.model.get_filtered_item( row ) selection = [ x.obj for x in self.grid.get_selection() ] if object not in selection: self.set_selection( object ) selection = [ object ] self.set_menu_context( selection, object, column ) #--------------------------------------------------------------------------- # Set one or more attributes without notifying the grid model: #--------------------------------------------------------------------------- def setx ( self, **keywords ): """ Set one or more attributes without notifying the grid model. """ self._no_notify = True for name, value in keywords.items(): setattr( self, name, value ) self._no_notify = False #-- Private Methods: ----------------------------------------------------------- #--------------------------------------------------------------------------- # Adds an 'undo' item to the undo history (if any): #--------------------------------------------------------------------------- def _add_undo ( self, undo_item, extend = False ): history = self.ui.history if history is not None: history.add( undo_item, extend ) #------------------------------------------------------------------------------- # 'TableFilterEditor' class: #------------------------------------------------------------------------------- class TableFilterEditor ( Handler ): """ Editor that manages table filters. """ #--------------------------------------------------------------------------- # Trait definitions: #--------------------------------------------------------------------------- # TableEditor this editor is associated with editor = Instance( TableEditor ) # Current filter filter = Instance( TableFilter, allow_none = True ) # Edit the current filter edit = Button # Create a new filter and edit it new = Button # Apply the current filter to the editor's table apply = Button # Delete the current filter delete = Button #--------------------------------------------------------------------------- # 'Handler' interface: #--------------------------------------------------------------------------- def init ( self, info ): """ Initializes the controls of a user interface. """ # Save both the original filter object reference and its contents: if self.filter is None: self.filter = info.filter.factory.values[0] self._filter = self.filter self._filter_copy = self.filter.clone_traits() def closed ( self, info, is_ok ): """ Handles a dialog-based user interface being closed by the user. """ if not is_ok: # Restore the contents of the original filter: self._filter.copy_traits( self._filter_copy ) #--------------------------------------------------------------------------- # Event handlers: #--------------------------------------------------------------------------- def object_filter_changed ( self, info ): """ Handles a new filter being selected. """ filter = info.object.filter info.edit.enabled = (not filter.template) info.delete.enabled = ((not filter.template) and (len( info.filter.factory.values ) > 1)) def object_edit_changed ( self, info ): """ Handles the user clicking the **Edit** button. """ if info.initialized: items = self.editor.model.get_filtered_items() if len(items) > 0: item = items[0] else: item = None # `item` is now either the first item in the table, or None if # the table is empty. ui = self.filter.edit(item) if ui.result: self._refresh_filters( info ) def object_new_changed ( self, info ): """ Handles the user clicking the **New** button. """ if info.initialized: # Get list of available filters and find the current filter in it: factory = info.filter.factory filters = factory.values filter = self.filter index = filters.index( filter ) + 1 n = len( filters ) while (index < n) and filters[ index ].template: index += 1 # Create a new filter based on the current filter: new_filter = filter.clone_traits() new_filter.template = False new_filter.name = new_filter._name = 'New filter' # Add it to the list of filters: filters.insert( index, new_filter ) self._refresh_filters( info ) # Set up the new filter as the current filter and edit it: self.filter = new_filter do_later( self._delayed_edit, info ) def object_apply_changed ( self, info ): """ Handles the user clicking the **Apply** button. """ if info.initialized: self.init( info ) self.editor._refresh_filters( info.filter.factory.values ) self.editor.filter = self.filter def object_delete_changed ( self, info ): """ Handles the user clicking the **Delete** button. """ # Get the list of available filters: filters = info.filter.factory.values if info.initialized: # Delete the current filter: index = filters.index( self.filter ) del filters[ index ] # Select a new filter: if index >= len( filters ): index -= 1 self.filter = filters[ index ] self._refresh_filters( info ) #--------------------------------------------------------------------------- # Private methods: #--------------------------------------------------------------------------- def _refresh_filters ( self, info ): """ Refresh the filter editor's list of filters. """ factory = info.filter.factory values, factory.values = factory.values, [] factory.values = values def _delayed_edit ( self, info ): """ Edits the current filter, and deletes it if the user cancels the edit. """ ui = self.filter.edit( self.editor.model.get_filtered_item( 0 ) ) if not ui.result: self.object_delete_changed( info ) else: self._refresh_filters( info ) # Allow deletion as long as there is more than 1 filter: if (not self.filter.template) and len( info.filter.factory.values ) > 1: info.delete.enabled = True #------------------------------------------------------------------------------- # 'TableEditorToolbar' class: #------------------------------------------------------------------------------- class TableEditorToolbar ( HasPrivateTraits ): """ Toolbar displayed in table editors. """ #--------------------------------------------------------------------------- # Trait definitions: #--------------------------------------------------------------------------- # Do not sort columns: no_sort = Instance( Action, { 'name': 'No Sorting', 'tooltip': 'Do not sort columns', 'action': 'on_no_sort', 'enabled': False, 'image': ImageResource( 'table_no_sort.png' ) } ) # Move current object up one row: move_up = Instance( Action, { 'name': 'Move Up', 'tooltip': 'Move current item up one row', 'action': 'on_move_up', 'enabled': False, 'image': ImageResource( 'table_move_up.png' ) } ) # Move current object down one row: move_down = Instance( Action, { 'name': 'Move Down', 'tooltip': 'Move current item down one row', 'action': 'on_move_down', 'enabled': False, 'image': ImageResource( 'table_move_down.png' ) }) # Search the table: search = Instance( Action, { 'name': 'Search', 'tooltip': 'Search table', 'action': 'on_search', 'image': ImageResource( 'table_search.png' ) } ) # Add a row: add = Instance( Action, { 'name': 'Add', 'tooltip': 'Insert new item', 'action': 'on_add', 'image': ImageResource( 'table_add.png' ) } ) # Delete selected row: delete = Instance( Action, { 'name': 'Delete', 'tooltip': 'Delete current item', 'action': 'on_delete', 'enabled': False, 'image': ImageResource( 'table_delete.png' ) } ) # Edit the user preferences: prefs = Instance( Action, { 'name': 'Preferences', 'tooltip': 'Set user preferences for table', 'action': 'on_prefs', 'image': ImageResource( 'table_prefs.png' ) } ) # The table editor that this is the toolbar for: editor = Instance( TableEditor ) # The toolbar control: control = Any #--------------------------------------------------------------------------- # Initializes the toolbar for a specified window: #--------------------------------------------------------------------------- def __init__ ( self, parent = None, **traits ): super( TableEditorToolbar, self ).__init__( **traits ) editor = self.editor factory = editor.factory actions = [] if factory.sortable and (not factory.sort_model): actions.append( self.no_sort ) if (not editor.in_column_mode) and factory.reorderable: actions.append( self.move_up ) actions.append( self.move_down ) if editor.in_row_mode and (factory.search is not None): actions.append( self.search ) if factory.editable: if (factory.row_factory is not None) and (not factory.auto_add): actions.append( self.add ) if (factory.deletable != False) and (not editor.in_column_mode): actions.append( self.delete ) if factory.configurable: actions.append( self.prefs ) if len( actions ) > 0: toolbar = ToolBar( image_size = ( 16, 16 ), show_tool_names = False, show_divider = False, *actions ) self.control = toolbar.create_tool_bar( parent, self ) self.control.SetBackgroundColour( parent.GetBackgroundColour() ) # fixme: Why do we have to explictly set the size of the toolbar? # Is there some method that needs to be called to do the # layout? self.control.SetSize( wx.Size( 23 * len( actions ), 16 ) ) #--------------------------------------------------------------------------- # PyFace/Traits menu/toolbar controller interface: #--------------------------------------------------------------------------- def add_to_menu ( self, menu_item ): """ Adds a menu item to the menu bar being constructed. """ pass def add_to_toolbar ( self, toolbar_item ): """ Adds a toolbar item to the too bar being constructed. """ pass def can_add_to_menu ( self, action ): """ Returns whether the action should be defined in the user interface. """ return True def can_add_to_toolbar ( self, action ): """ Returns whether the toolbar action should be defined in the user interface. """ return True def perform ( self, action, action_event = None ): """ Performs the action described by a specified Action object. """ getattr( self.editor, action.action )() #------------------------------------------------------------------------------- # 'TableSearchHandler' class: #------------------------------------------------------------------------------- class TableSearchHandler ( Handler ): """ Handler for saerching a table. """ #--------------------------------------------------------------------------- # Trait definitions: #--------------------------------------------------------------------------- # The editor that this handler is associated with editor = Instance( TableEditor ) # Find next matching item find_next = Button( 'Find Next' ) # Find previous matching item find_previous = Button( 'Find Previous' ) # Select all matching items select = Button # The user is finished searching OK = Button( 'Close' ) # Search status message: status = Str #--------------------------------------------------------------------------- # Handles the user clicking the 'Find next' button: #--------------------------------------------------------------------------- def handler_find_next_changed ( self, info ): """ Handles the user clicking the **Find** button. """ if info.initialized: editor = self.editor items = editor.model.get_filtered_items() for i in range( editor.selected_row_index + 1, len( items ) ): if info.object.filter( items[i] ): self.status = 'Item %d matches' % ( i + 1 ) editor.set_selection( items[i] ) editor.selected_row_index = i break else: self.status = 'No more matches found' #--------------------------------------------------------------------------- # Handles the user clicking the 'Find previous' button: #--------------------------------------------------------------------------- def handler_find_previous_changed ( self, info ): """ Handles the user clicking the **Find previous** button. """ if info.initialized: editor = self.editor items = editor.model.get_filtered_items() for i in range( editor.selected_row_index - 1, -1, -1 ): if info.object.filter( items[i] ): self.status = 'Item %d matches' % ( i + 1 ) editor.set_selection( items[i] ) editor.selected_row_index = i break else: self.status = 'No more matches found' #--------------------------------------------------------------------------- # Handles the user clicking the 'Select' button: #--------------------------------------------------------------------------- def handler_select_changed ( self, info ): """ Handles the user clicking the **Select** button. """ if info.initialized: editor = self.editor filter = info.object.filter items = [ item for item in editor.model.get_filtered_items() if filter( item ) ] editor.set_selection( items ) if len( items ) == 1: self.status = '1 item selected' else: self.status = '%d items selected' % len( items ) #--------------------------------------------------------------------------- # Handles the user clicking 'OK' button: #--------------------------------------------------------------------------- def handler_OK_changed ( self, info ): """ Handles the user clicking the OK button. """ if info.initialized: info.ui.dispose() # Define the SimpleEditor class. SimpleEditor = TableEditor # Define the ReadonlyEditor class. ReadonlyEditor = TableEditor