/[thuban]/trunk/thuban/Thuban/UI/classifier.py
ViewVC logotype

Diff of /trunk/thuban/Thuban/UI/classifier.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 549 by jonathan, Thu Mar 20 09:45:07 2003 UTC revision 2386 by jan, Thu Oct 7 14:43:45 2004 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001, 2003 by Intevation GmbH  # Copyright (c) 2003-2004 by Intevation GmbH
2  # Authors:  # Authors:
3  # Jonathan Coles <[email protected]>  # Jan-Oliver Wagner <[email protected]> (2003-2004)
4    # Martin Schulze <[email protected]> (2004)
5    # Frank Koormann <[email protected]> (2003)
6    # Bernhard Herzog <[email protected]> (2003)
7    # Jonathan Coles <[email protected]> (2003)
8  #  #
9  # This program is free software under the GPL (>=v2)  # This program is free software under the GPL (>=v2)
10  # Read the file COPYING coming with Thuban for details.  # Read the file COPYING coming with Thuban for details.
# Line 8  Line 12 
12  """Dialog for classifying how layers are displayed"""  """Dialog for classifying how layers are displayed"""
13    
14  __version__ = "$Revision$"  __version__ = "$Revision$"
15    # $Source$
16    # $Id$
17    
18  import copy  import copy
19    
# Line 18  from wxPython.wx import * Line 24  from wxPython.wx import *
24  from wxPython.grid import *  from wxPython.grid import *
25    
26  from Thuban import _  from Thuban import _
27  from Thuban.common import *  from Thuban.UI.common import Color2wxColour, wxColour2Color
 from Thuban.UI.common import *  
28    
29  from Thuban.Model.classification import *  from Thuban.Model.messages import MAP_LAYERS_REMOVED, LAYER_SHAPESTORE_REPLACED
30    from Thuban.Model.range import Range
31    from Thuban.Model.classification import \
32        Classification, ClassGroupDefault, \
33        ClassGroupSingleton, ClassGroupRange, ClassGroupMap, \
34        ClassGroupProperties
35    
36  from Thuban.Model.color import Color  from Thuban.Model.color import Transparent
37    
38  from Thuban.Model.layer import Layer, SHAPETYPE_ARC, SHAPETYPE_POLYGON, SHAPETYPE_POINT  from Thuban.Model.layer import Layer, RasterLayer
39    from Thuban.Model.data import SHAPETYPE_ARC, SHAPETYPE_POLYGON, SHAPETYPE_POINT
40    
41  from dialogs import NonModalDialog  from Thuban.UI.classgen import ClassGenDialog
42    from Thuban.UI.colordialog import ColorDialog
43    
44    from dialogs import NonModalNonParentDialog
45    from messages import MAP_REPLACED
46    
 # widget id's  
 ID_PROPERTY_SELECT = 4010  
47  ID_CLASS_TABLE = 40011  ID_CLASS_TABLE = 40011
48    
 ID_CLASSIFY_OK = 4001  
 ID_CLASSIFY_CANCEL = 4002  
 ID_CLASSIFY_ADD = 4003  
 ID_CLASSIFY_GENRANGE = 4004  
 ID_CLASSIFY_REMOVE = 4005  
 ID_CLASSIFY_MOVEUP = 4006  
 ID_CLASSIFY_MOVEDOWN = 4007  
 ID_CLASSIFY_APPLY = 4008  
49    
50  # table columns  # table columns
51  COL_SYMBOL = 0  COL_VISIBLE = 0
52  COL_VALUE  = 1  COL_SYMBOL  = 1
53  COL_LABEL  = 2  COL_VALUE   = 2
54    COL_LABEL   = 3
55    NUM_COLS    = 4
56    
57  # indices into the client data lists in Classifier.fields  # indices into the client data lists in Classifier.fields
58  FIELD_CLASS = 0  FIELD_CLASS = 0
# Line 59  FIELD_NAME = 2 Line 66  FIELD_NAME = 2
66  import weakref  import weakref
67  class ClassGrid(wxGrid):  class ClassGrid(wxGrid):
68    
69      def __init__(self, parent):  
70        def __init__(self, parent, classifier):
71          """Constructor.          """Constructor.
72    
73          parent -- the parent window          parent -- the parent window
# Line 68  class ClassGrid(wxGrid): Line 76  class ClassGrid(wxGrid):
76                   use for display.                   use for display.
77          """          """
78    
79          #wxGrid.__init__(self, parent, ID_CLASS_TABLE, size = (340, 160))          wxGrid.__init__(self, parent, ID_CLASS_TABLE, style = 0)
80          wxGrid.__init__(self, parent, ID_CLASS_TABLE)  
81          #self.SetTable(ClassTable(fieldData, layer.ShapeType(), self), True)          self.classifier = classifier
82    
83            self.currentSelection = []
84    
85          EVT_GRID_CELL_LEFT_DCLICK(self, self._OnCellDClick)          EVT_GRID_CELL_LEFT_DCLICK(self, self._OnCellDClick)
86          EVT_GRID_RANGE_SELECT(self, self._OnSelectedRange)          EVT_GRID_RANGE_SELECT(self, self._OnSelectedRange)
87          EVT_GRID_SELECT_CELL(self, self._OnSelectedCell)          EVT_GRID_SELECT_CELL(self, self._OnSelectedCell)
88            EVT_GRID_COL_SIZE(self, self._OnCellResize)
89            EVT_GRID_ROW_SIZE(self, self._OnCellResize)
90    
91          self.currentSelection = []      #def GetCellAttr(self, row, col):
92            #print "GetCellAttr ", row, col
93            #wxGrid.GetCellAttr(self, row, col)
94    
95      def CreateTable(self, clazz, shapeType):      def CreateTable(self, clazz, fieldType, shapeType, group = None):
96    
97          assert(isinstance(clazz, Classification))          assert isinstance(clazz, Classification)
98    
         self.shapeType = shapeType  
99          table = self.GetTable()          table = self.GetTable()
100          if table is None:          if table is None:
101              w = self.GetDefaultColSize() * 3 + self.GetDefaultRowLabelSize()              w = self.GetDefaultColSize() * NUM_COLS \
102              h = self.GetDefaultRowSize() * 4 + self.GetDefaultColLabelSize()                  + self.GetDefaultRowLabelSize()
103                h = self.GetDefaultRowSize() * 4 \
104                    + self.GetDefaultColLabelSize()
105    
106              self.SetDimensions(-1, -1, w, h)              self.SetDimensions(-1, -1, w, h)
107              self.SetSizeHints(w, h, -1, -1)              self.SetSizeHints(w, h, -1, -1)
108              self.SetTable(ClassTable(clazz, self.shapeType, self), True)              table = ClassTable(self)
109          else:              self.SetTable(table, True)
110              table.Reset(clazz, self.shapeType)  
111    
112          self.SetSelectionMode(wxGrid.wxGridSelectRows)          self.SetSelectionMode(wxGrid.wxGridSelectRows)
113          self.ClearSelection()          self.ClearSelection()
114    
115            table.Reset(clazz, fieldType, shapeType, group)
116    
117      def GetCurrentSelection(self):      def GetCurrentSelection(self):
118          """Return the currently highlighted rows as an increasing list          """Return the currently highlighted rows as an increasing list
119             of row numbers."""             of row numbers."""
# Line 103  class ClassGrid(wxGrid): Line 121  class ClassGrid(wxGrid):
121          sel.sort()          sel.sort()
122          return sel          return sel
123    
124      def SetCellRenderer(self, row, col):      def GetSelectedRows(self):
125          raise ValueError(_("Must not allow setting of renderer in ClassGrid!"))          return self.GetCurrentSelection()
126    
127        #def SetCellRenderer(self, row, col, renderer):
128            #raise ValueError(_("Must not allow setting of renderer in ClassGrid!"))
129    
130      #      #
131      # [Set|Get]Table is taken from http://wiki.wxpython.org      # [Set|Get]Table is taken from http://wiki.wxpython.org
# Line 169  class ClassGrid(wxGrid): Line 190  class ClassGrid(wxGrid):
190                  r = self.GetNumberRows() - 1                  r = self.GetNumberRows() - 1
191              self.SelectRow(r)              self.SelectRow(r)
192                    
193    
194        def SelectGroup(self, group, makeVisible = True):
195            if group is None: return
196    
197            assert isinstance(group, ClassGroup)
198    
199            table = self.GetTable()
200    
201            assert table is not None
202    
203            for i in range(table.GetNumberRows()):
204                g = table.GetClassGroup(i)
205                if g is group:
206                    self.SelectRow(i)
207                    if makeVisible:
208                        self.MakeCellVisible(i, 0)
209                    break
210    
211  #  #
212  # XXX: This isn't working, and there is no way to deselect rows wxPython!  # XXX: This isn't working, and there is no way to deselect rows wxPython!
213  #  #
# Line 181  class ClassGrid(wxGrid): Line 220  class ClassGrid(wxGrid):
220  #                                  sel = False))  #                                  sel = False))
221    
222      def _OnCellDClick(self, event):      def _OnCellDClick(self, event):
223          """Handle a double on a cell."""          """Handle a double click on a cell."""
224    
225          r = event.GetRow()          r = event.GetRow()
226          c = event.GetCol()          c = event.GetCol()
         if c == COL_SYMBOL:  
             prop = self.GetTable().GetValueAsCustom(r, c, None)  
             #prop = group.GetProperties()  
227    
228              # get a new ClassGroupProperties object and copy the          if c == COL_SYMBOL:
229              # values over to our current object              self.classifier.EditSymbol(r)
230              propDlg = SelectPropertiesDialog(NULL, prop, self.shapeType)          else:
231              if propDlg.ShowModal() == wxID_OK:              event.Skip()
                 new_prop = propDlg.GetClassGroupProperties()  
                 #prop.SetProperties(new_prop)  
                 self.GetTable().SetValueAsCustom(r, c, None, new_prop)  
             propDlg.Destroy()  
232    
233      #      #
234      # _OnSelectedRange() and _OnSelectedCell() were borrowed      # _OnSelectedRange() and _OnSelectedCell() were borrowed
# Line 223  class ClassGrid(wxGrid): Line 255  class ClassGrid(wxGrid):
255          #self.ConfigureForSelection()          #self.ConfigureForSelection()
256          event.Skip()          event.Skip()
257    
258        def _OnCellResize(self, event):
259            self.FitInside()
260            event.Skip()
261    
262  class ClassTable(wxPyGridTableBase):  class ClassTable(wxPyGridTableBase):
263      """Represents the underlying data structure for the grid."""      """Represents the underlying data structure for the grid."""
264    
265      NUM_COLS = 3      __col_labels = [_("Visible"), _("Symbol"), _("Value"), _("Label")]
266    
     __col_labels = [_("Symbol"), _("Value"), _("Label")]  
267    
268      def __init__(self, clazz, shapeType, view = None):      def __init__(self, view = None):
269          """Constructor.          """Constructor.
270    
271          shapeType -- the type of shape that the layer uses          shapeType -- the type of shape that the layer uses
# Line 240  class ClassTable(wxPyGridTableBase): Line 275  class ClassTable(wxPyGridTableBase):
275    
276          wxPyGridTableBase.__init__(self)          wxPyGridTableBase.__init__(self)
277    
278          self.SetView(view)          assert len(ClassTable.__col_labels) == NUM_COLS
         self.tdata = []  
279    
280          self.Reset(clazz, shapeType)          self.clazz = None
281            self.__colAttr = {}
282    
283            self.SetView(view)
284    
285      def Reset(self, clazz, shapeType):      def Reset(self, clazz, fieldType, shapeType, group = None):
286          """Reset the table with the given data.          """Reset the table with the given data.
287    
288          This is necessary because wxWindows does not allow a grid's          This is necessary because wxWindows does not allow a grid's
# Line 259  class ClassTable(wxPyGridTableBase): Line 296  class ClassTable(wxPyGridTableBase):
296          shapeType -- the type of shape that the layer uses          shapeType -- the type of shape that the layer uses
297          """          """
298    
299          assert(isinstance(clazz, Classification))          assert isinstance(clazz, Classification)
300    
301          self.GetView().BeginBatch()          self.GetView().BeginBatch()
302    
303          self.fieldType = clazz.GetFieldType()          self.fieldType = fieldType
304          self.shapeType = shapeType          self.shapeType = shapeType
305    
306          old_len = len(self.tdata)          self.SetClassification(clazz, group)
307            self.__Modified(-1)
308    
309            self.__colAttr = {}
310    
311          self.tdata = []          attr = wxGridCellAttr()
312            attr.SetEditor(wxGridCellBoolEditor())
313            attr.SetRenderer(wxGridCellBoolRenderer())
314            attr.SetAlignment(wxALIGN_CENTER, wxALIGN_CENTER)
315            self.__colAttr[COL_VISIBLE] = attr
316    
317            attr = wxGridCellAttr()
318            attr.SetRenderer(ClassRenderer(self.shapeType))
319            attr.SetReadOnly()
320            self.__colAttr[COL_SYMBOL] = attr
321    
322            self.GetView().EndBatch()
323            self.GetView().FitInside()
324    
325        def GetClassification(self):
326            """Return the current classification."""
327            return self.clazz
328    
329        def SetClassification(self, clazz, group = None):
330            """Fill in the table with the given classification.
331            Select the given group if group is not None.
332            """
333    
334            self.GetView().BeginBatch()
335    
336            old_len = self.GetNumberRows()
337    
338            row = -1
339            self.clazz = clazz
340    
341            self.__NotifyRowChanges(old_len, self.GetNumberRows())
342    
343          #          #
344          # copy the data out of the classification and into our          # XXX: this is dead code at the moment
         # array  
345          #          #
346          for p in clazz:          if row > -1:
347              np = copy.deepcopy(p)              self.GetView().ClearSelection()
348              self.__SetRow(-1, np)              self.GetView().SelectRow(row)
349                self.GetView().MakeCellVisible(row, 0)
   
         self.__Modified(-1)  
350    
351          self.__NotifyRowChanges(old_len, len(self.tdata))          self.__Modified()
352    
               
353          self.GetView().EndBatch()          self.GetView().EndBatch()
354            self.GetView().FitInside()
355    
356      def __NotifyRowChanges(self, curRows, newRows):      def __NotifyRowChanges(self, curRows, newRows):
357            """Make sure table updates correctly if the number of
358            rows changes.
359            """
360          #          #
361          # silly message processing for updates to the number of          # silly message processing for updates to the number of
362          # rows and columns          # rows and columns
# Line 300  class ClassTable(wxPyGridTableBase): Line 370  class ClassTable(wxPyGridTableBase):
370          elif newRows < curRows:          elif newRows < curRows:
371              msg = wxGridTableMessage(self,              msg = wxGridTableMessage(self,
372                          wxGRIDTABLE_NOTIFY_ROWS_DELETED,                          wxGRIDTABLE_NOTIFY_ROWS_DELETED,
373                          curRows - newRows,    # position                          curRows,              # position
374                          curRows - newRows)    # how many                          curRows - newRows)    # how many
375              self.GetView().ProcessTableMessage(msg)              self.GetView().ProcessTableMessage(msg)
376              self.GetView().FitInside()              self.GetView().FitInside()
# Line 310  class ClassTable(wxPyGridTableBase): Line 380  class ClassTable(wxPyGridTableBase):
380    
381          The table is considered modified after this operation.          The table is considered modified after this operation.
382    
383          row -- if row is -1 or greater than the current number of rows          row -- if row is < 0 'group' is inserted at the top of the table
384                 then group is appended to the end.                 if row is >= GetNumberRows() or None 'group' is append to
385                        the end of the table.
386                   otherwise 'group' replaces row 'row'
387          """          """
388    
389          # either append or replace          # either append or replace
390          if row == -1 or row >= self.GetNumberRows():          if row is None or row >= self.GetNumberRows():
391              self.tdata.append(group)              self.clazz.AppendGroup(group)
392            elif row < 0:
393                self.clazz.InsertGroup(0, group)
394          else:          else:
395              self.tdata[row] = group              if row == 0:
396                    self.clazz.SetDefaultGroup(group)
397                else:
398                    self.clazz.ReplaceGroup(row - 1, group)
399    
400          self.__Modified()          self.__Modified()
401    
# Line 329  class ClassTable(wxPyGridTableBase): Line 406  class ClassTable(wxPyGridTableBase):
406      def GetRowLabelValue(self, row):      def GetRowLabelValue(self, row):
407          """Return the label for the given row."""          """Return the label for the given row."""
408    
409          group = self.tdata[row]          if row == 0:
410          if isinstance(group, ClassGroupDefault):   return _("Default")              return _("Default")
411          if isinstance(group, ClassGroupSingleton): return _("Singleton")          else:
412          if isinstance(group, ClassGroupRange):     return _("Range")              group = self.clazz.GetGroup(row - 1)
413          if isinstance(group, ClassGroupMap):       return _("Map")              if isinstance(group, ClassGroupDefault):   return _("Default")
414                if isinstance(group, ClassGroupSingleton): return _("Singleton")
415                if isinstance(group, ClassGroupRange):     return _("Range")
416                if isinstance(group, ClassGroupMap):       return _("Map")
417    
418          assert(False) # shouldn't get here          assert False # shouldn't get here
419          return _("")          return ""
420    
421      def GetNumberRows(self):      def GetNumberRows(self):
422          """Return the number of rows."""          """Return the number of rows."""
423          return len(self.tdata)          if self.clazz is None:
424                return 0
425    
426            return self.clazz.GetNumGroups() + 1 # +1 for default group
427    
428      def GetNumberCols(self):      def GetNumberCols(self):
429          """Return the number of columns."""          """Return the number of columns."""
430          return self.NUM_COLS          return NUM_COLS
431    
432      def IsEmptyCell(self, row, col):      def IsEmptyCell(self, row, col):
433          """Determine if a cell is empty. This is always false."""          """Determine if a cell is empty. This is always false."""
# Line 362  class ClassTable(wxPyGridTableBase): Line 445  class ClassTable(wxPyGridTableBase):
445          """          """
446    
447          self.SetValueAsCustom(row, col, None, value)          self.SetValueAsCustom(row, col, None, value)
448          self.__Modified()  
         
449      def GetValueAsCustom(self, row, col, typeName):      def GetValueAsCustom(self, row, col, typeName):
450          """Return the object that is used to represent the given          """Return the object that is used to represent the given
451             cell coordinates. This may not be a string.             cell coordinates. This may not be a string.
452    
453          typeName -- unused, but needed to overload wxPyGridTableBase          typeName -- unused, but needed to overload wxPyGridTableBase
454          """          """
455    
456          group = self.tdata[row]          if row == 0:
457                group = self.clazz.GetDefaultGroup()
458            else:
459                group = self.clazz.GetGroup(row - 1)
460    
461    
462            if col == COL_VISIBLE:
463                return group.IsVisible()
464    
465          if col == COL_SYMBOL:          if col == COL_SYMBOL:
466              return group.GetProperties()              return group.GetProperties()
# Line 380  class ClassTable(wxPyGridTableBase): Line 469  class ClassTable(wxPyGridTableBase):
469              return group.GetLabel()              return group.GetLabel()
470    
471          # col must be COL_VALUE          # col must be COL_VALUE
472          assert(col == COL_VALUE)          assert col == COL_VALUE
473    
474          if isinstance(group, ClassGroupDefault):          if isinstance(group, ClassGroupDefault):
475              return _("DEFAULT")              return _("DEFAULT")
476          elif isinstance(group, ClassGroupSingleton):          elif isinstance(group, ClassGroupSingleton):
477              return group.GetValue()              return group.GetValue()
478          elif isinstance(group, ClassGroupRange):          elif isinstance(group, ClassGroupRange):
479              return _("%s - %s") % (group.GetMin(), group.GetMax())              return group.GetRange()
480    
481          assert(False) # shouldn't get here          assert False # shouldn't get here
482          return None          return None
483    
484      def __ParseInput(self, value):      def __ParseInput(self, value):
485          """Try to determine what kind of input value is          """Try to determine what kind of input value is
486             (string, number, or range)             (string, number, or range)
487    
488          Returns a tuple of length one if there is a single          Returns a tuple (type, data) where type is 0 if data is
489          value, or of length two if it is a range.          a singleton value, or 1 if is a range
490          """          """
491    
492          type = self.fieldType          type = self.fieldType
493    
494          if type == FIELDTYPE_STRING:          if type == FIELDTYPE_STRING:
495              return (value,)              return (0, value)
496          elif type == FIELDTYPE_INT or type == FIELDTYPE_DOUBLE:          elif type in (FIELDTYPE_INT, FIELDTYPE_DOUBLE):
   
497              if type == FIELDTYPE_INT:              if type == FIELDTYPE_INT:
498                    # the float call allows the user to enter 1.0 for 1
499                  conv = lambda p: int(float(p))                  conv = lambda p: int(float(p))
500              else:              else:
501                  conv = lambda p: p                  conv = float
502    
503              #              #
504              # first try to take the input as a single number              # first try to take the input as a single number
505              # if there's an exception try to break it into              # if there's an exception try to break it into
506              # a range seperated by a '-'. take care to ignore              # a range. if there is an exception here, let it
507              # a leading '-' as that could be for a negative number.              # pass up to the calling function.
             # then try to parse the individual parts. if there  
             # is an exception here, let it pass up to the calling  
             # function.  
508              #              #
509              try:              try:
510                  return (conv(Str2Num(value)),)                  return (0, conv(value))
511              except ValueError:              except ValueError:
512                  i = value.find('-')                  return (1, Range(value))
513                  if i == 0:  
514                      i = value.find('-', 1)          assert False  # shouldn't get here
515            return (0,None)
                 return (conv(Str2Num(value[:i])), conv(Str2Num(value[i+1:])))  
   
         assert(False) # shouldn't get here  
         return (0,)  
               
516    
517      def SetValueAsCustom(self, row, col, typeName, value):      def SetValueAsCustom(self, row, col, typeName, value):
518          """Set the cell specified by 'row' and 'col' to 'value'.          """Set the cell specified by 'row' and 'col' to 'value'.
# Line 445  class ClassTable(wxPyGridTableBase): Line 526  class ClassTable(wxPyGridTableBase):
526          typeName -- unused, but needed to overload wxPyGridTableBase          typeName -- unused, but needed to overload wxPyGridTableBase
527          """          """
528    
529          assert(col >= 0 and col < self.GetNumberCols())          assert 0 <= col < self.GetNumberCols()
530          assert(row >= 0 and row < self.GetNumberRows())          assert 0 <= row < self.GetNumberRows()
531    
532          group = self.tdata[row]          if row == 0:
533                group = self.clazz.GetDefaultGroup()
534            else:
535                group = self.clazz.GetGroup(row - 1)
536    
537          mod = True # assume the data will change          mod = True # assume the data will change
538    
539          if col == COL_SYMBOL:          if col == COL_VISIBLE:
540                group.SetVisible(value)
541            elif col == COL_SYMBOL:
542              group.SetProperties(value)              group.SetProperties(value)
543          elif col == COL_LABEL:          elif col == COL_LABEL:
544              group.SetLabel(value)              group.SetLabel(value)
# Line 480  class ClassTable(wxPyGridTableBase): Line 566  class ClassTable(wxPyGridTableBase):
566                      # changing the underlying group type if the                      # changing the underlying group type if the
567                      # group was a singleton and a range was entered                      # group was a singleton and a range was entered
568                      #                      #
569                      if len(dataInfo) == 1:                      if dataInfo[0] == 0:
570                          if not isinstance(group, ClassGroupSingleton):                          if not isinstance(group, ClassGroupSingleton):
571                              ngroup = ClassGroupSingleton(prop = props)                              ngroup = ClassGroupSingleton(props = props)
572                              changed = True                              changed = True
573                          ngroup.SetValue(dataInfo[0])                          ngroup.SetValue(dataInfo[1])
574                      elif len(dataInfo) == 2:                      elif dataInfo[0] == 1:
575                          if not isinstance(group, ClassGroupRange):                          if not isinstance(group, ClassGroupRange):
576                              ngroup = ClassGroupRange(prop = props)                              ngroup = ClassGroupRange(props = props)
577                              changed = True                              changed = True
578                          ngroup.SetRange(dataInfo[0], dataInfo[1])                          ngroup.SetRange(dataInfo[1])
579                      else:                      else:
580                          assert(False)                          assert False
581                          pass                          pass
582    
583                      if changed:                      if changed:
584                          ngroup.SetLabel(group.GetLabel())                          ngroup.SetLabel(group.GetLabel())
585                          self.SetClassGroup(row, ngroup)                          self.SetClassGroup(row, ngroup)
586          else:          else:
587              assert(False) # shouldn't be here              assert False # shouldn't be here
588              pass              pass
589    
590          if mod:          if mod:
# Line 508  class ClassTable(wxPyGridTableBase): Line 594  class ClassTable(wxPyGridTableBase):
594      def GetAttr(self, row, col, someExtraParameter):      def GetAttr(self, row, col, someExtraParameter):
595          """Returns the cell attributes"""          """Returns the cell attributes"""
596    
597          attr = wxGridCellAttr()          return self.__colAttr.get(col, wxGridCellAttr()).Clone()
         #attr = wxPyGridTableBase.GetAttr(self, row, col, someExtraParameter)  
   
         if col == COL_SYMBOL:  
             # we need to create a new renderer each time, because  
             # SetRenderer takes control of the parameter  
             attr.SetRenderer(ClassRenderer(self.shapeType))  
             attr.SetReadOnly()  
   
         return attr  
598    
599      def GetClassGroup(self, row):      def GetClassGroup(self, row):
600          """Return the ClassGroup object representing row 'row'."""          """Return the ClassGroup object representing row 'row'."""
601    
602          return self.tdata[row] # self.GetValueAsCustom(row, COL_SYMBOL, None)          #return self.GetValueAsCustom(row, COL_SYMBOL, None)
603            if row == 0:
604                return self.clazz.GetDefaultGroup()
605            else:
606                return self.clazz.GetGroup(row - 1)
607    
608      def SetClassGroup(self, row, group):      def SetClassGroup(self, row, group):
609            """Set the given row to properties of group."""
610          self.__SetRow(row, group)          self.__SetRow(row, group)
611          self.GetView().Refresh()          self.GetView().Refresh()
612    
# Line 553  class ClassTable(wxPyGridTableBase): Line 635  class ClassTable(wxPyGridTableBase):
635          The table is considered modified if any rows are removed.          The table is considered modified if any rows are removed.
636          """          """
637    
638          assert(pos >= 0)          assert pos >= 0
639          old_len = len(self.tdata)          old_len = self.GetNumberRows()
640          for row in range(pos, pos - numRows, -1):          for row in range(pos, pos - numRows, -1):
641              group = self.GetClassGroup(row)              group = self.GetClassGroup(row)
642              if not isinstance(group, ClassGroupDefault):              if row != 0:
643                  self.tdata.pop(row)                  self.clazz.RemoveGroup(row - 1)
644                  self.__Modified()                  self.__Modified()
645            
646          if self.IsModified():          if self.IsModified():
647              self.__NotifyRowChanges(old_len, len(self.tdata))              self.__NotifyRowChanges(old_len, self.GetNumberRows())
648    
649      def AppendRows(self, numRows = 1):      def AppendRows(self, numRows = 1):
650          """Append 'numRows' empty rows to the end of the table.          """Append 'numRows' empty rows to the end of the table.
# Line 570  class ClassTable(wxPyGridTableBase): Line 652  class ClassTable(wxPyGridTableBase):
652          The table is considered modified if any rows are appended.          The table is considered modified if any rows are appended.
653          """          """
654    
655          old_len = len(self.tdata)          old_len = self.GetNumberRows()
656          for i in range(numRows):          for i in range(numRows):
657              np = ClassGroupSingleton()              np = ClassGroupSingleton()
658              self.__SetRow(-1, np)              self.__SetRow(None, np)
659    
660          if self.IsModified():          if self.IsModified():
661              self.__NotifyRowChanges(old_len, len(self.tdata))              self.__NotifyRowChanges(old_len, self.GetNumberRows())
662    
663    
664  class Classifier(NonModalDialog):  ID_PROPERTY_REVERT = 4002
665    ID_PROPERTY_ADD = 4003
666    ID_PROPERTY_GENCLASS = 4004
667    ID_PROPERTY_REMOVE = 4005
668    ID_PROPERTY_MOVEUP = 4006
669    ID_PROPERTY_MOVEDOWN = 4007
670    ID_PROPERTY_TRY = 4008
671    ID_PROPERTY_EDITSYM = 4009
672    ID_PROPERTY_SELECT = 4011
673    ID_PROPERTY_TITLE = 4012
674    ID_PROPERTY_FIELDTEXT = 4013
675    
676    BTN_ADD = 0
677    BTN_EDIT = 1
678    BTN_GEN = 2
679    BTN_UP = 3
680    BTN_DOWN = 4
681    BTN_RM = 5
682    
683    EB_LAYER_TITLE = 0
684    EB_SELECT_FIELD = 1
685    EB_GEN_CLASS = 2
686    
687      def __init__(self, parent, name, layer):  class Classifier(NonModalNonParentDialog):
         NonModalDialog.__init__(self, parent, name,  
                                 _("Classifier: %s") % layer.Title())  
688    
689          panel = wxPanel(self, -1, size=(100, 100))      type2string = {None:             _("None"),
690                       FIELDTYPE_STRING: _("Text"),
691                       FIELDTYPE_INT:    _("Integer"),
692                       FIELDTYPE_DOUBLE: _("Decimal")}
693    
694          self.layer = layer      def __init__(self, parent, name, layer, group = None):
695            """Create a Properties/Classification dialog for a layer.
696            The layer is part of map. If group is not None, select that
697            group in the classification table.
698            """
699    
700          self.originalClass = self.layer.GetClassification()          NonModalNonParentDialog.__init__(self, parent, name, "")
         field = self.originalClass.GetField()  
         fieldType = self.originalClass.GetFieldType()  
701    
702          topBox = wxBoxSizer(wxVERTICAL)          self.__SetTitle(layer.Title())
         panelBox = wxBoxSizer(wxVERTICAL)  
703    
704          #panelBox.Add(wxStaticText(panel, -1, _("Layer: %s") % layer.Title()),          self.parent.Subscribe(MAP_REPLACED, self.map_replaced)
705              #0, wxALIGN_LEFT | wxALL, 4)          self.layer = layer
706          panelBox.Add(wxStaticText(panel, -1,          self.map = parent.Map()
                                 _("Layer Type: %s") % layer.ShapeType()),  
             0, wxALIGN_LEFT | wxALL, 4)  
707    
708            self.map.Subscribe(MAP_LAYERS_REMOVED, self.map_layers_removed)
709            self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
710                                 self.layer_shapestore_replaced)
711    
712            self.genDlg = None
713    
714            ############################
715            # Create the controls
716          #          #
         # make field combo box  
         #  
         self.fields = wxComboBox(panel, ID_PROPERTY_SELECT, "",  
                                      style = wxCB_READONLY)  
717    
718          self.num_cols = layer.table.field_count()          panel = wxPanel(self, -1)
         # just assume the first field in case one hasn't been  
         # specified in the file.  
         self.__cur_field = 0  
   
         self.fields.Append("<None>")  
         self.fields.SetClientData(0, None)  
   
         for i in range(self.num_cols):  
             type, name, len, decc = layer.table.field_info(i)  
             self.fields.Append(name)  
   
             if name == field:  
                 self.__cur_field = i + 1  
                 self.fields.SetClientData(i + 1, self.originalClass)  
             else:  
                 self.fields.SetClientData(i + 1, None)  
719    
720            text_title = wxTextCtrl(panel, ID_PROPERTY_TITLE, layer.Title())
721            self.fieldTypeText = wxStaticText(panel, -1, "")
722    
723          ###########          if layer.HasClassification():
724                self.originalClass = self.layer.GetClassification()
725                self.originalClassField = self.layer.GetClassificationColumn()
726                field = self.originalClassField
727                fieldType = self.layer.GetFieldType(field)
728    
729          self.fieldTypeText = wxStaticText(panel, -1, "")              table = layer.ShapeStore().Table()
730          panelBox.Add(self.fieldTypeText, 0, wxGROW | wxALIGN_LEFT | wxALL, 4)              #
731                # make field choice box
732                #
733                self.fields = wxChoice(panel, ID_PROPERTY_SELECT,)
734    
735          propertyBox = wxBoxSizer(wxHORIZONTAL)              self.num_cols = table.NumColumns()
736          propertyBox.Add(wxStaticText(panel, -1, _("Field: ")),              # just assume the first field in case one hasn't been
737              0, wxALIGN_LEFT | wxALL, 4)              # specified in the file.
738          propertyBox.Add(self.fields, 1, wxGROW|wxALL, 4)              self.__cur_field = 0
         EVT_COMBOBOX(self, ID_PROPERTY_SELECT, self._OnFieldSelect)  
739    
740          panelBox.Add(propertyBox, 0, wxGROW, 4)              self.fields.Append("<None>")
741    
742          ###########              if fieldType is None:
743          #                  self.fields.SetClientData(0, copy.deepcopy(self.originalClass))
744          # Classification data table              else:
745                    self.fields.SetClientData(0, None)
746    
747                for i in range(self.num_cols):
748                    name = table.Column(i).name
749                    self.fields.Append(name)
750    
751                    if name == field:
752                        self.__cur_field = i + 1
753                        self.fields.SetClientData(i + 1,
754                                                  copy.deepcopy(self.originalClass))
755                    else:
756                        self.fields.SetClientData(i + 1, None)
757    
758                button_gen = wxButton(panel, ID_PROPERTY_GENCLASS,
759                    _("Generate Class"))
760                button_add = wxButton(panel, ID_PROPERTY_ADD,
761                    _("Add"))
762                button_moveup = wxButton(panel, ID_PROPERTY_MOVEUP,
763                    _("Move Up"))
764                button_movedown = wxButton(panel, ID_PROPERTY_MOVEDOWN,
765                    _("Move Down"))
766                button_edit = wxButton(panel, ID_PROPERTY_EDITSYM,
767                    _("Edit Symbol"))
768                button_remove = wxButton(panel, ID_PROPERTY_REMOVE,
769                    _("Remove"))
770    
771                self.classGrid = ClassGrid(panel, self)
772    
773                # calling __SelectField after creating the classGrid fills in the
774                # grid with the correct information
775                self.fields.SetSelection(self.__cur_field)
776                self.__SelectField(self.__cur_field, group = group)
777    
778            button_try = wxButton(self, ID_PROPERTY_TRY, _("Try"))
779            button_revert = wxButton(self, ID_PROPERTY_REVERT, _("Revert"))
780            button_ok = wxButton(self, wxID_OK, _("OK"))
781            button_close = wxButton(self, wxID_CANCEL, _("Close"))
782            button_ok.SetDefault()
783    
784            ############################
785            # Layout the controls
786          #          #
787    
788          controlBox = wxBoxSizer(wxHORIZONTAL)          topBox = wxBoxSizer(wxVERTICAL)
789            panelBox = wxBoxSizer(wxVERTICAL)
790    
791          self.classGrid = ClassGrid(panel)          sizer = wxBoxSizer(wxHORIZONTAL)
792          self.__SetGridTable(self.__cur_field)          sizer.Add(wxStaticText(panel, -1, _("Title: ")),
793                0, wxALIGN_LEFT | wxALL | wxALIGN_CENTER_VERTICAL, 4)
794            sizer.Add(text_title, 1, wxGROW, 0)
795    
796          controlBox.Add(self.classGrid, 1, wxGROW, 0)          panelBox.Add(sizer, 0, wxGROW, 4)
797    
798          ###########          if isinstance(layer, RasterLayer):
799          #              type = "Image"
800          # Control buttons:          else:
801          #              type = layer.ShapeType()
         self.controlButtons = []  
802    
803          controlButtonBox = wxBoxSizer(wxVERTICAL)          panelBox.Add(wxStaticText(panel, -1, _("Type: %s") % type),
804                0, wxALIGN_LEFT | wxALL, 4)
805    
806          button = wxButton(panel, ID_CLASSIFY_ADD, _("Add"))          if layer.HasClassification():
         controlButtonBox.Add(button, 0, wxGROW | wxALL, 4)  
         self.controlButtons.append(button)  
807    
808          #button = wxButton(panel, ID_CLASSIFY_GENRANGE, _("Generate Ranges"))              classBox = wxStaticBoxSizer(
809          #controlButtonBox.Add(button, 0, wxGROW | wxALL, 4)                          wxStaticBox(panel, -1, _("Classification")), wxVERTICAL)
         #self.controlButtons.append(button)  
810    
         button = wxButton(panel, ID_CLASSIFY_MOVEUP, _("Move Up"))  
         controlButtonBox.Add(button, 0, wxGROW | wxALL, 4)  
         self.controlButtons.append(button)  
811    
812          button = wxButton(panel, ID_CLASSIFY_MOVEDOWN, _("Move Down"))              sizer = wxBoxSizer(wxHORIZONTAL)
813          controlButtonBox.Add(button, 0, wxGROW | wxALL, 4)              sizer.Add(wxStaticText(panel, ID_PROPERTY_FIELDTEXT, _("Field: ")),
814          self.controlButtons.append(button)                  0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 4)
815                sizer.Add(self.fields, 1, wxGROW | wxALL, 4)
816    
817          controlButtonBox.Add(60, 20, 0, wxGROW | wxALL | wxALIGN_BOTTOM, 4)              classBox.Add(sizer, 0, wxGROW, 4)
818    
819          button = wxButton(panel, ID_CLASSIFY_REMOVE, _("Remove"))              classBox.Add(self.fieldTypeText, 0,
820          controlButtonBox.Add(button, 0, wxGROW | wxALL | wxALIGN_BOTTOM, 4)                          wxGROW | wxALIGN_LEFT | wxALL | wxADJUST_MINSIZE, 4)
         self.controlButtons.append(button)  
821    
822          controlBox.Add(controlButtonBox, 0, wxGROW, 10)              controlBox = wxBoxSizer(wxHORIZONTAL)
823          panelBox.Add(controlBox, 1, wxGROW, 10)              controlButtonBox = wxBoxSizer(wxVERTICAL)
824    
825          EVT_BUTTON(self, ID_CLASSIFY_ADD, self._OnAdd)              controlButtonBox.Add(button_gen, 0, wxGROW|wxALL, 4)
826          EVT_BUTTON(self, ID_CLASSIFY_REMOVE, self._OnRemove)              controlButtonBox.Add(button_add, 0, wxGROW|wxALL, 4)
827          EVT_BUTTON(self, ID_CLASSIFY_GENRANGE, self._OnGenRange)              controlButtonBox.Add(button_moveup, 0, wxGROW|wxALL, 4)
828          EVT_BUTTON(self, ID_CLASSIFY_MOVEUP, self._OnMoveUp)              controlButtonBox.Add(button_movedown, 0, wxGROW|wxALL, 4)
829          EVT_BUTTON(self, ID_CLASSIFY_MOVEDOWN, self._OnMoveDown)              controlButtonBox.Add(button_edit, 0, wxGROW|wxALL, 4)
830                controlButtonBox.Add(60, 20, 0, wxGROW|wxALL|wxALIGN_BOTTOM, 4)
831                controlButtonBox.Add(button_remove, 0,
832                                     wxGROW|wxALL|wxALIGN_BOTTOM, 4)
833    
834          ###########              controlBox.Add(self.classGrid, 1, wxGROW, 0)
835                controlBox.Add(controlButtonBox, 0, wxGROW, 10)
836    
837          buttonBox = wxBoxSizer(wxHORIZONTAL)              classBox.Add(controlBox, 1, wxGROW, 10)
838          buttonBox.Add(wxButton(panel, ID_CLASSIFY_OK, _("OK")),              panelBox.Add(classBox, 1, wxGROW, 0)
                       0, wxALL, 4)  
         buttonBox.Add(60, 20, 0, wxALL, 4)  
         buttonBox.Add(wxButton(panel, ID_CLASSIFY_APPLY, _("Apply")),  
                       0, wxALL, 4)  
         buttonBox.Add(60, 20, 0, wxALL, 4)  
         buttonBox.Add(wxButton(panel, ID_CLASSIFY_CANCEL, _("Cancel")),  
                       0, wxALL, 4)  
         panelBox.Add(buttonBox, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_BOTTOM, 0)  
   
         EVT_BUTTON(self, ID_CLASSIFY_OK, self._OnOK)  
         EVT_BUTTON(self, ID_CLASSIFY_APPLY, self._OnApply)  
         EVT_BUTTON(self, ID_CLASSIFY_CANCEL, self._OnCancel)  
839    
         ###########  
840    
841          self.fields.SetSelection(self.__cur_field)          buttonBox = wxBoxSizer(wxHORIZONTAL)
842          self.__SelectField(self.__cur_field)          buttonBox.Add(button_try, 0, wxRIGHT|wxEXPAND, 10)
843            buttonBox.Add(button_revert, 0, wxRIGHT|wxEXPAND, 10)
844            buttonBox.Add(button_ok, 0, wxRIGHT|wxEXPAND, 10)
845            buttonBox.Add(button_close, 0, wxRIGHT|wxEXPAND, 10)
846    
847          panel.SetAutoLayout(True)          panel.SetAutoLayout(True)
848          panel.SetSizer(panelBox)          panel.SetSizer(panelBox)
849            panelBox.Fit(panel)
850          panelBox.SetSizeHints(panel)          panelBox.SetSizeHints(panel)
851    
852          topBox.Add(panel, 1, wxGROW, 0)          topBox.Add(panel, 1, wxGROW | wxALL, 4)
853          panelBox.SetSizeHints(self)          topBox.Add(buttonBox, 0, wxALIGN_RIGHT|wxBOTTOM|wxTOP, 10)
854    
855          self.SetAutoLayout(True)          self.SetAutoLayout(True)
856          self.SetSizer(topBox)          self.SetSizer(topBox)
857            topBox.Fit(self)
858            topBox.SetSizeHints(self)
859            self.Layout()
860    
861            ###########
862    
863            EVT_CHOICE(self, ID_PROPERTY_SELECT, self._OnFieldSelect)
864            EVT_TEXT(self, ID_PROPERTY_TITLE, self._OnTitleChanged)
865            EVT_BUTTON(self, wxID_OK, self._OnOK)
866            EVT_BUTTON(self, ID_PROPERTY_TRY, self._OnTry)
867            EVT_BUTTON(self, wxID_CANCEL, self._OnCloseBtn)
868            EVT_BUTTON(self, ID_PROPERTY_REVERT, self._OnRevert)
869    
870            EVT_BUTTON(self, ID_PROPERTY_ADD, self._OnAdd)
871            EVT_BUTTON(self, ID_PROPERTY_EDITSYM, self._OnEditSymbol)
872            EVT_BUTTON(self, ID_PROPERTY_REMOVE, self._OnRemove)
873            EVT_BUTTON(self, ID_PROPERTY_GENCLASS, self._OnGenClass)
874            EVT_BUTTON(self, ID_PROPERTY_MOVEUP, self._OnMoveUp)
875            EVT_BUTTON(self, ID_PROPERTY_MOVEDOWN, self._OnMoveDown)
876    
877          ######################          ######################
878    
879            text_title.SetFocus()
880          self.haveApplied = False          self.haveApplied = False
881    
882      def __BuildClassification(self, fieldIndex):      def unsubscribe_messages(self):
883            """Unsubscribe from all messages."""
884            self.parent.Unsubscribe(MAP_REPLACED, self.map_replaced)
885            self.map.Unsubscribe(MAP_LAYERS_REMOVED, self.map_layers_removed)
886            self.layer.Unsubscribe(LAYER_SHAPESTORE_REPLACED,
887                                   self.layer_shapestore_replaced)
888    
889        def map_layers_removed(self, map):
890            """Subscribed to MAP_LAYERS_REMOVED. If this layer was removed,
891            Close self.
892            """
893            if self.layer not in self.map.Layers():
894                self.Close()
895    
896        def layer_shapestore_replaced(self, *args):
897            """Subscribed to the map's LAYER_SHAPESTORE_REPLACED message.
898    
899          numRows = self.classGrid.GetNumberRows()          Close self.
900          assert(numRows > 0) # there should always be a default row          """
901            self.Close()
902    
903        def map_replaced(self, *args):
904            """Subscribed to the mainwindow's MAP_REPLACED message. Close self."""
905            self.Close()
906    
907        def EditSymbol(self, row):
908            """Open up a dialog where the user can select the properties
909            for a group.
910            """
911            table = self.classGrid.GetTable()
912            prop = table.GetValueAsCustom(row, COL_SYMBOL, None)
913    
914            # get a new ClassGroupProperties object and copy the
915            # values over to our current object
916            propDlg = SelectPropertiesDialog(self, prop, self.layer.ShapeType())
917    
918            self.Enable(False)
919            if propDlg.ShowModal() == wxID_OK:
920                new_prop = propDlg.GetClassGroupProperties()
921                table.SetValueAsCustom(row, COL_SYMBOL, None, new_prop)
922            self.Enable(True)
923            propDlg.Destroy()
924    
925        def _SetClassification(self, clazz):
926            """Called from the ClassGen dialog when a new classification has
927            been created and should be set in the table.
928            """
929            # FIXME: This could be implemented using a message
930    
931            self.fields.SetClientData(self.__cur_field, clazz)
932            self.classGrid.GetTable().SetClassification(clazz)
933    
934        def __BuildClassification(self, fieldIndex, copyClass=False, force=False):
935            """Pack the classification setting into a Classification object.
936            Returns (Classification, fieldName) where fieldName is the selected
937            field in the table that the classification should be used with.
938            """
939    
940    #       numRows = self.classGrid.GetNumberRows()
941    #       assert numRows > 0  # there should always be a default row
942    
         clazz = Classification()  
943          if fieldIndex == 0:          if fieldIndex == 0:
944              fieldName = None              fieldName = None
945              fieldType = None              fieldType = None
# Line 740  class Classifier(NonModalDialog): Line 947  class Classifier(NonModalDialog):
947              fieldName = self.fields.GetString(fieldIndex)              fieldName = self.fields.GetString(fieldIndex)
948              fieldType = self.layer.GetFieldType(fieldName)              fieldType = self.layer.GetFieldType(fieldName)
949    
950          clazz.SetField(fieldName)          clazz = self.fields.GetClientData(fieldIndex)
951          clazz.SetFieldType(fieldType)          if clazz is None or self.classGrid.GetTable().IsModified() or force:
952                clazz = self.classGrid.GetTable().GetClassification()
953                if copyClass:
954          table = self.classGrid.GetTable()                  clazz = copy.deepcopy(clazz)
955          clazz.SetDefaultGroup(table.GetClassGroup(0))  
956            return clazz, fieldName
957          for i in range(1, numRows):  
958              clazz.AddGroup(table.GetClassGroup(i))      def __SetGridTable(self, fieldIndex, group = None):
959            """Set the table with the classification associated with the
960          return clazz          selected field at fieldIndex. Select the specified group
961            if group is not None.
962      def __SetGridTable(self, fieldIndex):          """
963    
964          clazz = self.fields.GetClientData(fieldIndex)          clazz = self.fields.GetClientData(fieldIndex)
965    
# Line 763  class Classifier(NonModalDialog): Line 970  class Classifier(NonModalDialog):
970                      self.layer.GetClassification().                      self.layer.GetClassification().
971                                 GetDefaultGroup().GetProperties()))                                 GetDefaultGroup().GetProperties()))
972    
973              fieldName = self.fields.GetString(fieldIndex)          fieldName = self.fields.GetString(fieldIndex)
974              fieldType = self.layer.GetFieldType(fieldName)          fieldType = self.layer.GetFieldType(fieldName)
             clazz.SetFieldType(fieldType)  
975                                    
976          self.classGrid.CreateTable(clazz, self.layer.ShapeType())          self.classGrid.CreateTable(clazz, fieldType,
977                                       self.layer.ShapeType(), group)
   
   
     type2string = {None:             _("None"),  
                    FIELDTYPE_STRING: _("Text"),  
                    FIELDTYPE_INT:    _("Integer"),  
                    FIELDTYPE_DOUBLE: _("Decimal")}  
978    
979      def __SetFieldTypeText(self, fieldIndex):      def __SetFieldTypeText(self, fieldIndex):
980            """Set the field type string using the data type of the field
981            at fieldIndex.
982            """
983          fieldName = self.fields.GetString(fieldIndex)          fieldName = self.fields.GetString(fieldIndex)
984          fieldType = self.layer.GetFieldType(fieldName)          fieldType = self.layer.GetFieldType(fieldName)
985    
986          assert(Classifier.type2string.has_key(fieldType))          assert Classifier.type2string.has_key(fieldType)
987    
988          text = Classifier.type2string[fieldType]          text = Classifier.type2string[fieldType]
989    
990          self.fieldTypeText.SetLabel(_("Field Type: %s") % text)          self.fieldTypeText.SetLabel(_("Data Type: %s") % text)
991    
992      def __SelectField(self, newIndex, oldIndex = -1):      def __SelectField(self, newIndex, oldIndex = -1, group = None):
993            """This method assumes that the current selection for the
994            combo has already been set by a call to SetSelection().
995            """
996    
997          assert(oldIndex >= -1)          assert oldIndex >= -1
998    
999          if oldIndex != -1:          if oldIndex != -1:
1000              clazz = self.__BuildClassification(oldIndex)              clazz, name = self.__BuildClassification(oldIndex, force = True)
1001              self.fields.SetClientData(oldIndex, clazz)              self.fields.SetClientData(oldIndex, clazz)
1002    
1003          self.__SetGridTable(newIndex)          self.__SetGridTable(newIndex, group)
   
         enabled = newIndex != 0  
1004    
1005          for b in self.controlButtons:          self.__EnableButtons(EB_SELECT_FIELD)
             b.Enable(enabled)  
1006    
1007          self.__SetFieldTypeText(newIndex)          self.__SetFieldTypeText(newIndex)
1008    
1009        def __SetTitle(self, title):
1010            """Set the title of the dialog."""
1011            if title != "":
1012                title = ": " + title
1013    
1014            self.SetTitle(_("Layer Properties") + title)
1015    
1016        def _OnEditSymbol(self, event):
1017            """Open up a dialog for the user to select group properties."""
1018            sel = self.classGrid.GetCurrentSelection()
1019    
1020            if len(sel) == 1:
1021                self.EditSymbol(sel[0])
1022    
1023      def _OnFieldSelect(self, event):      def _OnFieldSelect(self, event):
1024          index = self.fields.GetSelection()          index = self.fields.GetSelection()
1025          self.__SelectField(index, self.__cur_field)          self.__SelectField(index, self.__cur_field)
1026          self.__cur_field = index          self.__cur_field = index
1027    
1028      def _OnApply(self, event):      def _OnTry(self, event):
1029          """Put the data from the table into a new Classification and hand          """Put the data from the table into a new Classification and hand
1030             it to the layer.             it to the layer.
1031          """          """
1032    
1033          clazz = self.fields.GetClientData(self.__cur_field)          if self.layer.HasClassification():
1034                clazz = self.fields.GetClientData(self.__cur_field)
1035    
1036          #              #
1037          # only build the classification if there wasn't one to              # only build the classification if there wasn't one to
1038          # to begin with or it has been modified              # to begin with or it has been modified
1039          #              #
1040          if clazz is None or self.classGrid.GetTable().IsModified():              self.classGrid.SaveEditControlValue()
1041              clazz = self.__BuildClassification(self.__cur_field)              clazz, name = self.__BuildClassification(self.__cur_field, True)
1042    
1043          self.layer.SetClassification(clazz)              self.layer.SetClassificationColumn(name)
1044                self.layer.SetClassification(clazz)
1045    
1046          self.haveApplied = True          self.haveApplied = True
1047    
1048      def _OnOK(self, event):      def _OnOK(self, event):
1049          self._OnApply(event)          self._OnTry(event)
1050          self.OnClose(event)          self.Close()
1051    
1052        def OnClose(self, event):
1053            self.unsubscribe_messages()
1054            NonModalNonParentDialog.OnClose(self, event)
1055    
1056        def _OnCloseBtn(self, event):
1057            """Close is similar to Cancel except that any changes that were
1058            made and applied remain applied, but the currently displayed
1059            classification is discarded.
1060            """
1061    
1062            self.Close()
1063    
1064      def _OnCancel(self, event):      def _OnRevert(self, event):
1065          """The layer's current classification stays the same."""          """The layer's current classification stays the same."""
1066          if self.haveApplied:          if self.haveApplied:
1067                self.layer.SetClassificationColumn(self.originalClassField)
1068              self.layer.SetClassification(self.originalClass)              self.layer.SetClassification(self.originalClass)
1069    
1070          self.OnClose(event)          #self.Close()
1071    
1072      def _OnAdd(self, event):      def _OnAdd(self, event):
1073          self.classGrid.AppendRows()          self.classGrid.AppendRows()
# Line 844  class Classifier(NonModalDialog): Line 1075  class Classifier(NonModalDialog):
1075      def _OnRemove(self, event):      def _OnRemove(self, event):
1076          self.classGrid.DeleteSelectedRows()          self.classGrid.DeleteSelectedRows()
1077    
1078      def _OnGenRange(self, event):      def _OnGenClass(self, event):
1079          print "Classifier._OnGenRange()"          """Open up a dialog for the user to generate classifications."""
1080    
1081            self.genDlg = ClassGenDialog(self, self.layer,
1082                              self.fields.GetString(self.__cur_field))
1083    
1084            EVT_CLOSE(self.genDlg, self._OnGenDialogClose)
1085    
1086            self.__EnableButtons(EB_GEN_CLASS)
1087    
1088            self.genDlg.Show()
1089    
1090        def _OnGenDialogClose(self, event):
1091            """Reenable buttons after the generate classification
1092            dialog is closed.
1093            """
1094            self.genDlg.Destroy()
1095            self.genDlg = None
1096            self.__EnableButtons(EB_GEN_CLASS)
1097    
1098      def _OnMoveUp(self, event):      def _OnMoveUp(self, event):
1099            """When the user clicks MoveUp, try to move a group up one row."""
1100          sel = self.classGrid.GetCurrentSelection()          sel = self.classGrid.GetCurrentSelection()
1101    
1102          if len(sel) == 1:          if len(sel) == 1:
# Line 860  class Classifier(NonModalDialog): Line 1109  class Classifier(NonModalDialog):
1109                  table.SetClassGroup(i, x)                  table.SetClassGroup(i, x)
1110                  self.classGrid.ClearSelection()                  self.classGrid.ClearSelection()
1111                  self.classGrid.SelectRow(i - 1)                  self.classGrid.SelectRow(i - 1)
1112                    self.classGrid.MakeCellVisible(i - 1, 0)
1113    
1114      def _OnMoveDown(self, event):      def _OnMoveDown(self, event):
1115            """When the user clicks MoveDown, try to move a group down one row."""
1116          sel = self.classGrid.GetCurrentSelection()          sel = self.classGrid.GetCurrentSelection()
1117    
1118          if len(sel) == 1:          if len(sel) == 1:
# Line 874  class Classifier(NonModalDialog): Line 1125  class Classifier(NonModalDialog):
1125                  table.SetClassGroup(i + 1, x)                  table.SetClassGroup(i + 1, x)
1126                  self.classGrid.ClearSelection()                  self.classGrid.ClearSelection()
1127                  self.classGrid.SelectRow(i + 1)                  self.classGrid.SelectRow(i + 1)
1128                    self.classGrid.MakeCellVisible(i + 1, 0)
1129    
1130        def _OnTitleChanged(self, event):
1131            """Update the dialog title when the user changed the layer name."""
1132            obj = event.GetEventObject()
1133    
1134            self.layer.SetTitle(obj.GetValue())
1135            self.__SetTitle(self.layer.Title())
1136    
1137            self.__EnableButtons(EB_LAYER_TITLE)
1138    
1139        def __EnableButtons(self, case):
1140            """Helper method that enables/disables the appropriate buttons
1141            based on the case provided. Cases are constants beginning with EB_.
1142            """
1143    
1144            list = {wxID_OK                 : True,
1145                    wxID_CANCEL             : True,
1146                    ID_PROPERTY_ADD         : True,
1147                    ID_PROPERTY_MOVEUP      : True,
1148                    ID_PROPERTY_MOVEDOWN    : True,
1149                    ID_PROPERTY_REMOVE      : True,
1150                    ID_PROPERTY_SELECT      : True,
1151                    ID_PROPERTY_FIELDTEXT   : True,
1152                    ID_PROPERTY_GENCLASS    : True,
1153                    ID_PROPERTY_EDITSYM     : True}
1154    
1155            if case == EB_LAYER_TITLE:  
1156                if self.layer.Title() == "":
1157                    list[wxID_OK] = False
1158                    list[wxID_CANCEL] = False
1159    
1160            elif case == EB_SELECT_FIELD:
1161                if self.fields.GetSelection() == 0:
1162                    list[ID_PROPERTY_GENCLASS] = False
1163                    list[ID_PROPERTY_ADD] = False
1164                    list[ID_PROPERTY_MOVEUP] = False
1165                    list[ID_PROPERTY_MOVEDOWN] = False
1166                    list[ID_PROPERTY_REMOVE] = False
1167    
1168            elif case == EB_GEN_CLASS:
1169                if self.genDlg is not None:
1170                    list[ID_PROPERTY_SELECT] = False
1171                    list[ID_PROPERTY_FIELDTEXT] = False
1172                    list[ID_PROPERTY_GENCLASS] = False
1173    
1174            for id, enable in list.items():
1175                win = self.FindWindowById(id)
1176                if win:
1177                    win.Enable(enable)
1178    
1179  ID_SELPROP_OK = 4001  ID_SELPROP_SPINCTRL_LINEWIDTH = 4002
 ID_SELPROP_CANCEL = 4002  
 ID_SELPROP_SPINCTRL = 4002  
1180  ID_SELPROP_PREVIEW = 4003  ID_SELPROP_PREVIEW = 4003
1181  ID_SELPROP_STROKECLR = 4004  ID_SELPROP_STROKECLR = 4004
1182  ID_SELPROP_FILLCLR = 4005  ID_SELPROP_FILLCLR = 4005
1183  ID_SELPROP_STROKECLRTRANS = 4006  ID_SELPROP_STROKECLRTRANS = 4006
1184  ID_SELPROP_FILLCLRTRANS = 4007  ID_SELPROP_FILLCLRTRANS = 4007
1185    ID_SELPROP_SPINCTRL_SIZE = 4008
1186    
1187  class SelectPropertiesDialog(wxDialog):  class SelectPropertiesDialog(wxDialog):
1188        """Dialog that allows the user to select group properties."""
1189    
1190      def __init__(self, parent, prop, shapeType):      def __init__(self, parent, prop, shapeType):
1191            """Open the dialog with the initial prop properties and shapeType."""
1192    
1193          wxDialog.__init__(self, parent, -1, _("Select Properties"),          wxDialog.__init__(self, parent, -1, _("Select Properties"),
1194                            style = wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)                            style = wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
1195    
# Line 901  class SelectPropertiesDialog(wxDialog): Line 1203  class SelectPropertiesDialog(wxDialog):
1203          previewBox = wxBoxSizer(wxVERTICAL)          previewBox = wxBoxSizer(wxVERTICAL)
1204          previewBox.Add(wxStaticText(self, -1, _("Preview:")),          previewBox.Add(wxStaticText(self, -1, _("Preview:")),
1205              0, wxALIGN_LEFT | wxALL, 4)              0, wxALIGN_LEFT | wxALL, 4)
1206          self.previewWin = ClassDataPreviewWindow(None, self.prop, shapeType,  
1207                                              self, ID_SELPROP_PREVIEW, (40, 40))          self.previewWin = ClassGroupPropertiesCtrl(
1208          previewBox.Add(self.previewWin, 1, wxGROW, 15)              self, ID_SELPROP_PREVIEW, self.prop, shapeType,
1209                (40, 40), wxSIMPLE_BORDER)
1210    
1211            self.previewWin.AllowEdit(False)
1212    
1213            previewBox.Add(self.previewWin, 1, wxGROW | wxALL, 4)
1214    
1215          itemBox.Add(previewBox, 1, wxALIGN_LEFT | wxALL | wxGROW, 0)          itemBox.Add(previewBox, 1, wxALIGN_LEFT | wxALL | wxGROW, 0)
1216    
# Line 911  class SelectPropertiesDialog(wxDialog): Line 1218  class SelectPropertiesDialog(wxDialog):
1218          ctrlBox = wxBoxSizer(wxVERTICAL)          ctrlBox = wxBoxSizer(wxVERTICAL)
1219    
1220          lineColorBox = wxBoxSizer(wxHORIZONTAL)          lineColorBox = wxBoxSizer(wxHORIZONTAL)
1221          lineColorBox.Add(          button = wxButton(self, ID_SELPROP_STROKECLR, _("Change Line Color"))
1222              wxButton(self, ID_SELPROP_STROKECLR, _("Change Line Color")),          button.SetFocus()
1223              1, wxALL | wxGROW, 4)          lineColorBox.Add(button, 1, wxALL | wxGROW, 4)
1224          EVT_BUTTON(self, ID_SELPROP_STROKECLR, self._OnChangeLineColor)          EVT_BUTTON(self, ID_SELPROP_STROKECLR, self._OnChangeLineColor)
1225    
1226          lineColorBox.Add(          lineColorBox.Add(
# Line 939  class SelectPropertiesDialog(wxDialog): Line 1246  class SelectPropertiesDialog(wxDialog):
1246              ctrlBox.Add(fillColorBox, 0,              ctrlBox.Add(fillColorBox, 0,
1247                          wxALIGN_CENTER_HORIZONTAL | wxALL | wxGROW, 4)                          wxALIGN_CENTER_HORIZONTAL | wxALL | wxGROW, 4)
1248    
1249            # Line width selection
1250          spinBox = wxBoxSizer(wxHORIZONTAL)          spinBox = wxBoxSizer(wxHORIZONTAL)
1251          spinBox.Add(wxStaticText(self, -1, _("Line Width: ")),          spinBox.Add(wxStaticText(self, -1, _("Line Width: ")),
1252                  0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 4)                  0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 4)
1253          self.spinCtrl = wxSpinCtrl(self, ID_SELPROP_SPINCTRL,          self.spinCtrl_linewidth = wxSpinCtrl(self,
1254                                     min=1, max=10,                                               ID_SELPROP_SPINCTRL_LINEWIDTH,
1255                                     value=str(prop.GetLineWidth()),                                               min=1, max=10,
1256                                     initial=prop.GetLineWidth())                                               value=str(prop.GetLineWidth()),
1257                                                 initial=prop.GetLineWidth())
1258    
1259          EVT_SPINCTRL(self, ID_SELPROP_SPINCTRL, self._OnSpin)          EVT_SPINCTRL(self, ID_SELPROP_SPINCTRL_LINEWIDTH,
1260                         self._OnSpinLineWidth)
         spinBox.Add(self.spinCtrl, 0, wxALIGN_LEFT | wxALL, 4)  
1261    
1262            spinBox.Add(self.spinCtrl_linewidth, 0, wxALIGN_LEFT | wxALL, 4)
1263          ctrlBox.Add(spinBox, 0, wxALIGN_RIGHT | wxALL, 0)          ctrlBox.Add(spinBox, 0, wxALIGN_RIGHT | wxALL, 0)
1264    
1265            # Size selection
1266            if shapeType == SHAPETYPE_POINT:
1267                spinBox = wxBoxSizer(wxHORIZONTAL)
1268                spinBox.Add(wxStaticText(self, -1, _("Size: ")),
1269                            0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 4)
1270                self.spinCtrl_size = wxSpinCtrl(self, ID_SELPROP_SPINCTRL_SIZE,
1271                                                min=1, max=100,
1272                                                value=str(prop.GetSize()),
1273                                                initial=prop.GetSize())
1274    
1275                EVT_SPINCTRL(self, ID_SELPROP_SPINCTRL_SIZE, self._OnSpinSize)
1276    
1277                spinBox.Add(self.spinCtrl_size, 0, wxALIGN_LEFT | wxALL, 4)
1278                ctrlBox.Add(spinBox, 0, wxALIGN_RIGHT | wxALL, 0)
1279    
1280    
1281          itemBox.Add(ctrlBox, 0, wxALIGN_RIGHT | wxALL | wxGROW, 0)          itemBox.Add(ctrlBox, 0, wxALIGN_RIGHT | wxALL | wxGROW, 0)
1282          topBox.Add(itemBox, 1, wxALIGN_LEFT | wxALL | wxGROW, 0)          topBox.Add(itemBox, 1, wxALIGN_LEFT | wxALL | wxGROW, 0)
1283    
# Line 959  class SelectPropertiesDialog(wxDialog): Line 1285  class SelectPropertiesDialog(wxDialog):
1285          # Control buttons:          # Control buttons:
1286          #          #
1287          buttonBox = wxBoxSizer(wxHORIZONTAL)          buttonBox = wxBoxSizer(wxHORIZONTAL)
1288          buttonBox.Add(wxButton(self, ID_SELPROP_OK, _("OK")),          button_ok = wxButton(self, wxID_OK, _("OK"))
1289                        0, wxALL, 4)          buttonBox.Add(button_ok, 0, wxRIGHT|wxEXPAND, 10)
1290          buttonBox.Add(wxButton(self, ID_SELPROP_CANCEL, _("Cancel")),          buttonBox.Add(wxButton(self, wxID_CANCEL, _("Cancel")),
1291                        0, wxALL, 4)                        0, wxRIGHT|wxEXPAND, 10)
1292          topBox.Add(buttonBox, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_BOTTOM, 10)          topBox.Add(buttonBox, 0, wxALIGN_RIGHT|wxBOTTOM|wxTOP, 10)
1293                                                                                    
1294          EVT_BUTTON(self, ID_SELPROP_OK, self._OnOK)          button_ok.SetDefault()
1295          EVT_BUTTON(self, ID_SELPROP_CANCEL, self._OnCancel)  
1296                                                                                            #EVT_BUTTON(self, wxID_OK, self._OnOK)
1297            #EVT_BUTTON(self, ID_SELPROP_CANCEL, self._OnCancel)
1298    
1299          self.SetAutoLayout(True)          self.SetAutoLayout(True)
1300          self.SetSizer(topBox)          self.SetSizer(topBox)
1301          topBox.Fit(self)          topBox.Fit(self)
1302          topBox.SetSizeHints(self)          topBox.SetSizeHints(self)
1303    
1304      def _OnOK(self, event):      def OnOK(self, event):
1305          self.EndModal(wxID_OK)          self.EndModal(wxID_OK)
1306    
1307      def _OnCancel(self, event):      def OnCancel(self, event):
1308          self.EndModal(wxID_CANCEL)          self.EndModal(wxID_CANCEL)
1309    
1310      def _OnSpin(self, event):      def _OnSpinLineWidth(self, event):
1311          self.prop.SetLineWidth(self.spinCtrl.GetValue())          self.prop.SetLineWidth(self.spinCtrl_linewidth.GetValue())
1312            self.previewWin.Refresh()
1313    
1314        def _OnSpinSize(self, event):
1315            self.prop.SetSize(self.spinCtrl_size.GetValue())
1316          self.previewWin.Refresh()          self.previewWin.Refresh()
1317    
1318      def __GetColor(self, cur):      def __GetColor(self, cur):
1319          dialog = wxColourDialog(self)          dialog = ColorDialog(self)
1320          dialog.GetColourData().SetColour(Color2wxColour(cur))          dialog.SetColor(cur)
1321    
1322          ret = None          ret = None
1323          if dialog.ShowModal() == wxID_OK:          if dialog.ShowModal() == wxID_OK:
1324              ret = wxColour2Color(dialog.GetColourData().GetColour())              ret = dialog.GetColor()
1325    
1326          dialog.Destroy()          dialog.Destroy()
1327    
1328          return ret          return ret
1329            
1330      def _OnChangeLineColor(self, event):      def _OnChangeLineColor(self, event):
1331          clr = self.__GetColor(self.prop.GetLineColor())          clr = self.__GetColor(self.prop.GetLineColor())
1332          if clr is not None:          if clr is not None:
# Line 1001  class SelectPropertiesDialog(wxDialog): Line 1334  class SelectPropertiesDialog(wxDialog):
1334          self.previewWin.Refresh() # XXX: work around, see ClassDataPreviewer          self.previewWin.Refresh() # XXX: work around, see ClassDataPreviewer
1335    
1336      def _OnChangeLineColorTrans(self, event):      def _OnChangeLineColorTrans(self, event):
1337          self.prop.SetLineColor(Color.None)          self.prop.SetLineColor(Transparent)
1338          self.previewWin.Refresh() # XXX: work around, see ClassDataPreviewer          self.previewWin.Refresh() # XXX: work around, see ClassDataPreviewer
1339            
1340      def _OnChangeFillColor(self, event):      def _OnChangeFillColor(self, event):
1341          clr = self.__GetColor(self.prop.GetFill())          clr = self.__GetColor(self.prop.GetFill())
1342          if clr is not None:          if clr is not None:
# Line 1011  class SelectPropertiesDialog(wxDialog): Line 1344  class SelectPropertiesDialog(wxDialog):
1344          self.previewWin.Refresh() # XXX: work around, see ClassDataPreviewer          self.previewWin.Refresh() # XXX: work around, see ClassDataPreviewer
1345    
1346      def _OnChangeFillColorTrans(self, event):      def _OnChangeFillColorTrans(self, event):
1347          self.prop.SetFill(Color.None)          self.prop.SetFill(Transparent)
1348          self.previewWin.Refresh() # XXX: work around, see ClassDataPreviewer          self.previewWin.Refresh() # XXX: work around, see ClassDataPreviewer
1349    
1350      def GetClassGroupProperties(self):      def GetClassGroupProperties(self):
# Line 1019  class SelectPropertiesDialog(wxDialog): Line 1352  class SelectPropertiesDialog(wxDialog):
1352    
1353    
1354  class ClassDataPreviewWindow(wxWindow):  class ClassDataPreviewWindow(wxWindow):
1355        """A custom window that draws group properties using the correct shape."""
1356    
1357      def __init__(self, rect, prop, shapeType,      def __init__(self, rect, prop, shapeType,
1358                         parent = None, id = -1, size = wxDefaultSize):                         parent = None, id = -1, size = wxDefaultSize):
1359            """Draws the appropriate shape as specified with shapeType using
1360            prop properities.
1361            """
1362          if parent is not None:          if parent is not None:
1363              wxWindow.__init__(self, parent, id, (0, 0), size)              wxWindow.__init__(self, parent, id, (0, 0), size)
1364              EVT_PAINT(self, self._OnPaint)              EVT_PAINT(self, self._OnPaint)
# Line 1032  class ClassDataPreviewWindow(wxWindow): Line 1369  class ClassDataPreviewWindow(wxWindow):
1369          self.shapeType = shapeType          self.shapeType = shapeType
1370          self.previewer = ClassDataPreviewer()          self.previewer = ClassDataPreviewer()
1371    
1372        def GetProperties():
1373            return self.prop
1374    
1375      def _OnPaint(self, event):      def _OnPaint(self, event):
1376          dc = wxPaintDC(self)          dc = wxPaintDC(self)
1377    
# Line 1047  class ClassDataPreviewWindow(wxWindow): Line 1387  class ClassDataPreviewWindow(wxWindow):
1387          self.previewer.Draw(dc, rect, self.prop, self.shapeType)          self.previewer.Draw(dc, rect, self.prop, self.shapeType)
1388    
1389  class ClassDataPreviewer:  class ClassDataPreviewer:
1390        """Class that actually draws a group property preview."""
1391    
1392      def Draw(self, dc, rect, prop, shapeType):      def Draw(self, dc, rect, prop, shapeType):
1393            """Draw the property.
1394    
1395            returns: (w, h) as adapted extend if the drawing size
1396            exceeded the given rect. This can only be the case
1397            for point symbols. If the symbol fits the given rect,
1398            None is returned.
1399            """
1400    
1401          assert(dc is not None)          assert dc is not None
1402          assert(isinstance(prop, ClassGroupProperties))          assert isinstance(prop, ClassGroupProperties)
1403    
1404          if rect is None:          if rect is None:
1405              x = 0              x = 0
# Line 1064  class ClassDataPreviewer: Line 1412  class ClassDataPreviewer:
1412              h = rect.GetHeight()              h = rect.GetHeight()
1413    
1414          stroke = prop.GetLineColor()          stroke = prop.GetLineColor()
1415          if stroke is Color.None:          if stroke is Transparent:
1416              pen = wxTRANSPARENT_PEN              pen = wxTRANSPARENT_PEN
1417          else:          else:
1418              pen = wxPen(Color2wxColour(stroke),              pen = wxPen(Color2wxColour(stroke),
# Line 1072  class ClassDataPreviewer: Line 1420  class ClassDataPreviewer:
1420                          wxSOLID)                          wxSOLID)
1421    
1422          stroke = prop.GetFill()          stroke = prop.GetFill()
1423          if stroke is Color.None:          if stroke is Transparent:
1424              brush = wxTRANSPARENT_BRUSH              brush = wxTRANSPARENT_BRUSH
1425          else:          else:
1426              brush = wxBrush(Color2wxColour(stroke), wxSOLID)              brush = wxBrush(Color2wxColour(stroke), wxSOLID)
# Line 1086  class ClassDataPreviewer: Line 1434  class ClassDataPreviewer:
1434                             wxPoint(x + w/2, y + h/4*3),                             wxPoint(x + w/2, y + h/4*3),
1435                             wxPoint(x + w, y)])                             wxPoint(x + w, y)])
1436    
1437          elif shapeType == SHAPETYPE_POINT or \          elif shapeType == SHAPETYPE_POINT:
1438               shapeType == SHAPETYPE_POLYGON:  
1439                dc.DrawCircle(x + w/2, y + h/2, prop.GetSize())
1440                circle_size =  prop.GetSize() * 2 + prop.GetLineWidth() * 2
1441                new_h = h
1442                new_w = w
1443                if h < circle_size: new_h = circle_size
1444                if w < circle_size: new_w = circle_size
1445                if new_h > h or new_w > w:
1446                    return (new_w, new_h)
1447    
1448              dc.DrawCircle(x + w/2, y + h/2,          elif shapeType == SHAPETYPE_POLYGON:
1449                            (min(w, h) - prop.GetLineWidth())/2)              dc.DrawRectangle(x, y, w, h)
1450    
1451            return None
1452    
1453  class ClassRenderer(wxPyGridCellRenderer):  class ClassRenderer(wxPyGridCellRenderer):
1454        """A wrapper class that can be used to draw group properties in a
1455        grid table.
1456        """
1457    
1458      def __init__(self, shapeType):      def __init__(self, shapeType):
1459          wxPyGridCellRenderer.__init__(self)          wxPyGridCellRenderer.__init__(self)
# Line 1110  class ClassRenderer(wxPyGridCellRenderer Line 1471  class ClassRenderer(wxPyGridCellRenderer
1471                           rect.GetWidth(), rect.GetHeight())                           rect.GetWidth(), rect.GetHeight())
1472    
1473          if not isinstance(data, ClassGroupMap):          if not isinstance(data, ClassGroupMap):
1474              self.previewer.Draw(dc, rect, data.GetProperties(), self.shapeType)              new_size = self.previewer.Draw(dc, rect, data.GetProperties(),
1475                                               self.shapeType)
1476                if new_size is not None:
1477                    (new_w, new_h) = new_size
1478                    grid.SetRowSize(row, new_h)
1479                    grid.SetColSize(col, new_h)
1480                    grid.ForceRefresh()
1481    
1482                    # now that we know the height, redraw everything
1483                    rect.SetHeight(new_h)
1484                    rect.SetWidth(new_w)
1485                    dc.DestroyClippingRegion()
1486                    dc.SetClippingRegion(rect.GetX(), rect.GetY(),
1487                                         rect.GetWidth(), rect.GetHeight())
1488                    dc.SetPen(wxPen(wxLIGHT_GREY))
1489                    dc.SetBrush(wxBrush(wxLIGHT_GREY, wxSOLID))
1490                    dc.DrawRectangle(rect.GetX(), rect.GetY(),
1491                                     rect.GetWidth(), rect.GetHeight())
1492                    self.previewer.Draw(dc, rect, data.GetProperties(),
1493                                        self.shapeType)
1494    
1495          if isSelected:          if isSelected:
1496              dc.SetPen(wxPen(wxColour(0 * 255, 0 * 255, 0 * 255),              dc.SetPen(wxPen(wxBLACK, 1, wxSOLID))
                       4, wxSOLID))  
1497              dc.SetBrush(wxTRANSPARENT_BRUSH)              dc.SetBrush(wxTRANSPARENT_BRUSH)
1498    
1499              dc.DrawRectangle(rect.GetX(), rect.GetY(),              dc.DrawRectangle(rect.GetX(), rect.GetY(),
1500                               rect.GetWidth(), rect.GetHeight())                               rect.GetWidth(), rect.GetHeight())
1501    
1502          dc.DestroyClippingRegion()          dc.DestroyClippingRegion()
1503    
1504    
1505    class ClassGroupPropertiesCtrl(wxWindow, wxControl):
1506        """A custom window and control that draw a preview of group properties
1507        and can open a dialog to modify the properties if the user double-clicks
1508        it.
1509        """
1510    
1511        def __init__(self, parent, id, props, shapeType,
1512                     size = wxDefaultSize, style = 0):
1513    
1514            wxWindow.__init__(self, parent, id, size = size, style = style)
1515    
1516            self.parent = parent
1517    
1518            self.SetProperties(props)
1519            self.SetShapeType(shapeType)
1520            self.AllowEdit(True)
1521    
1522            EVT_PAINT(self, self._OnPaint)
1523            EVT_LEFT_DCLICK(self, self._OnLeftDClick)
1524    
1525            self.previewer = ClassDataPreviewer()
1526    
1527        def _OnPaint(self, event):
1528            dc = wxPaintDC(self)
1529    
1530            # XXX: this doesn't seem to be having an effect:
1531            dc.DestroyClippingRegion()
1532    
1533            w, h = self.GetClientSize()
1534    
1535            self.previewer.Draw(dc,
1536                                wxRect(0, 0, w, h),
1537                                self.GetProperties(),
1538                                self.GetShapeType())
1539    
1540    
1541        def GetProperties(self):
1542            return self.props
1543    
1544        def SetProperties(self, props):
1545            self.props = props
1546            self.Refresh()
1547    
1548        def GetShapeType(self):
1549            return self.shapeType
1550    
1551        def SetShapeType(self, shapeType):
1552            self.shapeType = shapeType
1553            self.Refresh()
1554    
1555        def AllowEdit(self, allow):
1556            """Allow/Disallow double-clicking on the control."""
1557            self.allowEdit = allow
1558    
1559        def DoEdit(self):
1560            """Open the properties selector dialog."""
1561    
1562            if not self.allowEdit: return
1563    
1564            propDlg = SelectPropertiesDialog(self.parent,
1565                                             self.GetProperties(),
1566                                             self.GetShapeType())
1567    
1568            if propDlg.ShowModal() == wxID_OK:
1569                new_prop = propDlg.GetClassGroupProperties()
1570                self.SetProperties(new_prop)
1571                self.Refresh()
1572    
1573            propDlg.Destroy()
1574    
1575        def _OnLeftDClick(self, event):
1576            self.DoEdit()
1577    
1578    from Thuban.UI.mainwindow import layer_properties_dialogs
1579    layer_properties_dialogs.add(Layer, Classifier)
1580    layer_properties_dialogs.add(RasterLayer, Classifier)
Legend:
Removed from v.549  
changed lines
  Added in v.2386
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26