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 LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \
     CHANGED, LAYER_PROJECTION_CHANGED, LAYER_LEGEND_CHANGED, \
     LAYER_VISIBILITY_CHANGED

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.

        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 = (LAYER_PROJECTION_CHANGED,
                          LAYER_LEGEND_CHANGED,
                          LAYER_VISIBILITY_CHANGED)

    def __init__(self, title, projection = None):
        """Initialize the map."""
        TitledObject.__init__(self, title)
        self.layers = []
        self.label_layer = LabelLayer("Labels")
        self.label_layer.Subscribe(CHANGED, self.forward, 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, 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(LAYERS_CHANGED, self)

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