/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/UI/legend.py
ViewVC logotype

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

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

revision 542 by jonathan, Thu Mar 20 09:43:16 2003 UTC revision 990 by frank, Thu May 22 16:51:24 2003 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001, 2002, 2003 by Intevation GmbH  # Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2  # Authors:  # Authors:
3  # Jonathan Coles <[email protected]>  # Jonathan Coles <[email protected]>
4    # Frank Koormann <[email protected]>
5  #  #
6  # This program is free software under the GPL (>=v2)  # This program is free software under the GPL (>=v2)
7  # Read the file COPYING coming with Thuban for details.  # Read the file COPYING coming with Thuban for details.
# Line 9  __version__ = "$Revision$" Line 10  __version__ = "$Revision$"
10    
11  from Thuban import _  from Thuban import _
12    
13    import resource
14    
15  from wxPython.wx import *  from wxPython.wx import *
 from dialogs import NonModalDialog  
16    
17  from Thuban.Model.layer import Layer  from Thuban.Model.layer import BaseLayer
18  from Thuban.Model.map import Map  from Thuban.Model.map import Map
19    from Thuban.Model.classification import ClassGroup
20    
21  from Thuban.Model.messages import *  from Thuban.Model.messages import \
22        MAP_STACKING_CHANGED, MAP_LAYERS_ADDED, MAP_LAYERS_REMOVED, LAYER_CHANGED,\
23        LAYER_VISIBILITY_CHANGED, TITLE_CHANGED
24    
25  from Thuban.Model.classification import ClassGroup  from Thuban.UI.messages import SCALE_CHANGED
26    
27  from Thuban.UI.classifier import ClassDataPreviewer  from Thuban.UI.classifier import ClassDataPreviewer
28    from Thuban.UI.dock import DockPanel
29    from Thuban.UI.scalebar import ScaleBar
30    
31  ID_LEGEND_MOVEUP = 4001  from Thuban.Lib.connector import ConnectorError
32  ID_LEGEND_MOVEDOWN = 4002  
33  ID_LEGEND_TREE = 4003  ID_LEGEND_TOP = 4001
34  ID_LEGEND_CLASSIFY = 4004  ID_LEGEND_RAISE = 4002
35  ID_LEGEND_SHOWLAYER = 4005  ID_LEGEND_LOWER = 4003
36  ID_LEGEND_HIDELAYER = 4006  ID_LEGEND_BOTTOM = 4004
37    ID_LEGEND_TREE = 4005
38    ID_LEGEND_PROPS = 4006
39    ID_LEGEND_SHOWLAYER = 4007
40    ID_LEGEND_HIDELAYER = 4008
41    
42  BMP_SIZE_W = 30  BMP_SIZE_W = 30
43  BMP_SIZE_H = 15  BMP_SIZE_H = 15
44    
45  class Legend(NonModalDialog):  TOP_BMP = "top_layer"
46    RAISE_BMP = "raise_layer"
47    LOWER_BMP = "lower_layer"
48    BOTTOM_BMP = "bottom_layer"
49    SHOW_BMP  = "show_layer"
50    HIDE_BMP  = "hide_layer"
51    PROPS_BMP = "layer_properties"
52    
     def __init__(self, parent, name, map):  
         NonModalDialog.__init__(self, parent, name,  
                                 _("Legend: %s") % map.Title())  
53    
54          self.parent = parent  class LegendPanel(DockPanel):
55    
56        def __init__(self, parent, map, mainWindow):
57            DockPanel.__init__(self, parent, -1)
58    
59          panel = wxPanel(self, -1)          self.mainWindow = mainWindow
60            self.parent = parent
61    
62            self.buttons = []
63    
         topBox = wxBoxSizer(wxVERTICAL)  
64          panelBox = wxBoxSizer(wxVERTICAL)          panelBox = wxBoxSizer(wxVERTICAL)
65    
66          buttonBox = wxGridSizer(2, 3, 0, 0)          self.toolBar = wxToolBar(self, -1)
67            self.toolBar.SetToolBitmapSize(wxSize(24, 24))
68    
69          self.buttons = []          bmp = resource.GetBitmapResource(TOP_BMP, wxBITMAP_TYPE_XPM)
70            self.toolBar.AddTool(ID_LEGEND_TOP, bmp,
71                shortHelpString=_("Top Layer"))
72    
73            bmp = resource.GetBitmapResource(RAISE_BMP, wxBITMAP_TYPE_XPM)
74            self.toolBar.AddTool(ID_LEGEND_RAISE, bmp,
75                shortHelpString=_("Raise Layer"))
76    
77            bmp = resource.GetBitmapResource(LOWER_BMP, wxBITMAP_TYPE_XPM)
78            self.toolBar.AddTool(ID_LEGEND_LOWER, bmp,
79                shortHelpString=_("Lower Layer"))
80    
81            bmp = resource.GetBitmapResource(BOTTOM_BMP, wxBITMAP_TYPE_XPM)
82            self.toolBar.AddTool(ID_LEGEND_BOTTOM, bmp,
83                shortHelpString=_("Bottom Layer"))
84    
85            bmp = resource.GetBitmapResource(SHOW_BMP, wxBITMAP_TYPE_XPM)
86            self.toolBar.AddTool(ID_LEGEND_SHOWLAYER, bmp,
87                shortHelpString=_("Show Layer"))
88    
89            bmp = resource.GetBitmapResource(HIDE_BMP, wxBITMAP_TYPE_XPM)
90            self.toolBar.AddTool(ID_LEGEND_HIDELAYER, bmp,
91                shortHelpString=_("Hide Layer"))
92    
93            bmp = resource.GetBitmapResource(PROPS_BMP, wxBITMAP_TYPE_XPM)
94            self.toolBar.AddTool(ID_LEGEND_PROPS, bmp,
95                shortHelpString=_("Edit Layer Properties"))
96    
97            self.toolBar.Realize()
98            panelBox.Add(self.toolBar, 0, wxGROW, 0)
99    
100            EVT_TOOL(self, ID_LEGEND_TOP, self._OnMoveTop)
101            EVT_TOOL(self, ID_LEGEND_RAISE, self._OnMoveUp)
102            EVT_TOOL(self, ID_LEGEND_LOWER, self._OnMoveDown)
103            EVT_TOOL(self, ID_LEGEND_BOTTOM, self._OnMoveBottom)
104            EVT_TOOL(self, ID_LEGEND_PROPS, self._OnProperties)
105            EVT_TOOL(self, ID_LEGEND_SHOWLAYER, self._OnShowLayer)
106            EVT_TOOL(self, ID_LEGEND_HIDELAYER, self._OnHideLayer)
107    
108            self.tree = LegendTree(self, ID_LEGEND_TREE, map, mainWindow)
109    
110          button = wxButton(self, ID_LEGEND_MOVEUP, _("Move Up"))          panelBox.Add(self.tree, 1, wxGROW, 0)
         buttonBox.Add(button, 0, wxGROW | wxLEFT | wxRIGHT, 0)  
         self.buttons.append(button)  
111    
112          button = wxButton(self, ID_LEGEND_SHOWLAYER, _("Show Layer"))          self.scalebarbitmap = ScaleBarBitmap(self, map, mainWindow)
113          buttonBox.Add(button, 0, wxGROW | wxLEFT | wxRIGHT, 0)          panelBox.Add(self.scalebarbitmap, 0, wxGROW, 0)
         self.buttons.append(button)  
114    
115          button = wxButton(self, ID_LEGEND_CLASSIFY, _("Classify"))          self.SetAutoLayout(True)
116          buttonBox.Add(button, 0, wxGROW | wxLEFT | wxRIGHT, 0)          self.SetSizer(panelBox)
117          self.buttons.append(button)          panelBox.SetSizeHints(self)
118    
         button = wxButton(self, ID_LEGEND_MOVEDOWN, _("Move Down"))  
         buttonBox.Add(button, 0, wxGROW | wxLEFT | wxRIGHT, 0)  
         self.buttons.append(button)  
119    
120          button = wxButton(self, ID_LEGEND_HIDELAYER, _("Hide Layer"))          self.panelBox = panelBox
         buttonBox.Add(button, 0, wxGROW | wxLEFT | wxRIGHT, 0)  
         self.buttons.append(button)  
121    
122            self.__EnableButtons(False)
123    
124          EVT_BUTTON(self, ID_LEGEND_MOVEUP, self._OnMoveUp)          self.Create()
         EVT_BUTTON(self, ID_LEGEND_MOVEDOWN, self._OnMoveDown)  
         EVT_BUTTON(self, ID_LEGEND_CLASSIFY, self._OnClassify)  
         EVT_BUTTON(self, ID_LEGEND_SHOWLAYER, self._OnShowLayer)  
         EVT_BUTTON(self, ID_LEGEND_HIDELAYER, self._OnHideLayer)  
125    
126          panelBox.Add(buttonBox, 0, 0, 4)          EVT_CLOSE(self, self._OnClose)
127    
         self.tree = LegendTree(self, ID_LEGEND_TREE, map)  
128    
129          panelBox.Add(self.tree, 1, wxGROW, 4)      def GetMap(self):
130            return self.tree.GetMap()
131    
132          panel.SetAutoLayout(True)      def SetMap(self, map):
133          panel.SetSizer(panelBox)          self.tree.SetMap(map)
134          panelBox.SetSizeHints(panel)          self.scalebarbitmap.SetCanvas(self.mainWindow.canvas)
135    
136          topBox.Add(panel, 1, wxGROW, 0)      def DoOnSelChanged(self, layer, group):
         panelBox.SetSizeHints(self)  
137    
138          self.SetAutoLayout(True)          ok = isinstance(layer, BaseLayer)
139          self.SetSizer(topBox)          self.__EnableButtons(ok)
140    
141            self.mainWindow.SelectLayer(layer)
142    
143        def DoOnProperties(self):
144            list = self.tree.GetSelectedHierarchy()
145    
146      def DoOnSelChanged(self):          ok = isinstance(list[0], BaseLayer)
147          self.__EnableButtons(self.tree.GetSelection().IsOk())          if ok:
148                self.mainWindow.OpenLayerProperties(list[0], list[1])
149    
150      def _OnClassify(self, event):      def Destroy(self):
151          self.tree.DoOnClassify()          self.__Close()
152    
153        def _OnProperties(self, event):
154            self.DoOnProperties()
155    
156        def _OnMoveTop(self, event):
157            self.tree.MoveCurrentItemTop()
158            
159      def _OnMoveUp(self, event):      def _OnMoveUp(self, event):
160          self.tree.MoveCurrentItemUp()          self.tree.MoveCurrentItemUp()
161    
162      def _OnMoveDown(self, event):      def _OnMoveDown(self, event):
163          self.tree.MoveCurrentItemDown()          self.tree.MoveCurrentItemDown()
164    
165        def _OnMoveBottom(self, event):
166            self.tree.MoveCurrentItemBottom()
167    
168      def _OnShowLayer(self, event):      def _OnShowLayer(self, event):
169          self.tree.DoOnShowLayer()          self.tree.DoOnShowLayer()
170          pass          pass
171    
172        #def Close(self, force = False):
173            #DockPanel.Close(self, force)
174            
175        def _OnClose(self, event):
176            self.__Close()
177    
178      def _OnHideLayer(self, event):      def _OnHideLayer(self, event):
179          self.tree.DoOnHideLayer()          self.tree.DoOnHideLayer()
180          pass          pass
181    
   
182      def __EnableButtons(self, on):      def __EnableButtons(self, on):
183          for b in self.buttons:          self.toolBar.EnableTool(ID_LEGEND_TOP, on)
184              b.Enable(on)          self.toolBar.EnableTool(ID_LEGEND_RAISE, on)
185            self.toolBar.EnableTool(ID_LEGEND_LOWER, on)
186            self.toolBar.EnableTool(ID_LEGEND_BOTTOM, on)
187            self.toolBar.EnableTool(ID_LEGEND_SHOWLAYER,  on)
188            self.toolBar.EnableTool(ID_LEGEND_HIDELAYER,  on)
189            self.toolBar.EnableTool(ID_LEGEND_PROPS, on)
190    
191        def __Close(self):
192            self.tree.Close()
193    
194  class LegendTree(wxTreeCtrl):  class LegendTree(wxTreeCtrl):
195    
196      def __init__(self, parent, id, map):      def __init__(self, parent, id, map, mainWindow):
197          wxTreeCtrl.__init__(self, parent, id,          wxTreeCtrl.__init__(self, parent, id,
198                              style = wxTR_DEFAULT_STYLE | wxTR_HIDE_ROOT,                              style = wxTR_DEFAULT_STYLE | wxTR_HIDE_ROOT,
199                              size = (200, 200))                              size = (200, 200))
200    
201            self.mainWindow = mainWindow
202            self.map = None
203          self.parent = parent          self.parent = parent
204          self.map = map          self.layer2id = {}
         self.layer2id = None  
   
205    
206          self.image_list = None          self.image_list = None
207          self.emptyImageIndex = 0          self.emptyImageIndex = 0
208    
209          self.previewer = ClassDataPreviewer()          self.previewer = ClassDataPreviewer()
210    
   
211          EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)          EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)
212          EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)          EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)
213    
214          map.Subscribe(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged)          EVT_CLOSE(self, self._OnClose)
         map.Subscribe(MAP_LAYERS_CHANGED, self._OnMsgMapLayersChanged)  
215    
216          self.__FillTree(map)          self.SetMap(map)
217    
218      def MoveCurrentItemUp(self):      def _OnClose(self, event):
219          cur_id = self.GetSelection()          self.SetMap(None)
         assert(cur_id.IsOk())  
220    
221          cur_data = self.GetPyData(cur_id)      def GetMap(self):
222            return self.map
223    
224        def SetMap(self, map):
225    
226            sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),
227                        (MAP_LAYERS_ADDED, self._OnMsgMapLayersAddedRemoved),
228                        (MAP_LAYERS_REMOVED, self._OnMsgMapLayersAddedRemoved)]
229    
230            if self.map is not None:
231                for msg, func in sub_list: self.map.Unsubscribe(msg, func)
232                #self.mainWindow.application.Unsubscribe(SESSION_REPLACED,
233                    #self._OnMsgMapsChanged)
234                #try:
235                    #self.mainWindow.application.session.Unsubscribe(MAPS_CHANGED,
236                        #self._OnMsgMapsChanged)
237                #except ConnectorError:
238                    #pass
239                self.__DeleteAllItems()
240            
241            self.map = map
242    
243          #prev_id = self.GetPrevSibling(cur_id)          if self.map is not None:
244                for msg, func in sub_list: self.map.Subscribe(msg, func)
245                #self.mainWindow.application.session.Subscribe(MAPS_CHANGED,
246                    #self._OnMsgMapsChanged)
247                #self.mainWindow.application.Subscribe(SESSION_REPLACED,
248                    #self._OnMsgMapsChanged)
249                self.__FillTree(self.map)
250    
251          #      def MoveCurrentItemTop(self):
252          # Get out if there's nowhere to go          layer, group = self.GetSelectedHierarchy()
         #  
         #if prev_id == INVALID_TREE_ID: return  
253    
254          if isinstance(cur_data, Layer):          if layer is not None:
255              self.map.RaiseLayer(cur_data)              self.map.TopLayer(layer)
256          elif isinstance(cur_data, ClassGroup):          else:
257                assert False, "Shouldn't be allowed."
258              pass              pass
259    
260        def MoveCurrentItemUp(self):
261            layer, group = self.GetSelectedHierarchy()
262    
263            if layer is not None:
264                self.map.RaiseLayer(layer)
265          else:          else:
266              assert(False, "Shouldn't be here.")              assert False, "Shouldn't be allowed."
267              pass              pass
268    
269      def MoveCurrentItemDown(self):      def MoveCurrentItemDown(self):
270          cur_id = self.GetSelection()          layer, group = self.GetSelectedHierarchy()
         assert(cur_id.IsOk())  
271    
272          cur_data = self.GetPyData(cur_id)          if layer is not None:
273                self.map.LowerLayer(layer)
         if isinstance(cur_data, Layer):  
             self.map.LowerLayer(cur_data)  
         elif isinstance(cur_data, ClassGroup):  
             pass  
274          else:          else:
275              assert(False, "Shouldn't be here.")              assert False, "Shouldn't be allowed."
276              pass              pass
277    
278        def MoveCurrentItemBottom(self):
279            layer, group = self.GetSelectedHierarchy()
280    
281            if layer is not None:
282                self.map.BottomLayer(layer)
283            else:
284                assert False, "Shouldn't be allowed."
285                pass
286    
287      def OnCompareItems(self, item1, item2):      def OnCompareItems(self, item1, item2):
288    
289          data1 = self.GetPyData(item1)          data1 = self.GetPyData(item1)
290          data2 = self.GetPyData(item2)          data2 = self.GetPyData(item2)
291    
292          if isinstance(data1, Layer):          if isinstance(data1, BaseLayer):
293              layers = self.map.Layers()              layers = self.map.Layers()
294              return layers.index(data2) - layers.index(data1)              return layers.index(data2) - layers.index(data1)
295          else:          else:
296              return wxTreeCtrl.OnCompareItems(self, item1, item2)              return wxTreeCtrl.OnCompareItems(self, item1, item2)
297    
   
298      def DoOnShowLayer(self):      def DoOnShowLayer(self):
299          self.__ShowHideLayer(True)          #self.__ShowHideLayer(True)
300            layer, group = self.GetSelectedHierarchy()
301            layer.SetVisible(True)
302    
303      def DoOnHideLayer(self):      def DoOnHideLayer(self):
304          self.__ShowHideLayer(False)          #self.__ShowHideLayer(False)
305            layer, group = self.GetSelectedHierarchy()
306            layer.SetVisible(False)
307    
308      def DoOnClassify(self):      def Sort(self):
309          id = self.GetSelection()          self.SortChildren(self.GetRootItem())
         assert(id.IsOk())  
310    
311          item = self.GetPyData(id)      def GetSelectedHierarchy(self):
312          if isinstance(item, ClassGroup):          id = self.GetSelection()
             id = self.GetItemParent(id)  
             assert(id.IsOk())  
             item = self.GetPyData(id)  
313    
314          self.parent.parent.OpenClassifier(item)          if not id.IsOk():
315                return (None, None)
316    
317      def Sort(self):          layer = self.GetPyData(id)
318          self.SortChildren(self.GetRootItem())          group = None
319    
320            if isinstance(layer, ClassGroup):
321                id = self.GetItemParent(id)
322                assert id.IsOk()
323                group = layer
324                layer = self.GetPyData(id)
325    
326            return (layer, group)
327    
328        def _OnMsgMapsChanged(self):
329            #print self.map is self.mainWindow.Map()
330            self.SetMap(self.mainWindow.Map())
331            
332      def _OnSelChanged(self, event):      def _OnSelChanged(self, event):
333          self.parent.DoOnSelChanged()          self.__UpdateSelection()
334    
335      def _OnItemActivated(self, event):      def _OnItemActivated(self, event):
336          self.DoOnClassify()          self.parent.DoOnProperties()
337    
338      def _OnMsgLayerChanged(self, layer):      def _OnMsgLayerChanged(self, layer):
339          assert(isinstance(layer, Layer))          assert isinstance(layer, BaseLayer)
340    
341          id = self.layer2id[layer]          id = self.layer2id[layer]
342            assert id.IsOk()
343    
344          self.__FillTreeLayer(id)          # XXX: yikes! this is so bad, we should be doing what is
345            #      commented out, but there is a problem with keeping
346            #      track of the images in the image list when we replace
347            #      a layer. it ends up causing a seg fault.
348            self.__FillTree(self.map)
349            self.__UpdateSelection()
350            #self.__FillTreeLayer(id)
351    
352      def _OnMsgMapStackingChanged(self, *args):      def _OnMsgMapStackingChanged(self, *args):
353          self.Sort()          self.Sort()
354            id = self.GetSelection()
355    
356      def _OnMsgMapLayersChanged(self, map):          if id.IsOk():
357          assert(id(map) == id(self.map))              self.EnsureVisible(id)
358            self.__UpdateSelection()
359    
360        def _OnMsgMapLayersAddedRemoved(self, map):
361            assert map is self.map
362    
363          self.__FillTree(self.map)          self.__FillTree(self.map)
364            self.__UpdateSelection()
365    
366      def __FillTree(self, map):      def _OnMsgLayerVisibilityChanged(self, layer):
367            assert isinstance(layer, BaseLayer)
368    
369            self.__ShowHideLayer(layer)
370            self.__UpdateSelection()
371    
372          assert(isinstance(map, Map))      def _OnMsgLayerTitleChanged(self, layer):
373    
374            id = self.layer2id[layer]
375            if id.IsOk():
376                self.SetItemText(id, layer.Title())
377            self.__UpdateSelection()
378    
379        def __UpdateSelection(self):
380            layer, group = self.GetSelectedHierarchy()
381            self.parent.DoOnSelChanged(layer, group)
382            
383        def __FillTree(self, map):
384    
385          self.Freeze()          self.Freeze()
386    
# Line 263  class LegendTree(wxTreeCtrl): Line 407  class LegendTree(wxTreeCtrl):
407              for l in map.Layers():              for l in map.Layers():
408                  id = self.PrependItem(root, l.Title())                  id = self.PrependItem(root, l.Title())
409                  l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)                  l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
410                    l.Subscribe(LAYER_VISIBILITY_CHANGED,
411                                self._OnMsgLayerVisibilityChanged)
412                    l.Subscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
413                  self.SetPyData(id, l)                  self.SetPyData(id, l)
414                  font = self.GetItemFont(id)                  self.__SetVisibilityStyle(l.Visible(), id)
                 if not l.Visible():  
                     font.SetStyle(wxITALIC)  
                     self.SetItemFont(id, font)  
415    
416                  self.layer2id[l] = id                  self.layer2id[l] = id
417    
# Line 283  class LegendTree(wxTreeCtrl): Line 427  class LegendTree(wxTreeCtrl):
427    
428          self.DeleteChildren(pid)          self.DeleteChildren(pid)
429    
430          clazz = layer.GetClassification()          if layer.HasClassification():
   
         shapeType = layer.ShapeType()  
431    
432          for g in clazz:              clazz = layer.GetClassification()
             id = self.AppendItem(pid, g.GetDisplayText())  
             self.SetPyData(id, g)  
433    
434              bmp = self.__BuildGroupImage(g, shapeType)              shapeType = layer.ShapeType()
435    
436              if bmp is None:              show = layer.Visible()
437                  self.SetItemImage(id, self.emptyImageIndex)              for g in clazz:
438              else:                  if g.IsVisible():
439                  i = self.image_list.Add(bmp)                      id = self.AppendItem(pid, g.GetDisplayText())
440                  self.SetItemImage(id, i)                      self.SetPyData(id, g)
441                        self.__SetVisibilityStyle(show, id)
442              #self.layer2id[g] = id  
443                        bmp = self.__BuildGroupImage(g, shapeType)
444    
445                        if bmp is None:
446                            self.SetItemImage(id, self.emptyImageIndex)
447                        else:
448                            i = self.image_list.Add(bmp)
449                            self.SetItemImage(id, i)
450    
451          self.Thaw()          self.Thaw()
452    
453      def __BuildGroupImage(self, group, shapeType):      def __BuildGroupImage(self, group, shapeType):
         assert(isinstance(group, ClassGroup))  
454    
455          bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)          bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
456          #brush = wxBrush(Color2wxColour(item[1]), wxSOLID)          #brush = wxBrush(Color2wxColour(item[1]), wxSOLID)
# Line 317  class LegendTree(wxTreeCtrl): Line 463  class LegendTree(wxTreeCtrl):
463          return bmp          return bmp
464    
465      def __DeleteAllItems(self):      def __DeleteAllItems(self):
466    
467            while len(self.layer2id) > 0:
468                layer, id = self.layer2id.popitem()
469                layer.Unsubscribe(LAYER_CHANGED,
470                                  self._OnMsgLayerChanged)
471                layer.Unsubscribe(LAYER_VISIBILITY_CHANGED,
472                                  self._OnMsgLayerVisibilityChanged)
473                layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
474    
475          self.DeleteAllItems()          self.DeleteAllItems()
         self.layer2id = {}  
476    
477        def __SetVisibilityStyle(self, visible, id):
478            font = self.GetItemFont(id)
479    
480      def __ShowHideLayer(self, show):          if visible:
481          id = self.GetSelection()              font.SetStyle(wxNORMAL)
482          assert(id.IsOk())              color = wxBLACK
483            else:
484                #font.SetStyle(wxITALIC)
485                font.SetStyle(wxNORMAL)
486                color = wxLIGHT_GREY
487    
488            self.SetItemTextColour(id, color)
489            self.SetItemFont(id, font)
490                    
491          item = self.GetPyData(id)      def __ShowHideLayer(self, layer):
492          if isinstance(item, ClassGroup):          parent = self.layer2id[layer]
493              id = self.GetItemParent(id)          assert parent.IsOk()
494              assert(id.IsOk())  
495              item = self.GetPyData(id)          visible = layer.Visible()
496    
497            self.__SetVisibilityStyle(visible, parent)
498    
499          if show != item.Visible():          id, cookie = self.GetFirstChild(parent, 123)
500    
501              item.SetVisible(show)          while id.IsOk():
502                self.__SetVisibilityStyle(visible, id)
503                id, cookie = self.GetNextChild(parent, cookie)
504                
505    class ScaleBarBitmap(wxBoxSizer):
506    
507              font = self.GetItemFont(id)      def __init__(self, parent, map, mainWindow):
508              if show:          # While the width is fixed, get the height _now_.
509                  font.SetStyle(wxNORMAL)          dc = wxMemoryDC()
510                  self.SetItemFont(id, font)          textwidth, textheight = dc.GetTextExtent("%d"%0)
511              else:          self.width = 210
512                  font.SetStyle(wxITALIC)          self.height = textheight + 3*2 + 8
513                  self.SetItemFont(id, font)  
514            wxBoxSizer.__init__(self, wxVERTICAL)
515            bmp=wxEmptyBitmap(self.width, self.height)
516            self.scalebarBitmap = wxStaticBitmap(parent, -1, bmp)
517            self.Add(self.scalebarBitmap, 0, wxALIGN_CENTER|wxLEFT|wxTOP|wxRIGHT, 1)
518    
519            self.mainWindow = mainWindow
520            self.parent = parent
521            self.canvas = None
522            self.SetCanvas(self.mainWindow.canvas)
523    
524        def SetCanvas(self, canvas):
525            sub_list = [(SCALE_CHANGED, self._OnMsgScaleChanged)]
526    
527            if self.canvas is not None:
528                for msg, func in sub_list: self.canvas.Unsubscribe(msg, func)
529            
530            self.canvas = canvas
531            self.scalebar = ScaleBar(canvas.map)
532    
533            if self.canvas is not None:
534                for msg, func in sub_list: self.canvas.Subscribe(msg, func)
535                self.__SetScale(self.canvas.scale)
536    
537        def _OnMsgScaleChanged(self, scale):
538            self.__SetScale(scale)
539    
540        def __SetScale(self, scale):
541            bmp = wxEmptyBitmap(self.width, self.height)
542            dc = wxMemoryDC()
543            dc.SelectObject(bmp)
544            dc.Clear()
545    
546            self.scalebar.DrawScaleBar(scale, dc, (0,0), dc.GetSizeTuple())
547    
548            self.scalebarBitmap.SetBitmap(bmp)
549    
Legend:
Removed from v.542  
changed lines
  Added in v.990
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26