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$"

import os
from tempfile import mktemp
import weakref

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

from transientdb import TransientDatabase

class AutoRemoveFile:

    """Remove a file once all references go away."""

    def __init__(self, filename, tempdir = None):
        """Initialize the AutoRemoveFile

        Parameters:
           filename -- The name of the file to remove in __del__
           tempdir -- Another object simple stored as an instance variable.

        As the name suggests the tempdir parameter is intended for a
        temporary directory the file might be located in. The intended
        use is that it's an instance of AutoRemoveDir.
        """
        self.filename = filename
        self.tempdir = tempdir

    def __del__(self, remove = os.remove):
        remove(self.filename)

class AutoRemoveDir:

    """Remove a directory once all references go away

    The intended use of this class together with AutoRemoveFile is for
    temporary directories and files containd therein. An AutoRemoveDir
    should be instantiated for the directory and passed as the tempdir
    parameter to every AutoRemoveFile instance created for files in the
    directory. An AutoRemoveFile shold be instantiated for every file
    created in the directory so that the directory is automatically
    removed once the last file is removed.
    """

    def __init__(self, filename):
        """Initialize the AutoRemoveDir

        The parameter is the name of the directory.
        """
        self.filename = filename

    def __del__(self, rmdir = os.rmdir):
        rmdir(self.filename)


# WeakKey dictionary mapping objects like the transient_db to
# AutoRemoveDir or AutoRemoveFile instances to make sure that the
# temporary files and the directory are deleted but not before the
# objects that use them go away.
auto_remover = weakref.WeakKeyDictionary()

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.shapestores = []
        self.extensions = []
        self.temp_dir = None
        self.transient_db = None

    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 ShapeStores(self):
        """Return a list of all ShapeStore objects open in the session"""
        return [store() for store in self.shapestores]

    def _add_shapestore(self, store):
        """Internal: Add the shapestore to the list of shapestores"""
        self.shapestores.append(weakref.ref(store,
                                            self._clean_weak_store_refs))

    def _clean_weak_store_refs(self, weakref):
        """Internal: Remove the weakref from the shapestores list"""
        self.shapestores = [store for store in self.shapestores
                                  if store is not weakref]

    def Tables(self):
        """Return a list of all table objects open in the session"""
        # Tables are only available from shapestores at the moment, so
        # we just take them from there
        return [store.Table() for store in self.ShapeStores()]

    def temp_directory(self):
        """
        Return the name of the directory for session specific temporary files

        Create the directory if it doesn't exist yet.
        """
        if self.temp_dir is None:
            temp_dir = mktemp()
            os.mkdir(temp_dir, 0700)
            self.temp_dir = temp_dir
            self.temp_dir_remover = AutoRemoveDir(self.temp_dir)
        return self.temp_dir

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

    def TransientDB(self):
        if self.transient_db is None:
            filename = os.path.join(self.temp_directory(), "transientdb")
            self.transient_db = TransientDatabase(filename)
            #print self.temp_dir_remover
            auto_remover[self.transient_db] = AutoRemoveFile(filename,
                                                        self.temp_dir_remover)
        return self.transient_db

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

        # Close the transient DB explicitly so that it removes any
        # journal files from the temporary directory
        if self.transient_db is not None:
            self.transient_db.close()

    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	bh	765	import os
12			from tempfile import mktemp
13			import weakref
14
15	jan	197	from messages import MAPS_CHANGED, EXTENSIONS_CHANGED, FILENAME_CHANGED, \
16	jonathan	548	MAP_LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \
17	jonathan	582	LAYER_CHANGED, LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED,\
18	bh	232	EXTENSION_CHANGED, EXTENSION_OBJECTS_CHANGED, CHANGED
19	bh	6
20	jan	374	from Thuban import _
21
22	bh	6	from base import TitledObject, Modifiable
23			from map import Map
24	bh	723	from data import ShapefileStore
25	bh	6
26	bh	765	from transientdb import TransientDatabase
27	bh	6
28	bh	765	class AutoRemoveFile:
29
30			"""Remove a file once all references go away."""
31
32			def __init__(self, filename, tempdir = None):
33			"""Initialize the AutoRemoveFile
34
35			Parameters:
36			filename -- The name of the file to remove in __del__
37			tempdir -- Another object simple stored as an instance variable.
38
39			As the name suggests the tempdir parameter is intended for a
40			temporary directory the file might be located in. The intended
41			use is that it's an instance of AutoRemoveDir.
42			"""
43			self.filename = filename
44			self.tempdir = tempdir
45
46			def __del__(self, remove = os.remove):
47			remove(self.filename)
48
49			class AutoRemoveDir:
50
51			"""Remove a directory once all references go away
52
53			The intended use of this class together with AutoRemoveFile is for
54			temporary directories and files containd therein. An AutoRemoveDir
55			should be instantiated for the directory and passed as the tempdir
56			parameter to every AutoRemoveFile instance created for files in the
57			directory. An AutoRemoveFile shold be instantiated for every file
58			created in the directory so that the directory is automatically
59			removed once the last file is removed.
60			"""
61
62			def __init__(self, filename):
63			"""Initialize the AutoRemoveDir
64
65			The parameter is the name of the directory.
66			"""
67			self.filename = filename
68
69			def __del__(self, rmdir = os.rmdir):
70			rmdir(self.filename)
71
72
73			# WeakKey dictionary mapping objects like the transient_db to
74			# AutoRemoveDir or AutoRemoveFile instances to make sure that the
75			# temporary files and the directory are deleted but not before the
76			# objects that use them go away.
77			auto_remover = weakref.WeakKeyDictionary()
78
79	bh	6	class Session(TitledObject, Modifiable):
80
81			"""A complete session.
82
83	jan	197	A Session consists of arbitrary numbers of maps, tables and extensions
84	bh	6
85			Session objects send the following events:
86
87			TITLE_CHANGED -- The title has changed. Parameters: the session.
88
89			FILENAME_CHANGED -- The filename has changed. No parameters.
90
91			MAPS_CHANGED -- Maps were added, removed.
92
93	jan	197	EXTENSIONS_CHANGED -- Extensions were added, removed.
94
95	jonathan	548	MAP_LAYERS_CHANGED -- Same as the map's event of the same name.
96	bh	6	It's simply resent from the session to make
97			subscriptions easier.
98	bh	232
99			CHANGED -- Generic changed event. Parameters: the session. The
100			event is always issued when any other changed event
101			is issused. This is useful for code that needs to be
102			notified whenever something in the session has
103			changed but it's too cumbersome or error-prone to
104			subscribe to all the individual events.
105	bh	6	"""
106
107	bh	128	# message channels that have to be forwarded from maps contained in
108			# the session.
109			forwarded_channels = (
110	bh	318	# generic channels
111			CHANGED,
112
113	bh	128	# map specific channels
114			MAP_PROJECTION_CHANGED,
115	jonathan	548	MAP_LAYERS_CHANGED,
116	bh	128
117			# layer channels forwarded by the map
118			LAYER_PROJECTION_CHANGED,
119	jonathan	582	LAYER_CHANGED,
120	jan	197	LAYER_VISIBILITY_CHANGED,
121	bh	128
122	jan	197	# channels forwarded by an extension
123			EXTENSION_CHANGED,
124			EXTENSION_OBJECTS_CHANGED)
125
126	bh	6	def __init__(self, title):
127			TitledObject.__init__(self, title)
128			Modifiable.__init__(self)
129			self.filename = None
130			self.maps = []
131			self.tables = []
132	bh	851	self.shapestores = []
133	jan	197	self.extensions = []
134	bh	765	self.temp_dir = None
135			self.transient_db = None
136	bh	6
137	bh	232	def changed(self, channel = None, *args):
138			"""Like the inherited version but issue a CHANGED message as well.
139
140			The CHANGED message is only issued if channel given is a
141			different channel than CHANGED.
142			"""
143			Modifiable.changed(self, channel, *args)
144			if channel != CHANGED:
145			self.issue(CHANGED, self)
146
147	bh	6	def SetFilename(self, filename):
148			self.filename = filename
149			self.changed(FILENAME_CHANGED)
150
151			def Maps(self):
152			return self.maps
153
154			def HasMaps(self):
155			return len(self.maps) > 0
156
157			def AddMap(self, map):
158			self.maps.append(map)
159	bh	128	for channel in self.forwarded_channels:
160	bh	6	map.Subscribe(channel, self.forward, channel)
161			self.changed(MAPS_CHANGED)
162
163	bh	241	def RemoveMap(self, map):
164			for channel in self.forwarded_channels:
165			map.Unsubscribe(channel, self.forward, channel)
166			self.maps.remove(map)
167			self.changed(MAPS_CHANGED)
168			map.Destroy()
169
170	jan	197	def Extensions(self):
171			return self.extensions
172
173			def HasExtensions(self):
174			return len(self.extensions) > 0
175
176			def AddExtension(self, extension):
177			self.extensions.append(extension)
178			for channel in self.forwarded_channels:
179			extension.Subscribe(channel, self.forward, channel)
180			self.changed(EXTENSIONS_CHANGED)
181
182	bh	851	def ShapeStores(self):
183			"""Return a list of all ShapeStore objects open in the session"""
184			return [store() for store in self.shapestores]
185
186			def _add_shapestore(self, store):
187			"""Internal: Add the shapestore to the list of shapestores"""
188			self.shapestores.append(weakref.ref(store,
189			self._clean_weak_store_refs))
190
191			def _clean_weak_store_refs(self, weakref):
192			"""Internal: Remove the weakref from the shapestores list"""
193			self.shapestores = [store for store in self.shapestores
194			if store is not weakref]
195
196			def Tables(self):
197			"""Return a list of all table objects open in the session"""
198			# Tables are only available from shapestores at the moment, so
199			# we just take them from there
200			return [store.Table() for store in self.ShapeStores()]
201
202	bh	765	def temp_directory(self):
203			"""
204			Return the name of the directory for session specific temporary files
205
206			Create the directory if it doesn't exist yet.
207			"""
208			if self.temp_dir is None:
209			temp_dir = mktemp()
210			os.mkdir(temp_dir, 0700)
211			self.temp_dir = temp_dir
212			self.temp_dir_remover = AutoRemoveDir(self.temp_dir)
213			return self.temp_dir
214
215	bh	723	def OpenShapefile(self, filename):
216			"""Return a shapefile store object for the data in the given file"""
217	bh	851	store = ShapefileStore(self, filename)
218			self._add_shapestore(store)
219			return store
220	bh	723
221	bh	765	def TransientDB(self):
222			if self.transient_db is None:
223			filename = os.path.join(self.temp_directory(), "transientdb")
224			self.transient_db = TransientDatabase(filename)
225			#print self.temp_dir_remover
226			auto_remover[self.transient_db] = AutoRemoveFile(filename,
227			self.temp_dir_remover)
228			return self.transient_db
229
230	bh	6	def Destroy(self):
231			for map in self.maps:
232			map.Destroy()
233			self.maps = []
234			self.tables = []
235	bh	250	Modifiable.Destroy(self)
236	bh	6
237	bh	778	# Close the transient DB explicitly so that it removes any
238			# journal files from the temporary directory
239			if self.transient_db is not None:
240			self.transient_db.close()
241
242	bh	6	def forward(self, *args):
243	bh	232	"""Reissue events.
244
245			If the channel the event is forwarded to is a changed-channel
246			that is not the CHANGED channel issue CHANGED as well. An
247			channel is considered to be a changed-channel if it's name ends
248			with 'CHANGED'.
249			"""
250	bh	6	if len(args) > 1:
251			args = (args[-1],) + args[:-1]
252			apply(self.issue, args)
253	bh	232	channel = args[0]
254			# It's a bit of a kludge to rely on the channel name for this.
255			if channel.endswith("CHANGED") and channel != CHANGED:
256			self.issue(CHANGED, self)
257	bh	6
258			def WasModified(self):
259			"""Return true if the session or one of the maps was modified"""
260			if self.modified:
261			return 1
262			else:
263			for map in self.maps:
264			if map.WasModified():
265			return 1
266			return 0
267
268			def UnsetModified(self):
269			"""Unset the modified flag of the session and the maps"""
270			Modifiable.UnsetModified(self)
271			for map in self.maps:
272			map.UnsetModified()
273
274	bh	217	def TreeInfo(self):
275			items = []
276			if self.filename is None:
277	jan	374	items.append(_("Filename:"))
278	bh	217	else:
279	jan	374	items.append(_("Filename: %s") % self.filename)
280	bh	6
281	bh	217	if self.WasModified():
282	jan	374	items.append(_("Modified"))
283	bh	217	else:
284	jan	374	items.append(_("Unmodified"))
285	bh	6
286	bh	217	items.extend(self.maps)
287			items.extend(self.extensions)
288
289	jan	374	return (_("Session: %s") % self.title, items)
290	bh	217
291
292	bh	6	def create_empty_session():
293			"""Return an empty session useful as a starting point"""
294	jan	103	import os
295	jan	374	session = Session(_('unnamed session'))
296	jan	103	session.SetFilename(None)
297	jan	374	session.AddMap(Map(_('unnamed map')))
298	bh	56	session.UnsetModified()
299	bh	6	return session
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision