Thuban/Model/session.py

# Copyright (c) 2001, 2002 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 Thuban.Lib.connector import Publisher

from messages import MAPS_CHANGED, EXTENSIONS_CHANGED, FILENAME_CHANGED, \
     LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \
     LAYER_LEGEND_CHANGED, LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED,\
     EXTENSION_CHANGED, EXTENSION_OBJECTS_CHANGED, CHANGED

from base import TitledObject, Modifiable

from map import Map


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.

        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 = (
        # map specific channels
        MAP_PROJECTION_CHANGED,
        LAYERS_CHANGED,

        # layer channels forwarded by the map
        LAYER_PROJECTION_CHANGED,
        LAYER_LEGEND_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 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 Destroy(self):
        for map in self.maps:
            map.Destroy()
        self.maps = []
        self.tables = []
        Publisher.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	bh	128	# Copyright (c) 2001, 2002 by Intevation GmbH
2	bh	6	# Authors:
3			# Bernhard Herzog <[email protected]>
4	jan	197	# Jan-Oliver Wagner <[email protected]>
5	bh	6	#
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 Thuban.Lib.connector import Publisher
12
13	jan	197	from messages import MAPS_CHANGED, EXTENSIONS_CHANGED, FILENAME_CHANGED, \
14	bh	128	LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \
15	bh	232	LAYER_LEGEND_CHANGED, LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED,\
16			EXTENSION_CHANGED, EXTENSION_OBJECTS_CHANGED, CHANGED
17	bh	6
18			from base import TitledObject, Modifiable
19
20			from map import Map
21
22
23			class Session(TitledObject, Modifiable):
24
25			"""A complete session.
26
27	jan	197	A Session consists of arbitrary numbers of maps, tables and extensions
28	bh	6
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	jan	197	EXTENSIONS_CHANGED -- Extensions were added, removed.
38
39	bh	6	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	bh	232
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	bh	6	"""
50
51	bh	128	# message channels that have to be forwarded from maps contained in
52			# the session.
53			forwarded_channels = (
54			# map specific channels
55			MAP_PROJECTION_CHANGED,
56			LAYERS_CHANGED,
57
58			# layer channels forwarded by the map
59			LAYER_PROJECTION_CHANGED,
60			LAYER_LEGEND_CHANGED,
61	jan	197	LAYER_VISIBILITY_CHANGED,
62	bh	128
63	jan	197	# channels forwarded by an extension
64			EXTENSION_CHANGED,
65			EXTENSION_OBJECTS_CHANGED)
66
67	bh	6	def __init__(self, title):
68			TitledObject.__init__(self, title)
69			Modifiable.__init__(self)
70			self.filename = None
71			self.maps = []
72			self.tables = []
73	jan	197	self.extensions = []
74	bh	6
75	bh	232	def changed(self, channel = None, *args):
76			"""Like the inherited version but issue a CHANGED message as well.
77
78			The CHANGED message is only issued if channel given is a
79			different channel than CHANGED.
80			"""
81			Modifiable.changed(self, channel, *args)
82			if channel != CHANGED:
83			self.issue(CHANGED, self)
84
85	bh	6	def SetFilename(self, filename):
86			self.filename = filename
87			self.changed(FILENAME_CHANGED)
88
89			def Maps(self):
90			return self.maps
91
92			def HasMaps(self):
93			return len(self.maps) > 0
94
95			def AddMap(self, map):
96			self.maps.append(map)
97	bh	128	for channel in self.forwarded_channels:
98	bh	6	map.Subscribe(channel, self.forward, channel)
99			self.changed(MAPS_CHANGED)
100
101	jan	197	def Extensions(self):
102			return self.extensions
103
104			def HasExtensions(self):
105			return len(self.extensions) > 0
106
107			def AddExtension(self, extension):
108			self.extensions.append(extension)
109			for channel in self.forwarded_channels:
110			extension.Subscribe(channel, self.forward, channel)
111			self.changed(EXTENSIONS_CHANGED)
112
113	bh	6	def Destroy(self):
114			for map in self.maps:
115			map.Destroy()
116			self.maps = []
117			self.tables = []
118			Publisher.Destroy(self)
119
120			def forward(self, *args):
121	bh	232	"""Reissue events.
122
123			If the channel the event is forwarded to is a changed-channel
124			that is not the CHANGED channel issue CHANGED as well. An
125			channel is considered to be a changed-channel if it's name ends
126			with 'CHANGED'.
127			"""
128	bh	6	if len(args) > 1:
129			args = (args[-1],) + args[:-1]
130			apply(self.issue, args)
131	bh	232	channel = args[0]
132			# It's a bit of a kludge to rely on the channel name for this.
133			if channel.endswith("CHANGED") and channel != CHANGED:
134			self.issue(CHANGED, self)
135	bh	6
136			def WasModified(self):
137			"""Return true if the session or one of the maps was modified"""
138			if self.modified:
139			return 1
140			else:
141			for map in self.maps:
142			if map.WasModified():
143			return 1
144			return 0
145
146			def UnsetModified(self):
147			"""Unset the modified flag of the session and the maps"""
148			Modifiable.UnsetModified(self)
149			for map in self.maps:
150			map.UnsetModified()
151
152	bh	217	def TreeInfo(self):
153			items = []
154			if self.filename is None:
155			items.append("Filename:")
156			else:
157			items.append("Filename: %s" % self.filename)
158	bh	6
159	bh	217	if self.WasModified():
160			items.append("Modified")
161			else:
162			items.append("Unmodified")
163	bh	6
164	bh	217	items.extend(self.maps)
165			items.extend(self.extensions)
166
167			return ("Session: %s" % self.title, items)
168
169
170	bh	6	def create_empty_session():
171			"""Return an empty session useful as a starting point"""
172	jan	103	import os
173	bh	6	session = Session('unnamed session')
174	jan	103	session.SetFilename(None)
175	bh	6	session.AddMap(Map('unnamed map'))
176	bh	56	session.UnsetModified()
177	bh	6	return session
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision