Thuban/Model/map.py

# Copyright (c) 2001, 2002 by Intevation GmbH
# Authors:
# 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 messages import MAP_LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \
     CHANGED, LAYER_PROJECTION_CHANGED, LAYER_LEGEND_CHANGED, \
     LAYER_VISIBILITY_CHANGED, LAYER_CHANGED, MAP_STACKING_CHANGED, \
     MAP_LAYERS_ADDED, MAP_LAYERS_REMOVED

from Thuban import _

from base import TitledObject, Modifiable

from label import LabelLayer


class Map(TitledObject, Modifiable):

    """Represent a map. A map is simply a list of layers.

    Map objects send the following message types:

        TITLE_CHANGED -- The title has changed. Parameter: the map.

        MAP_LAYERS_CHANGED -- Layers were added, removed or rearranged.
                        Parameters: the map

        MAP_PROJECTION_CHANGED -- the map's projection has changed.
                        Parameter: the map
    """

    forwarded_channels = (CHANGED,
                          LAYER_PROJECTION_CHANGED,
                          LAYER_LEGEND_CHANGED,
                          LAYER_CHANGED,
                          LAYER_VISIBILITY_CHANGED)

    def __init__(self, title, projection = None):
        """Initialize the map."""
        TitledObject.__init__(self, title)
        Modifiable.__init__(self)
        self.layers = []
        self.label_layer = LabelLayer(_("Labels"))
        self.label_layer.Subscribe(CHANGED, self.forward, MAP_LAYERS_CHANGED)
        self.projection = projection

    def Destroy(self):
        # call Modifiable.Destroy first since it will call
        # Publisher.Destroy which removes all subscriptions. Otherwise
        # clearing the layers results in messages to be sent which can
        # cause problems.
        Modifiable.Destroy(self)
        self.ClearLayers()
        self.label_layer.Unsubscribe(CHANGED, self.forward, MAP_LAYERS_CHANGED)
        self.label_layer.Destroy()

    def AddLayer(self, layer):
        """Append layer to the map on top opf all."""
        self.layers.append(layer)
        self.subscribe_layer_channels(layer)
        self.changed(MAP_LAYERS_CHANGED, self)
        self.changed(MAP_LAYERS_ADDED, self)

    def RemoveLayer(self, layer):
        """Remove layer from the map."""
        self.unsubscribe_layer_channels(layer)
        self.layers.remove(layer)
        self.changed(MAP_LAYERS_CHANGED, self)
        self.changed(MAP_LAYERS_REMOVED, self)
        layer.Destroy()

    def CanRemoveLayer(self, layer):
        """Return true if the layer can be deleted.

        The default implementation always returns 1. Derived classes
        should override this method if they have e.g. special layers
        that the user should not be able to remove.
        """
        return 1

    def ClearLayers(self):
        """Delete all layers."""
        for layer in self.layers:
            self.unsubscribe_layer_channels(layer)
            layer.Destroy()
        del self.layers[:]
        self.label_layer.ClearLabels()
        self.changed(MAP_LAYERS_CHANGED, self)
        self.changed(MAP_LAYERS_REMOVED, self)

    def subscribe_layer_channels(self, layer):
        """Subscribe to some of layer's channels."""
        for channel in self.forwarded_channels:
            layer.Subscribe(channel, self.forward, channel)

    def unsubscribe_layer_channels(self, layer):
        """Unsubscribe to some of layer's channels."""
        for channel in self.forwarded_channels:
            layer.Unsubscribe(channel, self.forward, channel)

    def LabelLayer(self):
        """Return the Map's label layer"""
        return self.label_layer

    def Layers(self):
        """Return the list of layers contained in the map.

        The list does not include the label layer"""
        return self.layers

    def HasLayers(self):
        """Return true if the map has at least one shape layer"""
        return len(self.layers) > 0

    def RaiseLayer(self, layer):
        """Swap the layer with the one above it.

        If the layer is already at the top do nothing. If the stacking
        order has been changed, issue a MAP_LAYERS_CHANGED message.
        """
        index = self.layers.index(layer)
        if index < len(self.layers) - 1:
            del self.layers[index]
            self.layers.insert(index + 1, layer)
            self.changed(MAP_LAYERS_CHANGED, self)
            self.changed(MAP_STACKING_CHANGED, self)

    def LowerLayer(self, layer):
        """Swap the layer with the one below it.

        If the layer is already at the bottom do nothing. If the
        stacking order has been changed, issue a MAP_LAYERS_CHANGED message.
        """
        index = self.layers.index(layer)
        if index > 0:
            del self.layers[index]
            self.layers.insert(index - 1, layer)
            self.changed(MAP_LAYERS_CHANGED, self)
            self.changed(MAP_STACKING_CHANGED, self)

    def BoundingBox(self):
        """Return the bounding box of the map in Lat/Lon coordinates.

        Return None if there are no layers or no layer contains any shapes.
        """
        if not self.layers:
            return None
        llx = []
        lly = []
        urx = []
        ury = []
        for layer in self.layers:
            if layer is self.label_layer:
                continue
            # the layer's bbox may be None if it doesn't have any shapes
            bbox = layer.LatLongBoundingBox()
            if bbox is not None:
                left, bottom, right, top = bbox
                llx.append(left)
                lly.append(bottom)
                urx.append(right)
                ury.append(top)

        # check whether there were any empty layers.
        if llx:
            return (min(llx), min(lly), max(urx), max(ury))
        else:
            return None

    def ProjectedBoundingBox(self):
        """Return the bounding box of the map in projected coordinates.

        Return None if there are no layers or no layer contains any shapes.
        """
        # This simply returns the rectangle given by the projected
        # corners of the non-projected bbox.
        bbox = self.BoundingBox()
        if bbox is not None and self.projection is not None:
            bbox = self.projection.ForwardBBox(bbox)
        return bbox

    def GetProjection(self):
        return self.projection

    def SetProjection(self, projection):
        """Set the projection of the map.

        Issue a MAP_PROJECTION_CHANGED message."""
        self.projection = projection
        self.changed(MAP_PROJECTION_CHANGED, self)

    def forward(self, *args):
        """Reissue events"""
        if len(args) > 1:
            args = (args[-1],) + args[:-1]
        apply(self.issue, args)

    def WasModified(self):
        """Return true if the map or one of the layers was modified"""
        if self.modified:
            return 1
        else:
            for layer in self.layers:
                if layer.WasModified():
                    return 1
            return self.label_layer.WasModified()

    def UnsetModified(self):
        """Unset the modified flag of the map and the layers"""
        Modifiable.UnsetModified(self)
        for layer in self.layers:
            layer.UnsetModified()
        self.label_layer.UnsetModified()

    def TreeInfo(self):
        items = []
        if self.BoundingBox() != None:
            items.append(_("Extent (lat-lon): (%g, %g, %g, %g)")
                         % self.BoundingBox())
            if self.projection and len(self.projection.params) > 0:
                items.append(_("Extent (projected): (%g, %g, %g, %g)")
                             % self.ProjectedBoundingBox())
                items.append((_("Projection"),
                              [str(param)
                               for param in self.projection.params]))

        layers = self.layers[:]
        layers.reverse()
        items.extend(layers)

        return (_("Map: %s") % self.title, items)

1	bh	178	# Copyright (c) 2001, 2002 by Intevation GmbH
2	bh	6	# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			__version__ = "$Revision$"
9
10	jonathan	882	from messages import MAP_LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \
11			CHANGED, LAYER_PROJECTION_CHANGED, LAYER_LEGEND_CHANGED, \
12			LAYER_VISIBILITY_CHANGED, LAYER_CHANGED, MAP_STACKING_CHANGED, \
13			MAP_LAYERS_ADDED, MAP_LAYERS_REMOVED
14	bh	6
15	jan	374	from Thuban import _
16
17	bh	6	from base import TitledObject, Modifiable
18
19			from label import LabelLayer
20
21
22			class Map(TitledObject, Modifiable):
23
24			"""Represent a map. A map is simply a list of layers.
25
26			Map objects send the following message types:
27
28			TITLE_CHANGED -- The title has changed. Parameter: the map.
29
30	jonathan	546	MAP_LAYERS_CHANGED -- Layers were added, removed or rearranged.
31	bh	6	Parameters: the map
32
33			MAP_PROJECTION_CHANGED -- the map's projection has changed.
34			Parameter: the map
35			"""
36
37	bh	319	forwarded_channels = (CHANGED,
38			LAYER_PROJECTION_CHANGED,
39	bh	6	LAYER_LEGEND_CHANGED,
40	jonathan	559	LAYER_CHANGED,
41	bh	6	LAYER_VISIBILITY_CHANGED)
42
43			def __init__(self, title, projection = None):
44			"""Initialize the map."""
45			TitledObject.__init__(self, title)
46	bh	319	Modifiable.__init__(self)
47	bh	6	self.layers = []
48	jan	374	self.label_layer = LabelLayer(_("Labels"))
49	jonathan	546	self.label_layer.Subscribe(CHANGED, self.forward, MAP_LAYERS_CHANGED)
50	bh	6	self.projection = projection
51
52			def Destroy(self):
53	bh	249	# call Modifiable.Destroy first since it will call
54			# Publisher.Destroy which removes all subscriptions. Otherwise
55			# clearing the layers results in messages to be sent which can
56			# cause problems.
57			Modifiable.Destroy(self)
58			self.ClearLayers()
59	jonathan	546	self.label_layer.Unsubscribe(CHANGED, self.forward, MAP_LAYERS_CHANGED)
60	bh	249	self.label_layer.Destroy()
61	bh	6
62			def AddLayer(self, layer):
63	bh	249	"""Append layer to the map on top opf all."""
64	bh	6	self.layers.append(layer)
65	bh	245	self.subscribe_layer_channels(layer)
66	jonathan	546	self.changed(MAP_LAYERS_CHANGED, self)
67			self.changed(MAP_LAYERS_ADDED, self)
68	bh	6
69			def RemoveLayer(self, layer):
70	bh	249	"""Remove layer from the map."""
71	bh	245	self.unsubscribe_layer_channels(layer)
72	bh	6	self.layers.remove(layer)
73	jonathan	546	self.changed(MAP_LAYERS_CHANGED, self)
74			self.changed(MAP_LAYERS_REMOVED, self)
75	bh	6	layer.Destroy()
76
77	bh	298	def CanRemoveLayer(self, layer):
78			"""Return true if the layer can be deleted.
79
80			The default implementation always returns 1. Derived classes
81			should override this method if they have e.g. special layers
82			that the user should not be able to remove.
83			"""
84			return 1
85
86	bh	249	def ClearLayers(self):
87			"""Delete all layers."""
88			for layer in self.layers:
89			self.unsubscribe_layer_channels(layer)
90			layer.Destroy()
91			del self.layers[:]
92			self.label_layer.ClearLabels()
93	jonathan	546	self.changed(MAP_LAYERS_CHANGED, self)
94			self.changed(MAP_LAYERS_REMOVED, self)
95	bh	249
96	bh	245	def subscribe_layer_channels(self, layer):
97			"""Subscribe to some of layer's channels."""
98			for channel in self.forwarded_channels:
99			layer.Subscribe(channel, self.forward, channel)
100
101			def unsubscribe_layer_channels(self, layer):
102			"""Unsubscribe to some of layer's channels."""
103			for channel in self.forwarded_channels:
104			layer.Unsubscribe(channel, self.forward, channel)
105
106	bh	6	def LabelLayer(self):
107			"""Return the Map's label layer"""
108			return self.label_layer
109
110			def Layers(self):
111	bh	249	"""Return the list of layers contained in the map.
112
113			The list does not include the label layer"""
114	bh	6	return self.layers
115
116			def HasLayers(self):
117	bh	249	"""Return true if the map has at least one shape layer"""
118	bh	6	return len(self.layers) > 0
119
120			def RaiseLayer(self, layer):
121	bh	249	"""Swap the layer with the one above it.
122
123			If the layer is already at the top do nothing. If the stacking
124	jonathan	546	order has been changed, issue a MAP_LAYERS_CHANGED message.
125	bh	249	"""
126	bh	6	index = self.layers.index(layer)
127			if index < len(self.layers) - 1:
128			del self.layers[index]
129			self.layers.insert(index + 1, layer)
130	jonathan	546	self.changed(MAP_LAYERS_CHANGED, self)
131			self.changed(MAP_STACKING_CHANGED, self)
132	bh	6
133			def LowerLayer(self, layer):
134	bh	249	"""Swap the layer with the one below it.
135
136			If the layer is already at the bottom do nothing. If the
137	jonathan	546	stacking order has been changed, issue a MAP_LAYERS_CHANGED message.
138	bh	249	"""
139	bh	6	index = self.layers.index(layer)
140			if index > 0:
141			del self.layers[index]
142			self.layers.insert(index - 1, layer)
143	jonathan	546	self.changed(MAP_LAYERS_CHANGED, self)
144			self.changed(MAP_STACKING_CHANGED, self)
145	bh	6
146			def BoundingBox(self):
147	bh	249	"""Return the bounding box of the map in Lat/Lon coordinates.
148	bh	178
149			Return None if there are no layers or no layer contains any shapes.
150			"""
151	bh	6	if not self.layers:
152			return None
153			llx = []
154			lly = []
155			urx = []
156			ury = []
157			for layer in self.layers:
158			if layer is self.label_layer:
159			continue
160	jonathan	931	# the layer's bbox may be None if it doesn't have any shapes
161	bh	178	bbox = layer.LatLongBoundingBox()
162			if bbox is not None:
163			left, bottom, right, top = bbox
164			llx.append(left)
165			lly.append(bottom)
166			urx.append(right)
167			ury.append(top)
168	bh	6
169	bh	178	# check whether there were any empty layers.
170			if llx:
171			return (min(llx), min(lly), max(urx), max(ury))
172			else:
173			return None
174
175	bh	6	def ProjectedBoundingBox(self):
176	bh	249	"""Return the bounding box of the map in projected coordinates.
177
178			Return None if there are no layers or no layer contains any shapes.
179			"""
180	bh	6	# This simply returns the rectangle given by the projected
181			# corners of the non-projected bbox.
182			bbox = self.BoundingBox()
183			if bbox is not None and self.projection is not None:
184			bbox = self.projection.ForwardBBox(bbox)
185			return bbox
186
187	jonathan	707	def GetProjection(self):
188			return self.projection
189
190	bh	6	def SetProjection(self, projection):
191	bh	249	"""Set the projection of the map.
192
193			Issue a MAP_PROJECTION_CHANGED message."""
194	bh	6	self.projection = projection
195			self.changed(MAP_PROJECTION_CHANGED, self)
196
197			def forward(self, *args):
198			"""Reissue events"""
199			if len(args) > 1:
200			args = (args[-1],) + args[:-1]
201			apply(self.issue, args)
202
203			def WasModified(self):
204			"""Return true if the map or one of the layers was modified"""
205			if self.modified:
206			return 1
207			else:
208			for layer in self.layers:
209			if layer.WasModified():
210			return 1
211			return self.label_layer.WasModified()
212
213			def UnsetModified(self):
214			"""Unset the modified flag of the map and the layers"""
215			Modifiable.UnsetModified(self)
216			for layer in self.layers:
217			layer.UnsetModified()
218			self.label_layer.UnsetModified()
219
220	bh	217	def TreeInfo(self):
221			items = []
222			if self.BoundingBox() != None:
223	jan	374	items.append(_("Extent (lat-lon): (%g, %g, %g, %g)")
224	bh	217	% self.BoundingBox())
225	bh	231	if self.projection and len(self.projection.params) > 0:
226	jan	374	items.append(_("Extent (projected): (%g, %g, %g, %g)")
227	bh	231	% self.ProjectedBoundingBox())
228	jan	374	items.append((_("Projection"),
229	bh	231	[str(param)
230			for param in self.projection.params]))
231	bh	6
232	bh	217	layers = self.layers[:]
233			layers.reverse()
234			items.extend(layers)
235
236	jan	374	return (_("Map: %s") % self.title, items)
237	bh	217
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision