/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/UI/tree.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/Thuban/UI/tree.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 177 by bh, Wed May 15 14:02:09 2002 UTC revision 374 by jan, Mon Jan 27 14:20:02 2003 UTC
# Line 9  Line 9 
9    
10  __version__ = "$Revision$"  __version__ = "$Revision$"
11    
12    from types import StringType
13    
14  from wxPython.wx import *  from wxPython.wx import *
15    
16  from Thuban.Model.messages import MAPS_CHANGED, MAP_PROJECTION_CHANGED, \  from Thuban import _
17       LAYERS_CHANGED, LAYER_LEGEND_CHANGED, LAYER_VISIBILITY_CHANGED  
18  from Thuban.Model.layer import Layer, shapetype_names  from Thuban.Model.messages import CHANGED
19    from Thuban.Model.layer import Layer
20  from Thuban.Model.map import Map  from Thuban.Model.map import Map
21    
22  from dialogs import NonModalDialog  from dialogs import NonModalDialog
23  from messages import SESSION_CHANGED, SELECTED_LAYER  from messages import SESSION_CHANGED, SELECTED_LAYER
24    
 def color_string(color):  
     if color is None:  
         return "None"  
     return "(%.3f, %.3f, %.3f)" % (color.red, color.green, color.blue)  
   
25    
26  class SessionTreeCtrl(wxTreeCtrl):  class SessionTreeCtrl(wxTreeCtrl):
27    
28      # the session channels to subscribe to to update the tree      """Widget to display a tree view of the session.
29      session_channels = (MAPS_CHANGED, MAP_PROJECTION_CHANGED,  
30                          LAYERS_CHANGED, LAYER_LEGEND_CHANGED,      The tree view is created recursively from the session object. The
31                          LAYER_VISIBILITY_CHANGED)      tree view calls the session's TreeInfo method which should return a
32        pair (<title>, <item>) where <title> ist the title of the session
33        item in the tree view and <items> is a list of objects to use as the
34        children of the session in the tree view.
35    
36        The items list can contain three types of items:
37    
38           1. a string. The string is used as the title for a leaf item in
39              the tree view.
40    
41           2. an object with a TreeInfo method. This method is called and
42              should return a pair just like the session's TreeInfo method.
43    
44           3. a pair (<title>, <item>) which is treated like the return
45              value of TreeInfo.
46        """
47    
48      def __init__(self, parent, ID, app):      def __init__(self, parent, ID, app):
49          # Use the WANTS_CHARS style so the panel doesn't eat the Return key.          # Use the WANTS_CHARS style so the panel doesn't eat the Return key.
# Line 57  class SessionTreeCtrl(wxTreeCtrl): Line 70  class SessionTreeCtrl(wxTreeCtrl):
70    
71      def unsubscribe_all(self):      def unsubscribe_all(self):
72          if self.session is not None:          if self.session is not None:
73              for channel in self.session_channels:              self.session.Unsubscribe(CHANGED, self.update_tree)
                 self.session.Unsubscribe(channel, self.update_tree)  
74              self.session = None              self.session = None
75          self.app.Unsubscribe(SESSION_CHANGED, self.session_changed)          self.app.Unsubscribe(SESSION_CHANGED, self.session_changed)
76          self.app.interactor.Unsubscribe(SELECTED_LAYER, self.layer_selected)          self.app.interactor.Unsubscribe(SELECTED_LAYER, self.layer_selected)
# Line 66  class SessionTreeCtrl(wxTreeCtrl): Line 78  class SessionTreeCtrl(wxTreeCtrl):
78      def update_tree(self, *args):      def update_tree(self, *args):
79          """Clear and rebuild the tree"""          """Clear and rebuild the tree"""
80          self.DeleteAllItems()          self.DeleteAllItems()
         session = self.app.session  
         root = self.AddRoot("Session: %s" % session.title)  
81          self.layer_to_item.clear()          self.layer_to_item.clear()
         if session.filename == None:  
             self.AppendItem(root, "Filename:")  
         else:  
             self.AppendItem(root, "Filename: %s" % session.filename)  
         if session.WasModified():  
             self.AppendItem(root, "Modified: yes")  
         else:  
             self.AppendItem(root, "Modified: no")  
82    
83          for map in session.Maps():          session = self.app.session
84              mapitem = self.AppendItem(root, "Map: %s" % map.title)          info = session.TreeInfo()
85              self.SetPyData(mapitem, map)          root = self.AddRoot(info[0])
86              if map.BoundingBox() != None:          self.add_items(root, info[1])
                 self.AppendItem(mapitem, ("Extent (lat-lon): (%g, %g, %g, %g)"  
                                           % map.BoundingBox()))  
             if map.projection and len(map.projection.params) > 0:  
                 self.AppendItem(mapitem,  
                                 ("Extent (projected): (%g, %g, %g, %g)"  
                                  % map.ProjectedBoundingBox()))  
                 projectionitem = self.AppendItem(mapitem, "Projection")  
                 for param in map.projection.params:  
                     parameteritem = self.AppendItem(projectionitem, str(param))  
                 self.Expand(projectionitem)  
   
             layers = map.Layers()  
             for layer_index in range(len(layers) - 1, -1, -1):  
                 layer = layers[layer_index]  
                 idata = wxTreeItemData()  
                 idata.SetData(layer)  
                 layeritem = self.AppendItem(mapitem,  
                                             "Layer '%s'" % layer.Title(),  
                                             data = idata)  
                 self.layer_to_item[id(layer)] = layeritem  
                 if layer is self.app.interactor.selected_layer:  
                     self.SelectItem(layeritem)  
                 if isinstance(layer, Layer):  
                     if layer.Visible():  
                         text = "Shown"  
                     else:  
                         text = "Hidden"  
                     self.AppendItem(layeritem, text)  
                     self.AppendItem(layeritem, "Shapes: %d" %layer.NumShapes())  
                     bbox = layer.LatLongBoundingBox()  
                     if bbox is not None:  
                         self.AppendItem(layeritem,  
                                         ("Extent (lat-lon): (%g, %g, %g, %g)"  
                                          % bbox))  
                     else:  
                         self.AppendItem(layeritem, ("Extent (lat-lon):"))  
                     self.AppendItem(layeritem,  
                                     "Shapetype: %s"  
                                     % shapetype_names[layer.ShapeType()])  
                     self.AppendItem(layeritem,  
                                     "Fill: " + color_string(layer.fill))  
                     self.AppendItem(layeritem,  
                                     "Outline: " + color_string(layer.stroke))  
                 self.Expand(layeritem)  
             self.Expand(mapitem)  
87          self.Expand(root)          self.Expand(root)
88            # select the selected layer
89            selected_layer = self.app.interactor.selected_layer
90            if selected_layer is not None:
91                # One would expect that the selected_layer's id is in
92                # layer_to_item at this point as we've just rebuilt that
93                # mapping completely. However, when a new session is loaded
94                # for instance, it can happen that the tree view is updated
95                # before the interactor in which case selected_layer may be
96                # a layer of the old session.
97                item = self.layer_to_item.get(id(selected_layer))
98                if item is not None:
99                    self.SelectItem(item)
100    
101        def add_items(self, parent, items):
102            for item in items:
103                if hasattr(item, "TreeInfo"):
104                    # Supports the TreeInfo protocol
105                    info = item.TreeInfo()
106                    treeitem = self.AppendItem(parent, info[0])
107                    self.SetPyData(treeitem, item)
108                    self.add_items(treeitem, info[1])
109                    self.Expand(treeitem)
110                    if isinstance(item, Layer):
111                        self.layer_to_item[id(item)] = treeitem
112                elif isinstance(item, StringType):
113                    # it's a string
114                    # FIXME: What to do about UNICODE
115                    self.AppendItem(parent, item)
116                else:
117                    # assume its a sequence (title, items)
118                    treeitem = self.AppendItem(parent, item[0])
119                    self.add_items(treeitem, item[1])
120                    self.Expand(treeitem)
121    
122      def session_changed(self, *args):      def session_changed(self, *args):
123          new_session = self.app.session          new_session = self.app.session
124          # if the session has changed subscribe/unsubscribe          # if the session has changed subscribe/unsubscribe
125          if self.session is not new_session:          if self.session is not new_session:
126              if self.session is not None:              if self.session is not None:
127                  for channel in self.session_channels:                  self.session.Unsubscribe(CHANGED, self.update_tree)
                     self.session.Unsubscribe(channel, self.update_tree)  
128              if new_session is not None:              if new_session is not None:
129                  for channel in self.session_channels:                  new_session.Subscribe(CHANGED, self.update_tree)
                     new_session.Subscribe(channel, self.update_tree)  
130              self.session = new_session              self.session = new_session
131          self.update_tree()          self.update_tree()
132    
# Line 150  class SessionTreeCtrl(wxTreeCtrl): Line 138  class SessionTreeCtrl(wxTreeCtrl):
138              if isinstance(object, Layer) or isinstance(object, Map):              if isinstance(object, Layer) or isinstance(object, Map):
139                  break                  break
140              item = self.GetItemParent(item)              item = self.GetItemParent(item)
141            else:
142                # No layer or map was found in the chain of parents, so
143                # there's nothing we can do.
144                return
145    
146          self.changing_selection = 1          self.changing_selection = 1
147          try:          try:
# Line 187  class SessionTreeView(NonModalDialog): Line 179  class SessionTreeView(NonModalDialog):
179      """Non modal dialog showing the session as a tree"""      """Non modal dialog showing the session as a tree"""
180    
181      def __init__(self, parent, app, name):      def __init__(self, parent, app, name):
182          NonModalDialog.__init__(self, parent, app.interactor, name, "Session")          NonModalDialog.__init__(self, parent, app.interactor, name,
183                                    _("Session"))
184          self.tree = SessionTreeCtrl(self, -1, app)          self.tree = SessionTreeCtrl(self, -1, app)
185    
186      def OnClose(self, event):      def OnClose(self, event):
Legend:
Removed from v.177  
changed lines
  Added in v.374
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26