/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/UI/tableview.py

Diff of /branches/WIP-pyshapelib-bramz/Thuban/UI/tableview.py

Parent Directory | Revision Log | View Patch Patch

-revision 173 by bh,
Wed May 15 13:29:34 2002 UTC
+revision 1068 by bh,
Tue May 27 15:02:37 2003 UTC
 Line 1
- # Copyright (c) 2001, 2002 by Intevation GmbH
+ # Copyright (c) 2001, 2002, 2003 by Intevation GmbH
  # Authors:
  # Bernhard Herzog <[email protected]>
  #
 Line 7
  __version__ = "$Revision$"
+ import os.path
+ from Thuban import _
  from wxPython.wx import *
  from wxPython.grid import *
  from Thuban.Lib.connector import Publisher
  from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
-      FIELDTYPE_STRING
+      FIELDTYPE_STRING, table_to_dbf, table_to_csv
  import view
- from dialogs import NonModalDialog
+ from dialogs import NonModalNonParentDialog
- from messages import SELECTED_SHAPE
+ from messages import SHAPES_SELECTED, SESSION_REPLACED
+ from Thuban.Model.messages import TABLE_REMOVED
  wx_value_type_map = {FIELDTYPE_INT: wxGRID_VALUE_NUMBER,
                       FIELDTYPE_DOUBLE: wxGRID_VALUE_FLOAT,
-Line 23 
 wx_value_type_map = {FIELDTYPE_INT: wxGR
+Line 29 
 wx_value_type_map = {FIELDTYPE_INT: wxGR
  ROW_SELECTED = "ROW_SELECTED"
+ QUERY_KEY = 'S'
  class DataTable(wxPyGridTableBase):
-Line 38 
 class DataTable(wxPyGridTableBase):
+Line 45 
 class DataTable(wxPyGridTableBase):
      def SetTable(self, table):
          self.table = table
-         self.num_cols = table.field_count()
+         self.num_cols = table.NumColumns()
-         self.num_rows = table.record_count()
+         self.num_rows = table.NumRows()
          self.columns = []
          for i in range(self.num_cols):
-             type, name, len, decc = table.field_info(i)
+             col = table.Column(i)
-             self.columns.append((name, wx_value_type_map[type], len, decc))
+             self.columns.append((col.name, wx_value_type_map[col.type]))
      #
      # required methods for the wxPyGridTableBase interface
-Line 64 
 class DataTable(wxPyGridTableBase):
+Line 71 
 class DataTable(wxPyGridTableBase):
      # Renderer understands the type too,) not just strings as in the
      # C++ version.
      def GetValue(self, row, col):
-         record = self.table.read_record(row)
+         record = self.table.ReadRowAsDict(row)
          return record[self.columns[col][0]]
      def SetValue(self, row, col, value):
-Line 97 
 class DataTable(wxPyGridTableBase):
+Line 104 
 class DataTable(wxPyGridTableBase):
  class TableGrid(wxGrid, Publisher):
-     """A grid view for a Thuban table"""
+     """A grid view for a Thuban table
+     When rows are selected by the user the table issues ROW_SELECTED
+     messages. wx sends selection events even when the selection is
+     manipulated by code (instead of by the user) which usually lead to
+     ROW_SELECTED messages being sent in turn. Therefore sending messages
+     can be switched on and off with the allow_messages and
+     disallow_messages methods.
+     """
      def __init__(self, parent, table = None):
          wxGrid.__init__(self, parent, -1)
+         self.allow_messages_count = 0
          self.table = DataTable(table)
          # The second parameter means that the grid is to take ownership
          # of the table and will destroy it when done. Otherwise you
          # would need to keep a reference to it and call its Destroy
          # method later.
-         self.SetTable(self.table, true)
+         self.SetTable(self.table, True)
          #self.SetMargins(0,0)
-Line 116 
 class TableGrid(wxGrid, Publisher):
+Line 133 
 class TableGrid(wxGrid, Publisher):
          # column widths automatically but it would cause a traversal of
          # the entire table which for large .dbf files can take a very
          # long time.
-         #self.AutoSizeColumns(false)
+         #self.AutoSizeColumns(False)
          self.SetSelectionMode(wxGrid.wxGridSelectRows)
-         EVT_GRID_RANGE_SELECT(self, self.OnRangeSelect)
+         #EVT_GRID_RANGE_SELECT(self, None)
-         EVT_GRID_SELECT_CELL(self, self.OnSelectCell)
+         #EVT_GRID_SELECT_CELL(self, None)
+         #EVT_GRID_RANGE_SELECT(self, self.OnRangeSelect)
+         #EVT_GRID_SELECT_CELL(self, self.OnSelectCell)
+         self.ToggleEventListeners(True)
      def SetTableObject(self, table):
          self.table.SetTable(table)
      def OnRangeSelect(self, event):
+         rows = dict([(i, 0) for i in self.GetSelectedRows()])
+         # if we're selecting we need to include the selected range and
+         # make sure that the current row is also included, which may
+         # not be the case if you just click on a single row!
          if event.Selecting():
-             self.issue(ROW_SELECTED, event.GetTopLeftCoords().GetRow())
+             for i in range(event.GetTopRow(), event.GetBottomRow() + 1):
+                 rows[i] = 0
+             rows[event.GetTopLeftCoords().GetRow()] = 0
+         self.issue(ROW_SELECTED, rows.keys())
+         event.Skip()
      def OnSelectCell(self, event):
-         self.issue(ROW_SELECTED, event.GetRow())
+         self.issue(ROW_SELECTED, self.GetSelectedRows())
+         event.Skip()
-     def select_shape(self, layer, shape):
+     def ToggleEventListeners(self, on):
-         if layer is not None and layer.table is self.table.table \
+         if on:
-            and shape is not None:
+             EVT_GRID_RANGE_SELECT(self, self.OnRangeSelect)
-             self.SelectRow(shape)
+             EVT_GRID_SELECT_CELL(self, self.OnSelectCell)
-             self.SetGridCursor(shape, 0)
+         else:
-             self.MakeCellVisible(shape, 0)
+             EVT_GRID_RANGE_SELECT(self, None)
+             EVT_GRID_SELECT_CELL(self, None)
+     def disallow_messages(self):
+         """Disallow messages to be send.
+         This method only increases a counter so that calls to
+         disallow_messages and allow_messages can be nested. Only the
+         outermost calls will actually switch message sending on and off.
+         """
+         self.allow_messages_count += 1
+     def allow_messages(self):
+         """Allow messages to be send.
+         This method only decreases a counter so that calls to
+         disallow_messages and allow_messages can be nested. Only the
+         outermost calls will actually switch message sending on and off.
+         """
+         self.allow_messages_count -= 1
+     def issue(self, *args):
+         """Issue a message unless disallowed.
+         See the allow_messages and disallow_messages methods.
+         """
+         if self.allow_messages_count == 0:
+             Publisher.issue(self, *args)
+ class LayerTableGrid(TableGrid):
+     """Table grid for the layer tables.
+     The LayerTableGrid is basically the same as a TableGrid but it's
+     selection is usually coupled to the selected object in the map.
+     """
+     def select_shapes(self, layer, shapes):
+         """Select the row corresponding to the specified shape and layer
+         If layer is not the layer the table is associated with do
+         nothing. If shape or layer is None also do nothing.
+         """
+         if layer is not None \
+             and layer.table is self.table.table:
+             self.disallow_messages()
+             try:
+                 self.ClearSelection()
+                 if len(shapes) > 0:
+                     #
+                     # keep track of the lowest id so we can make it
+                     # the first visible item
+                     #
+                     first = shapes[0]
+                     for shape in shapes:
+                         self.SelectRow(shape, True)
+                         if shape < first:
+                             first = shape
+                     self.SetGridCursor(first, 0)
+                     self.MakeCellVisible(first, 0)
+             finally:
+                 self.allow_messages()
- class TableFrame(NonModalDialog):
+ class TableFrame(NonModalNonParentDialog):
      """Frame that displays a Thuban table in a grid view"""
-     def __init__(self, parent, interactor, name, title, layer = None,
+     def __init__(self, parent, name, title, table):
-                  table = None):
+         NonModalNonParentDialog.__init__(self, parent, name, title)
-         NonModalDialog.__init__(self, parent, interactor, name, title)
-         self.layer = layer
          self.table = table
-         self.grid = TableGrid(self, table)
+         self.grid = self.make_grid(self.table)
-         self.grid.Subscribe(ROW_SELECTED, self.row_selected)
+         self.app = self.parent.application
-         self.interactor.Subscribe(SELECTED_SHAPE, self.select_shape)
+         self.app.Subscribe(SESSION_REPLACED, self.close_on_session_replaced)
+         self.session = self.app.Session()
+         self.session.Subscribe(TABLE_REMOVED, self.close_on_table_removed)
+     def make_grid(self, table):
+         """Return the table grid to use in the frame.
+         The default implementation returns a TableGrid instance.
+         Override in derived classes to use different grid classes.
+         """
+         return TableGrid(self, table)
      def OnClose(self, event):
-         self.interactor.Unsubscribe(SELECTED_SHAPE, self.select_shape)
+         self.app.Unsubscribe(SESSION_REPLACED, self.close_on_session_replaced)
-         NonModalDialog.OnClose(self, event)
+         self.session.Unsubscribe(TABLE_REMOVED, self.close_on_table_removed)
+         NonModalNonParentDialog.OnClose(self, event)
+     def close_on_session_replaced(self, *args):
+         """Subscriber for the SESSION_REPLACED messages.
+         The table frame is tied to a session so close the window when
+         the session changes.
+         """
+         self.Close()
+     def close_on_table_removed(self, table):
+         """Subscriber for the TABLE_REMOVED messages.
+         The table frame is tied to a particular table so close the
+         window when the table is removed.
+         """
+         if table is self.table:
+             self.Close()
+ ID_QUERY = 4001
+ ID_EXPORT = 4002
+ class QueryTableFrame(TableFrame):
+     """Frame that displays a table in a grid view and offers user actions
+     selection and export
+     A LayerTableFrame is TableFrame whose selection is connected to the
+     selected object in a map.
+     """
+     def __init__(self, parent, name, title, table):
+         TableFrame.__init__(self, parent, name, title, table)
+         self.combo_fields = wxComboBox(self, -1, style=wxCB_READONLY)
+         self.choice_comp = wxChoice(self, -1,
+                               choices=["<", "<=", "==", "!=", ">=", ">"])
+         self.combo_value = wxComboBox(self, -1)
+         self.choice_action = wxChoice(self, -1,
+                                 choices=[_("Replace Selection"),
+                                         _("Refine Selection"),
+                                         _("Add to Selection")])
+         button_query = wxButton(self, ID_QUERY, _("Query"))
+         button_saveas = wxButton(self, ID_EXPORT, _("Export"))
+         self.grid.SetSize((400, 200))
+         self.combo_value.Append("")
+         for i in range(table.NumColumns()):
+             name = table.Column(i).name
+             self.combo_fields.Append(name)
+             self.combo_value.Append(name)
+         # assume at least one field?
+         self.combo_fields.SetSelection(0)
+         self.combo_value.SetSelection(0)
+         topBox = wxBoxSizer(wxVERTICAL)
+         sizer = wxStaticBoxSizer(wxStaticBox(self, -1,
+                                   _("Selection")),
+                                   wxHORIZONTAL)
+         sizer.Add(self.combo_fields, 1, wxEXPAND|wxALL, 4)
+         sizer.Add(self.choice_comp, 0, wxALL, 4)
+         sizer.Add(self.combo_value, 1, wxEXPAND|wxALL, 4)
+         sizer.Add(self.choice_action, 0, wxALL, 4)
+         sizer.Add(button_query, 0, wxALL | wxALIGN_CENTER_VERTICAL, 4)
+         sizer.Add(40, 20, 0, wxALL, 4)
+         sizer.Add(button_saveas, 0, wxALL | wxALIGN_CENTER_VERTICAL, 4)
+         topBox.Add(sizer, 0, wxEXPAND|wxALL, 4)
+         topBox.Add(self.grid, 1, wxEXPAND|wxALL, 0)
+         self.SetAutoLayout(True)
+         self.SetSizer(topBox)
+         topBox.Fit(self)
+         topBox.SetSizeHints(self)
+         self.grid.SetFocus()
+         EVT_BUTTON(self, ID_QUERY, self.OnQuery)
+         EVT_BUTTON(self, ID_EXPORT, self.OnSaveAs)
+         EVT_KEY_DOWN(self.grid, self.OnKeyDown)
+     def OnKeyDown(self, event):
+         """Catch query key from grid"""
+         if event.AltDown() and event.GetKeyCode() == ord(QUERY_KEY):
+             self.combo_fields.SetFocus()
+             self.combo_fields.refocus = True
+         else:
+             event.Skip()
+     def OnQuery(self, event):
+         wxBeginBusyCursor()
+         if self.combo_value.GetSelection() < 1:
+             value = self.combo_value.GetValue()
+         else:
+             value = self.table.Column(self.combo_value.GetValue())
+         ids = self.table.SimpleQuery(
+                 self.table.Column(self.combo_fields.GetStringSelection()),
+                 self.choice_comp.GetStringSelection(),
+                 value)
+         choice = self.choice_action.GetSelection()
+         #
+         # what used to be nice code got became a bit ugly because
+         # each time we select a row a message is sent to the grid
+         # which we are listening for and then we send further
+         # messages.
+         #
+         # now, we disable those listeners select everything but
+         # the first item, reenable the listeners, and select
+         # the first element, which causes everything to be
+         # updated properly.
+         #
+         self.grid.ToggleEventListeners(False)
+         if choice == 0:
+             # Replace Selection
+             self.grid.ClearSelection()
+         elif choice == 1:
+             # Refine Selection
+             sel = self.get_selected()
+             self.grid.ClearSelection()
+             ids = filter(sel.has_key, ids)
+         elif choice == 2:
+             # Add to Selection
+             pass
+         #
+         # select the rows (all but the first)
+         #
+         firsttime = True
+         for id in ids:
+             if firsttime:
+                 firsttime = False
+             else:
+                 self.grid.SelectRow(id, True)
+         self.grid.ToggleEventListeners(True)
+         #
+         # select the first row
+         #
+         if ids:
+             self.grid.SelectRow(ids[0], True)
-     def select_shape(self, layer, shape):
+         wxEndBusyCursor()
-         self.grid.select_shape(layer, shape)
+     def OnSaveAs(self, event):
+         dlg = wxFileDialog(self, _("Export Table To"), ".", "",
+                            _("DBF Files (*.dbf)|*.dbf|") +
+                            _("CSV Files (*.csv)|*.csv|") +
+                            _("All Files (*.*)|*.*"),
+                            wxSAVE|wxOVERWRITE_PROMPT)
+         if dlg.ShowModal() == wxID_OK:
+             filename = dlg.GetPath()
+             type = os.path.basename(filename).split('.')[-1:][0]
+             dlg.Destroy()
+             if type.upper() == "DBF":
+                 table_to_dbf(self.table, filename)
+             elif type.upper() == 'CSV':
+                 table_to_csv(self.table, filename)
+             else:
+                 dlg = wxMessageDialog(None, "Unsupported format: %s" % type,
+                                       "Table Export", wxOK|wxICON_WARNING)
+                 dlg.ShowModal()
+                 dlg.Destroy()
+         else:
+             dlg.Destroy()
-     def row_selected(self, row):
+     def OnClose(self, event):
+         TableFrame.OnClose(self, event)
+     def get_selected(self):
+         """Return a dictionary of the selected rows.
+         The dictionary has sthe indexes as keys."""
+         return dict([(i, 0) for i in self.grid.GetSelectedRows()])
+ class LayerTableFrame(QueryTableFrame):
+     """Frame that displays a layer table in a grid view
+     A LayerTableFrame is a QueryTableFrame whose selection is connected to the
+     selected object in a map.
+     """
+     def __init__(self, parent, name, title, layer, table):
+         QueryTableFrame.__init__(self, parent, name, title, table)
+         self.layer = layer
+         self.grid.Subscribe(ROW_SELECTED, self.rows_selected)
+         self.parent.Subscribe(SHAPES_SELECTED, self.select_shapes)
+         # if there is already a selection present, update the grid
+         # accordingly
+         sel = self.get_selected().keys()
+         for i in sel:
+             self.grid.SelectRow(i, True)
+     def make_grid(self, table):
+         """Override the derived method to return a LayerTableGrid.
+         """
+         return LayerTableGrid(self, table)
+     def get_selected(self):
+         """Override the derived method to return a dictionary of the selected
+         rows.
+         """
+         return dict([(i, 0) for i in self.parent.SelectedShapes()])
+     def OnClose(self, event):
+         """Override the derived method to first unsubscribed."""
+         self.parent.Unsubscribe(SHAPES_SELECTED, self.select_shapes)
+         QueryTableFrame.OnClose(self, event)
+     def select_shapes(self, layer, shapes):
+         """Subscribed to the SHAPES_SELECTED message.
+         If shapes contains exactly one shape id, select that shape in
+         the grid. Otherwise deselect all.
+         """
+         self.grid.select_shapes(layer, shapes)
+     def rows_selected(self, rows):
+         """Return the selected rows of the layer as they are returned
+         by Layer.SelectShapes().
+         """
          if self.layer is not None:
-             self.interactor.SelectLayerAndShape(self.layer, row)
+             self.parent.SelectShapes(self.layer, rows)

 Legend:



Removed from v.173
 


changed lines


 
Added in v.1068
 Legend:



Removed from v.173
 


changed lines


 
Added in v.1068
-Removed from v.173
+Added in v.1068

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26