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

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

Parent Directory | Revision Log | View Patch Patch

-trunk/thuban/Thuban/UI/classifier.py
revision 1452 by bh,
Fri Jul 18 12:57:59 2003 UTC
+branches/WIP-pyshapelib-bramz/Thuban/UI/classifier.py
revision 2734 by bramz,
Thu Mar  1 12:42:59 2007 UTC
 Line 1
- # Copyright (c) 2001, 2003 by Intevation GmbH
+ # Copyright (c) 2003-2005 by Intevation GmbH
  # Authors:
- # Jonathan Coles <[email protected]>
+ # Jan-Oliver Wagner <[email protected]> (2003-2004)
+ # Martin Schulze <[email protected]> (2004)
+ # Frank Koormann <[email protected]> (2003, 2006)
+ # Bernhard Herzog <[email protected]> (2003)
+ # Jonathan Coles <[email protected]> (2003)
  #
  # This program is free software under the GPL (>=v2)
  # Read the file COPYING coming with Thuban for details.
-Line 8
+Line 12
  """Dialog for classifying how layers are displayed"""
  __version__ = "$Revision$"
+ # $Source$
+ # $Id$
  import copy
+ import re
  from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
       FIELDTYPE_STRING
- from wxPython.wx import *
+ import wx
- from wxPython.grid import *
+ from wx import grid
  from Thuban import _
  from Thuban.UI.common import Color2wxColour, wxColour2Color
-Line 24 
 from Thuban.Model.messages import MAP_LA
+Line 31 
 from Thuban.Model.messages import MAP_LA
  from Thuban.Model.range import Range
  from Thuban.Model.classification import \
      Classification, ClassGroupDefault, \
-     ClassGroupSingleton, ClassGroupRange, ClassGroupMap, \
+     ClassGroupSingleton, ClassGroupPattern, ClassGroupRange, ClassGroupMap, \
      ClassGroupProperties
  from Thuban.Model.color import Transparent
- from Thuban.Model.layer import Layer, RasterLayer, \
+ from Thuban.Model.layer import Layer
-     SHAPETYPE_ARC, SHAPETYPE_POLYGON, SHAPETYPE_POINT
+ from Thuban.Model.data import SHAPETYPE_ARC, SHAPETYPE_POLYGON, SHAPETYPE_POINT
  from Thuban.UI.classgen import ClassGenDialog
+ from Thuban.UI.colordialog import ColorDialog
- from dialogs import NonModalNonParentDialog
+ from Thuban.UI.layerproperties import LayerProperties
+ from messages import MAP_REPLACED
- ID_CLASS_TABLE = 40011
  # table columns
-Line 56 
 FIELD_NAME = 2
+Line 63 
 FIELD_NAME = 2
  # passed into SetTable is the same that is returned by GetTable
  #
  import weakref
- class ClassGrid(wxGrid):
+ class ClassGrid(grid.Grid):
      def __init__(self, parent, classifier):
-Line 67 
 class ClassGrid(wxGrid):
+Line 74 
 class ClassGrid(wxGrid):
          clazz -- the working classification that this grid should
                   use for display.
          """
+         grid.Grid.__init__(self, parent, -1, style = 0)
-         wxGrid.__init__(self, parent, ID_CLASS_TABLE, style = 0)
          self.classifier = classifier
          self.currentSelection = []
-         EVT_GRID_CELL_LEFT_DCLICK(self, self._OnCellDClick)
+         self.Bind(grid.EVT_GRID_CELL_LEFT_DCLICK, self._OnCellDClick)
-         EVT_GRID_RANGE_SELECT(self, self._OnSelectedRange)
+         self.Bind(grid.EVT_GRID_RANGE_SELECT, self._OnSelectedRange)
-         EVT_GRID_SELECT_CELL(self, self._OnSelectedCell)
+         self.Bind(grid.EVT_GRID_SELECT_CELL, self._OnSelectedCell)
-         EVT_GRID_COL_SIZE(self, self._OnCellResize)
+         self.Bind(grid.EVT_GRID_COL_SIZE, self._OnCellResize)
-         EVT_GRID_ROW_SIZE(self, self._OnCellResize)
+         self.Bind(grid.EVT_GRID_ROW_SIZE, self._OnCellResize)
+         self.Bind(grid.EVT_GRID_LABEL_RIGHT_CLICK, self._OnLabelRightClicked)
      #def GetCellAttr(self, row, col):
          #print "GetCellAttr ", row, col
-         #wxGrid.GetCellAttr(self, row, col)
+         #Grid.GetCellAttr(self, row, col)
      def CreateTable(self, clazz, fieldType, shapeType, group = None):
-Line 91 
 class ClassGrid(wxGrid):
+Line 99 
 class ClassGrid(wxGrid):
          table = self.GetTable()
          if table is None:
              w = self.GetDefaultColSize() * NUM_COLS \
                  + self.GetDefaultRowLabelSize()
              h = self.GetDefaultRowSize() * 4 \
                  + self.GetDefaultColLabelSize()
-Line 101 
 class ClassGrid(wxGrid):
+Line 109 
 class ClassGrid(wxGrid):
              self.SetTable(table, True)
-         self.SetSelectionMode(wxGrid.wxGridSelectRows)
+         self.SetSelectionMode(grid.Grid.wxGridSelectRows)
          self.ClearSelection()
          table.Reset(clazz, fieldType, shapeType, group)
-Line 127 
 class ClassGrid(wxGrid):
+Line 135 
 class ClassGrid(wxGrid):
      #
      def SetTable(self, object, *attributes):
          self.tableRef = weakref.ref(object)
-         return wxGrid.SetTable(self, object, *attributes)
+         return grid.Grid.SetTable(self, object, *attributes)
      def GetTable(self):
          try:
-Line 137 
 class ClassGrid(wxGrid):
+Line 145 
 class ClassGrid(wxGrid):
      def DeleteSelectedRows(self):
          """Deletes all highlighted rows.
          If only one row is highlighted then after it is deleted the
          row that was below the deleted row is highlighted."""
          sel = self.GetCurrentSelection()
          # nothing to do
          if len(sel) == 0: return
          # if only one thing is selected check if it is the default
          # data row, because we can't remove that
-Line 152 
 class ClassGrid(wxGrid):
+Line 160 
 class ClassGrid(wxGrid):
              #group = self.GetTable().GetValueAsCustom(sel[0], COL_SYMBOL, None)
              group = self.GetTable().GetClassGroup(sel[0])
              if isinstance(group, ClassGroupDefault):
-                 wxMessageDialog(self,
+                 wx.MessageDialog(self,
-                                 "The Default group cannot be removed.",
+                                 _("The Default group cannot be removed."),
-                                 style = wxOK | wxICON_EXCLAMATION).ShowModal()
+                                 style = wx.OK | wx.ICON_EXCLAMATION).ShowModal()
                  return
          self.ClearSelection()
-Line 181 
 class ClassGrid(wxGrid):
+Line 189 
 class ClassGrid(wxGrid):
              if r > self.GetNumberRows() - 1:
                  r = self.GetNumberRows() - 1
              self.SelectRow(r)
      def SelectGroup(self, group, makeVisible = True):
          if group is None: return
          assert isinstance(group, ClassGroup)
          table = self.GetTable()
          assert table is not None
          for i in range(table.GetNumberRows()):
              g = table.GetClassGroup(i)
-Line 205 
 class ClassGrid(wxGrid):
+Line 213 
 class ClassGrid(wxGrid):
  #
  #   def DeselectRow(self, row):
  #       self.ProcessEvent(
- #           wxGridRangeSelectEvent(-1,
+ #           GridRangeSelectEvent(-1,
  #                                  wxEVT_GRID_RANGE_SELECT,
  #                                  self,
  #                                  (row, row), (row, row),
-Line 227 
 class ClassGrid(wxGrid):
+Line 235 
 class ClassGrid(wxGrid):
      # from http://wiki.wxpython.org to keep track of which
      # cells are currently highlighted
      #
      def _OnSelectedRange(self, event):
          """Internal update to the selection tracking list"""
          if event.Selecting():
              for index in range( event.GetTopRow(), event.GetBottomRow()+1):
                  if index not in self.currentSelection:
                      self.currentSelection.append( index )
          else:
              for index in range( event.GetTopRow(), event.GetBottomRow()+1):
                  while index in self.currentSelection:
                      self.currentSelection.remove( index )
          #self.ConfigureForSelection()
          event.Skip()
      def _OnSelectedCell( self, event ):
          """Internal update to the selection tracking list"""
          self.currentSelection = [ event.GetRow() ]
          #self.ConfigureForSelection()
          event.Skip()
      def _OnCellResize(self, event):
          self.FitInside()
          event.Skip()
- class ClassTable(wxPyGridTableBase):
+     def _OnLabelRightClicked(self, event):
+         """Process right click on label, raise popup for row labels."""
+         row, col = event.GetRow(), event.GetCol()
+         if col == -1:
+             self.labelPopup(event, row)
+     def labelPopup(self, event, row):
+         """Raise grid label popup."""
+         # check if row label is Pattern or Singleton
+         label = self.GetRowLabelValue(row)
+         if (label == _("Pattern") or label == _("Singleton")):
+             xe,ye = event.GetPosition()
+             x=self.GetRowSize(row)/2
+             menu = wx.Menu()
+             patternID = wx.NewId()
+             singletonID = wx.NewId()
+             def _SetSingleton(event, self=self, row=row):
+                 table = self.GetTable()
+                 group = table.clazz.GetGroup(row - 1)
+                 if not isinstance(group, ClassGroupSingleton):
+                     ngroup = ClassGroupSingleton(
+                                 group.GetPattern(),
+                                 group.GetProperties(),
+                                 group.GetLabel()
+                                 )
+                     table.SetClassGroup(row, ngroup)
+             def _SetPattern(event, self=self, row=row):
+                 table = self.GetTable()
+                 group = table.clazz.GetGroup(row - 1)
+                 if not isinstance(group, ClassGroupPattern):
+                     try:
+                         re.compile(group.GetValue())
+                     except:
+                         pass
+                     else:
+                         ngroup = ClassGroupPattern(
+                                 group.GetValue(),
+                                 group.GetProperties(),
+                                 group.GetLabel()
+                                 )
+                         table.SetClassGroup(row, ngroup)
+             menu.Append(singletonID, _("Singleton"))
+             self.Bind(wx.EVT_MENU, _SetSingleton, id=singletonID)
+             if self.GetTable().fieldType == FIELDTYPE_STRING:
+                 menu.Append(patternID, _("Pattern"))
+                 self.Bind(wx.EVT_MENU, _SetPattern, id=patternID)
+             self.PopupMenu(menu, wx.Point(x,ye))
+             menu.Destroy()
+ class ClassTable(grid.PyGridTableBase):
      """Represents the underlying data structure for the grid."""
      __col_labels = [_("Visible"), _("Symbol"), _("Value"), _("Label")]
-Line 262 
 class ClassTable(wxPyGridTableBase):
+Line 322 
 class ClassTable(wxPyGridTableBase):
          shapeType -- the type of shape that the layer uses
-         view -- a wxGrid object that uses this class for its table
+         view -- a Grid object that uses this class for its table
          """
-         wxPyGridTableBase.__init__(self)
+         grid.PyGridTableBase.__init__(self)
          assert len(ClassTable.__col_labels) == NUM_COLS
-Line 288 
 class ClassTable(wxPyGridTableBase):
+Line 348 
 class ClassTable(wxPyGridTableBase):
          shapeType -- the type of shape that the layer uses
          """
          assert isinstance(clazz, Classification)
          self.GetView().BeginBatch()
-Line 300 
 class ClassTable(wxPyGridTableBase):
+Line 360 
 class ClassTable(wxPyGridTableBase):
          self.__colAttr = {}
-         attr = wxGridCellAttr()
+         attr = grid.GridCellAttr()
-         attr.SetEditor(wxGridCellBoolEditor())
+         attr.SetEditor(grid.GridCellBoolEditor())
-         attr.SetRenderer(wxGridCellBoolRenderer())
+         attr.SetRenderer(grid.GridCellBoolRenderer())
-         attr.SetAlignment(wxALIGN_CENTER, wxALIGN_CENTER)
+         attr.SetAlignment(wx.ALIGN_CENTER, wx.ALIGN_CENTER)
          self.__colAttr[COL_VISIBLE] = attr
-         attr = wxGridCellAttr()
+         attr = grid.GridCellAttr()
          attr.SetRenderer(ClassRenderer(self.shapeType))
          attr.SetReadOnly()
          self.__colAttr[COL_SYMBOL] = attr
-Line 315 
 class ClassTable(wxPyGridTableBase):
+Line 375 
 class ClassTable(wxPyGridTableBase):
          self.GetView().FitInside()
      def GetClassification(self):
+         """Return the current classification."""
          return self.clazz
      def SetClassification(self, clazz, group = None):
+         """Fill in the table with the given classification.
+         Select the given group if group is not None.
+         """
          self.GetView().BeginBatch()
-Line 325 
 class ClassTable(wxPyGridTableBase):
+Line 389 
 class ClassTable(wxPyGridTableBase):
          row = -1
          self.clazz = clazz
          self.__NotifyRowChanges(old_len, self.GetNumberRows())
          #
-Line 338 
 class ClassTable(wxPyGridTableBase):
+Line 402 
 class ClassTable(wxPyGridTableBase):
          self.__Modified()
          self.GetView().EndBatch()
          self.GetView().FitInside()
      def __NotifyRowChanges(self, curRows, newRows):
+         """Make sure table updates correctly if the number of
+         rows changes.
+         """
          #
          # silly message processing for updates to the number of
          # rows and columns
          #
          if newRows > curRows:
-             msg = wxGridTableMessage(self,
+             msg = grid.GridTableMessage(self,
-                         wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
+                         grid.GRIDTABLE_NOTIFY_ROWS_APPENDED,
                          newRows - curRows)    # how many
              self.GetView().ProcessTableMessage(msg)
              self.GetView().FitInside()
          elif newRows < curRows:
-             msg = wxGridTableMessage(self,
+             msg = grid.GridTableMessage(self,
-                         wxGRIDTABLE_NOTIFY_ROWS_DELETED,
+                         grid.GRIDTABLE_NOTIFY_ROWS_DELETED,
                          curRows,              # position
                          curRows - newRows)    # how many
              self.GetView().ProcessTableMessage(msg)
              self.GetView().FitInside()
      def __SetRow(self, row, group):
          """Set a row's data to that of the group.
-Line 399 
 class ClassTable(wxPyGridTableBase):
+Line 464 
 class ClassTable(wxPyGridTableBase):
              group = self.clazz.GetGroup(row - 1)
              if isinstance(group, ClassGroupDefault):   return _("Default")
              if isinstance(group, ClassGroupSingleton): return _("Singleton")
+             if isinstance(group, ClassGroupPattern):   return _("Pattern")
              if isinstance(group, ClassGroupRange):     return _("Range")
              if isinstance(group, ClassGroupMap):       return _("Map")
-Line 432 
 class ClassTable(wxPyGridTableBase):
+Line 498 
 class ClassTable(wxPyGridTableBase):
          """
          self.SetValueAsCustom(row, col, None, value)
      def GetValueAsCustom(self, row, col, typeName):
          """Return the object that is used to represent the given
             cell coordinates. This may not be a string.
          typeName -- unused, but needed to overload wxPyGridTableBase
          """
-Line 456 
 class ClassTable(wxPyGridTableBase):
+Line 522 
 class ClassTable(wxPyGridTableBase):
              return group.GetLabel()
          # col must be COL_VALUE
          assert col == COL_VALUE
          if isinstance(group, ClassGroupDefault):
              return _("DEFAULT")
          elif isinstance(group, ClassGroupSingleton):
              return group.GetValue()
+         elif isinstance(group, ClassGroupPattern):
+             return group.GetPattern()
          elif isinstance(group, ClassGroupRange):
              return group.GetRange()
-Line 473 
 class ClassTable(wxPyGridTableBase):
+Line 541 
 class ClassTable(wxPyGridTableBase):
             (string, number, or range)
          Returns a tuple (type, data) where type is 0 if data is
-         a singleton value, or 1 if is a range
+         a singleton value, 1 if is a range or 2 if it is a pattern.
          """
          type = self.fieldType
          if type == FIELDTYPE_STRING:
-             return (0, value)
+             # Approach: if we can compile the value as an expression,
+             # make it a pattern, else a singleton.
+             # This is quite crude, however I don't have a better idea:
+             # How to distinct the singleton "Thuban" from the pattern "Thuban"?
+             try:
+                 re.compile(value)
+             except:
+                 return (0, value)
+             else:
+                 return (2, value)
          elif type in (FIELDTYPE_INT, FIELDTYPE_DOUBLE):
              if type == FIELDTYPE_INT:
                  # the float call allows the user to enter 1.0 for 1
-Line 513 
 class ClassTable(wxPyGridTableBase):
+Line 590 
 class ClassTable(wxPyGridTableBase):
          typeName -- unused, but needed to overload wxPyGridTableBase
          """
          assert 0 <= col < self.GetNumberCols()
          assert 0 <= row < self.GetNumberRows()
          if row == 0:
              group = self.clazz.GetDefaultGroup()
-Line 563 
 class ClassTable(wxPyGridTableBase):
+Line 640 
 class ClassTable(wxPyGridTableBase):
                              ngroup = ClassGroupRange(props = props)
                              changed = True
                          ngroup.SetRange(dataInfo[1])
+                     elif dataInfo[0] == 2:
+                         if not isinstance(group, ClassGroupPattern):
+                             ngroup = ClassGroupPattern(props = props)
+                             changed = True
+                         ngroup.SetPattern(dataInfo[1])
                      else:
                          assert False
                          pass
-Line 581 
 class ClassTable(wxPyGridTableBase):
+Line 663 
 class ClassTable(wxPyGridTableBase):
      def GetAttr(self, row, col, someExtraParameter):
          """Returns the cell attributes"""
-         return self.__colAttr.get(col, wxGridCellAttr()).Clone()
+         return self.__colAttr.get(col, grid.GridCellAttr()).Clone()
      def GetClassGroup(self, row):
          """Return the ClassGroup object representing row 'row'."""
-Line 593 
 class ClassTable(wxPyGridTableBase):
+Line 675 
 class ClassTable(wxPyGridTableBase):
              return self.clazz.GetGroup(row - 1)
      def SetClassGroup(self, row, group):
+         """Set the given row to properties of group."""
          self.__SetRow(row, group)
          self.GetView().Refresh()
-Line 621 
 class ClassTable(wxPyGridTableBase):
+Line 704 
 class ClassTable(wxPyGridTableBase):
          The table is considered modified if any rows are removed.
          """
          assert pos >= 0
          old_len = self.GetNumberRows()
          for row in range(pos, pos - numRows, -1):
              group = self.GetClassGroup(row)
              if row != 0:
                  self.clazz.RemoveGroup(row - 1)
                  self.__Modified()
          if self.IsModified():
              self.__NotifyRowChanges(old_len, self.GetNumberRows())
-Line 670 
 EB_LAYER_TITLE = 0
+Line 753 
 EB_LAYER_TITLE = 0
  EB_SELECT_FIELD = 1
  EB_GEN_CLASS = 2
- class Classifier(NonModalNonParentDialog):
+ class Classifier(LayerProperties):
      type2string = {None:             _("None"),
                     FIELDTYPE_STRING: _("Text"),
                     FIELDTYPE_INT:    _("Integer"),
                     FIELDTYPE_DOUBLE: _("Decimal")}
-     def __init__(self, parent, name, map, layer, group = None):
+     def __init__(self, parent, name, layer, group = None):
-         NonModalNonParentDialog.__init__(self, parent, name, "")
+         """Create a Properties/Classification dialog for a layer.
+         The layer is part of map. If group is not None, select that
-         self.__SetTitle(layer.Title())
+         group in the classification table.
+         """
-         self.layer = layer
+         LayerProperties.__init__(self, parent, name, layer)
-         self.map = map
-         self.map.Subscribe(MAP_LAYERS_REMOVED, self.map_layers_removed)
          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
                               self.layer_shapestore_replaced)
          self.genDlg = None
+         self.group = group
-         ############################
+         LayerProperties.dialog_layout(self)
-         # Create the controls
-         #
+     def dialog_layout(self, panel, panelBox):
-         panel = wxPanel(self, -1)
+         if self.layer.HasClassification():
-         text_title = wxTextCtrl(panel, ID_PROPERTY_TITLE, layer.Title())
+             self.fieldTypeText = wx.StaticText(panel, -1, "")
-         self.fieldTypeText = wxStaticText(panel, -1, "")
-         if layer.HasClassification():
              self.originalClass = self.layer.GetClassification()
              self.originalClassField = self.layer.GetClassificationColumn()
              field = self.originalClassField
              fieldType = self.layer.GetFieldType(field)
-             table = layer.ShapeStore().Table()
+             table = self.layer.ShapeStore().Table()
              #
              # make field choice box
              #
-             self.fields = wxChoice(panel, ID_PROPERTY_SELECT,)
+             self.fields = wx.Choice(panel, ID_PROPERTY_SELECT,)
              self.num_cols = table.NumColumns()
              # just assume the first field in case one hasn't been
              # specified in the file.
              self.__cur_field = 0
              self.fields.Append("<None>")
-Line 730 
 class Classifier(NonModalNonParentDialog
+Line 811 
 class Classifier(NonModalNonParentDialog
                  if name == field:
                      self.__cur_field = i + 1
                      self.fields.SetClientData(i + 1,
                                                copy.deepcopy(self.originalClass))
                  else:
                      self.fields.SetClientData(i + 1, None)
-             button_gen = wxButton(panel, ID_PROPERTY_GENCLASS,
+             button_gen = wx.Button(panel, ID_PROPERTY_GENCLASS,
                  _("Generate Class"))
-             button_add = wxButton(panel, ID_PROPERTY_ADD,
+             button_add = wx.Button(panel, ID_PROPERTY_ADD,
                  _("Add"))
-             button_moveup = wxButton(panel, ID_PROPERTY_MOVEUP,
+             button_moveup = wx.Button(panel, ID_PROPERTY_MOVEUP,
                  _("Move Up"))
-             button_movedown = wxButton(panel, ID_PROPERTY_MOVEDOWN,
+             button_movedown = wx.Button(panel, ID_PROPERTY_MOVEDOWN,
                  _("Move Down"))
-             button_edit = wxButton(panel, ID_PROPERTY_EDITSYM,
+             button_edit = wx.Button(panel, ID_PROPERTY_EDITSYM,
                  _("Edit Symbol"))
-             button_remove = wxButton(panel, ID_PROPERTY_REMOVE,
+             button_remove = wx.Button(panel, ID_PROPERTY_REMOVE,
                  _("Remove"))
              self.classGrid = ClassGrid(panel, self)
-Line 753 
 class Classifier(NonModalNonParentDialog
+Line 834 
 class Classifier(NonModalNonParentDialog
              # calling __SelectField after creating the classGrid fills in the
              # grid with the correct information
              self.fields.SetSelection(self.__cur_field)
-             self.__SelectField(self.__cur_field, group = group)
+             self.__SelectField(self.__cur_field, group = self.group)
-         button_try = wxButton(self, ID_PROPERTY_TRY, _("Try"))
-         button_revert = wxButton(self, ID_PROPERTY_REVERT, _("Revert"))
-         button_ok = wxButton(self, wxID_OK, _("OK"))
-         button_close = wxButton(self, wxID_CANCEL, _("Close"))
-         button_ok.SetDefault()
-         ############################
-         # Layout the controls
-         #
-         topBox = wxBoxSizer(wxVERTICAL)
-         panelBox = wxBoxSizer(wxVERTICAL)
-         sizer = wxBoxSizer(wxHORIZONTAL)
-         sizer.Add(wxStaticText(panel, -1, _("Title: ")),
-, wxALIGN_LEFT | wxALL | wxALIGN_CENTER_VERTICAL, 4)
-         sizer.Add(text_title, 1, wxGROW, 0)
-         panelBox.Add(sizer, 0, wxGROW, 4)
-         if isinstance(layer, RasterLayer):
-             type = "Image"
-         else:
-             type = layer.ShapeType()
-         panelBox.Add(wxStaticText(panel, -1, _("Type: %s") % type),
-, wxALIGN_LEFT | wxALL, 4)
-         if layer.HasClassification():
-             classBox = wxStaticBoxSizer(
-                         wxStaticBox(panel, -1, _("Classification")), wxVERTICAL)
-             sizer = wxBoxSizer(wxHORIZONTAL)
-             sizer.Add(wxStaticText(panel, ID_PROPERTY_FIELDTEXT, _("Field: ")),
-, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 4)
-             sizer.Add(self.fields, 1, wxGROW | wxALL, 4)
-             classBox.Add(sizer, 0, wxGROW, 4)
-             classBox.Add(self.fieldTypeText, 0,
-                         wxGROW | wxALIGN_LEFT | wxALL | wxADJUST_MINSIZE, 4)
-             controlBox = wxBoxSizer(wxHORIZONTAL)
-             controlButtonBox = wxBoxSizer(wxVERTICAL)
-             controlButtonBox.Add(button_gen, 0, wxGROW|wxALL, 4)
+             classBox = wx.StaticBoxSizer(
-             controlButtonBox.Add(button_add, 0, wxGROW|wxALL, 4)
+                         wx.StaticBox(panel, -1, _("Classification")), wx.VERTICAL)
-             controlButtonBox.Add(button_moveup, 0, wxGROW|wxALL, 4)
-             controlButtonBox.Add(button_movedown, 0, wxGROW|wxALL, 4)
-             controlButtonBox.Add(button_edit, 0, wxGROW|wxALL, 4)
-             controlButtonBox.Add(60, 20, 0, wxGROW|wxALL|wxALIGN_BOTTOM, 4)
-             controlButtonBox.Add(button_remove, 0,
-                                  wxGROW|wxALL|wxALIGN_BOTTOM, 4)
-             controlBox.Add(self.classGrid, 1, wxGROW, 0)
-             controlBox.Add(controlButtonBox, 0, wxGROW, 10)
-             classBox.Add(controlBox, 1, wxGROW, 10)
+             sizer = wx.BoxSizer(wx.HORIZONTAL)
-             panelBox.Add(classBox, 1, wxGROW, 0)
+             sizer.Add(wx.StaticText(panel, ID_PROPERTY_FIELDTEXT, _("Field: ")),
+, wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, 4)
+             sizer.Add(self.fields, 1, wx.GROW | wx.ALL, 4)
+             classBox.Add(sizer, 0, wx.GROW, 4)
-         buttonBox = wxBoxSizer(wxHORIZONTAL)
+             classBox.Add(self.fieldTypeText, 0,
-         buttonBox.Add(button_try, 0, wxRIGHT|wxEXPAND, 10)
+                         wx.GROW | wx.ALIGN_LEFT | wx.ALL | wx.ADJUST_MINSIZE, 4)
-         buttonBox.Add(button_revert, 0, wxRIGHT|wxEXPAND, 10)
-         buttonBox.Add(button_ok, 0, wxRIGHT|wxEXPAND, 10)
-         buttonBox.Add(button_close, 0, wxRIGHT|wxEXPAND, 10)
-         panel.SetAutoLayout(True)
+             controlBox = wx.BoxSizer(wx.HORIZONTAL)
-         panel.SetSizer(panelBox)
+             controlButtonBox = wx.BoxSizer(wx.VERTICAL)
-         panelBox.Fit(panel)
-         panelBox.SetSizeHints(panel)
-         topBox.Add(panel, 1, wxGROW | wxALL, 4)
+             controlButtonBox.Add(button_gen, 0, wx.GROW|wx.ALL, 4)
-         topBox.Add(buttonBox, 0, wxALIGN_RIGHT|wxBOTTOM|wxTOP, 10)
+             controlButtonBox.Add(button_add, 0, wx.GROW|wx.ALL, 4)
+             controlButtonBox.Add(button_moveup, 0, wx.GROW|wx.ALL, 4)
+             controlButtonBox.Add(button_movedown, 0, wx.GROW|wx.ALL, 4)
+             controlButtonBox.Add(button_edit, 0, wx.GROW|wx.ALL, 4)
+             controlButtonBox.Add( (60, 20), 0, wx.GROW|wx.ALL|wx.ALIGN_BOTTOM, 4)
+             controlButtonBox.Add(button_remove, 0,
+                                  wx.GROW|wx.ALL|wx.ALIGN_BOTTOM, 4)
-         self.SetAutoLayout(True)
+             controlBox.Add(self.classGrid, 1, wx.GROW, 0)
-         self.SetSizer(topBox)
+             controlBox.Add(controlButtonBox, 0, wx.GROW, 10)
-         topBox.Fit(self)
-         topBox.SetSizeHints(self)
-         self.Layout()
-         ###########
-         EVT_CHOICE(self, ID_PROPERTY_SELECT, self._OnFieldSelect)
+             classBox.Add(controlBox, 1, wx.GROW, 10)
-         EVT_TEXT(self, ID_PROPERTY_TITLE, self._OnTitleChanged)
+             panelBox.Add(classBox, 1, wx.GROW, 0)
-         EVT_BUTTON(self, wxID_OK, self._OnOK)
-         EVT_BUTTON(self, ID_PROPERTY_TRY, self._OnTry)
-         EVT_BUTTON(self, wxID_CANCEL, self._OnCloseBtn)
-         EVT_BUTTON(self, ID_PROPERTY_REVERT, self._OnRevert)
-         EVT_BUTTON(self, ID_PROPERTY_ADD, self._OnAdd)
-         EVT_BUTTON(self, ID_PROPERTY_EDITSYM, self._OnEditSymbol)
-         EVT_BUTTON(self, ID_PROPERTY_REMOVE, self._OnRemove)
-         EVT_BUTTON(self, ID_PROPERTY_GENCLASS, self._OnGenClass)
-         EVT_BUTTON(self, ID_PROPERTY_MOVEUP, self._OnMoveUp)
-         EVT_BUTTON(self, ID_PROPERTY_MOVEDOWN, self._OnMoveDown)
-         ######################
-         text_title.SetFocus()
+         self.Bind(wx.EVT_CHOICE, self._OnFieldSelect, id=ID_PROPERTY_SELECT)
-         self.haveApplied = False
+         self.Bind(wx.EVT_BUTTON, self._OnAdd, id=ID_PROPERTY_ADD)
+         self.Bind(wx.EVT_BUTTON, self._OnEditSymbol, id=ID_PROPERTY_EDITSYM)
+         self.Bind(wx.EVT_BUTTON, self._OnRemove, id=ID_PROPERTY_REMOVE)
+         self.Bind(wx.EVT_BUTTON, self._OnGenClass, id=ID_PROPERTY_GENCLASS)
+         self.Bind(wx.EVT_BUTTON, self._OnMoveUp, id=ID_PROPERTY_MOVEUP)
+         self.Bind(wx.EVT_BUTTON, self._OnMoveDown, id=ID_PROPERTY_MOVEDOWN)
      def unsubscribe_messages(self):
-         self.map.Unsubscribe(MAP_LAYERS_REMOVED, self.map_layers_removed)
+         """Unsubscribe from all messages."""
+         LayerProperties.unsubscribe_messages(self)
          self.layer.Unsubscribe(LAYER_SHAPESTORE_REPLACED,
                                 self.layer_shapestore_replaced)
-     def map_layers_removed(self, map):
-         if self.layer not in self.map.Layers():
-             self.Close()
      def layer_shapestore_replaced(self, *args):
+         """Subscribed to the map's LAYER_SHAPESTORE_REPLACED message.
+         Close self.
+         """
          self.Close()
      def EditSymbol(self, row):
+         """Open up a dialog where the user can select the properties
+         for a group.
+         """
          table = self.classGrid.GetTable()
          prop = table.GetValueAsCustom(row, COL_SYMBOL, None)
-Line 880 
 class Classifier(NonModalNonParentDialog
+Line 902 
 class Classifier(NonModalNonParentDialog
          propDlg = SelectPropertiesDialog(self, prop, self.layer.ShapeType())
          self.Enable(False)
-         if propDlg.ShowModal() == wxID_OK:
+         if propDlg.ShowModal() == wx.ID_OK:
              new_prop = propDlg.GetClassGroupProperties()
              table.SetValueAsCustom(row, COL_SYMBOL, None, new_prop)
          self.Enable(True)
          propDlg.Destroy()
      def _SetClassification(self, clazz):
+         """Called from the ClassGen dialog when a new classification has
+         been created and should be set in the table.
+         """
+         # FIXME: This could be implemented using a message
          self.fields.SetClientData(self.__cur_field, clazz)
          self.classGrid.GetTable().SetClassification(clazz)
      def __BuildClassification(self, fieldIndex, copyClass=False, force=False):
+         """Pack the classification setting into a Classification object.
+         Returns (Classification, fieldName) where fieldName is the selected
+         field in the table that the classification should be used with.
+         """
  #       numRows = self.classGrid.GetNumberRows()
  #       assert numRows > 0  # there should always be a default row
-Line 912 
 class Classifier(NonModalNonParentDialog
+Line 942 
 class Classifier(NonModalNonParentDialog
          return clazz, fieldName
      def __SetGridTable(self, fieldIndex, group = None):
+         """Set the table with the classification associated with the
+         selected field at fieldIndex. Select the specified group
+         if group is not None.
+         """
          clazz = self.fields.GetClientData(fieldIndex)
-Line 924 
 class Classifier(NonModalNonParentDialog
+Line 958 
 class Classifier(NonModalNonParentDialog
          fieldName = self.fields.GetString(fieldIndex)
          fieldType = self.layer.GetFieldType(fieldName)
          self.classGrid.CreateTable(clazz, fieldType,
                                     self.layer.ShapeType(), group)
      def __SetFieldTypeText(self, fieldIndex):
+         """Set the field type string using the data type of the field
+         at fieldIndex.
+         """
          fieldName = self.fields.GetString(fieldIndex)
          fieldType = self.layer.GetFieldType(fieldName)
          assert Classifier.type2string.has_key(fieldType)
          text = Classifier.type2string[fieldType]
-Line 956 
 class Classifier(NonModalNonParentDialog
+Line 993 
 class Classifier(NonModalNonParentDialog
          self.__SetFieldTypeText(newIndex)
      def __SetTitle(self, title):
+         """Set the title of the dialog."""
          if title != "":
              title = ": " + title
          self.SetTitle(_("Layer Properties") + title)
      def _OnEditSymbol(self, event):
+         """Open up a dialog for the user to select group properties."""
          sel = self.classGrid.GetCurrentSelection()
          if len(sel) == 1:
              self.EditSymbol(sel[0])
      def _OnFieldSelect(self, event):
          index = self.fields.GetSelection()
          self.__SelectField(index, self.__cur_field)
          self.__cur_field = index
-     def _OnTry(self, event):
+     def OnTry(self, event):
          """Put the data from the table into a new Classification and hand
             it to the layer.
          """
-Line 992 
 class Classifier(NonModalNonParentDialog
+Line 1031 
 class Classifier(NonModalNonParentDialog
          self.haveApplied = True
-     def _OnOK(self, event):
+     def OnOK(self, event):
-         self._OnTry(event)
+         self.OnTry(event)
-         self.Close()
-     def OnClose(self, event):
-         self.unsubscribe_messages()
-         NonModalNonParentDialog.OnClose(self, event)
-     def _OnCloseBtn(self, event):
-         """Close is similar to Cancel except that any changes that were
-         made and applied remain applied, but the currently displayed
-         classification is discarded.
-         """
          self.Close()
-     def _OnRevert(self, event):
+     def OnRevert(self, event):
          """The layer's current classification stays the same."""
-         if self.haveApplied:
+         if self.haveApplied and self.layer.HasClassification():
              self.layer.SetClassificationColumn(self.originalClassField)
              self.layer.SetClassification(self.originalClass)
          #self.Close()
      def _OnAdd(self, event):
          self.classGrid.AppendRows()
      def _OnRemove(self, event):
          self.classGrid.DeleteSelectedRows()
      def _OnGenClass(self, event):
+         """Open up a dialog for the user to generate classifications."""
          self.genDlg = ClassGenDialog(self, self.layer,
                            self.fields.GetString(self.__cur_field))
-         EVT_CLOSE(self.genDlg, self._OnGenDialogClose)
+         self.Bind(wx.EVT_CLOSE, self._OnGenDialogClose, self.genDlg)
          self.__EnableButtons(EB_GEN_CLASS)
          self.genDlg.Show()
      def _OnGenDialogClose(self, event):
+         """Reenable buttons after the generate classification
+         dialog is closed.
+         """
          self.genDlg.Destroy()
          self.genDlg = None
          self.__EnableButtons(EB_GEN_CLASS)
      def _OnMoveUp(self, event):
+         """When the user clicks MoveUp, try to move a group up one row."""
          sel = self.classGrid.GetCurrentSelection()
          if len(sel) == 1:
-Line 1054 
 class Classifier(NonModalNonParentDialog
+Line 1086 
 class Classifier(NonModalNonParentDialog
                  self.classGrid.MakeCellVisible(i - 1, 0)
      def _OnMoveDown(self, event):
+         """When the user clicks MoveDown, try to move a group down one row."""
          sel = self.classGrid.GetCurrentSelection()
          if len(sel) == 1:
-Line 1069 
 class Classifier(NonModalNonParentDialog
+Line 1102 
 class Classifier(NonModalNonParentDialog
                  self.classGrid.MakeCellVisible(i + 1, 0)
      def _OnTitleChanged(self, event):
+         """Update the dialog title when the user changed the layer name."""
          obj = event.GetEventObject()
          self.layer.SetTitle(obj.GetValue())
-Line 1077 
 class Classifier(NonModalNonParentDialog
+Line 1111 
 class Classifier(NonModalNonParentDialog
          self.__EnableButtons(EB_LAYER_TITLE)
      def __EnableButtons(self, case):
+         """Helper method that enables/disables the appropriate buttons
+         based on the case provided. Cases are constants beginning with EB_.
+         """
-         list = {wxID_OK                 : True,
+         list = {wx.ID_OK                 : True,
-                 wxID_CANCEL             : True,
+                 wx.ID_CANCEL             : True,
                  ID_PROPERTY_ADD         : True,
                  ID_PROPERTY_MOVEUP      : True,
                  ID_PROPERTY_MOVEDOWN    : True,
                  ID_PROPERTY_REMOVE      : True,
                  ID_PROPERTY_SELECT      : True,
                  ID_PROPERTY_FIELDTEXT   : True,
                  ID_PROPERTY_GENCLASS    : True,
                  ID_PROPERTY_EDITSYM     : True}
          if case == EB_LAYER_TITLE:
              if self.layer.Title() == "":
                  list[wxID_OK] = False
                  list[wxID_CANCEL] = False
-Line 1104 
 class Classifier(NonModalNonParentDialog
+Line 1141 
 class Classifier(NonModalNonParentDialog
          elif case == EB_GEN_CLASS:
              if self.genDlg is not None:
                  list[ID_PROPERTY_SELECT] = False
                  list[ID_PROPERTY_FIELDTEXT] = False
                  list[ID_PROPERTY_GENCLASS] = False
          for id, enable in list.items():
              win = self.FindWindowById(id)
              if win:
                  win.Enable(enable)
- ID_SELPROP_SPINCTRL = 4002
+ ID_SELPROP_SPINCTRL_LINEWIDTH = 4002
  ID_SELPROP_PREVIEW = 4003
  ID_SELPROP_STROKECLR = 4004
  ID_SELPROP_FILLCLR = 4005
  ID_SELPROP_STROKECLRTRANS = 4006
  ID_SELPROP_FILLCLRTRANS = 4007
+ ID_SELPROP_SPINCTRL_SIZE = 4008
- class SelectPropertiesDialog(wxDialog):
+ class SelectPropertiesDialog(wx.Dialog):
+     """Dialog that allows the user to select group properties."""
      def __init__(self, parent, prop, shapeType):
-         wxDialog.__init__(self, parent, -1, _("Select Properties"),
+         """Open the dialog with the initial prop properties and shapeType."""
-                           style = wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
+         wx.Dialog.__init__(self, parent, -1, _("Select Properties"),
+                           style = wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)
          self.prop = ClassGroupProperties(prop)
-         topBox = wxBoxSizer(wxVERTICAL)
+         topBox = wx.BoxSizer(wx.VERTICAL)
-         itemBox = wxBoxSizer(wxHORIZONTAL)
+         itemBox = wx.BoxSizer(wx.HORIZONTAL)
          # preview box
-         previewBox = wxBoxSizer(wxVERTICAL)
+         previewBox = wx.BoxSizer(wx.VERTICAL)
-         previewBox.Add(wxStaticText(self, -1, _("Preview:")),
+         previewBox.Add(wx.StaticText(self, -1, _("Preview:")),
-, wxALIGN_LEFT | wxALL, 4)
+, wx.ALIGN_LEFT | wx.ALL, 4)
          self.previewWin = ClassGroupPropertiesCtrl(
              self, ID_SELPROP_PREVIEW, self.prop, shapeType,
-             (40, 40), wxSIMPLE_BORDER)
+             (40, 40), wx.SIMPLE_BORDER)
          self.previewWin.AllowEdit(False)
-         previewBox.Add(self.previewWin, 1, wxGROW | wxALL, 4)
+         previewBox.Add(self.previewWin, 1, wx.GROW | wx.ALL, 4)
-         itemBox.Add(previewBox, 1, wxALIGN_LEFT | wxALL | wxGROW, 0)
+         itemBox.Add(previewBox, 1, wx.ALIGN_LEFT | wx.ALL | wx.GROW, 0)
          # control box
-         ctrlBox = wxBoxSizer(wxVERTICAL)
+         ctrlBox = wx.BoxSizer(wx.VERTICAL)
-         lineColorBox = wxBoxSizer(wxHORIZONTAL)
+         lineColorBox = wx.BoxSizer(wx.HORIZONTAL)
-         button = wxButton(self, ID_SELPROP_STROKECLR, _("Change Line Color"))
+         button = wx.Button(self, ID_SELPROP_STROKECLR, _("Change Line Color"))
          button.SetFocus()
-         lineColorBox.Add(button, 1, wxALL | wxGROW, 4)
+         lineColorBox.Add(button, 1, wx.ALL | wx.GROW, 4)
-         EVT_BUTTON(self, ID_SELPROP_STROKECLR, self._OnChangeLineColor)
+         self.Bind(wx.EVT_BUTTON, self._OnChangeLineColor, id=ID_SELPROP_STROKECLR)
          lineColorBox.Add(
-             wxButton(self, ID_SELPROP_STROKECLRTRANS, _("Transparent")),
+             wx.Button(self, ID_SELPROP_STROKECLRTRANS, _("Transparent")),
-, wxALL | wxGROW, 4)
+, wx.ALL | wx.GROW, 4)
-         EVT_BUTTON(self, ID_SELPROP_STROKECLRTRANS,
+         self.Bind(wx.EVT_BUTTON, self._OnChangeLineColorTrans, \
-                    self._OnChangeLineColorTrans)
+                                    id=ID_SELPROP_STROKECLRTRANS)
          ctrlBox.Add(lineColorBox, 0,
-                     wxALIGN_CENTER_HORIZONTAL | wxALL | wxGROW, 4)
+                     wx.ALIGN_CENTER_HORIZONTAL | wx.ALL | wx.GROW, 4)
          if shapeType != SHAPETYPE_ARC:
-             fillColorBox = wxBoxSizer(wxHORIZONTAL)
+             fillColorBox = wx.BoxSizer(wx.HORIZONTAL)
              fillColorBox.Add(
-                 wxButton(self, ID_SELPROP_FILLCLR, _("Change Fill Color")),
+                 wx.Button(self, ID_SELPROP_FILLCLR, _("Change Fill Color")),
-, wxALL | wxGROW, 4)
+, wx.ALL | wx.GROW, 4)
-             EVT_BUTTON(self, ID_SELPROP_FILLCLR, self._OnChangeFillColor)
+             self.Bind(wx.EVT_BUTTON, self._OnChangeFillColor, id=ID_SELPROP_FILLCLR)
              fillColorBox.Add(
-                 wxButton(self, ID_SELPROP_FILLCLRTRANS, _("Transparent")),
+                 wx.Button(self, ID_SELPROP_FILLCLRTRANS, _("Transparent")),
-, wxALL | wxGROW, 4)
+, wx.ALL | wx.GROW, 4)
-             EVT_BUTTON(self, ID_SELPROP_FILLCLRTRANS,
+             self.Bind(wx.EVT_BUTTON, self._OnChangeFillColorTrans,\
-                        self._OnChangeFillColorTrans)
+                                         id=ID_SELPROP_FILLCLRTRANS)
              ctrlBox.Add(fillColorBox, 0,
-                         wxALIGN_CENTER_HORIZONTAL | wxALL | wxGROW, 4)
+                         wx.ALIGN_CENTER_HORIZONTAL | wx.ALL | wx.GROW, 4)
-         spinBox = wxBoxSizer(wxHORIZONTAL)
+         # Line width selection
-         spinBox.Add(wxStaticText(self, -1, _("Line Width: ")),
+         spinBox = wx.BoxSizer(wx.HORIZONTAL)
-, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 4)
+         spinBox.Add(wx.StaticText(self, -1, _("Line Width: ")),
-         self.spinCtrl = wxSpinCtrl(self, ID_SELPROP_SPINCTRL,
+, wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, 4)
-                                    min=1, max=10,
+         self.spinCtrl_linewidth = wx.SpinCtrl(self,
-                                    value=str(prop.GetLineWidth()),
+                                              ID_SELPROP_SPINCTRL_LINEWIDTH,
-                                    initial=prop.GetLineWidth())
+                                              min=1, max=10,
+                                              value=str(prop.GetLineWidth()),
-         EVT_SPINCTRL(self, ID_SELPROP_SPINCTRL, self._OnSpin)
+                                              initial=prop.GetLineWidth())
-         spinBox.Add(self.spinCtrl, 0, wxALIGN_LEFT | wxALL, 4)
+         self.Bind(wx.EVT_SPINCTRL, self._OnSpinLineWidth, \
+                     id=ID_SELPROP_SPINCTRL_LINEWIDTH)
-         ctrlBox.Add(spinBox, 0, wxALIGN_RIGHT | wxALL, 0)
-         itemBox.Add(ctrlBox, 0, wxALIGN_RIGHT | wxALL | wxGROW, 0)
+         spinBox.Add(self.spinCtrl_linewidth, 0, wx.ALIGN_LEFT | wx.ALL, 4)
-         topBox.Add(itemBox, 1, wxALIGN_LEFT | wxALL | wxGROW, 0)
+         ctrlBox.Add(spinBox, 0, wx.ALIGN_RIGHT | wx.ALL, 0)
+         # Size selection
+         if shapeType == SHAPETYPE_POINT:
+             spinBox = wx.BoxSizer(wx.HORIZONTAL)
+             spinBox.Add(wx.StaticText(self, -1, _("Size: ")),
+, wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, 4)
+             self.spinCtrl_size = wx.SpinCtrl(self, ID_SELPROP_SPINCTRL_SIZE,
+                                             min=1, max=100,
+                                             value=str(prop.GetSize()),
+                                             initial=prop.GetSize())
+             self.Bind(wx.EVT_SPINCTRL, self._OnSpinSize, id=ID_SELPROP_SPINCTRL_SIZE)
+             spinBox.Add(self.spinCtrl_size, 0, wx.ALIGN_LEFT | wx.ALL, 4)
+             ctrlBox.Add(spinBox, 0, wx.ALIGN_RIGHT | wx.ALL, 0)
+         itemBox.Add(ctrlBox, 0, wx.ALIGN_RIGHT | wx.ALL | wx.GROW, 0)
+         topBox.Add(itemBox, 1, wx.ALIGN_LEFT | wx.ALL | wx.GROW, 0)
          #
          # Control buttons:
          #
-         buttonBox = wxBoxSizer(wxHORIZONTAL)
+         buttonBox = wx.BoxSizer(wx.HORIZONTAL)
-         button_ok = wxButton(self, wxID_OK, _("OK"))
+         button_ok = wx.Button(self, wx.ID_OK, _("OK"))
-         buttonBox.Add(button_ok, 0, wxRIGHT|wxEXPAND, 10)
+         buttonBox.Add(button_ok, 0, wx.RIGHT|wx.EXPAND, 10)
-         buttonBox.Add(wxButton(self, wxID_CANCEL, _("Cancel")),
+         buttonBox.Add(wx.Button(self, wx.ID_CANCEL, _("Cancel")),
-, wxRIGHT|wxEXPAND, 10)
+, wx.RIGHT|wx.EXPAND, 10)
-         topBox.Add(buttonBox, 0, wxALIGN_RIGHT|wxBOTTOM|wxTOP, 10)
+         topBox.Add(buttonBox, 0, wx.ALIGN_RIGHT|wx.BOTTOM|wx.TOP, 10)
          button_ok.SetDefault()
          #EVT_BUTTON(self, wxID_OK, self._OnOK)
          #EVT_BUTTON(self, ID_SELPROP_CANCEL, self._OnCancel)
          self.SetAutoLayout(True)
          self.SetSizer(topBox)
          topBox.Fit(self)
          topBox.SetSizeHints(self)
      def OnOK(self, event):
-         self.EndModal(wxID_OK)
+         self.EndModal(wx.ID_OK)
      def OnCancel(self, event):
-         self.EndModal(wxID_CANCEL)
+         self.EndModal(wx.ID_CANCEL)
+     def _OnSpinLineWidth(self, event):
+         self.prop.SetLineWidth(self.spinCtrl_linewidth.GetValue())
+         self.previewWin.Refresh()
-     def _OnSpin(self, event):
+     def _OnSpinSize(self, event):
-         self.prop.SetLineWidth(self.spinCtrl.GetValue())
+         self.prop.SetSize(self.spinCtrl_size.GetValue())
          self.previewWin.Refresh()
      def __GetColor(self, cur):
-         dialog = wxColourDialog(self)
+         dialog = ColorDialog(self)
-         if cur is not Transparent:
+         dialog.SetColor(cur)
-             dialog.GetColourData().SetColour(Color2wxColour(cur))
          ret = None
-         if dialog.ShowModal() == wxID_OK:
+         if dialog.ShowModal() == wx.ID_OK:
-             ret = wxColour2Color(dialog.GetColourData().GetColour())
+             ret = dialog.GetColor()
          dialog.Destroy()
          return ret
      def _OnChangeLineColor(self, event):
          clr = self.__GetColor(self.prop.GetLineColor())
          if clr is not None:
-Line 1247 
 class SelectPropertiesDialog(wxDialog):
+Line 1310 
 class SelectPropertiesDialog(wxDialog):
      def _OnChangeLineColorTrans(self, event):
          self.prop.SetLineColor(Transparent)
          self.previewWin.Refresh() # XXX: work around, see ClassDataPreviewer
      def _OnChangeFillColor(self, event):
          clr = self.__GetColor(self.prop.GetFill())
          if clr is not None:
-Line 1262 
 class SelectPropertiesDialog(wxDialog):
+Line 1325 
 class SelectPropertiesDialog(wxDialog):
          return self.prop
- class ClassDataPreviewWindow(wxWindow):
+ class ClassDataPreviewWindow(wx.Window):
+     """A custom window that draws group properties using the correct shape."""
      def __init__(self, rect, prop, shapeType,
-                        parent = None, id = -1, size = wxDefaultSize):
+                        parent = None, id = -1, size = wx.DefaultSize):
+         """Draws the appropriate shape as specified with shapeType using
+         prop properities.
+         """
          if parent is not None:
-             wxWindow.__init__(self, parent, id, (0, 0), size)
+             wx.Window.__init__(self, parent, id, (0, 0), size)
-             EVT_PAINT(self, self._OnPaint)
+             self.Bind(wx.EVT_PAINT, self._OnPaint)
          self.rect = rect
-Line 1280 
 class ClassDataPreviewWindow(wxWindow):
+Line 1347 
 class ClassDataPreviewWindow(wxWindow):
          return self.prop
      def _OnPaint(self, event):
-         dc = wxPaintDC(self)
+         dc = wx.PaintDC(self)
          # XXX: this doesn't seem to be having an effect:
          dc.DestroyClippingRegion()
          if self.rect is None:
              w, h = self.GetSize()
-             rect = wxRect(0, 0, w, h)
+             rect = wx.Rect(0, 0, w, h)
          else:
              rect = self.rect
          self.previewer.Draw(dc, rect, self.prop, self.shapeType)
  class ClassDataPreviewer:
+     """Class that actually draws a group property preview."""
      def Draw(self, dc, rect, prop, shapeType):
+         """Draw the property.
+         returns: (w, h) as adapted extend if the drawing size
+         exceeded the given rect. This can only be the case
+         for point symbols. If the symbol fits the given rect,
+         None is returned.
+         """
          assert dc is not None
          assert isinstance(prop, ClassGroupProperties)
-Line 1312 
 class ClassDataPreviewer:
+Line 1387 
 class ClassDataPreviewer:
          stroke = prop.GetLineColor()
          if stroke is Transparent:
-             pen = wxTRANSPARENT_PEN
+             pen = wx.TRANSPARENT_PEN
          else:
-             pen = wxPen(Color2wxColour(stroke),
+             pen = wx.Pen(Color2wxColour(stroke),
                          prop.GetLineWidth(),
-                         wxSOLID)
+                         wx.SOLID)
          stroke = prop.GetFill()
          if stroke is Transparent:
-             brush = wxTRANSPARENT_BRUSH
+             brush = wx.TRANSPARENT_BRUSH
          else:
-             brush = wxBrush(Color2wxColour(stroke), wxSOLID)
+             brush = wx.Brush(Color2wxColour(stroke), wx.SOLID)
          dc.SetPen(pen)
          dc.SetBrush(brush)
          if shapeType == SHAPETYPE_ARC:
-             dc.DrawSpline([wxPoint(x, y + h),
+             dc.DrawSpline([wx.Point(x, y + h),
-                            wxPoint(x + w/2, y + h/4),
+                            wx.Point(x + w/2, y + h/4),
-                            wxPoint(x + w/2, y + h/4*3),
+                            wx.Point(x + w/2, y + h/4*3),
-                            wxPoint(x + w, y)])
+                            wx.Point(x + w, y)])
          elif shapeType == SHAPETYPE_POINT:
-             dc.DrawCircle(x + w/2, y + h/2,
+             dc.DrawCircle(x + w/2, y + h/2, prop.GetSize())
-                           (min(w, h) - prop.GetLineWidth())/2)
+             circle_size =  prop.GetSize() * 2 + prop.GetLineWidth() * 2
+             new_h = h
+             new_w = w
+             if h < circle_size: new_h = circle_size
+             if w < circle_size: new_w = circle_size
+             if new_h > h or new_w > w:
+                 return (new_w, new_h)
          elif shapeType == SHAPETYPE_POLYGON:
              dc.DrawRectangle(x, y, w, h)
- class ClassRenderer(wxPyGridCellRenderer):
+         return None
+ class ClassRenderer(grid.PyGridCellRenderer):
+     """A wrapper class that can be used to draw group properties in a
+     grid table.
+     """
      def __init__(self, shapeType):
-         wxPyGridCellRenderer.__init__(self)
+         grid.PyGridCellRenderer.__init__(self)
          self.shapeType = shapeType
          self.previewer = ClassDataPreviewer()
      def Draw(self, grid, attr, dc, rect, row, col, isSelected):
          data = grid.GetTable().GetClassGroup(row)
          dc.SetClippingRegion(rect.GetX(), rect.GetY(),
                               rect.GetWidth(), rect.GetHeight())
-         dc.SetPen(wxPen(wxLIGHT_GREY))
+         dc.SetPen(wx.Pen(wx.LIGHT_GREY))
-         dc.SetBrush(wxBrush(wxLIGHT_GREY, wxSOLID))
+         dc.SetBrush(wx.Brush(wx.LIGHT_GREY, wx.SOLID))
          dc.DrawRectangle(rect.GetX(), rect.GetY(),
                           rect.GetWidth(), rect.GetHeight())
          if not isinstance(data, ClassGroupMap):
-             self.previewer.Draw(dc, rect, data.GetProperties(), self.shapeType)
+             new_size = self.previewer.Draw(dc, rect, data.GetProperties(),
+                                            self.shapeType)
+             if new_size is not None:
+                 (new_w, new_h) = new_size
+                 grid.SetRowSize(row, new_h)
+                 grid.SetColSize(col, new_h)
+                 grid.ForceRefresh()
+                 # now that we know the height, redraw everything
+                 rect.SetHeight(new_h)
+                 rect.SetWidth(new_w)
+                 dc.DestroyClippingRegion()
+                 dc.SetClippingRegion(rect.GetX(), rect.GetY(),
+                                      rect.GetWidth(), rect.GetHeight())
+                 dc.SetPen(wx.Pen(wx.LIGHT_GREY))
+                 dc.SetBrush(wx.Brush(wx.LIGHT_GREY, wx.SOLID))
+                 dc.DrawRectangle(rect.GetX(), rect.GetY(),
+                                  rect.GetWidth(), rect.GetHeight())
+                 self.previewer.Draw(dc, rect, data.GetProperties(),
+                                     self.shapeType)
          if isSelected:
-             dc.SetPen(wxPen(wxBLACK, 1, wxSOLID))
+             dc.SetPen(wx.Pen(wx.BLACK, 1, wx.SOLID))
-             dc.SetBrush(wxTRANSPARENT_BRUSH)
+             dc.SetBrush(wx.TRANSPARENT_BRUSH)
              dc.DrawRectangle(rect.GetX(), rect.GetY(),
                               rect.GetWidth(), rect.GetHeight())
          dc.DestroyClippingRegion()
- class ClassGroupPropertiesCtrl(wxWindow, wxControl):
+ class ClassGroupPropertiesCtrl(wx.Control):
+     """A custom window and control that draw a preview of group properties
-     def __init__(self, parent, id, props, shapeType,
+     and can open a dialog to modify the properties if the user double-clicks
-                  size = wxDefaultSize, style = 0):
+     it.
+     """
-         wxWindow.__init__(self, parent, id, size = size, style = style)
+     def __init__(self, parent, id, props, shapeType,
+                  size = wx.DefaultSize, style = 0):
+         wx.Control.__init__(self, parent, id, size = size, style = style)
          self.parent = parent
-Line 1384 
 class ClassGroupPropertiesCtrl(wxWindow,
+Line 1492 
 class ClassGroupPropertiesCtrl(wxWindow,
          self.SetShapeType(shapeType)
          self.AllowEdit(True)
-         EVT_PAINT(self, self._OnPaint)
+         self.Bind(wx.EVT_PAINT, self._OnPaint)
-         EVT_LEFT_DCLICK(self, self._OnLeftDClick)
+         self.Bind(wx.EVT_LEFT_DCLICK, self._OnLeftDClick)
          self.previewer = ClassDataPreviewer()
      def _OnPaint(self, event):
-         dc = wxPaintDC(self)
+         dc = wx.PaintDC(self)
          # XXX: this doesn't seem to be having an effect:
          dc.DestroyClippingRegion()
          w, h = self.GetClientSize()
          self.previewer.Draw(dc,
-                             wxRect(0, 0, w, h),
+                             wx.Rect(0, 0, w, h),
                              self.GetProperties(),
                              self.GetShapeType())
-Line 1418 
 class ClassGroupPropertiesCtrl(wxWindow,
+Line 1526 
 class ClassGroupPropertiesCtrl(wxWindow,
          self.Refresh()
      def AllowEdit(self, allow):
+         """Allow/Disallow double-clicking on the control."""
          self.allowEdit = allow
      def DoEdit(self):
+         """Open the properties selector dialog."""
          if not self.allowEdit: return
          propDlg = SelectPropertiesDialog(self.parent,
                                           self.GetProperties(),
                                           self.GetShapeType())
-         if propDlg.ShowModal() == wxID_OK:
+         if propDlg.ShowModal() == wx.ID_OK:
              new_prop = propDlg.GetClassGroupProperties()
              self.SetProperties(new_prop)
              self.Refresh()
-Line 1436 
 class ClassGroupPropertiesCtrl(wxWindow,
+Line 1547 
 class ClassGroupPropertiesCtrl(wxWindow,
      def _OnLeftDClick(self, event):
          self.DoEdit()

 Legend:



Removed from v.1452
 


changed lines


 
Added in v.2734
 Legend:



Removed from v.1452
 


changed lines


 
Added in v.2734
-Removed from v.1452
+Added in v.2734

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26