/[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 417 by jonathan, Wed Feb 19 16:53:22 2003 UTC
# Line 9  Line 9 
9    
10  __version__ = "$Revision$"  __version__ = "$Revision$"
11    
12    from types import StringType, UnicodeType
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.color import Color
19    
20    from Thuban.Model.messages import CHANGED
21    from Thuban.Model.layer import Layer
22  from Thuban.Model.map import Map  from Thuban.Model.map import Map
23    
24  from dialogs import NonModalDialog  from dialogs import NonModalDialog
25  from messages import SESSION_CHANGED, SELECTED_LAYER  from messages import SESSION_CHANGED, SELECTED_LAYER
26    
27  def color_string(color):  BMP_SIZE = 15
     if color is None:  
         return "None"  
     return "(%.3f, %.3f, %.3f)" % (color.red, color.green, color.blue)  
   
28    
29  class SessionTreeCtrl(wxTreeCtrl):  class SessionTreeCtrl(wxTreeCtrl):
30    
31      # the session channels to subscribe to to update the tree      """Widget to display a tree view of the session.
32      session_channels = (MAPS_CHANGED, MAP_PROJECTION_CHANGED,  
33                          LAYERS_CHANGED, LAYER_LEGEND_CHANGED,      The tree view is created recursively from the session object. The
34                          LAYER_VISIBILITY_CHANGED)      tree view calls the session's TreeInfo method which should return a
35        pair (<title>, <item>) where <title> ist the title of the session
36        item in the tree view and <items> is a list of objects to use as the
37        children of the session in the tree view.
38    
39        The items list can contain three types of items:
40    
41           1. a string. The string is used as the title for a leaf item in
42              the tree view.
43    
44           2. an object with a TreeInfo method. This method is called and
45              should return a pair just like the session's TreeInfo method.
46    
47           3. a pair (<title>, <item>) which is treated like the return
48              value of TreeInfo.
49        """
50    
51      def __init__(self, parent, ID, app):      def __init__(self, parent, ID, app):
52    
53          # 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.
54          wxTreeCtrl.__init__(self, parent, ID)          wxTreeCtrl.__init__(self, parent, ID)
55    
# Line 50  class SessionTreeCtrl(wxTreeCtrl): Line 67  class SessionTreeCtrl(wxTreeCtrl):
67          # the session currently displayed in the tree          # the session currently displayed in the tree
68          self.session = None          self.session = None
69    
70            self.image_list = wxImageList(BMP_SIZE, BMP_SIZE)
71            self.AssignImageList(self.image_list)
72    
73          # pretend the session has changed to build the initial tree          # pretend the session has changed to build the initial tree
74          self.session_changed()          self.session_changed()
75    
# Line 57  class SessionTreeCtrl(wxTreeCtrl): Line 77  class SessionTreeCtrl(wxTreeCtrl):
77    
78      def unsubscribe_all(self):      def unsubscribe_all(self):
79          if self.session is not None:          if self.session is not None:
80              for channel in self.session_channels:              self.session.Unsubscribe(CHANGED, self.update_tree)
                 self.session.Unsubscribe(channel, self.update_tree)  
81              self.session = None              self.session = None
82          self.app.Unsubscribe(SESSION_CHANGED, self.session_changed)          self.app.Unsubscribe(SESSION_CHANGED, self.session_changed)
83          self.app.interactor.Unsubscribe(SELECTED_LAYER, self.layer_selected)          self.app.interactor.Unsubscribe(SELECTED_LAYER, self.layer_selected)
# Line 66  class SessionTreeCtrl(wxTreeCtrl): Line 85  class SessionTreeCtrl(wxTreeCtrl):
85      def update_tree(self, *args):      def update_tree(self, *args):
86          """Clear and rebuild the tree"""          """Clear and rebuild the tree"""
87          self.DeleteAllItems()          self.DeleteAllItems()
         session = self.app.session  
         root = self.AddRoot("Session: %s" % session.title)  
88          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")  
89    
90          for map in session.Maps():          session = self.app.session
91              mapitem = self.AppendItem(root, "Map: %s" % map.title)          info = session.TreeInfo()
92              self.SetPyData(mapitem, map)          root = self.AddRoot(info[0])
93              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)  
94          self.Expand(root)          self.Expand(root)
95            # select the selected layer
96            selected_layer = self.app.interactor.selected_layer
97            if selected_layer is not None:
98                # One would expect that the selected_layer's id is in
99                # layer_to_item at this point as we've just rebuilt that
100                # mapping completely. However, when a new session is loaded
101                # for instance, it can happen that the tree view is updated
102                # before the interactor in which case selected_layer may be
103                # a layer of the old session.
104                item = self.layer_to_item.get(id(selected_layer))
105                if item is not None:
106                    self.SelectItem(item)
107    
108        def add_items(self, parent, items):
109    
110            if items is None: return
111    
112            for item in items:
113                if hasattr(item, "TreeInfo"):
114                    # Supports the TreeInfo protocol
115                    info = item.TreeInfo()
116                    treeitem = self.AppendItem(parent, info[0])
117                    self.SetPyData(treeitem, item)
118                    self.add_items(treeitem, info[1])
119                    self.Expand(treeitem)
120                    if isinstance(item, Layer):
121                        self.layer_to_item[id(item)] = treeitem
122                elif isinstance(item, StringType) or \
123                     isinstance(item, UnicodeType):
124                    # it's a string
125                    self.AppendItem(parent, item)
126                else:
127                    # assume its a sequence (title, items)
128                    if isinstance(item[1], Color):
129    
130                        treeitem = self.AppendItem(parent, "(%s)" % item[0])
131    
132                        bmp = wxEmptyBitmap(BMP_SIZE, BMP_SIZE)
133                        brush = wxBrush(wxColour(item[1].red * 255,
134                                                 item[1].green * 255,
135                                                 item[1].blue * 255),
136                                        wxSOLID)
137                        dc = wxMemoryDC()
138                        dc.SelectObject(bmp)
139                        dc.SetBrush(brush)
140                        dc.Clear()
141                        dc.DrawRoundedRectangle(0, 0,
142                                                bmp.GetWidth(), bmp.GetHeight(),
143                                                4)
144                        dc.SelectObject(wxNullBitmap)
145    
146                        i = self.image_list.Add(bmp)
147                        self.SetItemImage(treeitem, i)
148                    else:
149                        treeitem = self.AppendItem(parent, item[0])
150                        self.add_items(treeitem, item[1])
151                    self.Expand(treeitem)
152    
153      def session_changed(self, *args):      def session_changed(self, *args):
154          new_session = self.app.session          new_session = self.app.session
155          # if the session has changed subscribe/unsubscribe          # if the session has changed subscribe/unsubscribe
156          if self.session is not new_session:          if self.session is not new_session:
157              if self.session is not None:              if self.session is not None:
158                  for channel in self.session_channels:                  self.session.Unsubscribe(CHANGED, self.update_tree)
                     self.session.Unsubscribe(channel, self.update_tree)  
159              if new_session is not None:              if new_session is not None:
160                  for channel in self.session_channels:                  new_session.Subscribe(CHANGED, self.update_tree)
                     new_session.Subscribe(channel, self.update_tree)  
161              self.session = new_session              self.session = new_session
162          self.update_tree()          self.update_tree()
163    
# Line 150  class SessionTreeCtrl(wxTreeCtrl): Line 169  class SessionTreeCtrl(wxTreeCtrl):
169              if isinstance(object, Layer) or isinstance(object, Map):              if isinstance(object, Layer) or isinstance(object, Map):
170                  break                  break
171              item = self.GetItemParent(item)              item = self.GetItemParent(item)
172            else:
173                # No layer or map was found in the chain of parents, so
174                # there's nothing we can do.
175                return
176    
177          self.changing_selection = 1          self.changing_selection = 1
178          try:          try:
# Line 187  class SessionTreeView(NonModalDialog): Line 210  class SessionTreeView(NonModalDialog):
210      """Non modal dialog showing the session as a tree"""      """Non modal dialog showing the session as a tree"""
211    
212      def __init__(self, parent, app, name):      def __init__(self, parent, app, name):
213          NonModalDialog.__init__(self, parent, app.interactor, name, "Session")          NonModalDialog.__init__(self, parent, app.interactor, name,
214                                    _("Session"))
215          self.tree = SessionTreeCtrl(self, -1, app)          self.tree = SessionTreeCtrl(self, -1, app)
216    
217      def OnClose(self, event):      def OnClose(self, event):
Legend:
Removed from v.177  
changed lines
  Added in v.417
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26