# (C) Copyright 2005-2023 Enthought, Inc., Austin, TX # All rights reserved. # # This software is provided without warranty under the terms of the BSD # license included in 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! """ A grid control with a model/ui architecture. """ from os.path import abspath, exists import sys import warnings import wx import wx.lib.gridmovers as grid_movers from wx.grid import ( Grid as wxGrid, GridCellAttr, GridCellEditor, GridTableBase, GridTableMessage, GRIDTABLE_NOTIFY_ROWS_APPENDED, GRIDTABLE_NOTIFY_ROWS_DELETED, GRIDTABLE_NOTIFY_ROWS_INSERTED, GRIDTABLE_NOTIFY_COLS_APPENDED, GRIDTABLE_NOTIFY_COLS_DELETED, GRIDTABLE_NOTIFY_COLS_INSERTED, GRIDTABLE_REQUEST_VIEW_GET_VALUES, GRID_VALUE_STRING, ) from traits.api import ( Bool, Enum, Event, Instance, Int, Undefined, Union, ) from pyface.timer.api import do_later from pyface.ui.wx.layout_widget import LayoutWidget from pyface.ui_traits import TraitsUIColor as Color, TraitsUIFont as Font from pyface.wx.drag_and_drop import ( PythonDropSource, PythonDropTarget, ) from pyface.wx.drag_and_drop import clipboard as enClipboard, FileDropSource from .grid_model import GridModel # Is this code running on MS Windows? is_win32 = sys.platform == "win32" ASCII_C = 67 class Grid(LayoutWidget): """ A grid control with a model/ui architecture. """ # 'Grid' interface ----------------------------------------------------- # The model that provides the data for the grid. model = Instance(GridModel, ()) # Should grid lines be shown on the table? enable_lines = Bool(True) # The color to show gridlines in grid_line_color = Color("blue") # Show row headers? show_row_headers = Bool(True) # Show column headers? show_column_headers = Bool(True) # The default font to use for text in labels default_label_font = Font(None) # The default background color for labels default_label_bg_color = Color(wx.Colour(236, 233, 216)) # The default text color for labels default_label_text_color = Color("black") # The color to use for a selection background selection_bg_color = Union(None, Color, default_value=wx.Colour(49, 106, 197)) # The color to use for a selection foreground/text selection_text_color = Union(None, Color, default_value=wx.Colour(255, 255, 255)) # The default font to use for text in cells default_cell_font = Font(None) # The default text color to use for text in cells default_cell_text_color = Color("black") # The default background color to use for editable cells default_cell_bg_color = Color("white") # The default background color to use for read-only cells default_cell_read_only_color = Color(wx.Colour(248, 247, 241)) # Should the grid be read-only? If this is set to false, individual # cells can still declare themselves read-only. read_only = Bool(False) # Selection mode. selection_mode = Enum("cell", "rows", "cols", "") # Sort data when a column header is clicked? allow_column_sort = Bool(True) # Sort data when a row header is clicked? allow_row_sort = Bool(False) # pixel height of column labels column_label_height = Int(32) # pixel width of row labels row_label_width = Int(82) # auto-size columns and rows? autosize = Bool(False) # Allow single-click access to cell-editors? edit_on_first_click = Bool(True) # Events ---- # A cell has been activated (ie. double-clicked). cell_activated = Event() # The current selection has changed. selection_changed = Event() # A drag operation was started on a cell. cell_begin_drag = Event() # A left-click occurred on a cell. cell_left_clicked = Event() # A left-click occurred on a cell at specific location # Useful if the cell contains multiple controls though the hit test # is left to the consumer of the event cell_left_clicked_location = Event() # A right-click occurred on a cell. cell_right_clicked = Event() # protected variables to store the location of the clicked event _x_clicked = Int() _y_clicked = Int() # ------------------------------------------------------------------------ # 'object' interface. # ------------------------------------------------------------------------ def __init__(self, parent, **traits): """ Creates a new grid. 'parent' is the toolkit-specific control that is the grid's parent. """ create = traits.pop('create', True) # Base class constructors. super().__init__(parent=parent, **traits) if create: # Create the widget's toolkit-specific control. self.create() warnings.warn( "automatic widget creation is deprecated and will be removed " "in a future Pyface version, code should not pass the create " "parameter and should instead call create() explicitly", DeprecationWarning, stacklevel=2, ) elif create is not None: warnings.warn( "setting create=False is no longer required", DeprecationWarning, stacklevel=2, ) def _create_control(self, parent): # Flag set when columns are resizing: self._user_col_size = False # Create the toolkit-specific control. self._grid = grid = wxGrid(parent, -1) grid.grid = self self._moveTo = None self._edit = False grid.Bind(wx.EVT_IDLE, self._on_idle) # Set when moving edit cursor: grid._no_reset_col = False grid._no_reset_row = False # initialize the current selection self.__current_selection = () self.__initialize_counts(self.model) self.__initialize_sort_state() # Don't display any extra space around the rows and columns. grid.SetMargins(0, 0) # Provides more accurate scrolling behavior without creating large # margins on the bottom and right. The down side is that it makes # scrolling using the scroll bar buttons painfully slow: grid.SetScrollLineX(1) grid.SetScrollLineY(1) # Tell the grid to get its data from the model. # # N.B The terminology used in the wxPython API is a little confusing! # --- The 'SetTable' method is actually setting the model used by # the grid (which is the view)! # # The second parameter to 'SetTable' tells the grid to take ownership # of the model and to destroy it when it is done. Otherwise you would # need to keep a reference to the model and manually destroy it later # (by calling it's Destroy method). # # fixme: We should create a default model if one is not supplied. # The wx virtual table hook. self._grid_table_base = _GridTableBase(self.model, self) # keep the onership of the table in this class grid.SetTable(self._grid_table_base, takeOwnership=False) # Enable column and row moving: grid_movers.GridColMover(grid) grid_movers.GridRowMover(grid) grid.Bind(grid_movers.EVT_GRID_COL_MOVE, self._on_col_move) grid.Bind(grid_movers.EVT_GRID_ROW_MOVE, self._on_row_move) self.model.observe(self._on_model_content_changed, "content_changed") self.model.observe( self._on_model_structure_changed, "structure_changed" ) self.model.observe(self._on_row_sort, "row_sorted") self.model.observe(self._on_column_sort, "column_sorted") self.observe(self._on_new_model, "model") # hook up style trait handlers - note that we have to use # dynamic notification hook-ups because these handlers should # not be called until after the control object is initialized. # static trait notifiers get called when the object inits. self.observe(self._on_enable_lines_changed, "enable_lines") self.observe(self._on_grid_line_color_changed, "grid_line_color") self.observe(self._on_default_label_font_changed, "default_label_font") self.observe( self._on_default_label_bg_color_changed, "default_label_bg_color" ) self.observe( self._on_default_label_text_color_changed, "default_label_text_color", ) self.observe(self._on_selection_bg_color_changed, "selection_bg_color") self.observe( self._on_selection_text_color_changed, "selection_text_color" ) self.observe(self._on_default_cell_font_changed, "default_cell_font") self.observe( self._on_default_cell_text_color_changed, "default_cell_text_color" ) self.observe( self._on_default_cell_bg_color_changed, "default_cell_bg_color" ) self.observe(self._on_read_only_changed, "read_only") self.observe(self._on_selection_mode_changed, "selection_mode") self.observe( self._on_column_label_height_changed, "column_label_height" ) self.observe(self._on_row_label_width_changed, "row_label_width") self.observe( self._on_show_column_headers_changed, "show_column_headers" ) self.observe(self._on_show_row_headers_changed, "show_row_headers") # Initialize wx handlers: self._notify_select = True grid.Bind(wx.grid.EVT_GRID_SELECT_CELL, self._on_select_cell) grid.Bind(wx.grid.EVT_GRID_RANGE_SELECT, self._on_range_select) grid.Bind(wx.grid.EVT_GRID_COL_SIZE, self._on_col_size) grid.Bind(wx.grid.EVT_GRID_ROW_SIZE, self._on_row_size) # This starts the cell editor on a double-click as well as on a second # click: grid.Bind(wx.grid.EVT_GRID_CELL_LEFT_DCLICK, self._on_cell_left_dclick) # Notify when cells are clicked on: grid.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK, self._on_cell_right_click) grid.Bind( wx.grid.EVT_GRID_CELL_RIGHT_DCLICK, self._on_cell_right_dclick ) grid.Bind( wx.grid.EVT_GRID_LABEL_RIGHT_CLICK, self._on_label_right_click ) grid.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self._on_label_left_click) if is_win32: grid.Bind(wx.grid.EVT_GRID_EDITOR_HIDDEN, self._on_editor_hidden) # We handle key presses to change the behavior of the and # keys to make manual data entry smoother. grid.Bind(wx.EVT_KEY_DOWN, self._on_key_down) # We handle control resize events to adjust column widths grid.Bind(wx.EVT_SIZE, self._on_size) # Handle drags: self._corner_window = grid.GetGridCornerLabelWindow() self._grid_window = gw = grid.GetGridWindow() self._row_window = rw = grid.GetGridRowLabelWindow() self._col_window = cw = grid.GetGridColLabelWindow() # Handle mouse button state changes: self._ignore = False for window in (gw, rw, cw): window.Bind(wx.EVT_MOTION, self._on_grid_motion) window.Bind(wx.EVT_LEFT_DOWN, self._on_left_down) window.Bind(wx.EVT_LEFT_UP, self._on_left_up) # Initialize the row and column models: self.__initialize_rows(self.model) self.__initialize_columns(self.model) self.__initialize_fonts() # Handle trait style settings: self.__initialize_style_settings() # Enable the grid as a drag and drop target: self._grid.SetDropTarget(PythonDropTarget(self)) self.__autosize() self._edit = False grid.Bind(wx.EVT_IDLE, self._on_idle) return grid def dispose(self): # Remove all wx handlers: grid = self._grid if grid is not None: grid.Unbind(wx.grid.EVT_GRID_SELECT_CELL) grid.Unbind(wx.grid.EVT_GRID_RANGE_SELECT) grid.Unbind(wx.grid.EVT_GRID_COL_SIZE) grid.Unbind(wx.grid.EVT_GRID_ROW_SIZE) grid.Unbind(wx.grid.EVT_GRID_CELL_LEFT_DCLICK) grid.Unbind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK) grid.Unbind(wx.grid.EVT_GRID_CELL_RIGHT_DCLICK) grid.Unbind(wx.grid.EVT_GRID_LABEL_RIGHT_CLICK) grid.Unbind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK) grid.Unbind(wx.grid.EVT_GRID_EDITOR_CREATED) if is_win32: grid.Unbind(wx.grid.EVT_GRID_EDITOR_HIDDEN) grid.Unbind(wx.EVT_KEY_DOWN) grid.Unbind(wx.EVT_SIZE) self._grid_window.Unbind(wx.EVT_PAINT) for window in (self._grid_window, self._row_window, self._col_window): window.Unbind(wx.EVT_MOTION) window.Unbind(wx.EVT_LEFT_DOWN) window.Unbind(wx.EVT_LEFT_UP) self.model.observe( self._on_model_content_changed, "content_changed", remove=True ) self.model.observe( self._on_model_structure_changed, "structure_changed", remove=True ) self.model.observe(self._on_row_sort, "row_sorted", remove=True) self.model.observe(self._on_column_sort, "column_sorted", remove=True) self.observe(self._on_new_model, "model", remove=True) self.observe( self._on_enable_lines_changed, "enable_lines", remove=True ) self.observe( self._on_grid_line_color_changed, "grid_line_color", remove=True ) self.observe( self._on_default_label_font_changed, "default_label_font", remove=True, ) self.observe( self._on_default_label_bg_color_changed, "default_label_bg_color", remove=True, ) self.observe( self._on_default_label_text_color_changed, "default_label_text_color", remove=True, ) self.observe( self._on_selection_bg_color_changed, "selection_bg_color", remove=True, ) self.observe( self._on_selection_text_color_changed, "selection_text_color", remove=True, ) self.observe( self._on_default_cell_font_changed, "default_cell_font", remove=True, ) self.observe( self._on_default_cell_text_color_changed, "default_cell_text_color", remove=True, ) self.observe( self._on_default_cell_bg_color_changed, "default_cell_bg_color", remove=True, ) self.observe( self._on_read_only_changed, "read_only", remove=True ) self.observe( self._on_selection_mode_changed, "selection_mode", remove=True ) self.observe( self._on_column_label_height_changed, "column_label_height", remove=True, ) self.observe( self._on_row_label_width_changed, "row_label_width", remove=True ) self.observe( self._on_show_column_headers_changed, "show_column_headers", remove=True, ) self.observe( self._on_show_row_headers_changed, "show_row_headers", remove=True ) self._grid_table_base.dispose() self._grid = None # ------------------------------------------------------------------------ # Trait event handlers. # ------------------------------------------------------------------------ def _on_new_model(self, event): """ When we get a new model reinitialize grid match to that model. """ self._grid_table_base.model = self.model self.__initialize_counts(self.model) self._on_model_changed() if self.autosize: # Note that we don't call AutoSize() here, because autosizing # the rows looks like crap. self._grid.AutoSizeColumns(False) def _on_model_content_changed(self, event): """ A notification method called when the data in the underlying model changes. """ self._grid.ForceRefresh() def _on_model_structure_changed(self, event=None): """ A notification method called when the underlying model has changed. Responsible for making sure the view object updates correctly. """ # Disable any active editors in order to prevent a wx crash bug: self._edit = False grid = self._grid # Make sure any current active editor has been disabled: grid.DisableCellEditControl() # More wacky fun with wx. We have to manufacture the appropriate # grid messages and send them off to make sure the grid updates # correctly: should_autosize = False # First check to see if rows have been added or deleted: row_count = self.model.get_row_count() delta = row_count - self._row_count self._row_count = row_count if delta > 0: # Rows were added: msg = GridTableMessage( self._grid_table_base, GRIDTABLE_NOTIFY_ROWS_APPENDED, delta ) grid.ProcessTableMessage(msg) should_autosize = True elif delta < 0: # Rows were deleted: msg = GridTableMessage( self._grid_table_base, GRIDTABLE_NOTIFY_ROWS_DELETED, row_count, -delta, ) grid.ProcessTableMessage(msg) should_autosize = True # Now check for column changes: col_count = self.model.get_column_count() delta = col_count - self._col_count self._col_count = col_count if delta > 0: # Columns were added: msg = GridTableMessage( self._grid_table_base, GRIDTABLE_NOTIFY_COLS_APPENDED, delta ) grid.ProcessTableMessage(msg) should_autosize = True elif delta < 0: # Columns were deleted: msg = GridTableMessage( self._grid_table_base, GRIDTABLE_NOTIFY_COLS_DELETED, col_count, -delta, ) grid.ProcessTableMessage(msg) should_autosize = True # Finally make sure we update for any new values in the table: msg = GridTableMessage( self._grid_table_base, GRIDTABLE_REQUEST_VIEW_GET_VALUES ) grid.ProcessTableMessage(msg) if should_autosize: self.__autosize() # We have to make sure the editor/renderer cache in the GridTableBase # object is cleaned out: self._grid_table_base._clear_cache() grid.AdjustScrollbars() self._refresh() def _on_row_sort(self, event): """ Handles a row_sorted event from the underlying model. """ # First grab the new data out of the event: if event.new.index < 0: self._current_sorted_row = None else: self._current_sorted_row = event.new.index self._row_sort_reversed = event.new.reversed # Since the label may have changed we may need to autosize again: # fixme: when we change how we represent the sorted column # this should go away. self.__autosize() # Make sure everything updates to reflect the changes: self._on_model_structure_changed() def _on_column_sort(self, event): """ Handles a column_sorted event from the underlying model. """ # first grab the new data out of the event if event.new.index < 0: self._current_sorted_col = None else: self._current_sorted_col = event.new.index self._col_sort_reversed = event.new.reversed # since the label may have changed we may need to autosize again # fixme: when we change how we represent the sorted column # this should go away. self.__autosize() # make sure everything updates to reflect the changes self._on_model_structure_changed() def _on_enable_lines_changed(self, event=None): """ Handle a change to the enable_lines trait. """ self._grid.EnableGridLines(self.enable_lines) def _on_grid_line_color_changed(self, event=None): """ Handle a change to the enable_lines trait. """ self._grid.SetGridLineColour(self.grid_line_color) def _on_default_label_font_changed(self, event=None): """ Handle a change to the default_label_font trait. """ font = self.default_label_font if font is None: font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT) font.SetWeight(wx.BOLD) self._grid.SetLabelFont(font) def _on_default_label_text_color_changed(self, event=None): """ Handle a change to the default_cell_text_color trait. """ if self.default_label_text_color is not None: color = self.default_label_text_color self._grid.SetLabelTextColour(color) self._grid.ForceRefresh() def _on_default_label_bg_color_changed(self, event=None): """ Handle a change to the default_cell_text_color trait. """ if self.default_label_bg_color is not None: color = self.default_label_bg_color self._grid.SetLabelBackgroundColour(color) self._grid.ForceRefresh() def _on_selection_bg_color_changed(self, event=None): """ Handle a change to the selection_bg_color trait. """ if self.selection_bg_color is not None: self._grid.SetSelectionBackground(self.selection_bg_color) def _on_selection_text_color_changed(self, event=None): """ Handle a change to the selection_text_color trait. """ if self.selection_text_color is not None: self._grid.SetSelectionForeground(self.selection_text_color) def _on_default_cell_font_changed(self, event=None): """ Handle a change to the default_cell_font trait. """ if self.default_cell_font is not None: self._grid.SetDefaultCellFont(self.default_cell_font) self._grid.ForceRefresh() def _on_default_cell_text_color_changed(self, event=None): """ Handle a change to the default_cell_text_color trait. """ if self.default_cell_text_color is not None: color = self.default_cell_text_color self._grid.SetDefaultCellTextColour(color) self._grid.ForceRefresh() def _on_default_cell_bg_color_changed(self, event=None): """ Handle a change to the default_cell_bg_color trait. """ if self.default_cell_bg_color is not None: color = self.default_cell_bg_color self._grid.SetDefaultCellBackgroundColour(color) self._grid.ForceRefresh() def _on_read_only_changed(self, event=None): """ Handle a change to the read_only trait. """ # should the whole grid be read-only? if self.read_only: self._grid.EnableEditing(False) else: self._grid.EnableEditing(True) def _on_selection_mode_changed(self, event=None): """ Handle a change to the selection_mode trait. """ # should we allow individual cells to be selected or only rows # or only columns if self.selection_mode == "cell": self._grid.SetSelectionMode(wxGrid.SelectCells) elif self.selection_mode == "rows": self._grid.SetSelectionMode(wxGrid.SelectRows) elif self.selection_mode == "cols": self._grid.SetSelectionMode(wxGrid.SelectColumns) def _on_column_label_height_changed(self, event=None): """ Handle a change to the column_label_height trait. """ # handle setting for height of column labels if self.column_label_height is not None: self._grid.SetColLabelSize(self.column_label_height) def _on_row_label_width_changed(self, event=None): """ Handle a change to the row_label_width trait. """ # handle setting for width of row labels if self.row_label_width is not None: self._grid.SetRowLabelSize(self.row_label_width) def _on_show_column_headers_changed(self, event=None): """ Handle a change to the show_column_headers trait. """ if not self.show_column_headers: self._grid.SetColLabelSize(0) else: self._grid.SetColLabelSize(self.column_label_height) def _on_show_row_headers_changed(self, event=None): """ Handle a change to the show_row_headers trait. """ if not self.show_row_headers: self._grid.SetRowLabelSize(0) else: self._grid.SetRowLabelSize(self.row_label_width) # ------------------------------------------------------------------------ # 'Grid' interface. # ------------------------------------------------------------------------ def get_selection(self): """ Return a list of the currently selected objects. """ return self.__get_selection() def set_selection(self, selection_list, notify=True): """ Set the current selection to the objects listed in selection_list. Note that these objects are model-specific, as the grid depends on the underlying model to translate these objects into grid coordinates. A ValueError will be raised if the objects are not in the proper format for the underlying model. """ # Set the 'should we notify the model of the selection change' flag: self._notify_select = notify # First use the model to resolve the object list into a set of # grid coordinates cells = self.model.resolve_selection(selection_list) # Now make sure all those grid coordinates get set properly: grid = self._grid grid.BeginBatch() grid.ClearSelection() mode = self.selection_mode if mode == "rows": self._select_rows(cells) elif mode != "": for selection in cells: row, col = max(0, selection[0]), max(0, selection[1]) grid.SelectBlock(row, col, row, col, True) grid.EndBatch() # Indicate that the selection has been changed: if notify: self.__fire_selection_changed() self._notify_select = True def stop_editing_indices(self, indices): """ If editing is occuring in a row in 'indices', stop editing. """ if self._grid.GetGridCursorRow() in indices: self._grid.DisableCellEditControl() # ------------------------------------------------------------------------ # wx event handlers. # ------------------------------------------------------------------------ def _on_size(self, evt): """ Called when the grid is resized. """ self.__autosize() evt.Skip() def _on_editor_hidden(self, evt): # This is a hack to make clicking on a window button while a grid # editor is active work correctly under Windows. Normally, when the # user clicks on the button to exit grid cell editing and perform the # button function, only the grid cell editing is terminated under # Windows. A second click on the button is required to actually # trigger the button functionality. We circumvent this problem by # generating a 'fake' button click event. Technically this solution # is not correct since the button click should be generated on mouse # up, but I'm not sure if we will get the mouse up event, so we do it # here instead. Note that this handler is only set-up when the OS is # Windows. control = wx.FindWindowAtPointer() if isinstance(control, wx.Button): do_later( wx.PostEvent, control, wx.CommandEvent( wx.wxEVT_COMMAND_BUTTON_CLICKED, control.GetId() ), ) def _on_left_down(self, evt): """ Called when the left mouse button is pressed. """ grid = self._grid self._x_clicked = evt.GetX() self._y_clicked = evt.GetY() self._ignore = (grid.XToEdgeOfCol(evt.GetX()) != wx.NOT_FOUND) or ( grid.YToEdgeOfRow(evt.GetY()) != wx.NOT_FOUND ) evt.Skip() def _on_left_up(self, evt): """ Called when the left mouse button is released. """ self._ignore = False evt.Skip() def _on_motion(self, evt): """ Called when the mouse moves. """ evt.Skip() if evt.Dragging() and not evt.ControlDown(): data = self.__get_drag_value() if isinstance(data, str): file = abspath(data) if exists(file): FileDropSource(self._grid, file) return PythonDropSource(self._grid, data) def _on_grid_motion(self, evt): if evt.GetEventObject() is self._grid_window: x, y = self._grid.CalcUnscrolledPosition(evt.GetPosition().Get()) row = self._grid.YToRow(y) col = self._grid.XToCol(x) # Notify the model that the mouse has moved into the cell at row,col, # only if the row and col are valid. if (row >= 0) and (col >= 0): self.model.mouse_cell = (row, col) # If we are not ignoring mouse events, call _on_motion. if not self._ignore: self._on_motion(evt) evt.Skip() def _on_select_cell(self, evt): """ Called when the user has moved to another cell. """ row, col = evt.GetRow(), evt.GetCol() self._moveTo = (row, col) self.cell_left_clicked = self.model.click = (row, col) # Try to find a renderer for this cell: renderer = self.model.get_cell_renderer(row, col) # If the renderer has defined a handler then call it: result = False if renderer is not None: result = renderer.on_left_click(self, row, col) # print("self._grid.GetParent()", self._grid.GetParent().GetParent().GetParent()) # if the handler didn't tell us to stop further handling then skip if not result: if (self.selection_mode != "") or (not self.edit_on_first_click): self._grid.SelectBlock(row, col, row, col, evt.ControlDown()) self._edit = True evt.Skip() def _on_range_select(self, evt): if evt.Selecting(): if (self.selection_mode == "cell") and evt.ControlDown(): self._grid.SelectBlock( evt.GetTopRow(), evt.GetLeftCol(), evt.GetBottomRow(), evt.GetRightCol(), True, ) if self._notify_select: self.__fire_selection_changed() def _on_col_size(self, evt): """ Called when the user changes a column's width. """ self.__autosize() evt.Skip() def _on_row_size(self, evt): """ Called when the user changes a row's height. """ self._grid.AdjustScrollbars() evt.Skip() def _on_idle(self, evt): """ Immediately jumps into editing mode, bypassing the usual select mode of a spreadsheet. See also self.OnSelectCell(). """ if self._edit and self.edit_on_first_click: if self._grid.CanEnableCellControl(): self._grid.EnableCellEditControl() self._edit = False evt.Skip() def _on_cell_left_dclick(self, evt): """ Called when the left mouse button was double-clicked. From the wxPython demo code:- 'I do this because I don't like the default behaviour of not starting the cell editor on double clicks, but only a second click.' Fair enuff! """ row, col = evt.GetRow(), evt.GetCol() data = self.model.get_value(row, col) self.cell_activated = data # Tell the model that a cell was double-clicked on: self.model.dclick = (row, col) # Try to find a renderer for this cell renderer = self.model.get_cell_renderer(row, col) # If the renderer has defined a handler then call it if renderer is not None: renderer.on_left_dclick(self, row, col) def _on_cell_right_dclick(self, evt): """ Called when the right mouse button was double-clicked. From the wxPython demo code:- 'I do this because I don't like the default behaviour of not starting the cell editor on double clicks, but only a second click.' Fair enuff! """ row, col = evt.GetRow(), evt.GetCol() # try to find a renderer for this cell renderer = self.model.get_cell_renderer(row, col) # if the renderer has defined a handler then call it if renderer is not None: renderer.on_right_dclick(self, row, col) def _on_cell_right_click(self, evt): """ Called when a right click occurred in a cell. """ row, col = evt.GetRow(), evt.GetCol() # try to find a renderer for this cell renderer = self.model.get_cell_renderer(row, col) # if the renderer has defined a handler then call it result = False if renderer is not None: result = renderer.on_right_click(self, row, col) # if the handler didn't tell us to stop further handling then skip if not result: # ask model for the appropriate context menu menu_manager = self.model.get_cell_context_menu(row, col) # get the underlying menu object if menu_manager is not None: controller = None if type(menu_manager) is tuple: menu_manager, controller = menu_manager menu = menu_manager.create_menu(self._grid, controller) # if it has anything in it pop it up if menu.GetMenuItemCount() > 0: # Popup the menu (if an action is selected it will be # performed before before 'PopupMenu' returns). x, y = evt.GetPosition().Get() self._grid.PopupMenu(menu, x - 10, y - 10) self.cell_right_clicked = (row, col) evt.Skip() def _on_label_right_click(self, evt): """ Called when a right click occurred on a label. """ row, col = evt.GetRow(), evt.GetCol() # a row value of -1 means this click happened on a column. # vice versa, a col value of -1 means a row click. menu_manager = None if row == -1: menu_manager = self.model.get_column_context_menu(col) else: menu_manager = self.model.get_row_context_menu(row) if menu_manager is not None: # get the underlying menu object menu = menu_manager.create_menu(self._grid) # if it has anything in it pop it up if menu.GetMenuItemCount() > 0: # Popup the menu (if an action is selected it will be performed # before before 'PopupMenu' returns). self._grid.PopupMenu(menu, evt.GetPosition().Get()) elif col >= 0: cws = getattr(self, "_cached_widths", None) if (cws is not None) and (0 <= col < len(cws)): cws[col] = None self.__autosize() evt.Skip() def _on_label_left_click(self, evt): """ Called when a left click occurred on a label. """ row, col = evt.GetRow(), evt.GetCol() # A row value of -1 means this click happened on a column. # vice versa, a col value of -1 means a row click. if (row == -1) and self.allow_column_sort and evt.ControlDown(): self._column_sort(col) elif (col == -1) and self.allow_row_sort and evt.ControlDown(): self._row_sort(row) evt.Skip() def _column_sort(self, col): """ Sorts the data on the specified column **col**. """ self._grid.Freeze() if (col == self._current_sorted_col) and (not self._col_sort_reversed): # If this column is currently sorted on then reverse it: self.model.sort_by_column(col, True) elif (col == self._current_sorted_col) and self._col_sort_reversed: # If this column is currently reverse-sorted then unsort it: try: self.model.no_column_sort() except NotImplementedError: # If an unsort function is not implemented then just # reverse the sort: self.model.sort_by_column(col, False) else: # Sort the data: self.model.sort_by_column(col, False) self._grid.Thaw() def _row_sort(self, row): self._grid.Freeze() if (row == self._current_sorted_row) and (not self._row_sort_reversed): # If this row is currently sorted on then reverse it: self.model.sort_by_row(row, True) elif row == self._current_sorted_row and self._row_sort_reversed: # If this row is currently reverse-sorted then unsort it: try: self.model.no_row_sort() except NotImplementedError: # If an unsort function is not implemented then just # reverse the sort: self.model.sort_by_row(row, False) else: # Sort the data: self.model.sort_by_row(row, False) self._grid.Thaw() def _on_key_down(self, evt): """ Called when a key is pressed. """ # This changes the behaviour of the and keys to make # manual data entry smoother! # # Don't change the behavior if the key is pressed as this # has meaning to the edit control. evt.Skip() def _move_to_next_cell(self, expandSelection=False): """ Move to the 'next' cell. """ # Complete the edit on the current cell. self._grid.DisableCellEditControl() # Try to move to the next column. success = self._grid.MoveCursorRight(expandSelection) # If the move failed then we must be at the end of a row. if not success: # Move to the first column in the next row. newRow = self._grid.GetGridCursorRow() + 1 if newRow < self._grid.GetNumberRows(): self._grid.SetGridCursor(newRow, 0) self._grid.MakeCellVisible(newRow, 0) else: # This would be a good place to add a new row if your app # needs to do that. pass return success def _move_to_previous_cell(self, expandSelection=False): """ Move to the 'previous' cell. """ # Complete the edit on the current cell. self._grid.DisableCellEditControl() # Try to move to the previous column (without expanding the current # selection). success = self._grid.MoveCursorLeft(expandSelection) # If the move failed then we must be at the start of a row. if not success: # Move to the last column in the previous row. newRow = self._grid.GetGridCursorRow() - 1 if newRow >= 0: self._grid.SetGridCursor( newRow, self._grid.GetNumberCols() - 1 ) self._grid.MakeCellVisible( newRow, self._grid.GetNumberCols() - 1 ) def _refresh(self): self._grid.GetParent().Layout() def _on_col_move(self, evt): """ Called when a column move is taking place. """ self._ignore = True # Get the column being moved: frm = evt.GetMoveColumn() # Get the column to insert it before: to = evt.GetBeforeColumn() # Tell the model to update its columns: if self.model._move_column(frm, to): # Modify the grid: grid = self._grid cols = grid.GetNumberCols() widths = [grid.GetColSize(i) for i in range(cols)] width = widths[frm] del widths[frm] to -= frm < to widths.insert(to, width) grid.BeginBatch() grid.ProcessTableMessage( GridTableMessage( self._grid_table_base, GRIDTABLE_NOTIFY_COLS_DELETED, frm, 1, ) ) grid.ProcessTableMessage( GridTableMessage( self._grid_table_base, GRIDTABLE_NOTIFY_COLS_INSERTED, to, 1, ) ) [grid.SetColSize(i, widths[i]) for i in range(min(frm, to), cols)] grid.EndBatch() def _on_row_move(self, evt): """ Called when a row move is taking place. """ self._ignore = True # Get the column being moved: frm = evt.GetMoveRow() # Get the column to insert it before: to = evt.GetBeforeRow() # Tell the model to update its rows: if self.model._move_row(frm, to): # Notify the grid: grid = self._grid rows = grid.GetNumberRows() heights = [grid.GetRowSize(i) for i in range(rows)] height = heights[frm] del heights[frm] to -= frm < to heights.insert(to, height) grid.BeginBatch() grid.ProcessTableMessage( GridTableMessage( self._grid_table_base, GRIDTABLE_NOTIFY_ROWS_DELETED, frm, 1, ) ) grid.ProcessTableMessage( GridTableMessage( self._grid_table_base, GRIDTABLE_NOTIFY_ROWS_INSERTED, to, 1, ) ) [grid.SetRowSize(i, heights[i]) for i in range(min(frm, to), rows)] grid.EndBatch() # ------------------------------------------------------------------------ # PythonDropTarget interface. # ------------------------------------------------------------------------ def wx_dropped_on(self, x, y, drag_object, drag_result): # first resolve the x/y coords into a grid row/col row, col = self.__resolve_grid_coords(x, y) result = wx.DragNone if row != -1 and col != -1: # now ask the model if the target cell can accept this object valid_target = self.model.is_valid_cell_value( row, col, drag_object ) # if this is a valid target then attempt to set the value if valid_target: # find the data data = drag_object # sometimes a 'node' attribute on the clipboard gets set # to a binding. if this happens we want to use it, otherwise # we want to just use the drag_object passed to us if ( hasattr(enClipboard, "node") and enClipboard.node is not None ): data = enClipboard.node # now make sure the value gets set in the model self.model.set_value(row, col, data) result = drag_result return result def wx_drag_over(self, x, y, drag_object, drag_result): # first resolve the x/y coords into a grid row/col row, col = self.__resolve_grid_coords(x, y) result = wx.DragNone if row != -1 and col != -1: # now ask the model if the target cell can accept this object valid_target = self.model.is_valid_cell_value( row, col, drag_object ) if valid_target: result = drag_result return result # ------------------------------------------------------------------------ # private interface. # ------------------------------------------------------------------------ def __initialize_fonts(self): """ Initialize the label fonts. """ self._on_default_label_font_changed() self._on_default_cell_font_changed() self._on_default_cell_text_color_changed() self._on_grid_line_color_changed() self._grid.SetColLabelAlignment(wx.ALIGN_CENTRE, wx.ALIGN_CENTRE) self._grid.SetRowLabelAlignment(wx.ALIGN_RIGHT, wx.ALIGN_CENTRE) def __initialize_rows(self, model): """ Initialize the row headers. """ # should we really be doing this? for row in range(model.get_row_count()): if model.is_row_read_only(row): attr = wx.grid.GridCellAttr() attr.SetReadOnly() # attr.SetRenderer(None) # attr.SetBackgroundColour('linen') self._grid.SetRowAttr(row, attr) def __initialize_columns(self, model): """ Initialize the column headers. """ # should we really be doing this? for column in range(model.get_column_count()): if model.is_column_read_only(column): attr = wx.grid.GridCellAttr() attr.SetReadOnly() # attr.SetRenderer(None) # attr.SetBackgroundColour('linen') self._grid.SetColAttr(column, attr) def __initialize_counts(self, model): """ Initializes the row and column counts. """ if model is not None: self._row_count = model.get_row_count() else: self._row_count = 0 if model is not None: self._col_count = model.get_column_count() else: self._col_count = 0 def __initialize_sort_state(self): """ Initializes the row and column counts. """ self._current_sorted_col = None self._current_sorted_row = None self._col_sort_reversed = False self._row_sort_reversed = False def __initialize_style_settings(self): # make sure all the handlers for traits defining styles get called self._on_enable_lines_changed() self._on_read_only_changed() self._on_selection_mode_changed() self._on_column_label_height_changed() self._on_row_label_width_changed() self._on_show_column_headers_changed() self._on_show_row_headers_changed() self._on_default_cell_bg_color_changed() self._on_default_label_bg_color_changed() self._on_default_label_text_color_changed() self._on_selection_bg_color_changed() self._on_selection_text_color_changed() def __get_drag_value(self): """ Calculates the drag value based on the current selection. """ return self.model.get_cell_drag_value( self._grid.GetGridCursorRow(), self._grid.GetGridCursorCol() ) def __get_selection(self): """ Returns a list of values for the current selection. """ rows, cols = self.__get_selected_rows_and_cols() if len(rows) > 0: rows.sort() value = self.model.get_rows_selection_value(rows) elif len(cols) > 0: cols.sort() value = self.model.get_cols_selection_value(cols) else: # our final option -- grab the cell that the cursor is currently in row = self._grid.GetGridCursorRow() col = self._grid.GetGridCursorCol() value = self.model.get_cell_selection_value(row, col) if value is not None: value = [value] if value is None: value = [] return value def __get_selected_rows_and_cols(self): """ Return lists of the selected rows and the selected columns. """ # note: because the wx grid control is so screwy, we have limited # the selection behavior. we only allow single cells to be selected, # or whole row, or whole columns. rows = self._grid.GetSelectedRows() cols = self._grid.GetSelectedCols() # because of wx we have to check this as well # note that all this malarkey is working on the assumption that # only entire rows or entire columns or single cells are selected. top_left = self._grid.GetSelectionBlockTopLeft() bottom_right = self._grid.GetSelectionBlockBottomRight() selection_mode = self._grid.GetSelectionMode() if selection_mode == wxGrid.SelectRows: # handle rows differently. figure out which rows were # selected. turns out that in this case, wx adds a "block" # per row, so we have to cycle over the list returned by # the GetSelectionBlock routines for i in range(len(top_left)): top_point = top_left[i] bottom_point = bottom_right[i] for row_index in range(top_point[0], bottom_point[0] + 1): rows.append(row_index) elif selection_mode == wxGrid.SelectColumns: # again, in this case we know that only whole columns can be # selected for i in range(len(top_left)): top_point = top_left[i] bottom_point = bottom_right[i] for col_index in range(top_point[1], bottom_point[1] + 1): cols.append(col_index) elif selection_mode == wxGrid.SelectCells: # this is the case where the selection_mode is cell, which also # allows complete columns or complete rows to be selected. # first find the size of the grid row_size = self.model.get_row_count() col_size = self.model.get_column_count() for i in range(len(top_left)): top_point = top_left[i] bottom_point = bottom_right[i] # precalculate whether this is a row or column select row_select = ( top_point[1] == 0 and bottom_point[1] == col_size - 1 ) col_select = ( top_point[0] == 0 and bottom_point[0] == row_size - 1 ) if row_select: for row_index in range(top_point[0], bottom_point[0] + 1): rows.append(row_index) if col_select: for col_index in range(top_point[1], bottom_point[1] + 1): cols.append(top_point[0]) return (rows, cols) def __fire_selection_changed(self): self.selection_changed = True def __autosize(self): """ Autosize the grid with appropriate flags. """ model = self.model grid = self._grid if grid is not None and self.autosize: grid.AutoSizeColumns(False) grid.AutoSizeRows(False) # Whenever we size the grid we need to take in to account any # explicitly set column sizes: grid.BeginBatch() dx, dy = grid.GetClientSize().Get() n = model.get_column_count() pdx = 0 wdx = 0.0 widths = [] cached = getattr(self, "_cached_widths", None) current = [grid.GetColSize(i) for i in range(n)] if (cached is None) or (len(cached) != n): self._cached_widths = cached = [None] * n for i in range(n): cw = cached[i] if ( (cw is None) or (-cw == current[i]) or # hack: For some reason wx always seems to adjust column 0 by # 1 pixel from what we set it to (at least on Windows), so we # need to add a little fudge factor just for this column: ((i == 0) and (abs(current[i] + cw) <= 1)) ): width = model.get_column_size(i) if width is None: width = 0.0 if width <= 0.0: width = 0.1 if width <= 1.0: wdx += width cached[i] = -1 else: width = int(width) pdx += width if cw is None: cached[i] = width else: cached[i] = width = current[i] pdx += width widths.append(width) # The '-1' below adjusts for an off by 1 error in the way the wx.Grid # control determines whether or not it needs a horizontal scroll bar: adx = max(0, dx - pdx - 1) for i in range(n): width = cached[i] if width < 0: width = widths[i] if width <= 1.0: w = max(30, int(round((adx * width) / wdx))) wdx -= width width = w adx -= width cached[i] = -w grid.SetColSize(i, width) grid.AdjustScrollbars() grid.EndBatch() grid.ForceRefresh() def __resolve_grid_coords(self, x, y): """ Resolve the specified x and y coordinates into row/col coordinates. Returns row, col. """ # the x,y coordinates here are Unscrolled coordinates. # They must be changed to scrolled coordinates. x, y = self._grid.CalcUnscrolledPosition(x, y) # now we need to get the row and column from the grid # but we need to first remove the RowLabel and ColumnLabel # bounding boxes if self.show_row_headers: x = x - self._grid.GetGridRowLabelWindow().GetRect().width if self.show_column_headers: y = y - self._grid.GetGridColLabelWindow().GetRect().height return (self._grid.YToRow(y), self._grid.XToCol(x)) def _select_rows(self, cells): """ Selects all of the rows specified by a list of (row,column) pairs. """ # For a large set of rows, simply calling 'SelectBlock' on the Grid # object for each row is very inefficient, so we first make a pass over # all of the cells to merge them into contiguous ranges as much as # possible: sb = self._grid.SelectBlock # Extract the rows and sort them: rows = [row for row, column in cells] rows.sort() # Now find contiguous ranges of rows, and select the current range # whenever a break in the sequence is found: first = last = -999 for row in rows: if row == (last + 1): last = row else: if first >= 0: sb(first, 0, last, 0, True) first = last = row # Handle the last pending range of lines to be selected: if first >= 0: sb(first, 0, last, 0, True) class _GridTableBase(GridTableBase): """ A private adapter for the underlying wx grid implementation. """ # ------------------------------------------------------------------------ # 'object' interface. # ------------------------------------------------------------------------ def __init__(self, model, grid): """ Creates a new table base. """ # Base class constructor. GridTableBase.__init__(self) # The Pyface model that provides the data. self.model = model self._grid = grid # hacky state variables so we can identify when rows have been # added or deleted. self._row_count = -1 self._col_count = -1 # caches for editors and renderers self._editor_cache = {} self._renderer_cache = {} def dispose(self): # Make sure dispose gets called on all traits editors: for editor in self._editor_cache.values(): editor.dispose() self._editor_cache = {} for renderer in self._renderer_cache.values(): renderer.dispose() self._renderer_cache = {} # ------------------------------------------------------------------------ # 'wxGridTableBase' interface. # ------------------------------------------------------------------------ def GetNumberRows(self): """ Return the number of rows in the model. """ # because wx is such a wack job we have to store away the row # and column counts so we can figure out when rows or cols have # been appended or deleted. lacking a better place to do this # we just set the local variable every time GetNumberRows is called. self._row_count = self.model.get_row_count() return self._row_count def GetNumberCols(self): """ Return the number of columns in the model. """ # see comment in GetNumberRows for logic here self._col_count = self.model.get_column_count() return self._col_count def IsEmptyCell(self, row, col): """ Is the specified cell empty? """ return self.model.is_cell_empty(row, col) def GetValue(self, row, col): """ Get the value at the specified row and column. """ return self.model.get_value(row, col) def SetValue(self, row, col, value): """ Set the value at the specified row and column. """ return self.model.set_value(row, col, value) def GetRowLabelValue(self, row): """ Called when the grid needs to display a row label. """ label = self.model.get_row_name(row) if row == self._grid._current_sorted_row: if self._grid._row_sort_reversed: if is_win32: ulabel = str(label, "ascii") + " \u00ab" label = ulabel.encode("latin-1") else: label += " <<" elif is_win32: ulabel = str(label, "ascii") + " \u00bb" label = ulabel.encode("latin-1") else: label += " >>" return label def GetColLabelValue(self, col): """ Called when the grid needs to display a column label. """ label = self.model.get_column_name(col) if col == self._grid._current_sorted_col: if self._grid._col_sort_reversed: if is_win32: ulabel = str(label, "ascii") + " \u00ab" label = ulabel.encode("latin-1") else: label += " <<" elif is_win32: ulabel = str(label, "ascii") + " \u00bb" label = ulabel.encode("latin-1") else: label += " >>" return label def GetTypeName(self, row, col): """ Called to determine the kind of editor/renderer to use. This doesn't necessarily have to be the same type used natively by the editor/renderer if they know how to convert. """ typename = None try: typename = self.model.get_type(row, col) except NotImplementedError: pass if typename is None: typename = GRID_VALUE_STRING return typename def DeleteRows(self, pos, num_rows): """ Called when the view is deleting rows. """ # clear the cache self._clear_cache() return self.model.delete_rows(pos, num_rows) def InsertRows(self, pos, num_rows): """ Called when the view is inserting rows. """ # clear the cache self._clear_cache() return self.model.insert_rows(pos, num_rows) def AppendRows(self, num_rows): """ Called when the view is inserting rows. """ # clear the cache self._clear_cache() pos = self.model.get_row_count() return self.model.insert_rows(pos, num_rows) def DeleteCols(self, pos, num_cols): """ Called when the view is deleting columns. """ # clear the cache self._clear_cache() return self.model.delete_columns(pos, num_cols) def InsertCols(self, pos, num_cols): """ Called when the view is inserting columns. """ # clear the cache self._clear_cache() return self.model.insert_columns(pos, num_cols) def AppendCols(self, num_cols): """ Called when the view is inserting columns. """ # clear the cache self._clear_cache() pos = self.model.get_column_count() return self.model.insert_columns(pos, num_cols) def GetAttr(self, row, col, kind): """ Retrieve the cell attribute object for the specified cell. """ result = GridCellAttr() # we only handle cell requests, for other delegate to the supa if kind != GridCellAttr.Cell and kind != GridCellAttr.Any: return result rows = self.model.get_row_count() cols = self.model.get_column_count() # First look in the cache for the editor: editor = self._editor_cache.get((row, col)) if editor is None: if (row >= rows) or (col >= cols): editor = DummyGridCellEditor() else: # Ask the underlying model for an editor for this cell: editor = self.model.get_cell_editor(row, col) if editor is not None: self._editor_cache[(row, col)] = editor editor._grid_info = (self._grid._grid, row, col) if False: # editor is not None: # Note: We have to increment the reference to keep the # underlying code from destroying our object. editor.IncRef() result.SetEditor(editor) # try to find a renderer for this cell renderer = None if row < rows and col < cols: renderer = self.model.get_cell_renderer(row, col) if renderer is not None and renderer.renderer is not None: renderer.renderer.IncRef() result.SetRenderer(renderer.renderer) # look to see if this cell is editable read_only = False if row < rows and col < cols: read_only = ( self.model.is_cell_read_only(row, col) or self.model.is_row_read_only(row) or self.model.is_column_read_only(col) ) result.SetReadOnly(read_only) if read_only: read_only_color = self._grid.default_cell_read_only_color if ( read_only_color is not None and read_only_color is not Undefined ): result.SetBackgroundColour(read_only_color) # check to see if colors or fonts are specified for this cell bgcolor = None if row < rows and col < cols: bgcolor = self.model.get_cell_bg_color(row, col) else: bgcolor = self._grid.default_cell_bg_color if bgcolor is not None: result.SetBackgroundColour(bgcolor) text_color = None if row < rows and col < cols: text_color = self.model.get_cell_text_color(row, col) else: text_color = self._grid.default_cell_text_color if text_color is not None: result.SetTextColour(text_color) cell_font = None if row < rows and col < cols: cell_font = self.model.get_cell_font(row, col) else: cell_font = self._grid.default_cell_font if cell_font is not None: result.SetFont(cell_font) # check for alignment definition for this cell halignment = valignment = None if row < rows and col < cols: halignment = self.model.get_cell_halignment(row, col) valignment = self.model.get_cell_valignment(row, col) if halignment is not None and valignment is not None: if halignment == "center": h = wx.ALIGN_CENTRE elif halignment == "right": h = wx.ALIGN_RIGHT else: h = wx.ALIGN_LEFT if valignment == "top": v = wx.ALIGN_TOP elif valignment == "bottom": v = wx.ALIGN_BOTTOM else: v = wx.ALIGN_CENTRE result.SetAlignment(h, v) return result # ------------------------------------------------------------------------ # private interface. # ------------------------------------------------------------------------ def _clear_cache(self): """ Clean out the editor/renderer cache. """ # Dispose of the editors in the cache after a brief delay, so as # to allow completion of the current event: do_later(self._editor_dispose, list(self._editor_cache.values())) self._editor_cache = {} self._renderer_cache = {} def _editor_dispose(self, editors): for editor in editors: editor.dispose() class DummyGridCellEditor(GridCellEditor): def Show(self, show, attr): return