/[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 990 by frank, Thu May 22 16:51:24 2003 UTC revision 1231 by jonathan, Wed Jun 18 14:46:57 2003 UTC
# Line 39  ID_LEGEND_PROPS = 4006 Line 39  ID_LEGEND_PROPS = 4006
39  ID_LEGEND_SHOWLAYER = 4007  ID_LEGEND_SHOWLAYER = 4007
40  ID_LEGEND_HIDELAYER = 4008  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  TOP_BMP = "top_layer"  TOP_BMP = "top_layer"
# Line 201  class LegendTree(wxTreeCtrl): Line 201  class LegendTree(wxTreeCtrl):
201          self.mainWindow = mainWindow          self.mainWindow = mainWindow
202          self.map = None          self.map = None
203          self.parent = parent          self.parent = parent
204          self.layer2id = {}          self.changing_selection = 0
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            self.preventExpandCollapse = False
224    
225          EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)          EVT_TREE_ITEM_ACTIVATED(self, ID_LEGEND_TREE, self._OnItemActivated)
226          EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)          EVT_TREE_SEL_CHANGED(self, ID_LEGEND_TREE, self._OnSelChanged)
227            EVT_TREE_ITEM_EXPANDING(self, ID_LEGEND_TREE, self.OnItemExpandCollapse)
228            EVT_TREE_ITEM_COLLAPSING(self, ID_LEGEND_TREE, self.OnItemExpandCollapse)
229    
230          EVT_CLOSE(self, self._OnClose)          EVT_CLOSE(self, self._OnClose)
231    
232          self.SetMap(map)          self.SetMap(map)
233    
234        def find_layer(self, layer):
235            """Return the tree item for the layer"""
236            root = self.GetRootItem()
237            id, cookie = self.GetFirstChild(root, 0)
238            while id.IsOk():
239                if self.GetPyData(id) is layer:
240                    return id
241                id, cookie = self.GetNextChild(root, cookie)
242            return None
243    
244      def _OnClose(self, event):      def _OnClose(self, event):
245          self.SetMap(None)          self.SetMap(None)
246    
# Line 224  class LegendTree(wxTreeCtrl): Line 250  class LegendTree(wxTreeCtrl):
250      def SetMap(self, map):      def SetMap(self, map):
251    
252          sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),          sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),
253                      (MAP_LAYERS_ADDED, self._OnMsgMapLayersAddedRemoved),                      (MAP_LAYERS_ADDED, self._OnMsgMapLayersAdded),
254                      (MAP_LAYERS_REMOVED, self._OnMsgMapLayersAddedRemoved)]                      (MAP_LAYERS_REMOVED, self._OnMsgMapLayersRemoved)]
255    
256          if self.map is not None:          if self.map is not None:
257              for msg, func in sub_list: self.map.Unsubscribe(msg, func)              for msg, func in sub_list: self.map.Unsubscribe(msg, func)
# Line 236  class LegendTree(wxTreeCtrl): Line 262  class LegendTree(wxTreeCtrl):
262                      #self._OnMsgMapsChanged)                      #self._OnMsgMapsChanged)
263              #except ConnectorError:              #except ConnectorError:
264                  #pass                  #pass
265              self.__DeleteAllItems()              self.DeleteAllItems()
266                    
267          self.map = map          self.map = map
268    
# Line 252  class LegendTree(wxTreeCtrl): Line 278  class LegendTree(wxTreeCtrl):
278          layer, group = self.GetSelectedHierarchy()          layer, group = self.GetSelectedHierarchy()
279    
280          if layer is not None:          if layer is not None:
281              self.map.TopLayer(layer)              self.map.MoveLayerToTop(layer)
282          else:          else:
283              assert False, "Shouldn't be allowed."              assert False, "Shouldn't be allowed."
284              pass              pass
# Line 279  class LegendTree(wxTreeCtrl): Line 305  class LegendTree(wxTreeCtrl):
305          layer, group = self.GetSelectedHierarchy()          layer, group = self.GetSelectedHierarchy()
306    
307          if layer is not None:          if layer is not None:
308              self.map.BottomLayer(layer)              self.map.MoveLayerToBottom(layer)
309          else:          else:
310              assert False, "Shouldn't be allowed."              assert False, "Shouldn't be allowed."
311              pass              pass
# Line 296  class LegendTree(wxTreeCtrl): Line 322  class LegendTree(wxTreeCtrl):
322              return wxTreeCtrl.OnCompareItems(self, item1, item2)              return wxTreeCtrl.OnCompareItems(self, item1, item2)
323    
324      def DoOnShowLayer(self):      def DoOnShowLayer(self):
         #self.__ShowHideLayer(True)  
325          layer, group = self.GetSelectedHierarchy()          layer, group = self.GetSelectedHierarchy()
326          layer.SetVisible(True)          layer.SetVisible(True)
327    
328      def DoOnHideLayer(self):      def DoOnHideLayer(self):
         #self.__ShowHideLayer(False)  
329          layer, group = self.GetSelectedHierarchy()          layer, group = self.GetSelectedHierarchy()
330          layer.SetVisible(False)          layer.SetVisible(False)
331    
# Line 330  class LegendTree(wxTreeCtrl): Line 354  class LegendTree(wxTreeCtrl):
354          self.SetMap(self.mainWindow.Map())          self.SetMap(self.mainWindow.Map())
355                    
356      def _OnSelChanged(self, event):      def _OnSelChanged(self, event):
357            # If we change the selection from normalize_selection do nothing.
358            if self.changing_selection:
359                return
360    
361            self.normalize_selection()
362          self.__UpdateSelection()          self.__UpdateSelection()
363    
364        def normalize_selection(self):
365            """Select the layer containing currently selected item"""
366            # This is really a workaround for a bug in wx where deleting a
367            # subtree with DeleteChildren does not update the selection
368            # properly and can lead to segfaults later because the return
369            # value of GetSelection points to invalid data.
370            item = self.GetSelection()
371            while item.IsOk():
372                object = self.GetPyData(item)
373                if isinstance(object, BaseLayer):
374                    break
375                item = self.GetItemParent(item)
376            else:
377                # No layer was found in the chain of parents, so there's
378                # nothing we can do.
379                return
380    
381            self.changing_selection = 1
382            try:
383                self.SelectItem(item)
384            finally:
385                self.changing_selection = 0
386    
387    
388        def OnItemExpandCollapse(self, event):
389            if self.preventExpandCollapse:
390                event.Veto()
391                self.preventExpandCollapse = False
392    
393      def _OnItemActivated(self, event):      def _OnItemActivated(self, event):
394            self.preventExpandCollapse = True
395          self.parent.DoOnProperties()          self.parent.DoOnProperties()
396    
397      def _OnMsgLayerChanged(self, layer):      def _OnMsgLayerChanged(self, layer):
398          assert isinstance(layer, BaseLayer)          assert isinstance(layer, BaseLayer)
399    
400          id = self.layer2id[layer]          id = self.find_layer(layer)
401          assert id.IsOk()          assert id is not None
402    
403          # 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)  
404          self.__UpdateSelection()          self.__UpdateSelection()
         #self.__FillTreeLayer(id)  
405    
406      def _OnMsgMapStackingChanged(self, *args):      def _OnMsgMapStackingChanged(self, *args):
407          self.Sort()          self.Sort()
# Line 357  class LegendTree(wxTreeCtrl): Line 411  class LegendTree(wxTreeCtrl):
411              self.EnsureVisible(id)              self.EnsureVisible(id)
412          self.__UpdateSelection()          self.__UpdateSelection()
413    
414      def _OnMsgMapLayersAddedRemoved(self, map):      def _OnMsgMapLayersAdded(self, map):
415          assert map is self.map          assert map is self.map
416    
417          self.__FillTree(self.map)          # Build a dict with all layers known by the the tree as keys
418            layers = {}
419            root = self.GetRootItem()
420            id, cookie = self.GetFirstChild(root, 0)
421            while id.IsOk():
422                layers[self.GetPyData(id)] = 1
423                id, cookie = self.GetNextChild(root, cookie)
424    
425            # Add layers in the map but not in the dict
426            i = 0
427            for l in map.Layers():
428                if not l in layers:
429                    self.__AddLayer(i, l)
430    
431            self.__UpdateSelection()
432    
433        def _OnMsgMapLayersRemoved(self, map):
434            assert map is self.map
435    
436            layers = map.Layers()
437    
438            root = self.GetRootItem()
439            id, cookie = self.GetFirstChild(root, 0)
440            while id.IsOk():
441                if self.GetPyData(id) not in layers:
442                    self.__RemoveLayer(id)
443                id, cookie = self.GetNextChild(root, cookie)
444    
445    
446          self.__UpdateSelection()          self.__UpdateSelection()
447    
448      def _OnMsgLayerVisibilityChanged(self, layer):      def _OnMsgLayerVisibilityChanged(self, layer):
# Line 371  class LegendTree(wxTreeCtrl): Line 453  class LegendTree(wxTreeCtrl):
453    
454      def _OnMsgLayerTitleChanged(self, layer):      def _OnMsgLayerTitleChanged(self, layer):
455    
456          id = self.layer2id[layer]          id = self.find_layer(layer)
457          if id.IsOk():          if id.IsOk():
458              self.SetItemText(id, layer.Title())              self.SetItemText(id, layer.Title())
459          self.__UpdateSelection()          self.__UpdateSelection()
# Line 384  class LegendTree(wxTreeCtrl): Line 466  class LegendTree(wxTreeCtrl):
466    
467          self.Freeze()          self.Freeze()
468    
469          self.__DeleteAllItems()          self.DeleteAllItems()
470    
471          if map.HasLayers():          if map.HasLayers():
472                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("")  
   
473              for l in map.Layers():              for l in map.Layers():
474                  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)  
475    
476          self.Thaw()          self.Thaw()
477    
# Line 443  class LegendTree(wxTreeCtrl): Line 498  class LegendTree(wxTreeCtrl):
498                      bmp = self.__BuildGroupImage(g, shapeType)                      bmp = self.__BuildGroupImage(g, shapeType)
499    
500                      if bmp is None:                      if bmp is None:
501                          self.SetItemImage(id, self.emptyImageIndex)                          self.SetItemImage(id, -1)
502                            self.SetItemSelectedImage(id, -1)
503                      else:                      else:
504                          i = self.image_list.Add(bmp)                          if self.availImgListIndices:
505                                i = self.availImgListIndices.pop(0)
506                                self.image_list.Replace(i, bmp)
507                            else:
508                                i = self.image_list.Add(bmp)
509    
510                          self.SetItemImage(id, i)                          self.SetItemImage(id, i)
511                            self.SetItemSelectedImage(id, i)
512    
513          self.Thaw()          self.Thaw()
514    
# Line 462  class LegendTree(wxTreeCtrl): Line 524  class LegendTree(wxTreeCtrl):
524    
525          return bmp          return bmp
526    
527      def __DeleteAllItems(self):      def DeleteAllItems(self):
528    
529          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)  
530    
531          self.DeleteAllItems()          id, cookie = self.GetFirstChild(pid, 123)
532            while id.IsOk():
533                self.__RemoveLayer(id)
534                id, cookie = self.GetNextChild(pid, cookie)
535    
536            wxTreeCtrl.DeleteAllItems(self)
537    
538        def __AddLayer(self, before, l):
539            root = self.GetRootItem()
540            id = self.InsertItemBefore(root, before,
541                                l.Title(),
542                                self.mapImageIndex,
543                                self.mapImageIndex)
544    
545            self.SetPyData(id, l)
546            self.__SetVisibilityStyle(l.Visible(), id)
547    
548            self.__FillTreeLayer(id)
549            self.Expand(id)
550    
551            l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
552            l.Subscribe(LAYER_VISIBILITY_CHANGED,
553                        self._OnMsgLayerVisibilityChanged)
554            l.Subscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
555    
556        def __RemoveLayer(self, id):
557            self.DeleteChildren(id)
558    
559            layer = self.GetPyData(id)
560            layer.Unsubscribe(LAYER_CHANGED,
561                              self._OnMsgLayerChanged)
562            layer.Unsubscribe(LAYER_VISIBILITY_CHANGED,
563                              self._OnMsgLayerVisibilityChanged)
564            layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
565    
566            self.Delete(id)
567    
568        def DeleteChildren(self, pid):
569            id, cookie = self.GetFirstChild(pid, 123)
570            while id.IsOk():
571                self.availImgListIndices.append(self.GetItemImage(id))
572                id, cookie = self.GetNextChild(pid, cookie)
573            wxTreeCtrl.DeleteChildren(self, pid)
574    
575        def GetRootItem(self):
576            root = wxTreeCtrl.GetRootItem(self)
577    
578            if not root.IsOk():
579                self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)
580    
581                bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
582                dc = wxMemoryDC()
583                dc.SelectObject(bmp)
584                dc.SetBrush(wxBLACK_BRUSH)
585                dc.Clear()
586                dc.SelectObject(wxNullBitmap)
587    
588                self.emptyImageIndex = \
589                    self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))
590    
591                bmp = resource.GetBitmapResource("legend_icon_layer",
592                                                  wxBITMAP_TYPE_XPM)
593                self.mapImageIndex = \
594                    self.image_list.Add(bmp)
595    
596                self.AssignImageList(self.image_list)
597                self.availImgListIndices = []
598    
599                root = self.AddRoot("")
600    
601            return root
602    
603      def __SetVisibilityStyle(self, visible, id):      def __SetVisibilityStyle(self, visible, id):
604          font = self.GetItemFont(id)          font = self.GetItemFont(id)
# Line 489  class LegendTree(wxTreeCtrl): Line 615  class LegendTree(wxTreeCtrl):
615          self.SetItemFont(id, font)          self.SetItemFont(id, font)
616                    
617      def __ShowHideLayer(self, layer):      def __ShowHideLayer(self, layer):
618          parent = self.layer2id[layer]          parent = self.find_layer(layer)
619          assert parent.IsOk()          assert parent.IsOk()
620    
621          visible = layer.Visible()          visible = layer.Visible()
# Line 543  class ScaleBarBitmap(wxBoxSizer): Line 669  class ScaleBarBitmap(wxBoxSizer):
669          dc.SelectObject(bmp)          dc.SelectObject(bmp)
670          dc.Clear()          dc.Clear()
671    
672          self.scalebar.DrawScaleBar(scale, dc, (0,0), dc.GetSizeTuple())          if self.canvas.map is not None \
673                and self.canvas.map.projection is not None:
674                self.scalebar.DrawScaleBar(scale, dc, (0,0), dc.GetSizeTuple())
675    
676          self.scalebarBitmap.SetBitmap(bmp)          self.scalebarBitmap.SetBitmap(bmp)
677    
Legend:
Removed from v.990  
changed lines
  Added in v.1231
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26