Thuban/UI/tree.py

#! /usr/bin/python
# Copyright (c) 2001 by Intevation GmbH
# Authors:
# Jan-Oliver Wagner <[email protected]>
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

__version__ = "$Revision$"

from wxPython.wx import *

from Thuban.Model.messages import MAPS_CHANGED, MAP_PROJECTION_CHANGED, \
     LAYERS_CHANGED, LAYER_LEGEND_CHANGED, LAYER_VISIBILITY_CHANGED
from Thuban.Model.layer import Layer, shapetype_names
from Thuban.Model.map import Map
import view

from messages import SESSION_CHANGED, SELECTED_LAYER

def color_string(color):
    if color is None:
        return "None"
    return "(%.3f, %.3f, %.3f)" % (color.red, color.green, color.blue)

class myTreeCtrlPanel(wxPanel):

    def __init__(self, parent, app):
        # Use the WANTS_CHARS style so the panel doesn't eat the Return key.
        wxPanel.__init__(self, parent, -1, style=wxWANTS_CHARS)
        self.app = app

        EVT_SIZE(self, self.OnSize)
        self.tree = wxTreeCtrl(self, -1)

        self.app.Subscribe(SESSION_CHANGED, self.session_changed)
        self.app.interactor.Subscribe(SELECTED_LAYER, self.layer_selected)
        # pretend the session has changed to build the initial tree
        self.session_changed()

        EVT_TREE_SEL_CHANGED(self, self.tree.GetId(), self.OnSelChanged)

    def update_tree(self, *args):
        """Clear and rebuild the tree"""
        self.tree.DeleteAllItems()
        session = self.app.session
        root = self.tree.AddRoot("Session: %s" % session.title)
        for map in session.Maps():
            mapitem = self.tree.AppendItem(root, "Map: %s" % map.title)
            self.tree.SetPyData(mapitem, map)
            if map.projection and len(map.projection.params) > 0:
                projectionitem = self.tree.AppendItem(mapitem, "Projection")
                for param in map.projection.params:
                    parameteritem = self.tree.AppendItem(projectionitem,
                                                         str(param))
                self.tree.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.tree.AppendItem(mapitem,
                                                 "Layer '%s'" % layer.Title(),
                                                 data = idata)
                if layer is self.app.interactor.selected_layer:
                    self.tree.SelectItem(layeritem)
                if isinstance(layer, Layer):
                    if layer.Visible():
                        text = "Shown"
                    else:
                        text = "Hidden"
                    self.tree.AppendItem(layeritem, text)
                    self.tree.AppendItem(layeritem,
                                         "Shapes: %d" % layer.NumShapes())
                    self.tree.AppendItem(layeritem,
                                         ("Extents: (%g, %g, %g, %g)" 
                                          % layer.LatLongBoundingBox()))
                    self.tree.AppendItem(layeritem,
                                         "Shapetype: %s" %
                                         shapetype_names[layer.ShapeType()])
                    self.tree.AppendItem(layeritem,
                                         "Fill: " + color_string(layer.fill))
                    self.tree.AppendItem(layeritem,
                                      "Outline: " + color_string(layer.stroke))
                self.tree.Expand(layeritem)
            self.tree.Expand(mapitem)
        self.tree.Expand(root)

    def session_changed(self, *args):
        for channel in (MAPS_CHANGED,
                        MAP_PROJECTION_CHANGED,
                        LAYERS_CHANGED,
                        LAYER_LEGEND_CHANGED,
                        LAYER_VISIBILITY_CHANGED):
            self.app.session.Subscribe(channel, self.update_tree)
        self.update_tree()

    def OnSize(self, event):
        w,h = self.GetClientSizeTuple()
        self.tree.SetDimensions(0, 0, w, h)

    def normalize_selection(self):
        """Select the layer or map containing currently selected item"""
        tree = self.tree
        item = self.tree.GetSelection()
        while item.IsOk():
            object = tree.GetPyData(item)
            if isinstance(object, Layer) or isinstance(object, Map):
                break
            item = tree.GetItemParent(item)

        self.tree.SelectItem(item)

    def SelectedLayer(self):
        """Return the layer object currently selected in the tree.
        Return None if no layer is selected"""
        tree = self.tree
        layer = tree.GetPyData(tree.GetSelection())
        if isinstance(layer, Layer):
            return layer
        return None

    def OnSelChanged(self, event):
        self.normalize_selection()
        layer = self.SelectedLayer()
        if layer is not None:
            self.app.interactor.SelectLayer(layer)

    def layer_selected(self, layer):
        pass
1	bh	6	#! /usr/bin/python
2			# Copyright (c) 2001 by Intevation GmbH
3			# Authors:
4			# Jan-Oliver Wagner <[email protected]>
5			# Bernhard Herzog <[email protected]>
6			#
7			# This program is free software under the GPL (>=v2)
8			# Read the file COPYING coming with Thuban for details.
9
10			__version__ = "$Revision$"
11
12			from wxPython.wx import *
13
14			from Thuban.Model.messages import MAPS_CHANGED, MAP_PROJECTION_CHANGED, \
15			LAYERS_CHANGED, LAYER_LEGEND_CHANGED, LAYER_VISIBILITY_CHANGED
16			from Thuban.Model.layer import Layer, shapetype_names
17			from Thuban.Model.map import Map
18			import view
19
20			from messages import SESSION_CHANGED, SELECTED_LAYER
21
22			def color_string(color):
23			if color is None:
24			return "None"
25			return "(%.3f, %.3f, %.3f)" % (color.red, color.green, color.blue)
26
27			class myTreeCtrlPanel(wxPanel):
28
29			def __init__(self, parent, app):
30			# Use the WANTS_CHARS style so the panel doesn't eat the Return key.
31			wxPanel.__init__(self, parent, -1, style=wxWANTS_CHARS)
32			self.app = app
33
34			EVT_SIZE(self, self.OnSize)
35			self.tree = wxTreeCtrl(self, -1)
36
37			self.app.Subscribe(SESSION_CHANGED, self.session_changed)
38			self.app.interactor.Subscribe(SELECTED_LAYER, self.layer_selected)
39			# pretend the session has changed to build the initial tree
40			self.session_changed()
41
42			EVT_TREE_SEL_CHANGED(self, self.tree.GetId(), self.OnSelChanged)
43
44			def update_tree(self, *args):
45			"""Clear and rebuild the tree"""
46			self.tree.DeleteAllItems()
47			session = self.app.session
48			root = self.tree.AddRoot("Session: %s" % session.title)
49			for map in session.Maps():
50			mapitem = self.tree.AppendItem(root, "Map: %s" % map.title)
51			self.tree.SetPyData(mapitem, map)
52			if map.projection and len(map.projection.params) > 0:
53			projectionitem = self.tree.AppendItem(mapitem, "Projection")
54			for param in map.projection.params:
55			parameteritem = self.tree.AppendItem(projectionitem,
56			str(param))
57			self.tree.Expand(projectionitem)
58
59			layers = map.Layers()
60			for layer_index in range(len(layers) - 1, -1, -1):
61			layer = layers[layer_index]
62			idata = wxTreeItemData()
63			idata.SetData(layer)
64			layeritem = self.tree.AppendItem(mapitem,
65			"Layer '%s'" % layer.Title(),
66			data = idata)
67			if layer is self.app.interactor.selected_layer:
68			self.tree.SelectItem(layeritem)
69			if isinstance(layer, Layer):
70			if layer.Visible():
71			text = "Shown"
72			else:
73			text = "Hidden"
74			self.tree.AppendItem(layeritem, text)
75			self.tree.AppendItem(layeritem,
76			"Shapes: %d" % layer.NumShapes())
77			self.tree.AppendItem(layeritem,
78			("Extents: (%g, %g, %g, %g)"
79			% layer.LatLongBoundingBox()))
80			self.tree.AppendItem(layeritem,
81			"Shapetype: %s" %
82			shapetype_names[layer.ShapeType()])
83			self.tree.AppendItem(layeritem,
84			"Fill: " + color_string(layer.fill))
85			self.tree.AppendItem(layeritem,
86			"Outline: " + color_string(layer.stroke))
87			self.tree.Expand(layeritem)
88			self.tree.Expand(mapitem)
89			self.tree.Expand(root)
90
91			def session_changed(self, *args):
92			for channel in (MAPS_CHANGED,
93			MAP_PROJECTION_CHANGED,
94			LAYERS_CHANGED,
95			LAYER_LEGEND_CHANGED,
96			LAYER_VISIBILITY_CHANGED):
97			self.app.session.Subscribe(channel, self.update_tree)
98			self.update_tree()
99
100			def OnSize(self, event):
101			w,h = self.GetClientSizeTuple()
102			self.tree.SetDimensions(0, 0, w, h)
103
104			def normalize_selection(self):
105			"""Select the layer or map containing currently selected item"""
106			tree = self.tree
107			item = self.tree.GetSelection()
108			while item.IsOk():
109			object = tree.GetPyData(item)
110			if isinstance(object, Layer) or isinstance(object, Map):
111			break
112			item = tree.GetItemParent(item)
113
114			self.tree.SelectItem(item)
115
116			def SelectedLayer(self):
117			"""Return the layer object currently selected in the tree.
118			Return None if no layer is selected"""
119			tree = self.tree
120			layer = tree.GetPyData(tree.GetSelection())
121			if isinstance(layer, Layer):
122			return layer
123			return None
124
125			def OnSelChanged(self, event):
126			self.normalize_selection()
127			layer = self.SelectedLayer()
128			if layer is not None:
129			self.app.interactor.SelectLayer(layer)
130
131			def layer_selected(self, layer):
132			pass
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision