/[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 1050 by frank, Tue May 27 09:31:13 2003 UTC revision 1180 by jonathan, Thu Jun 12 16:28:54 2003 UTC
# 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
# Line 215  class LegendTree(wxTreeCtrl): Line 227  class LegendTree(wxTreeCtrl):
227    
228          self.SetMap(map)          self.SetMap(map)
229    
230        def find_layer(self, layer):
231            """Return the tree item for the layer"""
232            root = self.GetRootItem()
233            id, cookie = self.GetFirstChild(root, 0)
234            while id.IsOk():
235                if self.GetPyData(id) is layer:
236                    return id
237                id, cookie = self.GetNextChild(root, cookie)
238            return None
239    
240      def _OnClose(self, event):      def _OnClose(self, event):
241          self.SetMap(None)          self.SetMap(None)
242    
# Line 224  class LegendTree(wxTreeCtrl): Line 246  class LegendTree(wxTreeCtrl):
246      def SetMap(self, map):      def SetMap(self, map):
247    
248          sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),          sub_list = [(MAP_STACKING_CHANGED, self._OnMsgMapStackingChanged),
249                      (MAP_LAYERS_ADDED, self._OnMsgMapLayersAddedRemoved),                      (MAP_LAYERS_ADDED, self._OnMsgMapLayersAdded),
250                      (MAP_LAYERS_REMOVED, self._OnMsgMapLayersAddedRemoved)]                      (MAP_LAYERS_REMOVED, self._OnMsgMapLayersRemoved)]
251    
252          if self.map is not None:          if self.map is not None:
253              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 258  class LegendTree(wxTreeCtrl):
258                      #self._OnMsgMapsChanged)                      #self._OnMsgMapsChanged)
259              #except ConnectorError:              #except ConnectorError:
260                  #pass                  #pass
261              self.__DeleteAllItems()              self.DeleteAllItems()
262                    
263          self.map = map          self.map = map
264    
# Line 252  class LegendTree(wxTreeCtrl): Line 274  class LegendTree(wxTreeCtrl):
274          layer, group = self.GetSelectedHierarchy()          layer, group = self.GetSelectedHierarchy()
275    
276          if layer is not None:          if layer is not None:
277              self.map.TopLayer(layer)              self.map.MoveLayerToTop(layer)
278          else:          else:
279              assert False, "Shouldn't be allowed."              assert False, "Shouldn't be allowed."
280              pass              pass
# Line 279  class LegendTree(wxTreeCtrl): Line 301  class LegendTree(wxTreeCtrl):
301          layer, group = self.GetSelectedHierarchy()          layer, group = self.GetSelectedHierarchy()
302    
303          if layer is not None:          if layer is not None:
304              self.map.BottomLayer(layer)              self.map.MoveLayerToBottom(layer)
305          else:          else:
306              assert False, "Shouldn't be allowed."              assert False, "Shouldn't be allowed."
307              pass              pass
# Line 296  class LegendTree(wxTreeCtrl): Line 318  class LegendTree(wxTreeCtrl):
318              return wxTreeCtrl.OnCompareItems(self, item1, item2)              return wxTreeCtrl.OnCompareItems(self, item1, item2)
319    
320      def DoOnShowLayer(self):      def DoOnShowLayer(self):
         #self.__ShowHideLayer(True)  
321          layer, group = self.GetSelectedHierarchy()          layer, group = self.GetSelectedHierarchy()
322          layer.SetVisible(True)          layer.SetVisible(True)
323    
324      def DoOnHideLayer(self):      def DoOnHideLayer(self):
         #self.__ShowHideLayer(False)  
325          layer, group = self.GetSelectedHierarchy()          layer, group = self.GetSelectedHierarchy()
326          layer.SetVisible(False)          layer.SetVisible(False)
327    
# Line 330  class LegendTree(wxTreeCtrl): Line 350  class LegendTree(wxTreeCtrl):
350          self.SetMap(self.mainWindow.Map())          self.SetMap(self.mainWindow.Map())
351                    
352      def _OnSelChanged(self, event):      def _OnSelChanged(self, event):
353            # If we change the selection from normalize_selection do nothing.
354            if self.changing_selection:
355                return
356    
357            self.normalize_selection()
358          self.__UpdateSelection()          self.__UpdateSelection()
359    
360        def normalize_selection(self):
361            """Select the layer containing currently selected item"""
362            # This is really a workaround for a bug in wx where deleting a
363            # subtree with DeleteChildren does not update the selection
364            # properly and can lead to segfaults later because the return
365            # value of GetSelection points to invalid data.
366            item = self.GetSelection()
367            while item.IsOk():
368                object = self.GetPyData(item)
369                if isinstance(object, BaseLayer):
370                    break
371                item = self.GetItemParent(item)
372            else:
373                # No layer was found in the chain of parents, so there's
374                # nothing we can do.
375                return
376    
377            self.changing_selection = 1
378            try:
379                self.SelectItem(item)
380            finally:
381                self.changing_selection = 0
382    
383    
384      def _OnItemActivated(self, event):      def _OnItemActivated(self, event):
385          self.parent.DoOnProperties()          self.parent.DoOnProperties()
386    
387      def _OnMsgLayerChanged(self, layer):      def _OnMsgLayerChanged(self, layer):
388          assert isinstance(layer, BaseLayer)          assert isinstance(layer, BaseLayer)
389    
390          id = self.layer2id[layer]          id = self.find_layer(layer)
391          assert id.IsOk()          assert id is not None
392    
393          # 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)  
394          self.__UpdateSelection()          self.__UpdateSelection()
         #self.__FillTreeLayer(id)  
395    
396      def _OnMsgMapStackingChanged(self, *args):      def _OnMsgMapStackingChanged(self, *args):
397          self.Sort()          self.Sort()
# Line 357  class LegendTree(wxTreeCtrl): Line 401  class LegendTree(wxTreeCtrl):
401              self.EnsureVisible(id)              self.EnsureVisible(id)
402          self.__UpdateSelection()          self.__UpdateSelection()
403    
404      def _OnMsgMapLayersAddedRemoved(self, map):      def _OnMsgMapLayersAdded(self, map):
405            assert map is self.map
406    
407            # Build a dict with all layers known by the the tree as keys
408            layers = {}
409            root = self.GetRootItem()
410            id, cookie = self.GetFirstChild(root, 0)
411            while id.IsOk():
412                layers[self.GetPyData(id)] = 1
413                id, cookie = self.GetNextChild(root, cookie)
414    
415            # Add layers in the map but not in the dict
416            i = 0
417            for l in map.Layers():
418                if not l in layers:
419                    self.__AddLayer(i, l)
420    
421            self.__UpdateSelection()
422    
423        def _OnMsgMapLayersRemoved(self, map):
424          assert map is self.map          assert map is self.map
425    
426          self.__FillTree(self.map)          layers = map.Layers()
427    
428            root = self.GetRootItem()
429            id, cookie = self.GetFirstChild(root, 0)
430            while id.IsOk():
431                if self.GetPyData(id) not in layers:
432                    self.__RemoveLayer(id)
433                id, cookie = self.GetNextChild(root, cookie)
434    
435    
436          self.__UpdateSelection()          self.__UpdateSelection()
437    
438      def _OnMsgLayerVisibilityChanged(self, layer):      def _OnMsgLayerVisibilityChanged(self, layer):
# Line 371  class LegendTree(wxTreeCtrl): Line 443  class LegendTree(wxTreeCtrl):
443    
444      def _OnMsgLayerTitleChanged(self, layer):      def _OnMsgLayerTitleChanged(self, layer):
445    
446          id = self.layer2id[layer]          id = self.find_layer(layer)
447          if id.IsOk():          if id.IsOk():
448              self.SetItemText(id, layer.Title())              self.SetItemText(id, layer.Title())
449          self.__UpdateSelection()          self.__UpdateSelection()
# Line 384  class LegendTree(wxTreeCtrl): Line 456  class LegendTree(wxTreeCtrl):
456    
457          self.Freeze()          self.Freeze()
458    
459          self.__DeleteAllItems()          self.DeleteAllItems()
460    
461          if map.HasLayers():          if map.HasLayers():
462                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))  
                                                                                   
             bmp = resource.GetBitmapResource("legend_icon_map",  
                                               wxBITMAP_TYPE_XPM)  
             self.mapImageIndex = \  
                 self.image_list.Add(bmp)  
   
             self.AssignImageList(self.image_list)  
   
             root = self.AddRoot("")  
   
463              for l in map.Layers():              for l in map.Layers():
464                  id = self.PrependItem(root, l.Title())                  self.__AddLayer(0, l)
                 self.SetItemImage(id, self.mapImageIndex)  
                 self.SetItemSelectedImage(id, self.mapImageIndex)  
   
                 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)  
465    
466          self.Thaw()          self.Thaw()
467    
# Line 454  class LegendTree(wxTreeCtrl): Line 491  class LegendTree(wxTreeCtrl):
491                          self.SetItemImage(id, -1)                          self.SetItemImage(id, -1)
492                          self.SetItemSelectedImage(id, -1)                          self.SetItemSelectedImage(id, -1)
493                      else:                      else:
494                          i = self.image_list.Add(bmp)                          if self.availImgListIndices:
495                                i = self.availImgListIndices.pop(0)
496                                self.image_list.Replace(i, bmp)
497                            else:
498                                i = self.image_list.Add(bmp)
499    
500                          self.SetItemImage(id, i)                          self.SetItemImage(id, i)
501                          self.SetItemSelectedImage(id, i)                          self.SetItemSelectedImage(id, i)
502    
# Line 472  class LegendTree(wxTreeCtrl): Line 514  class LegendTree(wxTreeCtrl):
514    
515          return bmp          return bmp
516    
517      def __DeleteAllItems(self):      def DeleteAllItems(self):
518    
519          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)  
520    
521          self.DeleteAllItems()          id, cookie = self.GetFirstChild(pid, 123)
522            while id.IsOk():
523                self.__RemoveLayer(id)
524                id, cookie = self.GetNextChild(pid, cookie)
525    
526            wxTreeCtrl.DeleteAllItems(self)
527    
528        def __AddLayer(self, before, l):
529            root = self.GetRootItem()
530            id = self.InsertItemBefore(root, before,
531                                l.Title(),
532                                self.mapImageIndex,
533                                self.mapImageIndex)
534    
535            self.SetPyData(id, l)
536            self.__SetVisibilityStyle(l.Visible(), id)
537    
538            self.__FillTreeLayer(id)
539            self.Expand(id)
540    
541            l.Subscribe(LAYER_CHANGED, self._OnMsgLayerChanged)
542            l.Subscribe(LAYER_VISIBILITY_CHANGED,
543                        self._OnMsgLayerVisibilityChanged)
544            l.Subscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
545    
546        def __RemoveLayer(self, id):
547            self.DeleteChildren(id)
548    
549            layer = self.GetPyData(id)
550            layer.Unsubscribe(LAYER_CHANGED,
551                              self._OnMsgLayerChanged)
552            layer.Unsubscribe(LAYER_VISIBILITY_CHANGED,
553                              self._OnMsgLayerVisibilityChanged)
554            layer.Unsubscribe(TITLE_CHANGED, self._OnMsgLayerTitleChanged)
555    
556            self.Delete(id)
557    
558        def DeleteChildren(self, pid):
559            id, cookie = self.GetFirstChild(pid, 123)
560            while id.IsOk():
561                self.availImgListIndices.append(self.GetItemImage(id))
562                id, cookie = self.GetNextChild(pid, cookie)
563            wxTreeCtrl.DeleteChildren(self, pid)
564    
565        def GetRootItem(self):
566            root = wxTreeCtrl.GetRootItem(self)
567    
568            if not root.IsOk():
569                self.image_list = wxImageList(BMP_SIZE_W, BMP_SIZE_H, False, 0)
570    
571                bmp = wxEmptyBitmap(BMP_SIZE_W, BMP_SIZE_H)
572                dc = wxMemoryDC()
573                dc.SelectObject(bmp)
574                dc.SetBrush(wxBLACK_BRUSH)
575                dc.Clear()
576                dc.SelectObject(wxNullBitmap)
577    
578                self.emptyImageIndex = \
579                    self.image_list.AddWithColourMask(bmp, wxColour(0, 0, 0))
580    
581                bmp = resource.GetBitmapResource("legend_icon_layer",
582                                                  wxBITMAP_TYPE_XPM)
583                self.mapImageIndex = \
584                    self.image_list.Add(bmp)
585    
586                self.AssignImageList(self.image_list)
587                self.availImgListIndices = []
588    
589                root = self.AddRoot("")
590    
591            return root
592    
593      def __SetVisibilityStyle(self, visible, id):      def __SetVisibilityStyle(self, visible, id):
594          font = self.GetItemFont(id)          font = self.GetItemFont(id)
# Line 499  class LegendTree(wxTreeCtrl): Line 605  class LegendTree(wxTreeCtrl):
605          self.SetItemFont(id, font)          self.SetItemFont(id, font)
606                    
607      def __ShowHideLayer(self, layer):      def __ShowHideLayer(self, layer):
608          parent = self.layer2id[layer]          parent = self.find_layer(layer)
609          assert parent.IsOk()          assert parent.IsOk()
610    
611          visible = layer.Visible()          visible = layer.Visible()
# Line 553  class ScaleBarBitmap(wxBoxSizer): Line 659  class ScaleBarBitmap(wxBoxSizer):
659          dc.SelectObject(bmp)          dc.SelectObject(bmp)
660          dc.Clear()          dc.Clear()
661    
662          self.scalebar.DrawScaleBar(scale, dc, (0,0), dc.GetSizeTuple())          if self.canvas.map.projection is not None:
663                self.scalebar.DrawScaleBar(scale, dc, (0,0), dc.GetSizeTuple())
664    
665          self.scalebarBitmap.SetBitmap(bmp)          self.scalebarBitmap.SetBitmap(bmp)
666    
Legend:
Removed from v.1050  
changed lines
  Added in v.1180
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26