/[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 1119 by bh, Mon Jun 2 10:37:59 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    from Thuban.Lib.connector import ConnectorError
32    
33  ID_LEGEND_MOVEUP = 4001  ID_LEGEND_TOP = 4001
34  ID_LEGEND_MOVEDOWN = 4002  ID_LEGEND_RAISE = 4002
35  ID_LEGEND_TREE = 4003  ID_LEGEND_LOWER = 4003
36  ID_LEGEND_CLASSIFY = 4004  ID_LEGEND_BOTTOM = 4004
37  ID_LEGEND_SHOWLAYER = 4005  ID_LEGEND_TREE = 4005
38  ID_LEGEND_HIDELAYER = 4006  ID_LEGEND_PROPS = 4006
39    ID_LEGEND_SHOWLAYER = 4007
40    ID_LEGEND_HIDELAYER = 4008
41    
42  BMP_SIZE_W = 30  BMP_SIZE_W = 15
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            self.mainWindow = mainWindow
60            self.parent = parent
61    
62          panel = wxPanel(self, -1)          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          button = wxButton(self, ID_LEGEND_MOVEUP, _("Move Up"))          self.tree = LegendTree(self, ID_LEGEND_TREE, map, mainWindow)
         buttonBox.Add(button, 0, wxGROW | wxLEFT | wxRIGHT, 0)  
         self.buttons.append(button)  
109    
110          button = wxButton(self, ID_LEGEND_SHOWLAYER, _("Show Layer"))          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_CLASSIFY, _("Classify"))          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_MOVEDOWN, _("Move Down"))          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_HIDELAYER, _("Hide Layer"))  
         buttonBox.Add(button, 0, wxGROW | wxLEFT | wxRIGHT, 0)  
         self.buttons.append(button)  
119    
120            self.panelBox = panelBox
121    
122          EVT_BUTTON(self, ID_LEGEND_MOVEUP, self._OnMoveUp)          self.__EnableButtons(False)
         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)  
123    
124          panelBox.Add(buttonBox, 0, 0, 4)          self.Create()
125    
126          self.tree = LegendTree(self, ID_LEGEND_TREE, map)          EVT_CLOSE(self, self._OnClose)
127    
         panelBox.Add(self.tree, 1, wxGROW, 4)  
128    
129          panel.SetAutoLayout(True)      def GetMap(self):
130          panel.SetSizer(panelBox)          return self.tree.GetMap()
         panelBox.SetSizeHints(panel)  
131    
132          topBox.Add(panel, 1, wxGROW, 0)      def SetMap(self, map):
133          panelBox.SetSizeHints(self)          self.tree.SetMap(map)
134            self.scalebarbitmap.SetCanvas(self.mainWindow.canvas)
135    
136          self.SetAutoLayout(True)      def DoOnSelChanged(self, layer, group):
137          self.SetSizer(topBox)  
138            ok = isinstance(layer, BaseLayer)
139            self.__EnableButtons(ok)
140    
141            self.mainWindow.SelectLayer(layer)
142    
143        def DoOnProperties(self):
144            list = self.tree.GetSelectedHierarchy()
145    
146            ok = isinstance(list[0], BaseLayer)
147            if ok:
148                self.mainWindow.OpenLayerProperties(list[0], list[1])
149    
150      def DoOnSelChanged(self):      def Destroy(self):
151          self.__EnableButtons(self.tree.GetSelection().IsOk())          self.__Close()
152    
153      def _OnClassify(self, event):      def _OnProperties(self, event):
154          self.tree.DoOnClassify()          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 = {}
205          self.layer2id = None          self.changing_selection = 0
206    
207            #
208            # The image list used by the wxTreeCtrl causes problems when
209            # we remove layers and/or change a classification because it
210            # changes the image indices if you remove images from the list.
211            # Rather than removing unused images we use this list to keep
212            # track of which indices are available in the image list
213            # (because of a previous removal) and then  replace those indices
214            # with new images rather than appending to the end of the image
215            # list (assuming there are any that are available).
216            #
217            self.availImgListIndices = []
218    
219          self.image_list = None          self.image_list = None
220          self.emptyImageIndex = 0          self.emptyImageIndex = 0
221    
222          self.previewer = ClassDataPreviewer()          self.previewer = ClassDataPreviewer()
223    
   
224          EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)          EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)
225          EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)          EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)
226    
227          map.Subscribe(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged)          EVT_CLOSE(self, self._OnClose)
         map.Subscribe(MAP_LAYERS_CHANGED, self._OnMsgMapLayersChanged)  
228    
229          self.__FillTree(map)          self.SetMap(map)
230    
231      def MoveCurrentItemUp(self):      def _OnClose(self, event):
232          cur_id = self.GetSelection()          self.SetMap(None)
         assert(cur_id.IsOk())  
233    
234          cur_data = self.GetPyData(cur_id)      def GetMap(self):
235            return self.map
236    
237        def SetMap(self, map):
238    
239            sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),
240                        (MAP_LAYERS_ADDED, self._OnMsgMapLayersAdded),
241                        (MAP_LAYERS_REMOVED, self._OnMsgMapLayersRemoved)]
242    
243            if self.map is not None:
244                for msg, func in sub_list: self.map.Unsubscribe(msg, func)
245                #self.mainWindow.application.Unsubscribe(SESSION_REPLACED,
246                    #self._OnMsgMapsChanged)
247                #try:
248                    #self.mainWindow.application.session.Unsubscribe(MAPS_CHANGED,
249                        #self._OnMsgMapsChanged)
250                #except ConnectorError:
251                    #pass
252                self.DeleteAllItems()
253            
254            self.map = map
255    
256          #prev_id = self.GetPrevSibling(cur_id)          if self.map is not None:
257                for msg, func in sub_list: self.map.Subscribe(msg, func)
258                #self.mainWindow.application.session.Subscribe(MAPS_CHANGED,
259                    #self._OnMsgMapsChanged)
260                #self.mainWindow.application.Subscribe(SESSION_REPLACED,
261                    #self._OnMsgMapsChanged)
262                self.__FillTree(self.map)
263    
264          #      def MoveCurrentItemTop(self):
265          # Get out if there's nowhere to go          layer, group = self.GetSelectedHierarchy()
         #  
         #if prev_id == INVALID_TREE_ID: return  
266    
267          if isinstance(cur_data, Layer):          if layer is not None:
268              self.map.RaiseLayer(cur_data)              self.map.MoveLayerToTop(layer)
269          elif isinstance(cur_data, ClassGroup):          else:
270                assert False, "Shouldn't be allowed."
271              pass              pass
272    
273        def MoveCurrentItemUp(self):
274            layer, group = self.GetSelectedHierarchy()
275    
276            if layer is not None:
277                self.map.RaiseLayer(layer)
278          else:          else:
279              assert(False, "Shouldn't be here.")              assert False, "Shouldn't be allowed."
280              pass              pass
281    
282      def MoveCurrentItemDown(self):      def MoveCurrentItemDown(self):
283          cur_id = self.GetSelection()          layer, group = self.GetSelectedHierarchy()
         assert(cur_id.IsOk())  
284    
285          cur_data = self.GetPyData(cur_id)          if layer is not None:
286                self.map.LowerLayer(layer)
         if isinstance(cur_data, Layer):  
             self.map.LowerLayer(cur_data)  
         elif isinstance(cur_data, ClassGroup):  
             pass  
287          else:          else:
288              assert(False, "Shouldn't be here.")              assert False, "Shouldn't be allowed."
289              pass              pass
290    
291        def MoveCurrentItemBottom(self):
292            layer, group = self.GetSelectedHierarchy()
293    
294            if layer is not None:
295                self.map.MoveLayerToBottom(layer)
296            else:
297                assert False, "Shouldn't be allowed."
298                pass
299    
300      def OnCompareItems(self, item1, item2):      def OnCompareItems(self, item1, item2):
301    
302          data1 = self.GetPyData(item1)          data1 = self.GetPyData(item1)
303          data2 = self.GetPyData(item2)          data2 = self.GetPyData(item2)
304    
305          if isinstance(data1, Layer):          if isinstance(data1, BaseLayer):
306              layers = self.map.Layers()              layers = self.map.Layers()
307              return layers.index(data2) - layers.index(data1)              return layers.index(data2) - layers.index(data1)
308          else:          else:
309              return wxTreeCtrl.OnCompareItems(self, item1, item2)              return wxTreeCtrl.OnCompareItems(self, item1, item2)
310    
   
311      def DoOnShowLayer(self):      def DoOnShowLayer(self):
312          self.__ShowHideLayer(True)          layer, group = self.GetSelectedHierarchy()
313            layer.SetVisible(True)
314    
315      def DoOnHideLayer(self):      def DoOnHideLayer(self):
316          self.__ShowHideLayer(False)          layer, group = self.GetSelectedHierarchy()
317            layer.SetVisible(False)
318    
319      def DoOnClassify(self):      def Sort(self):
320          id = self.GetSelection()          self.SortChildren(self.GetRootItem())
         assert(id.IsOk())  
321    
322          item = self.GetPyData(id)      def GetSelectedHierarchy(self):
323          if isinstance(item, ClassGroup):          id = self.GetSelection()
             id = self.GetItemParent(id)  
             assert(id.IsOk())  
             item = self.GetPyData(id)  
324    
325          self.parent.parent.OpenClassifier(item)          if not id.IsOk():
326                return (None, None)
327    
328      def Sort(self):          layer = self.GetPyData(id)
329          self.SortChildren(self.GetRootItem())          group = None
330    
331            if isinstance(layer, ClassGroup):
332                id = self.GetItemParent(id)
333                assert id.IsOk()
334                group = layer
335                layer = self.GetPyData(id)
336    
337            return (layer, group)
338    
339        def _OnMsgMapsChanged(self):
340            #print self.map is self.mainWindow.Map()
341            self.SetMap(self.mainWindow.Map())
342            
343      def _OnSelChanged(self, event):      def _OnSelChanged(self, event):
344          self.parent.DoOnSelChanged()          # If we change the selection from normalize_selection do nothing.
345            if self.changing_selection:
346                return
347    
348            self.normalize_selection()
349            self.__UpdateSelection()
350    
351        def normalize_selection(self):
352            """Select the layer containing currently selected item"""
353            # This is really a workaround for a bug in wx where deleting a
354            # subtree with DeleteChildren does not update the selection
355            # properly and can lead to segfaults later because the return
356            # value of GetSelection points to invalid data.
357            item = self.GetSelection()
358            while item.IsOk():
359                object = self.GetPyData(item)
360                if isinstance(object, BaseLayer):
361                    break
362                item = self.GetItemParent(item)
363            else:
364                # No layer was found in the chain of parents, so there's
365                # nothing we can do.
366                return
367    
368            self.changing_selection = 1
369            try:
370                self.SelectItem(item)
371            finally:
372                self.changing_selection = 0
373    
374    
375      def _OnItemActivated(self, event):      def _OnItemActivated(self, event):
376          self.DoOnClassify()          self.parent.DoOnProperties()
377    
378      def _OnMsgLayerChanged(self, layer):      def _OnMsgLayerChanged(self, layer):
379          assert(isinstance(layer, Layer))          assert isinstance(layer, BaseLayer)
380    
381          id = self.layer2id[layer]          id = self.layer2id[layer]
382            assert id.IsOk()
383    
384          self.__FillTreeLayer(id)          self.__FillTreeLayer(id)
385            self.__UpdateSelection()
386    
387      def _OnMsgMapStackingChanged(self, *args):      def _OnMsgMapStackingChanged(self, *args):
388          self.Sort()          self.Sort()
389            id = self.GetSelection()
390    
391      def _OnMsgMapLayersChanged(self, map):          if id.IsOk():
392          assert(id(map) == id(self.map))              self.EnsureVisible(id)
393            self.__UpdateSelection()
394    
395          self.__FillTree(self.map)      def _OnMsgMapLayersAdded(self, map):
396            assert map is self.map
397    
398      def __FillTree(self, map):          root = self.GetRootItem()
399    
400          assert(isinstance(map, Map))          i = 0
401            for l in map.Layers():
402                if not self.layer2id.has_key(l):
403                    self.__AddLayer(i, l)
404    
405          self.Freeze()          self.__UpdateSelection()
406    
407          self.__DeleteAllItems()      def _OnMsgMapLayersRemoved(self, map):
408            assert map is self.map
409    
410          if map.HasLayers():          layers = map.Layers()
411    
412              self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)          for layer, id in self.layer2id.items():
413                                                                                                if layer not in layers:
414              bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)                  if id.IsOk():
415              dc = wxMemoryDC()                      self.__RemoveLayer(id)
             dc.SelectObject(bmp)  
             dc.SetBrush(wxBLACK_BRUSH)  
             dc.Clear()  
             dc.SelectObject(wxNullBitmap)  
                                                                                   
             self.emptyImageIndex = \  
                 self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))  
                                                                                   
             self.AssignImageList(self.image_list)  
416    
417              root = self.AddRoot("")          self.__UpdateSelection()
418    
419              for l in map.Layers():      def _OnMsgLayerVisibilityChanged(self, layer):
420                  id = self.PrependItem(root, l.Title())          assert isinstance(layer, BaseLayer)
421                  l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)  
422                  self.SetPyData(id, l)          self.__ShowHideLayer(layer)
423                  font = self.GetItemFont(id)          self.__UpdateSelection()
424                  if not l.Visible():  
425                      font.SetStyle(wxITALIC)      def _OnMsgLayerTitleChanged(self, layer):
426                      self.SetItemFont(id, font)  
427            id = self.layer2id[layer]
428            if id.IsOk():
429                self.SetItemText(id, layer.Title())
430            self.__UpdateSelection()
431    
432        def __UpdateSelection(self):
433            layer, group = self.GetSelectedHierarchy()
434            self.parent.DoOnSelChanged(layer, group)
435            
436        def __FillTree(self, map):
437    
438            self.Freeze()
439    
440                  self.layer2id[l] = id          self.DeleteAllItems()
441    
442                  self.__FillTreeLayer(id)          if map.HasLayers():
443                  self.Expand(id)              root = self.GetRootItem()
444                for l in map.Layers():
445                    self.__AddLayer(0, l)
446    
447          self.Thaw()          self.Thaw()
448    
# Line 283  class LegendTree(wxTreeCtrl): Line 453  class LegendTree(wxTreeCtrl):
453    
454          self.DeleteChildren(pid)          self.DeleteChildren(pid)
455    
456          clazz = layer.GetClassification()          if layer.HasClassification():
457    
458          shapeType = layer.ShapeType()              clazz = layer.GetClassification()
459    
460          for g in clazz:              shapeType = layer.ShapeType()
             id = self.AppendItem(pid, g.GetDisplayText())  
             self.SetPyData(id, g)  
461    
462              bmp = self.__BuildGroupImage(g, shapeType)              show = layer.Visible()
463                for g in clazz:
464                    if g.IsVisible():
465                        id = self.AppendItem(pid, g.GetDisplayText())
466                        self.SetPyData(id, g)
467                        self.__SetVisibilityStyle(show, id)
468    
469                        bmp = self.__BuildGroupImage(g, shapeType)
470    
471                        if bmp is None:
472                            self.SetItemImage(id, -1)
473                            self.SetItemSelectedImage(id, -1)
474                        else:
475                            if self.availImgListIndices:
476                                i = self.availImgListIndices.pop(0)
477                                self.image_list.Replace(i, bmp)
478                            else:
479                                i = self.image_list.Add(bmp)
480    
481              if bmp is None:                          self.SetItemImage(id, i)
482                  self.SetItemImage(id, self.emptyImageIndex)                          self.SetItemSelectedImage(id, i)
             else:  
                 i = self.image_list.Add(bmp)  
                 self.SetItemImage(id, i)  
   
             #self.layer2id[g] = id  
483    
484          self.Thaw()          self.Thaw()
485    
486      def __BuildGroupImage(self, group, shapeType):      def __BuildGroupImage(self, group, shapeType):
         assert(isinstance(group, ClassGroup))  
487    
488          bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)          bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
489          #brush = wxBrush(Color2wxColour(item[1]), wxSOLID)          #brush = wxBrush(Color2wxColour(item[1]), wxSOLID)
# Line 316  class LegendTree(wxTreeCtrl): Line 495  class LegendTree(wxTreeCtrl):
495    
496          return bmp          return bmp
497    
498      def __DeleteAllItems(self):      def DeleteAllItems(self):
         self.DeleteAllItems()  
         self.layer2id = {}  
499    
500            pid = self.GetRootItem()
501    
502      def __ShowHideLayer(self, show):          id, cookie = self.GetFirstChild(pid, 123)
503          id = self.GetSelection()          while id.IsOk():
504          assert(id.IsOk())              self.__RemoveLayer(id)
505                id, cookie = self.GetNextChild(pid, cookie)
506    
507            wxTreeCtrl.DeleteAllItems(self)
508    
509        def __AddLayer(self, before, l):
510            root = self.GetRootItem()
511            id = self.InsertItemBefore(root, before,
512                                l.Title(),
513                                self.mapImageIndex,
514                                self.mapImageIndex)
515    
516            self.SetPyData(id, l)
517            self.__SetVisibilityStyle(l.Visible(), id)
518    
519            self.layer2id[l] = id
520    
521            self.__FillTreeLayer(id)
522            self.Expand(id)
523    
524            l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
525            l.Subscribe(LAYER_VISIBILITY_CHANGED,
526                        self._OnMsgLayerVisibilityChanged)
527            l.Subscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
528    
529        def __RemoveLayer(self, id):
530            self.DeleteChildren(id)
531    
532            layer = self.GetPyData(id)
533            layer.Unsubscribe(LAYER_CHANGED,
534                              self._OnMsgLayerChanged)
535            layer.Unsubscribe(LAYER_VISIBILITY_CHANGED,
536                              self._OnMsgLayerVisibilityChanged)
537            layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
538    
539            self.Delete(id)
540            del self.layer2id[layer]
541    
542        def DeleteChildren(self, pid):
543            id, cookie = self.GetFirstChild(pid, 123)
544            while id.IsOk():
545                self.availImgListIndices.append(self.GetItemImage(id))
546                id, cookie = self.GetNextChild(pid, cookie)
547            wxTreeCtrl.DeleteChildren(self, pid)
548    
549        def GetRootItem(self):
550            root = wxTreeCtrl.GetRootItem(self)
551    
552            if not root.IsOk():
553                self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)
554    
555                bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
556                dc = wxMemoryDC()
557                dc.SelectObject(bmp)
558                dc.SetBrush(wxBLACK_BRUSH)
559                dc.Clear()
560                dc.SelectObject(wxNullBitmap)
561    
562                self.emptyImageIndex = \
563                    self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))
564    
565                bmp = resource.GetBitmapResource("legend_icon_layer",
566                                                  wxBITMAP_TYPE_XPM)
567                self.mapImageIndex = \
568                    self.image_list.Add(bmp)
569    
570                self.AssignImageList(self.image_list)
571                self.availImgListIndices = []
572    
573                root = self.AddRoot("")
574    
575            return root
576    
577        def __SetVisibilityStyle(self, visible, id):
578            font = self.GetItemFont(id)
579    
580            if visible:
581                font.SetStyle(wxNORMAL)
582                color = wxBLACK
583            else:
584                #font.SetStyle(wxITALIC)
585                font.SetStyle(wxNORMAL)
586                color = wxLIGHT_GREY
587    
588            self.SetItemTextColour(id, color)
589            self.SetItemFont(id, font)
590                    
591          item = self.GetPyData(id)      def __ShowHideLayer(self, layer):
592          if isinstance(item, ClassGroup):          parent = self.layer2id[layer]
593              id = self.GetItemParent(id)          assert parent.IsOk()
594              assert(id.IsOk())  
595              item = self.GetPyData(id)          visible = layer.Visible()
596    
597            self.__SetVisibilityStyle(visible, parent)
598    
599            id, cookie = self.GetFirstChild(parent, 123)
600    
601            while id.IsOk():
602                self.__SetVisibilityStyle(visible, id)
603                id, cookie = self.GetNextChild(parent, cookie)
604                
605    class ScaleBarBitmap(wxBoxSizer):
606    
607        def __init__(self, parent, map, mainWindow):
608            # While the width is fixed, get the height _now_.
609            dc = wxMemoryDC()
610            textwidth, textheight = dc.GetTextExtent("%d"%0)
611            self.width = 210
612            self.height = textheight + 3*2 + 8
613    
614            wxBoxSizer.__init__(self, wxVERTICAL)
615            bmp=wxEmptyBitmap(self.width, self.height)
616            self.scalebarBitmap = wxStaticBitmap(parent, -1, bmp)
617            self.Add(self.scalebarBitmap, 0, wxALIGN_CENTER|wxLEFT|wxTOP|wxRIGHT, 1)
618    
619            self.mainWindow = mainWindow
620            self.parent = parent
621            self.canvas = None
622            self.SetCanvas(self.mainWindow.canvas)
623    
624        def SetCanvas(self, canvas):
625            sub_list = [(SCALE_CHANGED, self._OnMsgScaleChanged)]
626    
627            if self.canvas is not None:
628                for msg, func in sub_list: self.canvas.Unsubscribe(msg, func)
629            
630            self.canvas = canvas
631            self.scalebar = ScaleBar(canvas.map)
632    
633          if show != item.Visible():          if self.canvas is not None:
634                for msg, func in sub_list: self.canvas.Subscribe(msg, func)
635                self.__SetScale(self.canvas.scale)
636    
637              item.SetVisible(show)      def _OnMsgScaleChanged(self, scale):
638            self.__SetScale(scale)
639    
640              font = self.GetItemFont(id)      def __SetScale(self, scale):
641              if show:          bmp = wxEmptyBitmap(self.width, self.height)
642                  font.SetStyle(wxNORMAL)          dc = wxMemoryDC()
643                  self.SetItemFont(id, font)          dc.SelectObject(bmp)
644              else:          dc.Clear()
                 font.SetStyle(wxITALIC)  
                 self.SetItemFont(id, font)  
645    
646            self.scalebar.DrawScaleBar(scale, dc, (0,0), dc.GetSizeTuple())
647    
648            self.scalebarBitmap.SetBitmap(bmp)
649    
Legend:
Removed from v.542  
changed lines
  Added in v.1119
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26