Thuban/Model/map.py

# Copyright (c) 2001 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):
        for layer in self.layers:
            layer.Destroy()
        self.label_layer.Unsubscribe(CHANGED, self.forward, LAYERS_CHANGED)
        Modifiable.Destroy(self)

    def AddLayer(self, layer):
        self.layers.append(layer)
        for channel in self.forwarded_channels:
            layer.Subscribe(channel, self.forward, channel)
        self.changed(LAYERS_CHANGED, self)

    def RemoveLayer(self, layer):
        for channel in self.forwarded_channels:
            layer.Unsubscribe(channel, self.forward, channel)
        self.layers.remove(layer)
        self.changed(LAYERS_CHANGED, self)
        layer.Destroy()

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

    def Layers(self):
        return self.layers

    def HasLayers(self):
        return len(self.layers) > 0

    def RaiseLayer(self, layer):
        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):
        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):
        if not self.layers:
            return None
        llx = []
        lly = []
        urx = []
        ury = []
        for layer in self.layers:
            if layer is self.label_layer:
                continue
            left, bottom, right, top = layer.LatLongBoundingBox()
            llx.append(left)
            lly.append(bottom)
            urx.append(right)
            ury.append(top)
        return (min(llx), min(lly), max(urx), max(ury))

    def ProjectedBoundingBox(self):
        # 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):
        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()


1	# Copyright (c) 2001 by Intevation GmbH
2	# 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	for layer in self.layers:
49	layer.Destroy()
50	self.label_layer.Unsubscribe(CHANGED, self.forward, LAYERS_CHANGED)
51	Modifiable.Destroy(self)
52
53	def AddLayer(self, layer):
54	self.layers.append(layer)
55	for channel in self.forwarded_channels:
56	layer.Subscribe(channel, self.forward, channel)
57	self.changed(LAYERS_CHANGED, self)
58
59	def RemoveLayer(self, layer):
60	for channel in self.forwarded_channels:
61	layer.Unsubscribe(channel, self.forward, channel)
62	self.layers.remove(layer)
63	self.changed(LAYERS_CHANGED, self)
64	layer.Destroy()
65
66	def LabelLayer(self):
67	"""Return the Map's label layer"""
68	return self.label_layer
69
70	def Layers(self):
71	return self.layers
72
73	def HasLayers(self):
74	return len(self.layers) > 0
75
76	def RaiseLayer(self, layer):
77	index = self.layers.index(layer)
78	if index < len(self.layers) - 1:
79	del self.layers[index]
80	self.layers.insert(index + 1, layer)
81	self.changed(LAYERS_CHANGED, self)
82
83	def LowerLayer(self, layer):
84	index = self.layers.index(layer)
85	if index > 0:
86	del self.layers[index]
87	self.layers.insert(index - 1, layer)
88	self.changed(LAYERS_CHANGED, self)
89
90	def BoundingBox(self):
91	if not self.layers:
92	return None
93	llx = []
94	lly = []
95	urx = []
96	ury = []
97	for layer in self.layers:
98	if layer is self.label_layer:
99	continue
100	left, bottom, right, top = layer.LatLongBoundingBox()
101	llx.append(left)
102	lly.append(bottom)
103	urx.append(right)
104	ury.append(top)
105	return (min(llx), min(lly), max(urx), max(ury))
106
107	def ProjectedBoundingBox(self):
108	# This simply returns the rectangle given by the projected
109	# corners of the non-projected bbox.
110	bbox = self.BoundingBox()
111	if bbox is not None and self.projection is not None:
112	bbox = self.projection.ForwardBBox(bbox)
113	return bbox
114
115	def SetProjection(self, projection):
116	self.projection = projection
117	self.changed(MAP_PROJECTION_CHANGED, self)
118
119	def forward(self, *args):
120	"""Reissue events"""
121	if len(args) > 1:
122	args = (args[-1],) + args[:-1]
123	apply(self.issue, args)
124
125	def WasModified(self):
126	"""Return true if the map or one of the layers was modified"""
127	if self.modified:
128	return 1
129	else:
130	for layer in self.layers:
131	if layer.WasModified():
132	return 1
133	return self.label_layer.WasModified()
134
135	def UnsetModified(self):
136	"""Unset the modified flag of the map and the layers"""
137	Modifiable.UnsetModified(self)
138	for layer in self.layers:
139	layer.UnsetModified()
140	self.label_layer.UnsetModified()
141
142
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision