/[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 2366 by joey, Fri Oct 1 18:24:10 2004 UTC revision 2556 by bernhard, Mon Feb 7 13:46:53 2005 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 29  from Thuban.Model.classification import Line 35  from Thuban.Model.classification import
35    
36  from Thuban.Model.color import Transparent  from Thuban.Model.color import Transparent
37    
38  from Thuban.Model.layer import Layer, RasterLayer  from Thuban.Model.layer import Layer
39  from Thuban.Model.data import SHAPETYPE_ARC, SHAPETYPE_POLYGON, SHAPETYPE_POINT  from Thuban.Model.data import SHAPETYPE_ARC, SHAPETYPE_POLYGON, SHAPETYPE_POINT
40    
41  from Thuban.UI.classgen import ClassGenDialog  from Thuban.UI.classgen import ClassGenDialog
42  from Thuban.UI.colordialog import ColorDialog  from Thuban.UI.colordialog import ColorDialog
43    
44  from dialogs import NonModalNonParentDialog  from Thuban.UI.layerproperties import LayerProperties
45  from messages import MAP_REPLACED  from messages import MAP_REPLACED
46    
47  ID_CLASS_TABLE = 40011  ID_CLASS_TABLE = 40011
# Line 155  class ClassGrid(wxGrid): Line 161  class ClassGrid(wxGrid):
161              group = self.GetTable().GetClassGroup(sel[0])              group = self.GetTable().GetClassGroup(sel[0])
162              if isinstance(group, ClassGroupDefault):              if isinstance(group, ClassGroupDefault):
163                  wxMessageDialog(self,                  wxMessageDialog(self,
164                                  "The Default group cannot be removed.",                                  _("The Default group cannot be removed."),
165                                  style = wxOK | wxICON_EXCLAMATION).ShowModal()                                  style = wxOK | wxICON_EXCLAMATION).ShowModal()
166                  return                  return
167                    
# Line 331  class ClassTable(wxPyGridTableBase): Line 337  class ClassTable(wxPyGridTableBase):
337    
338          row = -1          row = -1
339          self.clazz = clazz          self.clazz = clazz
340    
341          self.__NotifyRowChanges(old_len, self.GetNumberRows())          self.__NotifyRowChanges(old_len, self.GetNumberRows())
342    
343          #          #
# Line 439  class ClassTable(wxPyGridTableBase): Line 445  class ClassTable(wxPyGridTableBase):
445          """          """
446    
447          self.SetValueAsCustom(row, col, None, value)          self.SetValueAsCustom(row, col, None, value)
448          
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    
# Line 678  EB_LAYER_TITLE = 0 Line 684  EB_LAYER_TITLE = 0
684  EB_SELECT_FIELD = 1  EB_SELECT_FIELD = 1
685  EB_GEN_CLASS = 2  EB_GEN_CLASS = 2
686    
687  class Classifier(NonModalNonParentDialog):  class Classifier(LayerProperties):
688    
689      type2string = {None:             _("None"),      type2string = {None:             _("None"),
690                     FIELDTYPE_STRING: _("Text"),                     FIELDTYPE_STRING: _("Text"),
# Line 691  class Classifier(NonModalNonParentDialog Line 697  class Classifier(NonModalNonParentDialog
697          group in the classification table.          group in the classification table.
698          """          """
699    
700          NonModalNonParentDialog.__init__(self, parent, name, "")          LayerProperties.__init__(self, parent, name, layer)
701    
         self.__SetTitle(layer.Title())  
   
         self.parent.Subscribe(MAP_REPLACED, self.map_replaced)  
         self.layer = layer  
         self.map = parent.Map()  
   
         self.map.Subscribe(MAP_LAYERS_REMOVED, self.map_layers_removed)  
702          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
703                               self.layer_shapestore_replaced)                               self.layer_shapestore_replaced)
704    
705          self.genDlg = None          self.genDlg = None
706            self.group = group
707    
708          ############################          LayerProperties.dialog_layout(self)
709          # Create the controls  
710          #      def dialog_layout(self, panel, panelBox):
711    
712          panel = wxPanel(self, -1)          if self.layer.HasClassification():
713    
714          text_title = wxTextCtrl(panel, ID_PROPERTY_TITLE, layer.Title())              self.fieldTypeText = wxStaticText(panel, -1, "")
         self.fieldTypeText = wxStaticText(panel, -1, "")  
715    
         if layer.HasClassification():  
716              self.originalClass = self.layer.GetClassification()              self.originalClass = self.layer.GetClassification()
717              self.originalClassField = self.layer.GetClassificationColumn()              self.originalClassField = self.layer.GetClassificationColumn()
718              field = self.originalClassField              field = self.originalClassField
719              fieldType = self.layer.GetFieldType(field)              fieldType = self.layer.GetFieldType(field)
720    
721              table = layer.ShapeStore().Table()              table = self.layer.ShapeStore().Table()
722              #              #
723              # make field choice box              # make field choice box
724              #              #
# Line 767  class Classifier(NonModalNonParentDialog Line 765  class Classifier(NonModalNonParentDialog
765              # calling __SelectField after creating the classGrid fills in the              # calling __SelectField after creating the classGrid fills in the
766              # grid with the correct information              # grid with the correct information
767              self.fields.SetSelection(self.__cur_field)              self.fields.SetSelection(self.__cur_field)
768              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: ")),  
             0, wxALIGN_LEFT | wxALL | wxALIGN_CENTER_VERTICAL, 4)  
         sizer.Add(text_title, 1, wxGROW, 0)  
769    
         panelBox.Add(sizer, 0, wxGROW, 4)  
   
         if isinstance(layer, RasterLayer):  
             type = "Image"  
         else:  
             type = layer.ShapeType()  
   
         panelBox.Add(wxStaticText(panel, -1, _("Type: %s") % type),  
             0, wxALIGN_LEFT | wxALL, 4)  
   
         if layer.HasClassification():  
770    
771              classBox = wxStaticBoxSizer(              classBox = wxStaticBoxSizer(
772                          wxStaticBox(panel, -1, _("Classification")), wxVERTICAL)                          wxStaticBox(panel, -1, _("Classification")), wxVERTICAL)
# Line 832  class Classifier(NonModalNonParentDialog Line 801  class Classifier(NonModalNonParentDialog
801              panelBox.Add(classBox, 1, wxGROW, 0)              panelBox.Add(classBox, 1, wxGROW, 0)
802    
803    
         buttonBox = wxBoxSizer(wxHORIZONTAL)  
         buttonBox.Add(button_try, 0, wxRIGHT|wxEXPAND, 10)  
         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)  
         panel.SetSizer(panelBox)  
         panelBox.Fit(panel)  
         panelBox.SetSizeHints(panel)  
   
         topBox.Add(panel, 1, wxGROW | wxALL, 4)  
         topBox.Add(buttonBox, 0, wxALIGN_RIGHT|wxBOTTOM|wxTOP, 10)  
   
         self.SetAutoLayout(True)  
         self.SetSizer(topBox)  
         topBox.Fit(self)  
         topBox.SetSizeHints(self)  
         self.Layout()  
   
         ###########  
   
804          EVT_CHOICE(self, ID_PROPERTY_SELECT, self._OnFieldSelect)          EVT_CHOICE(self, ID_PROPERTY_SELECT, self._OnFieldSelect)
         EVT_TEXT(self, ID_PROPERTY_TITLE, self._OnTitleChanged)  
         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)  
   
805          EVT_BUTTON(self, ID_PROPERTY_ADD, self._OnAdd)          EVT_BUTTON(self, ID_PROPERTY_ADD, self._OnAdd)
806          EVT_BUTTON(self, ID_PROPERTY_EDITSYM, self._OnEditSymbol)          EVT_BUTTON(self, ID_PROPERTY_EDITSYM, self._OnEditSymbol)
807          EVT_BUTTON(self, ID_PROPERTY_REMOVE, self._OnRemove)          EVT_BUTTON(self, ID_PROPERTY_REMOVE, self._OnRemove)
# Line 868  class Classifier(NonModalNonParentDialog Line 809  class Classifier(NonModalNonParentDialog
809          EVT_BUTTON(self, ID_PROPERTY_MOVEUP, self._OnMoveUp)          EVT_BUTTON(self, ID_PROPERTY_MOVEUP, self._OnMoveUp)
810          EVT_BUTTON(self, ID_PROPERTY_MOVEDOWN, self._OnMoveDown)          EVT_BUTTON(self, ID_PROPERTY_MOVEDOWN, self._OnMoveDown)
811    
         ######################  
   
         text_title.SetFocus()  
         self.haveApplied = False  
   
812      def unsubscribe_messages(self):      def unsubscribe_messages(self):
813          """Unsubscribe from all messages."""          """Unsubscribe from all messages."""
814          self.parent.Unsubscribe(MAP_REPLACED, self.map_replaced)          LayerProperties.unsubscribe_messages(self)
         self.map.Unsubscribe(MAP_LAYERS_REMOVED, self.map_layers_removed)  
815          self.layer.Unsubscribe(LAYER_SHAPESTORE_REPLACED,          self.layer.Unsubscribe(LAYER_SHAPESTORE_REPLACED,
816                                 self.layer_shapestore_replaced)                                 self.layer_shapestore_replaced)
817    
     def map_layers_removed(self, map):  
         """Subscribed to MAP_LAYERS_REMOVED. If this layer was removed,  
         Close self.  
         """  
         if self.layer not in self.map.Layers():  
             self.Close()  
   
818      def layer_shapestore_replaced(self, *args):      def layer_shapestore_replaced(self, *args):
819          """Subscribed to the map's LAYER_SHAPESTORE_REPLACED message.          """Subscribed to the map's LAYER_SHAPESTORE_REPLACED message.
   
820          Close self.          Close self.
821          """          """
822          self.Close()          self.Close()
823    
     def map_replaced(self, *args):  
         """Subscribed to the mainwindow's MAP_REPLACED message. Close self."""  
         self.Close()  
   
824      def EditSymbol(self, row):      def EditSymbol(self, row):
825          """Open up a dialog where the user can select the properties          """Open up a dialog where the user can select the properties
826          for a group.          for a group.
# Line 915  class Classifier(NonModalNonParentDialog Line 838  class Classifier(NonModalNonParentDialog
838              table.SetValueAsCustom(row, COL_SYMBOL, None, new_prop)              table.SetValueAsCustom(row, COL_SYMBOL, None, new_prop)
839          self.Enable(True)          self.Enable(True)
840          propDlg.Destroy()          propDlg.Destroy()
841            
842      def _SetClassification(self, clazz):      def _SetClassification(self, clazz):
843          """Called from the ClassGen dialog when a new classification has          """Called from the ClassGen dialog when a new classification has
844          been created and should be set in the table.          been created and should be set in the table.
845          """          """
846          # FIXME: This could be implemented using a message          # FIXME: This could be implemented using a message
847            
848          self.fields.SetClientData(self.__cur_field, clazz)          self.fields.SetClientData(self.__cur_field, clazz)
849          self.classGrid.GetTable().SetClassification(clazz)          self.classGrid.GetTable().SetClassification(clazz)
850    
# Line 1019  class Classifier(NonModalNonParentDialog Line 942  class Classifier(NonModalNonParentDialog
942          self.__SelectField(index, self.__cur_field)          self.__SelectField(index, self.__cur_field)
943          self.__cur_field = index          self.__cur_field = index
944    
945      def _OnTry(self, event):      def OnTry(self, event):
946          """Put the data from the table into a new Classification and hand          """Put the data from the table into a new Classification and hand
947             it to the layer.             it to the layer.
948          """          """
# Line 1039  class Classifier(NonModalNonParentDialog Line 962  class Classifier(NonModalNonParentDialog
962    
963          self.haveApplied = True          self.haveApplied = True
964    
965      def _OnOK(self, event):      def OnOK(self, event):
966          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.  
         """  
   
967          self.Close()          self.Close()
968    
969      def _OnRevert(self, event):      def OnRevert(self, event):
970          """The layer's current classification stays the same."""          """The layer's current classification stays the same."""
971          if self.haveApplied:          if self.haveApplied and self.layer.HasClassification():
972              self.layer.SetClassificationColumn(self.originalClassField)              self.layer.SetClassificationColumn(self.originalClassField)
973              self.layer.SetClassification(self.originalClass)              self.layer.SetClassification(self.originalClass)
974    
# Line 1170  class Classifier(NonModalNonParentDialog Line 1081  class Classifier(NonModalNonParentDialog
1081              if win:              if win:
1082                  win.Enable(enable)                  win.Enable(enable)
1083    
1084  ID_SELPROP_SPINCTRL = 4002  ID_SELPROP_SPINCTRL_LINEWIDTH = 4002
1085  ID_SELPROP_PREVIEW = 4003  ID_SELPROP_PREVIEW = 4003
1086  ID_SELPROP_STROKECLR = 4004  ID_SELPROP_STROKECLR = 4004
1087  ID_SELPROP_FILLCLR = 4005  ID_SELPROP_FILLCLR = 4005
1088  ID_SELPROP_STROKECLRTRANS = 4006  ID_SELPROP_STROKECLRTRANS = 4006
1089  ID_SELPROP_FILLCLRTRANS = 4007  ID_SELPROP_FILLCLRTRANS = 4007
1090    ID_SELPROP_SPINCTRL_SIZE = 4008
1091    
1092  class SelectPropertiesDialog(wxDialog):  class SelectPropertiesDialog(wxDialog):
1093      """Dialog that allows the user to select group properties."""      """Dialog that allows the user to select group properties."""
# Line 1239  class SelectPropertiesDialog(wxDialog): Line 1151  class SelectPropertiesDialog(wxDialog):
1151              ctrlBox.Add(fillColorBox, 0,              ctrlBox.Add(fillColorBox, 0,
1152                          wxALIGN_CENTER_HORIZONTAL | wxALL | wxGROW, 4)                          wxALIGN_CENTER_HORIZONTAL | wxALL | wxGROW, 4)
1153    
1154            # Line width selection
1155          spinBox = wxBoxSizer(wxHORIZONTAL)          spinBox = wxBoxSizer(wxHORIZONTAL)
1156          spinBox.Add(wxStaticText(self, -1, _("Line Width: ")),          spinBox.Add(wxStaticText(self, -1, _("Line Width: ")),
1157                  0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 4)                  0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 4)
1158          self.spinCtrl = wxSpinCtrl(self, ID_SELPROP_SPINCTRL,          self.spinCtrl_linewidth = wxSpinCtrl(self,
1159                                     min=1, max=10,                                               ID_SELPROP_SPINCTRL_LINEWIDTH,
1160                                     value=str(prop.GetLineWidth()),                                               min=1, max=10,
1161                                     initial=prop.GetLineWidth())                                               value=str(prop.GetLineWidth()),
1162                                                 initial=prop.GetLineWidth())
         EVT_SPINCTRL(self, ID_SELPROP_SPINCTRL, self._OnSpin)  
1163    
1164          spinBox.Add(self.spinCtrl, 0, wxALIGN_LEFT | wxALL, 4)          EVT_SPINCTRL(self, ID_SELPROP_SPINCTRL_LINEWIDTH,
1165                         self._OnSpinLineWidth)
1166    
1167            spinBox.Add(self.spinCtrl_linewidth, 0, wxALIGN_LEFT | wxALL, 4)
1168          ctrlBox.Add(spinBox, 0, wxALIGN_RIGHT | wxALL, 0)          ctrlBox.Add(spinBox, 0, wxALIGN_RIGHT | wxALL, 0)
1169    
1170            # Size selection
1171            if shapeType == SHAPETYPE_POINT:
1172                spinBox = wxBoxSizer(wxHORIZONTAL)
1173                spinBox.Add(wxStaticText(self, -1, _("Size: ")),
1174                            0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 4)
1175                self.spinCtrl_size = wxSpinCtrl(self, ID_SELPROP_SPINCTRL_SIZE,
1176                                                min=1, max=100,
1177                                                value=str(prop.GetSize()),
1178                                                initial=prop.GetSize())
1179    
1180                EVT_SPINCTRL(self, ID_SELPROP_SPINCTRL_SIZE, self._OnSpinSize)
1181    
1182                spinBox.Add(self.spinCtrl_size, 0, wxALIGN_LEFT | wxALL, 4)
1183                ctrlBox.Add(spinBox, 0, wxALIGN_RIGHT | wxALL, 0)
1184    
1185    
1186          itemBox.Add(ctrlBox, 0, wxALIGN_RIGHT | wxALL | wxGROW, 0)          itemBox.Add(ctrlBox, 0, wxALIGN_RIGHT | wxALL | wxGROW, 0)
1187          topBox.Add(itemBox, 1, wxALIGN_LEFT | wxALL | wxGROW, 0)          topBox.Add(itemBox, 1, wxALIGN_LEFT | wxALL | wxGROW, 0)
1188    
# Line 1266  class SelectPropertiesDialog(wxDialog): Line 1197  class SelectPropertiesDialog(wxDialog):
1197          topBox.Add(buttonBox, 0, wxALIGN_RIGHT|wxBOTTOM|wxTOP, 10)          topBox.Add(buttonBox, 0, wxALIGN_RIGHT|wxBOTTOM|wxTOP, 10)
1198    
1199          button_ok.SetDefault()          button_ok.SetDefault()
1200                                                                                    
1201          #EVT_BUTTON(self, wxID_OK, self._OnOK)          #EVT_BUTTON(self, wxID_OK, self._OnOK)
1202          #EVT_BUTTON(self, ID_SELPROP_CANCEL, self._OnCancel)          #EVT_BUTTON(self, ID_SELPROP_CANCEL, self._OnCancel)
1203                                                                                    
1204          self.SetAutoLayout(True)          self.SetAutoLayout(True)
1205          self.SetSizer(topBox)          self.SetSizer(topBox)
1206          topBox.Fit(self)          topBox.Fit(self)
# Line 1281  class SelectPropertiesDialog(wxDialog): Line 1212  class SelectPropertiesDialog(wxDialog):
1212      def OnCancel(self, event):      def OnCancel(self, event):
1213          self.EndModal(wxID_CANCEL)          self.EndModal(wxID_CANCEL)
1214    
1215      def _OnSpin(self, event):      def _OnSpinLineWidth(self, event):
1216          self.prop.SetLineWidth(self.spinCtrl.GetValue())          self.prop.SetLineWidth(self.spinCtrl_linewidth.GetValue())
1217            self.previewWin.Refresh()
1218    
1219        def _OnSpinSize(self, event):
1220            self.prop.SetSize(self.spinCtrl_size.GetValue())
1221          self.previewWin.Refresh()          self.previewWin.Refresh()
1222    
1223      def __GetColor(self, cur):      def __GetColor(self, cur):
# Line 1296  class SelectPropertiesDialog(wxDialog): Line 1231  class SelectPropertiesDialog(wxDialog):
1231          dialog.Destroy()          dialog.Destroy()
1232    
1233          return ret          return ret
1234            
1235      def _OnChangeLineColor(self, event):      def _OnChangeLineColor(self, event):
1236          clr = self.__GetColor(self.prop.GetLineColor())          clr = self.__GetColor(self.prop.GetLineColor())
1237          if clr is not None:          if clr is not None:
# Line 1306  class SelectPropertiesDialog(wxDialog): Line 1241  class SelectPropertiesDialog(wxDialog):
1241      def _OnChangeLineColorTrans(self, event):      def _OnChangeLineColorTrans(self, event):
1242          self.prop.SetLineColor(Transparent)          self.prop.SetLineColor(Transparent)
1243          self.previewWin.Refresh() # XXX: work around, see ClassDataPreviewer          self.previewWin.Refresh() # XXX: work around, see ClassDataPreviewer
1244            
1245      def _OnChangeFillColor(self, event):      def _OnChangeFillColor(self, event):
1246          clr = self.__GetColor(self.prop.GetFill())          clr = self.__GetColor(self.prop.GetFill())
1247          if clr is not None:          if clr is not None:
# Line 1360  class ClassDataPreviewer: Line 1295  class ClassDataPreviewer:
1295      """Class that actually draws a group property preview."""      """Class that actually draws a group property preview."""
1296    
1297      def Draw(self, dc, rect, prop, shapeType):      def Draw(self, dc, rect, prop, shapeType):
1298            """Draw the property.
1299    
1300            returns: (w, h) as adapted extend if the drawing size
1301            exceeded the given rect. This can only be the case
1302            for point symbols. If the symbol fits the given rect,
1303            None is returned.
1304            """
1305    
1306          assert dc is not None          assert dc is not None
1307          assert isinstance(prop, ClassGroupProperties)          assert isinstance(prop, ClassGroupProperties)
# Line 1399  class ClassDataPreviewer: Line 1341  class ClassDataPreviewer:
1341    
1342          elif shapeType == SHAPETYPE_POINT:          elif shapeType == SHAPETYPE_POINT:
1343    
1344              dc.DrawCircle(x + w/2, y + h/2,              dc.DrawCircle(x + w/2, y + h/2, prop.GetSize())
1345                            (min(w, h) - prop.GetLineWidth())/2)              circle_size =  prop.GetSize() * 2 + prop.GetLineWidth() * 2
1346                new_h = h
1347                new_w = w
1348                if h < circle_size: new_h = circle_size
1349                if w < circle_size: new_w = circle_size
1350                if new_h > h or new_w > w:
1351                    return (new_w, new_h)
1352    
1353          elif shapeType == SHAPETYPE_POLYGON:          elif shapeType == SHAPETYPE_POLYGON:
1354              dc.DrawRectangle(x, y, w, h)              dc.DrawRectangle(x, y, w, h)
1355    
1356            return None
1357    
1358  class ClassRenderer(wxPyGridCellRenderer):  class ClassRenderer(wxPyGridCellRenderer):
1359      """A wrapper class that can be used to draw group properties in a      """A wrapper class that can be used to draw group properties in a
1360      grid table.      grid table.
# Line 1426  class ClassRenderer(wxPyGridCellRenderer Line 1376  class ClassRenderer(wxPyGridCellRenderer
1376                           rect.GetWidth(), rect.GetHeight())                           rect.GetWidth(), rect.GetHeight())
1377    
1378          if not isinstance(data, ClassGroupMap):          if not isinstance(data, ClassGroupMap):
1379              self.previewer.Draw(dc, rect, data.GetProperties(), self.shapeType)              new_size = self.previewer.Draw(dc, rect, data.GetProperties(),
1380                                               self.shapeType)
1381                if new_size is not None:
1382                    (new_w, new_h) = new_size
1383                    grid.SetRowSize(row, new_h)
1384                    grid.SetColSize(col, new_h)
1385                    grid.ForceRefresh()
1386    
1387                    # now that we know the height, redraw everything
1388                    rect.SetHeight(new_h)
1389                    rect.SetWidth(new_w)
1390                    dc.DestroyClippingRegion()
1391                    dc.SetClippingRegion(rect.GetX(), rect.GetY(),
1392                                         rect.GetWidth(), rect.GetHeight())
1393                    dc.SetPen(wxPen(wxLIGHT_GREY))
1394                    dc.SetBrush(wxBrush(wxLIGHT_GREY, wxSOLID))
1395                    dc.DrawRectangle(rect.GetX(), rect.GetY(),
1396                                     rect.GetWidth(), rect.GetHeight())
1397                    self.previewer.Draw(dc, rect, data.GetProperties(),
1398                                        self.shapeType)
1399    
1400          if isSelected:          if isSelected:
1401              dc.SetPen(wxPen(wxBLACK, 1, wxSOLID))              dc.SetPen(wxPen(wxBLACK, 1, wxSOLID))
# Line 1511  class ClassGroupPropertiesCtrl(wxWindow, Line 1480  class ClassGroupPropertiesCtrl(wxWindow,
1480      def _OnLeftDClick(self, event):      def _OnLeftDClick(self, event):
1481          self.DoEdit()          self.DoEdit()
1482    
 from Thuban.UI.mainwindow import layer_properties_dialogs  
 layer_properties_dialogs.add(Layer, Classifier)  
 layer_properties_dialogs.add(RasterLayer, Classifier)  
Legend:
Removed from v.2366  
changed lines
  Added in v.2556
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26