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

from dialogs import NonModalDialog
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 SessionTreeCtrl(wxTreeCtrl):

    def __init__(self, parent, ID, app):
        # Use the WANTS_CHARS style so the panel doesn't eat the Return key.
        wxTreeCtrl.__init__(self, parent, ID)

        self.app = app
        # boolean to indicate that we manipulate the selection ourselves
        # so that we can ignore the selection events generated
        self.changing_selection = 0

        # Dictionary mapping layer id's to tree items
        self.layer_to_item = {}

        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.GetId(), self.OnSelChanged)

    def update_tree(self, *args):
        """Clear and rebuild the tree"""
        self.DeleteAllItems()
        session = self.app.session
        root = self.AddRoot("Session: %s" % session.title)
        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")

        for map in session.Maps():
            mapitem = self.AppendItem(root, "Map: %s" % map.title)
            self.SetPyData(mapitem, map)
            if map.BoundingBox() != None:
                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())
                    self.AppendItem(layeritem,
                                    ("Extent (lat-lon): (%g, %g, %g, %g)" 
                                     % layer.LatLongBoundingBox()))
                    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)
        self.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 normalize_selection(self):
        """Select the layer or map containing currently selected item"""
        item = self.GetSelection()
        while item.IsOk():
            object = self.GetPyData(item)
            if isinstance(object, Layer) or isinstance(object, Map):
                break
            item = self.GetItemParent(item)

        self.changing_selection = 1
        try:
            self.SelectItem(item)
        finally:
            self.changing_selection = 0

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

    def OnSelChanged(self, event):
        if self.changing_selection:
            # we're changing the selection ourselves (probably through
            # self.normalize_selection(). ignore the event.
            return
        self.normalize_selection()
        # SelectedLayer returns None if no layer is selected. Since
        # passing None to interactor.SelectLayer deselects the layer we
        # can simply pass the result of SelectedLayer on in all cases
        self.app.interactor.SelectLayer(self.SelectedLayer())

    def layer_selected(self, layer):
        item = self.layer_to_item.get(id(layer))
        if item is not None and item != self.GetSelection():
            self.SelectItem(item)


class SessionTreeView(NonModalDialog):

    """Non modal dialog showing the session as a tree"""

    def __init__(self, parent, app, name):
        NonModalDialog.__init__(self, parent, app.interactor, name, "Session")
        self.tree = SessionTreeCtrl(self, -1, app)

    def OnClose(self, event):
        #self.interactor.Unsubscribe(SELECTED_SHAPE, self.select_shape)
        NonModalDialog.OnClose(self, event)

1	#! /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
19	from dialogs import NonModalDialog
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
28	class SessionTreeCtrl(wxTreeCtrl):
29
30	def __init__(self, parent, ID, app):
31	# Use the WANTS_CHARS style so the panel doesn't eat the Return key.
32	wxTreeCtrl.__init__(self, parent, ID)
33
34	self.app = app
35	# boolean to indicate that we manipulate the selection ourselves
36	# so that we can ignore the selection events generated
37	self.changing_selection = 0
38
39	# Dictionary mapping layer id's to tree items
40	self.layer_to_item = {}
41
42	self.app.Subscribe(SESSION_CHANGED, self.session_changed)
43	self.app.interactor.Subscribe(SELECTED_LAYER, self.layer_selected)
44	# pretend the session has changed to build the initial tree
45	self.session_changed()
46
47	EVT_TREE_SEL_CHANGED(self, self.GetId(), self.OnSelChanged)
48
49	def update_tree(self, *args):
50	"""Clear and rebuild the tree"""
51	self.DeleteAllItems()
52	session = self.app.session
53	root = self.AddRoot("Session: %s" % session.title)
54	self.layer_to_item.clear()
55	if session.filename == None:
56	self.AppendItem(root, "Filename:")
57	else:
58	self.AppendItem(root, "Filename: %s" % session.filename)
59	if session.WasModified():
60	self.AppendItem(root, "Modified: yes")
61	else:
62	self.AppendItem(root, "Modified: no")
63
64	for map in session.Maps():
65	mapitem = self.AppendItem(root, "Map: %s" % map.title)
66	self.SetPyData(mapitem, map)
67	if map.BoundingBox() != None:
68	self.AppendItem(mapitem, ("Extent (lat-lon): (%g, %g, %g, %g)"
69	% map.BoundingBox()))
70	if map.projection and len(map.projection.params) > 0:
71	self.AppendItem(mapitem,
72	("Extent (projected): (%g, %g, %g, %g)"
73	% map.ProjectedBoundingBox()))
74	projectionitem = self.AppendItem(mapitem, "Projection")
75	for param in map.projection.params:
76	parameteritem = self.AppendItem(projectionitem, str(param))
77	self.Expand(projectionitem)
78
79	layers = map.Layers()
80	for layer_index in range(len(layers) - 1, -1, -1):
81	layer = layers[layer_index]
82	idata = wxTreeItemData()
83	idata.SetData(layer)
84	layeritem = self.AppendItem(mapitem,
85	"Layer '%s'" % layer.Title(),
86	data = idata)
87	self.layer_to_item[id(layer)] = layeritem
88	if layer is self.app.interactor.selected_layer:
89	self.SelectItem(layeritem)
90	if isinstance(layer, Layer):
91	if layer.Visible():
92	text = "Shown"
93	else:
94	text = "Hidden"
95	self.AppendItem(layeritem, text)
96	self.AppendItem(layeritem, "Shapes: %d" %layer.NumShapes())
97	self.AppendItem(layeritem,
98	("Extent (lat-lon): (%g, %g, %g, %g)"
99	% layer.LatLongBoundingBox()))
100	self.AppendItem(layeritem,
101	"Shapetype: %s"
102	% shapetype_names[layer.ShapeType()])
103	self.AppendItem(layeritem,
104	"Fill: " + color_string(layer.fill))
105	self.AppendItem(layeritem,
106	"Outline: " + color_string(layer.stroke))
107	self.Expand(layeritem)
108	self.Expand(mapitem)
109	self.Expand(root)
110
111	def session_changed(self, *args):
112	for channel in (MAPS_CHANGED,
113	MAP_PROJECTION_CHANGED,
114	LAYERS_CHANGED,
115	LAYER_LEGEND_CHANGED,
116	LAYER_VISIBILITY_CHANGED):
117	self.app.session.Subscribe(channel, self.update_tree)
118	self.update_tree()
119
120	def normalize_selection(self):
121	"""Select the layer or map containing currently selected item"""
122	item = self.GetSelection()
123	while item.IsOk():
124	object = self.GetPyData(item)
125	if isinstance(object, Layer) or isinstance(object, Map):
126	break
127	item = self.GetItemParent(item)
128
129	self.changing_selection = 1
130	try:
131	self.SelectItem(item)
132	finally:
133	self.changing_selection = 0
134
135	def SelectedLayer(self):
136	"""Return the layer object currently selected in the tree.
137	Return None if no layer is selected"""
138	layer = self.GetPyData(self.GetSelection())
139	if isinstance(layer, Layer):
140	return layer
141	return None
142
143	def OnSelChanged(self, event):
144	if self.changing_selection:
145	# we're changing the selection ourselves (probably through
146	# self.normalize_selection(). ignore the event.
147	return
148	self.normalize_selection()
149	# SelectedLayer returns None if no layer is selected. Since
150	# passing None to interactor.SelectLayer deselects the layer we
151	# can simply pass the result of SelectedLayer on in all cases
152	self.app.interactor.SelectLayer(self.SelectedLayer())
153
154	def layer_selected(self, layer):
155	item = self.layer_to_item.get(id(layer))
156	if item is not None and item != self.GetSelection():
157	self.SelectItem(item)
158
159
160	class SessionTreeView(NonModalDialog):
161
162	"""Non modal dialog showing the session as a tree"""
163
164	def __init__(self, parent, app, name):
165	NonModalDialog.__init__(self, parent, app.interactor, name, "Session")
166	self.tree = SessionTreeCtrl(self, -1, app)
167
168	def OnClose(self, event):
169	#self.interactor.Unsubscribe(SELECTED_SHAPE, self.select_shape)
170	NonModalDialog.OnClose(self, event)
171
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision