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	bh	723	# Copyright (c) 2001, 2002, 2003 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	jan	197	from messages import MAPS_CHANGED, EXTENSIONS_CHANGED, FILENAME_CHANGED, \
12	jonathan	548	MAP_LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \
13	jonathan	582	LAYER_CHANGED, LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED,\
14	bh	232	EXTENSION_CHANGED, EXTENSION_OBJECTS_CHANGED, CHANGED
15	bh	6
16	jan	374	from Thuban import _
17
18	bh	6	from base import TitledObject, Modifiable
19			from map import Map
20	bh	723	from data import ShapefileStore
21	bh	6
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	jonathan	548	MAP_LAYERS_CHANGED -- Same as the map's event of the same name.
40	bh	6	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	bh	318	# generic channels
55			CHANGED,
56
57	bh	128	# map specific channels
58			MAP_PROJECTION_CHANGED,
59	jonathan	548	MAP_LAYERS_CHANGED,
60	bh	128
61			# layer channels forwarded by the map
62			LAYER_PROJECTION_CHANGED,
63	jonathan	582	LAYER_CHANGED,
64	jan	197	LAYER_VISIBILITY_CHANGED,
65	bh	128
66	jan	197	# channels forwarded by an extension
67			EXTENSION_CHANGED,
68			EXTENSION_OBJECTS_CHANGED)
69
70	bh	6	def __init__(self, title):
71			TitledObject.__init__(self, title)
72			Modifiable.__init__(self)
73			self.filename = None
74			self.maps = []
75			self.tables = []
76	jan	197	self.extensions = []
77	bh	6
78	bh	232	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	bh	6	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	bh	128	for channel in self.forwarded_channels:
101	bh	6	map.Subscribe(channel, self.forward, channel)
102			self.changed(MAPS_CHANGED)
103
104	bh	241	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	jan	197	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	bh	723	def OpenShapefile(self, filename):
124			"""Return a shapefile store object for the data in the given file"""
125			return ShapefileStore(self, filename)
126
127	bh	6	def Destroy(self):
128			for map in self.maps:
129			map.Destroy()
130			self.maps = []
131			self.tables = []
132	bh	250	Modifiable.Destroy(self)
133	bh	6
134			def forward(self, *args):
135	bh	232	"""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	bh	6	if len(args) > 1:
143			args = (args[-1],) + args[:-1]
144			apply(self.issue, args)
145	bh	232	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	bh	6
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	bh	217	def TreeInfo(self):
167			items = []
168			if self.filename is None:
169	jan	374	items.append(_("Filename:"))
170	bh	217	else:
171	jan	374	items.append(_("Filename: %s") % self.filename)
172	bh	6
173	bh	217	if self.WasModified():
174	jan	374	items.append(_("Modified"))
175	bh	217	else:
176	jan	374	items.append(_("Unmodified"))
177	bh	6
178	bh	217	items.extend(self.maps)
179			items.extend(self.extensions)
180
181	jan	374	return (_("Session: %s") % self.title, items)
182	bh	217
183
184	bh	6	def create_empty_session():
185			"""Return an empty session useful as a starting point"""
186	jan	103	import os
187	jan	374	session = Session(_('unnamed session'))
188	jan	103	session.SetFilename(None)
189	jan	374	session.AddMap(Map(_('unnamed map')))
190	bh	56	session.UnsetModified()
191	bh	6	return session
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision