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