/[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 858 by frank, Thu May 8 10:30:17 2003 UTC revision 1837 by frank, Tue Oct 21 09:29:52 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.
8    
9  __version__ = "$Revision$"  __version__ = "$Revision$"
10    
11    from  math import fabs, cos, pi
12    
13  from Thuban import _  from Thuban import _
14    
15  import resource  import resource
16    
17  from wxPython.wx import *  from wxPython.wx import *
18    
19  from Thuban.Model.layer import Layer  from Thuban.Model.layer import BaseLayer
20  from Thuban.Model.map import Map  from Thuban.Model.map import Map
 from Thuban.Model.scalebar import ScaleBar  
 from Thuban.Model.messages import *  
21  from Thuban.Model.classification import ClassGroup  from Thuban.Model.classification import ClassGroup
22    from Thuban.Model.proj import PROJ_UNITS_DEGREES
23    
24    from Thuban.Model.messages import \
25        MAP_STACKING_CHANGED, MAP_LAYERS_ADDED, MAP_LAYERS_REMOVED, LAYER_CHANGED,\
26        LAYER_VISIBILITY_CHANGED, TITLE_CHANGED
27    
28    from Thuban.UI.messages import SCALE_CHANGED
29    
 from Thuban.UI.messages import *  
30  from Thuban.UI.classifier import ClassDataPreviewer  from Thuban.UI.classifier import ClassDataPreviewer
31  from Thuban.UI.dock import DockPanel  from Thuban.UI.dock import DockPanel
32    from Thuban.UI.scalebar import ScaleBar
33    
34  from Thuban.Lib.connector import ConnectorError  from Thuban.Lib.connector import ConnectorError
35    
36  ID_LEGEND_RAISE = 4001  ID_LEGEND_TOP = 4001
37  ID_LEGEND_LOWER = 4002  ID_LEGEND_RAISE = 4002
38  ID_LEGEND_TREE = 4003  ID_LEGEND_LOWER = 4003
39  ID_LEGEND_PROPS = 4004  ID_LEGEND_BOTTOM = 4004
40  ID_LEGEND_SHOWLAYER = 4005  ID_LEGEND_TREE = 4005
41  ID_LEGEND_HIDELAYER = 4006  ID_LEGEND_PROPS = 4006
42    ID_LEGEND_SHOWLAYER = 4007
43    ID_LEGEND_HIDELAYER = 4008
44    
45    ID_POPUP_TOP = 4501
46    ID_POPUP_UP  = 4502
47    ID_POPUP_DOWN = 4503
48    ID_POPUP_BOTTOM = 4504
49    ID_POPUP_PROPS  = 4506
50    ID_POPUP_VISIBLE = 4507
51    ID_POPUP_PROJ = 4509
52    
53  BMP_SIZE_W = 30  BMP_SIZE_W = 15
54  BMP_SIZE_H = 15  BMP_SIZE_H = 15
55    
56    TOP_BMP = "top_layer"
57  RAISE_BMP = "raise_layer"  RAISE_BMP = "raise_layer"
58  LOWER_BMP = "lower_layer"  LOWER_BMP = "lower_layer"
59    BOTTOM_BMP = "bottom_layer"
60  SHOW_BMP  = "show_layer"  SHOW_BMP  = "show_layer"
61  HIDE_BMP  = "hide_layer"  HIDE_BMP  = "hide_layer"
62  PROPS_BMP = "layer_properties"  PROPS_BMP = "layer_properties"
# Line 57  class LegendPanel(DockPanel): Line 77  class LegendPanel(DockPanel):
77          self.toolBar = wxToolBar(self, -1)          self.toolBar = wxToolBar(self, -1)
78          self.toolBar.SetToolBitmapSize(wxSize(24, 24))          self.toolBar.SetToolBitmapSize(wxSize(24, 24))
79    
80            bmp = resource.GetBitmapResource(TOP_BMP, wxBITMAP_TYPE_XPM)
81            self.toolBar.AddTool(ID_LEGEND_TOP, bmp,
82                shortHelpString=_("Top Layer"))
83    
84          bmp = resource.GetBitmapResource(RAISE_BMP, wxBITMAP_TYPE_XPM)          bmp = resource.GetBitmapResource(RAISE_BMP, wxBITMAP_TYPE_XPM)
85          self.toolBar.AddTool(ID_LEGEND_RAISE, bmp,          self.toolBar.AddTool(ID_LEGEND_RAISE, bmp,
86              shortHelpString=_("Raise Layer"))              shortHelpString=_("Raise Layer"))
# Line 65  class LegendPanel(DockPanel): Line 89  class LegendPanel(DockPanel):
89          self.toolBar.AddTool(ID_LEGEND_LOWER, bmp,          self.toolBar.AddTool(ID_LEGEND_LOWER, bmp,
90              shortHelpString=_("Lower Layer"))              shortHelpString=_("Lower Layer"))
91    
92            bmp = resource.GetBitmapResource(BOTTOM_BMP, wxBITMAP_TYPE_XPM)
93            self.toolBar.AddTool(ID_LEGEND_BOTTOM, bmp,
94                shortHelpString=_("Bottom Layer"))
95    
96          bmp = resource.GetBitmapResource(SHOW_BMP, wxBITMAP_TYPE_XPM)          bmp = resource.GetBitmapResource(SHOW_BMP, wxBITMAP_TYPE_XPM)
97          self.toolBar.AddTool(ID_LEGEND_SHOWLAYER, bmp,          self.toolBar.AddTool(ID_LEGEND_SHOWLAYER, bmp,
98              shortHelpString=_("Show Layer"))              shortHelpString=_("Show Layer"))
# Line 80  class LegendPanel(DockPanel): Line 108  class LegendPanel(DockPanel):
108          self.toolBar.Realize()          self.toolBar.Realize()
109          panelBox.Add(self.toolBar, 0, wxGROW, 0)          panelBox.Add(self.toolBar, 0, wxGROW, 0)
110    
111            EVT_TOOL(self, ID_LEGEND_TOP, self._OnMoveTop)
112          EVT_TOOL(self, ID_LEGEND_RAISE, self._OnMoveUp)          EVT_TOOL(self, ID_LEGEND_RAISE, self._OnMoveUp)
113          EVT_TOOL(self, ID_LEGEND_LOWER, self._OnMoveDown)          EVT_TOOL(self, ID_LEGEND_LOWER, self._OnMoveDown)
114            EVT_TOOL(self, ID_LEGEND_BOTTOM, self._OnMoveBottom)
115          EVT_TOOL(self, ID_LEGEND_PROPS, self._OnProperties)          EVT_TOOL(self, ID_LEGEND_PROPS, self._OnProperties)
116          EVT_TOOL(self, ID_LEGEND_SHOWLAYER, self._OnShowLayer)          EVT_TOOL(self, ID_LEGEND_SHOWLAYER, self._OnShowLayer)
117          EVT_TOOL(self, ID_LEGEND_HIDELAYER, self._OnHideLayer)          EVT_TOOL(self, ID_LEGEND_HIDELAYER, self._OnHideLayer)
118    
119            EVT_MENU(self, ID_POPUP_PROPS, self._OnProperties)
120            EVT_MENU(self, ID_POPUP_TOP, self._OnMoveTop)
121            EVT_MENU(self, ID_POPUP_UP, self._OnMoveUp)
122            EVT_MENU(self, ID_POPUP_DOWN, self._OnMoveDown)
123            EVT_MENU(self, ID_POPUP_BOTTOM, self._OnMoveBottom)
124            EVT_MENU(self, ID_POPUP_VISIBLE, self._OnToggleVisibility)
125            EVT_MENU(self, ID_POPUP_PROJ, self._OnProjection)
126            
127          self.tree = LegendTree(self, ID_LEGEND_TREE, map, mainWindow)          self.tree = LegendTree(self, ID_LEGEND_TREE, map, mainWindow)
128    
129          panelBox.Add(self.tree, 1, wxGROW, 0)          panelBox.Add(self.tree, 1, wxGROW, 0)
# Line 116  class LegendPanel(DockPanel): Line 154  class LegendPanel(DockPanel):
154    
155      def DoOnSelChanged(self, layer, group):      def DoOnSelChanged(self, layer, group):
156    
157          ok = isinstance(layer, Layer)          ok = isinstance(layer, BaseLayer)
158          self.__EnableButtons(ok)          self.__EnableButtons(ok)
159    
160          self.mainWindow.SelectLayer(layer)          self.mainWindow.SelectLayer(layer)
# Line 124  class LegendPanel(DockPanel): Line 162  class LegendPanel(DockPanel):
162      def DoOnProperties(self):      def DoOnProperties(self):
163          list = self.tree.GetSelectedHierarchy()          list = self.tree.GetSelectedHierarchy()
164    
165          ok = isinstance(list[0], Layer)          ok = isinstance(list[0], BaseLayer)
166          if ok:          if ok:
167              self.mainWindow.OpenLayerProperties(list[0], list[1])              self.mainWindow.OpenLayerProperties(list[0], list[1])
168    
# Line 134  class LegendPanel(DockPanel): Line 172  class LegendPanel(DockPanel):
172      def _OnProperties(self, event):      def _OnProperties(self, event):
173          self.DoOnProperties()          self.DoOnProperties()
174    
175        def _OnMoveTop(self, event):
176            self.tree.MoveCurrentItemTop()
177            
178      def _OnMoveUp(self, event):      def _OnMoveUp(self, event):
179          self.tree.MoveCurrentItemUp()          self.tree.MoveCurrentItemUp()
180    
181      def _OnMoveDown(self, event):      def _OnMoveDown(self, event):
182          self.tree.MoveCurrentItemDown()          self.tree.MoveCurrentItemDown()
183    
184        def _OnMoveBottom(self, event):
185            self.tree.MoveCurrentItemBottom()
186    
187      def _OnShowLayer(self, event):      def _OnShowLayer(self, event):
188          self.tree.DoOnShowLayer()          self.tree.DoOnShowLayer()
189          pass          pass
# Line 154  class LegendPanel(DockPanel): Line 198  class LegendPanel(DockPanel):
198          self.tree.DoOnHideLayer()          self.tree.DoOnHideLayer()
199          pass          pass
200    
201        def _OnToggleVisibility(self, event):
202            self.tree.ToggleVisibility()
203    
204        def _OnProjection(self, event):
205            self.tree.LayerProjection()
206    
207      def __EnableButtons(self, on):      def __EnableButtons(self, on):
208            self.toolBar.EnableTool(ID_LEGEND_TOP, on)
209          self.toolBar.EnableTool(ID_LEGEND_RAISE, on)          self.toolBar.EnableTool(ID_LEGEND_RAISE, on)
210          self.toolBar.EnableTool(ID_LEGEND_LOWER, on)          self.toolBar.EnableTool(ID_LEGEND_LOWER, on)
211            self.toolBar.EnableTool(ID_LEGEND_BOTTOM, on)
212          self.toolBar.EnableTool(ID_LEGEND_SHOWLAYER,  on)          self.toolBar.EnableTool(ID_LEGEND_SHOWLAYER,  on)
213          self.toolBar.EnableTool(ID_LEGEND_HIDELAYER,  on)          self.toolBar.EnableTool(ID_LEGEND_HIDELAYER,  on)
214          self.toolBar.EnableTool(ID_LEGEND_PROPS, on)          self.toolBar.EnableTool(ID_LEGEND_PROPS, on)
# Line 174  class LegendTree(wxTreeCtrl): Line 226  class LegendTree(wxTreeCtrl):
226          self.mainWindow = mainWindow          self.mainWindow = mainWindow
227          self.map = None          self.map = None
228          self.parent = parent          self.parent = parent
229          self.layer2id = {}          self.changing_selection = 0
230    
231            #
232            # The image list used by the wxTreeCtrl causes problems when
233            # we remove layers and/or change a classification because it
234            # changes the image indices if you remove images from the list.
235            # Rather than removing unused images we use this list to keep
236            # track of which indices are available in the image list
237            # (because of a previous removal) and then  replace those indices
238            # with new images rather than appending to the end of the image
239            # list (assuming there are any that are available).
240            #
241            self.availImgListIndices = []
242    
243          self.image_list = None          self.image_list = None
244          self.emptyImageIndex = 0          self.emptyImageIndex = 0
245    
246          self.previewer = ClassDataPreviewer()          self.previewer = ClassDataPreviewer()
247    
248            self.preventExpandCollapse = False
249            self.raiseProperties = False
250    
251          EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)          EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)
252          EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)          EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)
253            EVT_TREE_ITEM_EXPANDING(self, ID_LEGEND_TREE, self.OnItemExpandCollapse)
254            EVT_TREE_ITEM_COLLAPSING(self, ID_LEGEND_TREE, self.OnItemExpandCollapse)
255            EVT_TREE_ITEM_RIGHT_CLICK(self, ID_LEGEND_TREE, self._OnRightClick)
256    
257          EVT_CLOSE(self, self._OnClose)          EVT_CLOSE(self, self._OnClose)
258    
259          self.SetMap(map)          self.SetMap(map)
260    
261        def find_layer(self, layer):
262            """Return the tree item for the layer"""
263            root = self.GetRootItem()
264            id, cookie = self.GetFirstChild(root, 0)
265            while id.IsOk():
266                if self.GetPyData(id) is layer:
267                    return id
268                id, cookie = self.GetNextChild(root, cookie)
269            return None
270    
271      def _OnClose(self, event):      def _OnClose(self, event):
272          self.SetMap(None)          self.SetMap(None)
273    
# Line 197  class LegendTree(wxTreeCtrl): Line 277  class LegendTree(wxTreeCtrl):
277      def SetMap(self, map):      def SetMap(self, map):
278    
279          sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),          sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),
280                      (MAP_LAYERS_ADDED, self._OnMsgMapLayersAddedRemoved),                      (MAP_LAYERS_ADDED, self._OnMsgMapLayersAdded),
281                      (MAP_LAYERS_REMOVED, self._OnMsgMapLayersAddedRemoved)]                      (MAP_LAYERS_REMOVED, self._OnMsgMapLayersRemoved)]
282    
283          if self.map is not None:          if self.map is not None:
284              for msg, func in sub_list: self.map.Unsubscribe(msg, func)              for msg, func in sub_list: self.map.Unsubscribe(msg, func)
# Line 209  class LegendTree(wxTreeCtrl): Line 289  class LegendTree(wxTreeCtrl):
289                      #self._OnMsgMapsChanged)                      #self._OnMsgMapsChanged)
290              #except ConnectorError:              #except ConnectorError:
291                  #pass                  #pass
292              self.__DeleteAllItems()              self.DeleteAllItems()
293                    
294          self.map = map          self.map = map
295    
# Line 221  class LegendTree(wxTreeCtrl): Line 301  class LegendTree(wxTreeCtrl):
301                  #self._OnMsgMapsChanged)                  #self._OnMsgMapsChanged)
302              self.__FillTree(self.map)              self.__FillTree(self.map)
303    
304        def MoveCurrentItemTop(self):
305            layer, group = self.GetSelectedHierarchy()
306    
307            if layer is not None:
308                self.map.MoveLayerToTop(layer)
309            else:
310                assert False, "Shouldn't be allowed."
311                pass
312    
313      def MoveCurrentItemUp(self):      def MoveCurrentItemUp(self):
314          layer, group = self.GetSelectedHierarchy()          layer, group = self.GetSelectedHierarchy()
315    
# Line 239  class LegendTree(wxTreeCtrl): Line 328  class LegendTree(wxTreeCtrl):
328              assert False, "Shouldn't be allowed."              assert False, "Shouldn't be allowed."
329              pass              pass
330    
331        def MoveCurrentItemBottom(self):
332            layer, group = self.GetSelectedHierarchy()
333    
334            if layer is not None:
335                self.map.MoveLayerToBottom(layer)
336            else:
337                assert False, "Shouldn't be allowed."
338                pass
339    
340      def OnCompareItems(self, item1, item2):      def OnCompareItems(self, item1, item2):
341    
342          data1 = self.GetPyData(item1)          data1 = self.GetPyData(item1)
343          data2 = self.GetPyData(item2)          data2 = self.GetPyData(item2)
344    
345          if isinstance(data1, Layer):          if isinstance(data1, BaseLayer):
346              layers = self.map.Layers()              layers = self.map.Layers()
347              return layers.index(data2) - layers.index(data1)              return layers.index(data2) - layers.index(data1)
348          else:          else:
349              return wxTreeCtrl.OnCompareItems(self, item1, item2)              return wxTreeCtrl.OnCompareItems(self, item1, item2)
350    
   
351      def DoOnShowLayer(self):      def DoOnShowLayer(self):
         #self.__ShowHideLayer(True)  
352          layer, group = self.GetSelectedHierarchy()          layer, group = self.GetSelectedHierarchy()
353          layer.SetVisible(True)          layer.SetVisible(True)
354    
355      def DoOnHideLayer(self):      def DoOnHideLayer(self):
         #self.__ShowHideLayer(False)  
356          layer, group = self.GetSelectedHierarchy()          layer, group = self.GetSelectedHierarchy()
357          layer.SetVisible(False)          layer.SetVisible(False)
358    
359        def ToggleVisibility(self):
360            layer, group = self.GetSelectedHierarchy()
361    
362            layer.SetVisible(not layer.Visible())
363    
364        def LayerProjection(self):
365            self.parent.mainWindow.LayerProjection()
366    
367      def Sort(self):      def Sort(self):
368          self.SortChildren(self.GetRootItem())          self.SortChildren(self.GetRootItem())
369    
# Line 286  class LegendTree(wxTreeCtrl): Line 389  class LegendTree(wxTreeCtrl):
389          self.SetMap(self.mainWindow.Map())          self.SetMap(self.mainWindow.Map())
390                    
391      def _OnSelChanged(self, event):      def _OnSelChanged(self, event):
392            # If we change the selection from normalize_selection do nothing.
393            if self.changing_selection:
394                return
395    
396            self.normalize_selection()
397          self.__UpdateSelection()          self.__UpdateSelection()
398    
399        def normalize_selection(self):
400            """Select the layer containing currently selected item"""
401            # This is really a workaround for a bug in wx where deleting a
402            # subtree with DeleteChildren does not update the selection
403            # properly and can lead to segfaults later because the return
404            # value of GetSelection points to invalid data.
405            item = self.GetSelection()
406            while item.IsOk():
407                object = self.GetPyData(item)
408                if isinstance(object, BaseLayer):
409                    break
410                item = self.GetItemParent(item)
411            else:
412                # No layer was found in the chain of parents, so there's
413                # nothing we can do.
414                return
415    
416            self.changing_selection = 1
417            try:
418                self.SelectItem(item)
419            finally:
420                self.changing_selection = 0
421    
422    
423        def OnItemExpandCollapse(self, event):
424            if self.preventExpandCollapse:
425                event.Veto()
426                self.preventExpandCollapse = False
427    
428        def _OnRightClick(self, event):
429            """Select item and pop up a context menu"""
430    
431            # The pop up menu is related to the legend tree, so we have direct
432            # access on the tree items. The events issued by the menu are handled
433            # by the legend panel, since most of the handlers are already
434            # implemented there.
435    
436            # Update item selection to the right click
437            item = event.GetItem()
438            self.SelectItem(item)
439    
440            # Create the menu
441            menu = wxMenu("", 0)
442    
443            # The "Visible" item is a special ...
444            menuitem = wxMenuItem(menu, ID_POPUP_VISIBLE, _("Visible"),
445                                    "", wxITEM_CHECK)
446            menu.AppendItem(menuitem)
447            layer, group = self.GetSelectedHierarchy()
448            menuitem.Check(layer.Visible())
449    
450            menu.AppendSeparator()
451            menu.Append(ID_POPUP_PROPS, _("Properties"))
452            menu.Append(ID_POPUP_PROJ, _("Projection"))
453            menu.AppendSeparator()
454            menu.Append(ID_POPUP_TOP, _("Top"))
455            menu.Append(ID_POPUP_UP, _("Up"))
456            menu.Append(ID_POPUP_DOWN, _("Down"))
457            menu.Append(ID_POPUP_BOTTOM, _("Bottom"))
458    
459            # Display the menu
460            pos = event.GetPoint()
461            shift = self.ClientToScreen((0,0))
462            self.PopupMenu(menu, pos)
463    
464      def _OnItemActivated(self, event):      def _OnItemActivated(self, event):
465          self.parent.DoOnProperties()          # The following looks strange but is need under Windows to
466            # raise the Properties on double-click: The tree control
467            # always gets an Expanded / Collapsed event after the ItemActivated
468            # on double click, which raises the main window again. We add a second
469            # ItemActivated event to the queue, which simply raises the already
470            # displayed window.
471            if self.raiseProperties:
472                self.parent.DoOnProperties()
473                self.raiseProperties = False
474            else:
475                self.raiseProperties = True
476                self.preventExpandCollapse = True
477                self.parent.DoOnProperties()
478                self.AddPendingEvent(event)
479    
480      def _OnMsgLayerChanged(self, layer):      def _OnMsgLayerChanged(self, layer):
481          assert isinstance(layer, Layer)          assert isinstance(layer, BaseLayer)
482    
483          id = self.layer2id[layer]          id = self.find_layer(layer)
484          assert id.IsOk()          assert id is not None
485    
486          # XXX: yikes! this is so bad, we should be doing what is          self.__FillTreeLayer(id)
         #      commented out, but there is a problem with keeping  
         #      track of the images in the image list when we replace  
         #      a layer. it ends up causing a seg fault.  
         self.__FillTree(self.map)  
487          self.__UpdateSelection()          self.__UpdateSelection()
         #self.__FillTreeLayer(id)  
488    
489      def _OnMsgMapStackingChanged(self, *args):      def _OnMsgMapStackingChanged(self, *args):
490          self.Sort()          self.Sort()
# Line 313  class LegendTree(wxTreeCtrl): Line 494  class LegendTree(wxTreeCtrl):
494              self.EnsureVisible(id)              self.EnsureVisible(id)
495          self.__UpdateSelection()          self.__UpdateSelection()
496    
497      def _OnMsgMapLayersAddedRemoved(self, map):      def _OnMsgMapLayersAdded(self, map):
498          assert map is self.map          assert map is self.map
499    
500          self.__FillTree(self.map)          # Build a dict with all layers known by the the tree as keys
501            layers = {}
502            root = self.GetRootItem()
503            id, cookie = self.GetFirstChild(root, 0)
504            while id.IsOk():
505                layers[self.GetPyData(id)] = 1
506                id, cookie = self.GetNextChild(root, cookie)
507    
508            # Add layers in the map but not in the dict
509            i = 0
510            for l in map.Layers():
511                if not l in layers:
512                    self.__AddLayer(i, l)
513    
514            self.__UpdateSelection()
515    
516        def _OnMsgMapLayersRemoved(self, map):
517            assert map is self.map
518    
519            layers = map.Layers()
520    
521            root = self.GetRootItem()
522            id, cookie = self.GetFirstChild(root, 0)
523            while id.IsOk():
524                if self.GetPyData(id) not in layers:
525                    self.__RemoveLayer(id)
526                id, cookie = self.GetNextChild(root, cookie)
527    
528    
529          self.__UpdateSelection()          self.__UpdateSelection()
530    
531      def _OnMsgLayerVisibilityChanged(self, layer):      def _OnMsgLayerVisibilityChanged(self, layer):
532          assert isinstance(layer, Layer)          assert isinstance(layer, BaseLayer)
533    
534          self.__ShowHideLayer(layer)          self.__ShowHideLayer(layer)
535          self.__UpdateSelection()          self.__UpdateSelection()
536    
537      def _OnMsgLayerTitleChanged(self, layer):      def _OnMsgLayerTitleChanged(self, layer):
538    
539          id = self.layer2id[layer]          id = self.find_layer(layer)
540          if id.IsOk():          if id.IsOk():
541              self.SetItemText(id, layer.Title())              self.SetItemText(id, layer.Title())
542          self.__UpdateSelection()          self.__UpdateSelection()
# Line 340  class LegendTree(wxTreeCtrl): Line 549  class LegendTree(wxTreeCtrl):
549    
550          self.Freeze()          self.Freeze()
551    
552          self.__DeleteAllItems()          self.DeleteAllItems()
553    
554          if map.HasLayers():          if map.HasLayers():
555                root = self.GetRootItem()
             self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)  
                                                                                   
             bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)  
             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)  
   
             root = self.AddRoot("")  
   
556              for l in map.Layers():              for l in map.Layers():
557                  id = self.PrependItem(root, l.Title())                  self.__AddLayer(0, l)
                 l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)  
                 l.Subscribe(LAYER_VISIBILITY_CHANGED,  
                             self._OnMsgLayerVisibilityChanged)  
                 l.Subscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)  
                 self.SetPyData(id, l)  
                 self.__SetVisibilityStyle(l.Visible(), id)  
   
                 self.layer2id[l] = id  
   
                 self.__FillTreeLayer(id)  
                 self.Expand(id)  
558    
559          self.Thaw()          self.Thaw()
560    
# Line 383  class LegendTree(wxTreeCtrl): Line 565  class LegendTree(wxTreeCtrl):
565    
566          self.DeleteChildren(pid)          self.DeleteChildren(pid)
567    
568          clazz = layer.GetClassification()          if layer.HasClassification():
569    
570          shapeType = layer.ShapeType()              clazz = layer.GetClassification()
571    
572          show = layer.Visible()              shapeType = layer.ShapeType()
573          for g in clazz:  
574              if g.IsVisible():              show = layer.Visible()
575                  id = self.AppendItem(pid, g.GetDisplayText())              for g in clazz:
576                  self.SetPyData(id, g)                  if g.IsVisible():
577                  self.__SetVisibilityStyle(show, id)                      id = self.AppendItem(pid, g.GetDisplayText())
578                        self.SetPyData(id, g)
579                  bmp = self.__BuildGroupImage(g, shapeType)                      self.__SetVisibilityStyle(show, id)
580    
581                  if bmp is None:                      bmp = self.__BuildGroupImage(g, shapeType)
582                      self.SetItemImage(id, self.emptyImageIndex)  
583                  else:                      if bmp is None:
584                      i = self.image_list.Add(bmp)                          self.SetItemImage(id, -1)
585                      self.SetItemImage(id, i)                          self.SetItemSelectedImage(id, -1)
586                        else:
587                            if self.availImgListIndices:
588                                i = self.availImgListIndices.pop(0)
589                                self.image_list.Replace(i, bmp)
590                            else:
591                                i = self.image_list.Add(bmp)
592    
593                            self.SetItemImage(id, i)
594                            self.SetItemSelectedImage(id, i)
595    
596          self.Thaw()          self.Thaw()
597    
# Line 416  class LegendTree(wxTreeCtrl): Line 607  class LegendTree(wxTreeCtrl):
607    
608          return bmp          return bmp
609    
610      def __DeleteAllItems(self):      def DeleteAllItems(self):
611    
612          while len(self.layer2id) > 0:          pid = self.GetRootItem()
             layer, id = self.layer2id.popitem()  
             layer.Unsubscribe(LAYER_CHANGED,  
                               self._OnMsgLayerChanged)  
             layer.Unsubscribe(LAYER_VISIBILITY_CHANGED,  
                               self._OnMsgLayerVisibilityChanged)  
             layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)  
613    
614          self.DeleteAllItems()          id, cookie = self.GetFirstChild(pid, 123)
615            while id.IsOk():
616                self.__RemoveLayer(id)
617                id, cookie = self.GetNextChild(pid, cookie)
618    
619            wxTreeCtrl.DeleteAllItems(self)
620    
621        def __AddLayer(self, before, l):
622            root = self.GetRootItem()
623            id = self.InsertItemBefore(root, before,
624                                l.Title(),
625                                self.mapImageIndex,
626                                self.mapImageIndex)
627    
628            self.SetPyData(id, l)
629            self.__SetVisibilityStyle(l.Visible(), id)
630    
631            self.__FillTreeLayer(id)
632            self.Expand(id)
633    
634            l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
635            l.Subscribe(LAYER_VISIBILITY_CHANGED,
636                        self._OnMsgLayerVisibilityChanged)
637            l.Subscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
638    
639        def __RemoveLayer(self, id):
640            self.DeleteChildren(id)
641    
642            layer = self.GetPyData(id)
643            layer.Unsubscribe(LAYER_CHANGED,
644                              self._OnMsgLayerChanged)
645            layer.Unsubscribe(LAYER_VISIBILITY_CHANGED,
646                              self._OnMsgLayerVisibilityChanged)
647            layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
648    
649            self.Delete(id)
650    
651        def DeleteChildren(self, pid):
652            id, cookie = self.GetFirstChild(pid, 123)
653            while id.IsOk():
654                self.availImgListIndices.append(self.GetItemImage(id))
655                id, cookie = self.GetNextChild(pid, cookie)
656            wxTreeCtrl.DeleteChildren(self, pid)
657    
658        def GetRootItem(self):
659            root = wxTreeCtrl.GetRootItem(self)
660    
661            if not root.IsOk():
662                self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)
663    
664                bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
665                dc = wxMemoryDC()
666                dc.SelectObject(bmp)
667                dc.SetBrush(wxBLACK_BRUSH)
668                dc.Clear()
669                dc.SelectObject(wxNullBitmap)
670    
671                self.emptyImageIndex = \
672                    self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))
673    
674                bmp = resource.GetBitmapResource("legend_icon_layer",
675                                                  wxBITMAP_TYPE_XPM)
676                self.mapImageIndex = \
677                    self.image_list.Add(bmp)
678    
679                self.AssignImageList(self.image_list)
680                self.availImgListIndices = []
681    
682                root = self.AddRoot("")
683    
684            return root
685    
686      def __SetVisibilityStyle(self, visible, id):      def __SetVisibilityStyle(self, visible, id):
687          font = self.GetItemFont(id)          font = self.GetItemFont(id)
# Line 435  class LegendTree(wxTreeCtrl): Line 690  class LegendTree(wxTreeCtrl):
690              font.SetStyle(wxNORMAL)              font.SetStyle(wxNORMAL)
691              color = wxBLACK              color = wxBLACK
692          else:          else:
693              font.SetStyle(wxITALIC)              #font.SetStyle(wxITALIC)
694                font.SetStyle(wxNORMAL)
695              color = wxLIGHT_GREY              color = wxLIGHT_GREY
696    
697          self.SetItemTextColour(id, color)          self.SetItemTextColour(id, color)
698          self.SetItemFont(id, font)          self.SetItemFont(id, font)
699                    
700      def __ShowHideLayer(self, layer):      def __ShowHideLayer(self, layer):
701          parent = self.layer2id[layer]          parent = self.find_layer(layer)
702          assert parent.IsOk()          assert parent.IsOk()
703    
704          visible = layer.Visible()          visible = layer.Visible()
# Line 461  class ScaleBarBitmap(wxBoxSizer): Line 717  class ScaleBarBitmap(wxBoxSizer):
717          # While the width is fixed, get the height _now_.          # While the width is fixed, get the height _now_.
718          dc = wxMemoryDC()          dc = wxMemoryDC()
719          textwidth, textheight = dc.GetTextExtent("%d"%0)          textwidth, textheight = dc.GetTextExtent("%d"%0)
720          self.width = 200          self.width = 210
721          self.height = textheight + 3*2 + 8          self.height = textheight + 3*2 + 8
722    
723          wxBoxSizer.__init__(self, wxVERTICAL)          wxBoxSizer.__init__(self, wxVERTICAL)
# Line 496  class ScaleBarBitmap(wxBoxSizer): Line 752  class ScaleBarBitmap(wxBoxSizer):
752          dc.SelectObject(bmp)          dc.SelectObject(bmp)
753          dc.Clear()          dc.Clear()
754    
755          self.scalebar.DrawScalebar(scale, dc)          if self.canvas.map is not None \
756                and self.canvas.map.projection is not None:
757    
758                # if we are using a projection with geographics coordinates
759                # we need to change the scale value based on where we are
760                # on the globe.
761                if self.canvas.map.projection.GetProjectedUnits() \
762                    == PROJ_UNITS_DEGREES:
763    
764                    width, height = self.canvas.GetSizeTuple()
765                    long, lat = self.canvas.win_to_proj(width/2, height/2)
766    
767                    # slightly inaccurate, but if we are looking at
768                    # the north/south pole we could end up dividing by zero
769                    #
770                    # it shouldn't matter for our purposes that we ignore
771                    # the original sign of lat.
772                    if fabs(lat) > 89.9: lat = 89.9
773    
774                    #
775                    # one degree is about 111,133m at the equator
776                    # we need to adjust that for latitude as
777                    # we move north/south. use the center of the map
778                    # as the point to scale the length to.
779                    #
780                    scale = scale / (111133.0 * fabs(cos(lat * pi/180)))
781    
782                self.scalebar.DrawScaleBar(scale, dc, (0,0), dc.GetSizeTuple())
783    
784          self.scalebarBitmap.SetBitmap(bmp)          self.scalebarBitmap.SetBitmap(bmp)
785    
Legend:
Removed from v.858  
changed lines
  Added in v.1837
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26