/[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 198 by jan, Thu Jun 20 15:24:26 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       EXTENSIONS_CHANGED, EXTENSION_OBJECTS_CHANGED  from Thuban.Model.messages import CHANGED
19  from Thuban.Model.layer import Layer, shapetype_names  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 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, EXTENSIONS_CHANGED,      tree view calls the session's TreeInfo method which should return a
32                          EXTENSION_OBJECTS_CHANGED)      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 59  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 68  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          for extension in session.Extensions():          selected_layer = self.app.interactor.selected_layer
90              extensionitem = self.AppendItem(root, "Extension: %s" %          if selected_layer is not None:
91                                              extension.title)              # One would expect that the selected_layer's id is in
92              for object in extension.Objects():              # layer_to_item at this point as we've just rebuilt that
93                  objectitem = self.AppendItem(extensionitem, "%s: %s" %              # mapping completely. However, when a new session is loaded
94                                               (object.title, object.name))              # for instance, it can happen that the tree view is updated
95              self.Expand(extensionitem)              # 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 161  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 198  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.198  
changed lines
  Added in v.374
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26