Thuban/Model/session.py

# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
# Jan-Oliver Wagner <[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 MAPS_CHANGED, EXTENSIONS_CHANGED, FILENAME_CHANGED, \
     MAP_LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \
     LAYER_CHANGED, LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED,\
     EXTENSION_CHANGED, EXTENSION_OBJECTS_CHANGED, CHANGED

from Thuban import _

from base import TitledObject, Modifiable
from map import Map
from data import ShapefileStore


class Session(TitledObject, Modifiable):

    """A complete session.

    A Session consists of arbitrary numbers of maps, tables and extensions

    Session objects send the following events:

        TITLE_CHANGED -- The title has changed. Parameters: the session.

        FILENAME_CHANGED -- The filename has changed. No parameters.

        MAPS_CHANGED -- Maps were added, removed.

        EXTENSIONS_CHANGED -- Extensions were added, removed.

        MAP_LAYERS_CHANGED -- Same as the map's event of the same name.
                          It's simply resent from the session to make
                          subscriptions easier.

        CHANGED -- Generic changed event. Parameters: the session. The
                   event is always issued when any other changed event
                   is issused. This is useful for code that needs to be
                   notified whenever something in the session has
                   changed but it's too cumbersome or error-prone to
                   subscribe to all the individual events.
    """

    # message channels that have to be forwarded from maps contained in
    # the session.
    forwarded_channels = (
        # generic channels
        CHANGED,

        # map specific channels
        MAP_PROJECTION_CHANGED,
        MAP_LAYERS_CHANGED,

        # layer channels forwarded by the map
        LAYER_PROJECTION_CHANGED,
        LAYER_CHANGED,
        LAYER_VISIBILITY_CHANGED,

        # channels forwarded by an extension
        EXTENSION_CHANGED,
        EXTENSION_OBJECTS_CHANGED)

    def __init__(self, title):
        TitledObject.__init__(self, title)
        Modifiable.__init__(self)
        self.filename = None
        self.maps = []
        self.tables = []
        self.extensions = []

    def changed(self, channel = None, *args):
        """Like the inherited version but issue a CHANGED message as well.

        The CHANGED message is only issued if channel given is a
        different channel than CHANGED.
        """
        Modifiable.changed(self, channel, *args)
        if channel != CHANGED:
            self.issue(CHANGED, self)

    def SetFilename(self, filename):
        self.filename = filename
        self.changed(FILENAME_CHANGED)

    def Maps(self):
        return self.maps

    def HasMaps(self):
        return len(self.maps) > 0

    def AddMap(self, map):
        self.maps.append(map)
        for channel in self.forwarded_channels:
            map.Subscribe(channel, self.forward, channel)
        self.changed(MAPS_CHANGED)

    def RemoveMap(self, map):
        for channel in self.forwarded_channels:
            map.Unsubscribe(channel, self.forward, channel)
        self.maps.remove(map)
        self.changed(MAPS_CHANGED)
        map.Destroy()

    def Extensions(self):
        return self.extensions

    def HasExtensions(self):
        return len(self.extensions) > 0

    def AddExtension(self, extension):
        self.extensions.append(extension)
        for channel in self.forwarded_channels:
            extension.Subscribe(channel, self.forward, channel)
        self.changed(EXTENSIONS_CHANGED)

    def OpenShapefile(self, filename):
        """Return a shapefile store object for the data in the given file"""
        return ShapefileStore(self, filename)

    def Destroy(self):
        for map in self.maps:
            map.Destroy()
        self.maps = []
        self.tables = []
        Modifiable.Destroy(self)

    def forward(self, *args):
        """Reissue events.

        If the channel the event is forwarded to is a changed-channel
        that is not the CHANGED channel issue CHANGED as well. An
        channel is considered to be a changed-channel if it's name ends
        with 'CHANGED'.
        """
        if len(args) > 1:
            args = (args[-1],) + args[:-1]
        apply(self.issue, args)
        channel = args[0]
        # It's a bit of a kludge to rely on the channel name for this.
        if channel.endswith("CHANGED") and channel != CHANGED:
            self.issue(CHANGED, self)

    def WasModified(self):
        """Return true if the session or one of the maps was modified"""
        if self.modified:
            return 1
        else:
            for map in self.maps:
                if map.WasModified():
                    return 1
        return 0

    def UnsetModified(self):
        """Unset the modified flag of the session and the maps"""
        Modifiable.UnsetModified(self)
        for map in self.maps:
            map.UnsetModified()

    def TreeInfo(self):
        items = []
        if self.filename is None:
            items.append(_("Filename:"))
        else:
            items.append(_("Filename: %s") % self.filename)

        if self.WasModified():
            items.append(_("Modified"))
        else:
            items.append(_("Unmodified"))

        items.extend(self.maps)
        items.extend(self.extensions)

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


def create_empty_session():
    """Return an empty session useful as a starting point"""
    import os
    session = Session(_('unnamed session'))
    session.SetFilename(None)
    session.AddMap(Map(_('unnamed map')))
    session.UnsetModified()
    return session
1	# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2	# Authors:
3	# Bernhard Herzog <[email protected]>
4	# Jan-Oliver Wagner <[email protected]>
5	#
6	# This program is free software under the GPL (>=v2)
7	# Read the file COPYING coming with Thuban for details.
8
9	__version__ = "$Revision$"
10
11	from messages import MAPS_CHANGED, EXTENSIONS_CHANGED, FILENAME_CHANGED, \
12	MAP_LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \
13	LAYER_CHANGED, LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED,\
14	EXTENSION_CHANGED, EXTENSION_OBJECTS_CHANGED, CHANGED
15
16	from Thuban import _
17
18	from base import TitledObject, Modifiable
19	from map import Map
20	from data import ShapefileStore
21
22
23	class Session(TitledObject, Modifiable):
24
25	"""A complete session.
26
27	A Session consists of arbitrary numbers of maps, tables and extensions
28
29	Session objects send the following events:
30
31	TITLE_CHANGED -- The title has changed. Parameters: the session.
32
33	FILENAME_CHANGED -- The filename has changed. No parameters.
34
35	MAPS_CHANGED -- Maps were added, removed.
36
37	EXTENSIONS_CHANGED -- Extensions were added, removed.
38
39	MAP_LAYERS_CHANGED -- Same as the map's event of the same name.
40	It's simply resent from the session to make
41	subscriptions easier.
42
43	CHANGED -- Generic changed event. Parameters: the session. The
44	event is always issued when any other changed event
45	is issused. This is useful for code that needs to be
46	notified whenever something in the session has
47	changed but it's too cumbersome or error-prone to
48	subscribe to all the individual events.
49	"""
50
51	# message channels that have to be forwarded from maps contained in
52	# the session.
53	forwarded_channels = (
54	# generic channels
55	CHANGED,
56
57	# map specific channels
58	MAP_PROJECTION_CHANGED,
59	MAP_LAYERS_CHANGED,
60
61	# layer channels forwarded by the map
62	LAYER_PROJECTION_CHANGED,
63	LAYER_CHANGED,
64	LAYER_VISIBILITY_CHANGED,
65
66	# channels forwarded by an extension
67	EXTENSION_CHANGED,
68	EXTENSION_OBJECTS_CHANGED)
69
70	def __init__(self, title):
71	TitledObject.__init__(self, title)
72	Modifiable.__init__(self)
73	self.filename = None
74	self.maps = []
75	self.tables = []
76	self.extensions = []
77
78	def changed(self, channel = None, *args):
79	"""Like the inherited version but issue a CHANGED message as well.
80
81	The CHANGED message is only issued if channel given is a
82	different channel than CHANGED.
83	"""
84	Modifiable.changed(self, channel, *args)
85	if channel != CHANGED:
86	self.issue(CHANGED, self)
87
88	def SetFilename(self, filename):
89	self.filename = filename
90	self.changed(FILENAME_CHANGED)
91
92	def Maps(self):
93	return self.maps
94
95	def HasMaps(self):
96	return len(self.maps) > 0
97
98	def AddMap(self, map):
99	self.maps.append(map)
100	for channel in self.forwarded_channels:
101	map.Subscribe(channel, self.forward, channel)
102	self.changed(MAPS_CHANGED)
103
104	def RemoveMap(self, map):
105	for channel in self.forwarded_channels:
106	map.Unsubscribe(channel, self.forward, channel)
107	self.maps.remove(map)
108	self.changed(MAPS_CHANGED)
109	map.Destroy()
110
111	def Extensions(self):
112	return self.extensions
113
114	def HasExtensions(self):
115	return len(self.extensions) > 0
116
117	def AddExtension(self, extension):
118	self.extensions.append(extension)
119	for channel in self.forwarded_channels:
120	extension.Subscribe(channel, self.forward, channel)
121	self.changed(EXTENSIONS_CHANGED)
122
123	def OpenShapefile(self, filename):
124	"""Return a shapefile store object for the data in the given file"""
125	return ShapefileStore(self, filename)
126
127	def Destroy(self):
128	for map in self.maps:
129	map.Destroy()
130	self.maps = []
131	self.tables = []
132	Modifiable.Destroy(self)
133
134	def forward(self, *args):
135	"""Reissue events.
136
137	If the channel the event is forwarded to is a changed-channel
138	that is not the CHANGED channel issue CHANGED as well. An
139	channel is considered to be a changed-channel if it's name ends
140	with 'CHANGED'.
141	"""
142	if len(args) > 1:
143	args = (args[-1],) + args[:-1]
144	apply(self.issue, args)
145	channel = args[0]
146	# It's a bit of a kludge to rely on the channel name for this.
147	if channel.endswith("CHANGED") and channel != CHANGED:
148	self.issue(CHANGED, self)
149
150	def WasModified(self):
151	"""Return true if the session or one of the maps was modified"""
152	if self.modified:
153	return 1
154	else:
155	for map in self.maps:
156	if map.WasModified():
157	return 1
158	return 0
159
160	def UnsetModified(self):
161	"""Unset the modified flag of the session and the maps"""
162	Modifiable.UnsetModified(self)
163	for map in self.maps:
164	map.UnsetModified()
165
166	def TreeInfo(self):
167	items = []
168	if self.filename is None:
169	items.append(_("Filename:"))
170	else:
171	items.append(_("Filename: %s") % self.filename)
172
173	if self.WasModified():
174	items.append(_("Modified"))
175	else:
176	items.append(_("Unmodified"))
177
178	items.extend(self.maps)
179	items.extend(self.extensions)
180
181	return (_("Session: %s") % self.title, items)
182
183
184	def create_empty_session():
185	"""Return an empty session useful as a starting point"""
186	import os
187	session = Session(_('unnamed session'))
188	session.SetFilename(None)
189	session.AddMap(Map(_('unnamed map')))
190	session.UnsetModified()
191	return session
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision