/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/Model/session.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/Thuban/Model/session.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 128 by bh, Fri May 3 14:38:16 2002 UTC revision 1068 by bh, Tue May 27 15:02:37 2003 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001, 2002 by Intevation GmbH  # Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]>
4    # Jan-Oliver Wagner <[email protected]>
5  #  #
6  # This program is free software under the GPL (>=v2)  # This program is free software under the GPL (>=v2)
7  # Read the file COPYING coming with Thuban for details.  # Read the file COPYING coming with Thuban for details.
8    
9  __version__ = "$Revision$"  __version__ = "$Revision$"
10    
11  from Thuban.Lib.connector import Publisher  import os
12    from tempfile import mktemp
13    import weakref
14    
15    from messages import MAPS_CHANGED, EXTENSIONS_CHANGED, FILENAME_CHANGED, \
16         MAP_LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \
17         LAYER_CHANGED, LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED,\
18         EXTENSION_CHANGED, EXTENSION_OBJECTS_CHANGED, CHANGED, \
19         TABLE_REMOVED
20    
21  from messages import MAPS_CHANGED, FILENAME_CHANGED, \  from Thuban import _
      LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \  
      LAYER_LEGEND_CHANGED, LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED  
22    
23  from base import TitledObject, Modifiable  from base import TitledObject, Modifiable
   
24  from map import Map  from map import Map
25    from data import ShapefileStore
26    from table import DBFTable
27    
28    from transientdb import TransientDatabase, AutoTransientTable
29    
30    class AutoRemoveFile:
31    
32        """Remove a file once all references go away."""
33    
34        def __init__(self, filename, tempdir = None):
35            """Initialize the AutoRemoveFile
36    
37            Parameters:
38               filename -- The name of the file to remove in __del__
39               tempdir -- Another object simple stored as an instance variable.
40    
41            As the name suggests the tempdir parameter is intended for a
42            temporary directory the file might be located in. The intended
43            use is that it's an instance of AutoRemoveDir.
44            """
45            self.filename = filename
46            self.tempdir = tempdir
47    
48        def __del__(self, remove = os.remove):
49            remove(self.filename)
50    
51    class AutoRemoveDir:
52    
53        """Remove a directory once all references go away
54    
55        The intended use of this class together with AutoRemoveFile is for
56        temporary directories and files containd therein. An AutoRemoveDir
57        should be instantiated for the directory and passed as the tempdir
58        parameter to every AutoRemoveFile instance created for files in the
59        directory. An AutoRemoveFile shold be instantiated for every file
60        created in the directory so that the directory is automatically
61        removed once the last file is removed.
62        """
63    
64        def __init__(self, filename):
65            """Initialize the AutoRemoveDir
66    
67            The parameter is the name of the directory.
68            """
69            self.filename = filename
70    
71        def __del__(self, rmdir = os.rmdir):
72            rmdir(self.filename)
73    
74    
75    # WeakKey dictionary mapping objects like the transient_db to
76    # AutoRemoveDir or AutoRemoveFile instances to make sure that the
77    # temporary files and the directory are deleted but not before the
78    # objects that use them go away.
79    auto_remover = weakref.WeakKeyDictionary()
80    
81  class Session(TitledObject, Modifiable):  class Session(TitledObject, Modifiable):
82    
83      """A complete session.      """A complete session.
84    
85      A Session consists of arbitrary numbers of maps and tables      A Session consists of arbitrary numbers of maps, tables and extensions
86    
87      Session objects send the following events:      Session objects send the following events:
88    
# Line 32  class Session(TitledObject, Modifiable): Line 92  class Session(TitledObject, Modifiable):
92    
93          MAPS_CHANGED -- Maps were added, removed.          MAPS_CHANGED -- Maps were added, removed.
94    
95          LAYERS_CHANGED -- Same as the map's event of the same name.          EXTENSIONS_CHANGED -- Extensions were added, removed.
96    
97            MAP_LAYERS_CHANGED -- Same as the map's event of the same name.
98                            It's simply resent from the session to make                            It's simply resent from the session to make
99                            subscriptions easier.                            subscriptions easier.
100    
101            CHANGED -- Generic changed event. Parameters: the session. The
102                       event is always issued when any other changed event
103                       is issused. This is useful for code that needs to be
104                       notified whenever something in the session has
105                       changed but it's too cumbersome or error-prone to
106                       subscribe to all the individual events.
107      """      """
108    
109      # message channels that have to be forwarded from maps contained in      # message channels that have to be forwarded from maps contained in
110      # the session.      # the session.
111      forwarded_channels = (      forwarded_channels = (
112            # generic channels
113            CHANGED,
114    
115          # map specific channels          # map specific channels
116          MAP_PROJECTION_CHANGED,          MAP_PROJECTION_CHANGED,
117          LAYERS_CHANGED,          MAP_LAYERS_CHANGED,
118    
119          # layer channels forwarded by the map          # layer channels forwarded by the map
120          LAYER_PROJECTION_CHANGED,          LAYER_PROJECTION_CHANGED,
121          LAYER_LEGEND_CHANGED,          LAYER_CHANGED,
122          LAYER_VISIBILITY_CHANGED)          LAYER_VISIBILITY_CHANGED,
123    
124            # channels forwarded by an extension
125            EXTENSION_CHANGED,
126            EXTENSION_OBJECTS_CHANGED)
127    
128      def __init__(self, title):      def __init__(self, title):
129          TitledObject.__init__(self, title)          TitledObject.__init__(self, title)
# Line 55  class Session(TitledObject, Modifiable): Line 131  class Session(TitledObject, Modifiable):
131          self.filename = None          self.filename = None
132          self.maps = []          self.maps = []
133          self.tables = []          self.tables = []
134            self.shapestores = []
135            self.extensions = []
136            self.temp_dir = None
137            self.transient_db = None
138    
139        def changed(self, channel = None, *args):
140            """Like the inherited version but issue a CHANGED message as well.
141    
142            The CHANGED message is only issued if channel given is a
143            different channel than CHANGED.
144            """
145            Modifiable.changed(self, channel, *args)
146            if channel != CHANGED:
147                self.issue(CHANGED, self)
148    
149      def SetFilename(self, filename):      def SetFilename(self, filename):
150          self.filename = filename          self.filename = filename
# Line 72  class Session(TitledObject, Modifiable): Line 162  class Session(TitledObject, Modifiable):
162              map.Subscribe(channel, self.forward, channel)              map.Subscribe(channel, self.forward, channel)
163          self.changed(MAPS_CHANGED)          self.changed(MAPS_CHANGED)
164    
165        def RemoveMap(self, map):
166            for channel in self.forwarded_channels:
167                map.Unsubscribe(channel, self.forward, channel)
168            self.maps.remove(map)
169            self.changed(MAPS_CHANGED)
170            map.Destroy()
171    
172        def Extensions(self):
173            return self.extensions
174    
175        def HasExtensions(self):
176            return len(self.extensions) > 0
177    
178        def AddExtension(self, extension):
179            self.extensions.append(extension)
180            for channel in self.forwarded_channels:
181                extension.Subscribe(channel, self.forward, channel)
182            self.changed(EXTENSIONS_CHANGED)
183    
184        def ShapeStores(self):
185            """Return a list of all ShapeStore objects open in the session"""
186            return [store() for store in self.shapestores]
187    
188        def _add_shapestore(self, store):
189            """Internal: Add the shapestore to the list of shapestores"""
190            self.shapestores.append(weakref.ref(store,
191                                                self._clean_weak_store_refs))
192    
193        def _clean_weak_store_refs(self, weakref):
194            """Internal: Remove the weakref from the shapestores list"""
195            self.shapestores = [store for store in self.shapestores
196                                      if store is not weakref]
197    
198        def Tables(self):
199            """Return a list of all table objects open in the session
200    
201            The list includes all tables that are indirectly opened through
202            shape stores and the tables that have been opened explicitly.
203            """
204            return self.tables + [store.Table() for store in self.ShapeStores()]
205    
206        def UnreferencedTables(self):
207            """Return the tables that are not referenced by other data sources"""
208            known = {}
209            for table in self.tables:
210                known[id(table)] = 0
211            for table in self.tables + self.ShapeStores():
212                for dep in table.Dependencies():
213                    known[id(dep)] = 1
214            return [table for table in self.tables if known[id(table)] == 0]
215    
216        def AddTable(self, table):
217            """Add the table to the session
218    
219            All tables associated with the session that are not implicitly
220            created by the OpenShapefile method (and maybe other Open*
221            methods in the future) have to be passed to this method to make
222            sure the session knows about it. The session keeps a reference
223            to the table. Only tables managed by the session in this way
224            should be used for layers contained in one of the session's
225            maps.
226    
227            The table parameter may be any object implementing the table
228            interface. If it's not already one of the transient tables
229            instantiate an AutoTransientTable with it and use that instead
230            of the original table (note that the AutoTransientTable keeps a
231            reference to the original table).
232    
233            Return the table object actually used by the session.
234            """
235            if not hasattr(table, "transient_table"):
236                transient_table = AutoTransientTable(self.TransientDB(), table)
237            else:
238                transient_table = table
239            self.tables.append(transient_table)
240            return transient_table
241    
242        def RemoveTable(self, table):
243            """Remove the table from the session.
244    
245            The table object must be a table object previously returned by
246            the AddTable method. If the table is not part of the session
247            raise a ValueError.
248    
249            Issue a TABLE_REMOVED message after the table has been removed.
250            The message has the removed table as the single parameter.
251            """
252            tables = [t for t in self.tables if t is not table]
253            if len(tables) == len(self.tables):
254                raise ValueError
255            self.tables = tables
256            self.changed(TABLE_REMOVED, table)
257    
258        def OpenTableFile(self, filename):
259            """Open the table file filename and return the table object.
260    
261            The filename argument must be the name of a DBF file.
262            """
263            return self.AddTable(DBFTable(filename))
264    
265        def temp_directory(self):
266            """
267            Return the name of the directory for session specific temporary files
268    
269            Create the directory if it doesn't exist yet.
270            """
271            if self.temp_dir is None:
272                temp_dir = mktemp()
273                os.mkdir(temp_dir, 0700)
274                self.temp_dir = temp_dir
275                self.temp_dir_remover = AutoRemoveDir(self.temp_dir)
276            return self.temp_dir
277    
278        def OpenShapefile(self, filename):
279            """Return a shapefile store object for the data in the given file"""
280            store = ShapefileStore(self, filename)
281            self._add_shapestore(store)
282            return store
283    
284        def AddShapeStore(self, shapestore):
285            """Add the shapestore to the session.
286    
287            The session only holds a weak reference to the shapestore, so it
288            will automatically be removed from the session when the last
289            reference goes away.
290            """
291            self._add_shapestore(shapestore)
292            return shapestore
293    
294        def TransientDB(self):
295            if self.transient_db is None:
296                filename = os.path.join(self.temp_directory(), "transientdb")
297                self.transient_db = TransientDatabase(filename)
298                #print self.temp_dir_remover
299                auto_remover[self.transient_db] = AutoRemoveFile(filename,
300                                                            self.temp_dir_remover)
301            return self.transient_db
302    
303      def Destroy(self):      def Destroy(self):
304          for map in self.maps:          for map in self.maps:
305              map.Destroy()              map.Destroy()
306          self.maps = []          self.maps = []
307          self.tables = []          self.tables = []
308          Publisher.Destroy(self)          Modifiable.Destroy(self)
309    
310            # Close the transient DB explicitly so that it removes any
311            # journal files from the temporary directory
312            if self.transient_db is not None:
313                self.transient_db.close()
314    
315      def forward(self, *args):      def forward(self, *args):
316          """Reissue events"""          """Reissue events.
317    
318            If the channel the event is forwarded to is a changed-channel
319            that is not the CHANGED channel issue CHANGED as well. An
320            channel is considered to be a changed-channel if it's name ends
321            with 'CHANGED'.
322            """
323          if len(args) > 1:          if len(args) > 1:
324              args = (args[-1],) + args[:-1]              args = (args[-1],) + args[:-1]
325          apply(self.issue, args)          apply(self.issue, args)
326            channel = args[0]
327            # It's a bit of a kludge to rely on the channel name for this.
328            if channel.endswith("CHANGED") and channel != CHANGED:
329                self.issue(CHANGED, self)
330    
331      def WasModified(self):      def WasModified(self):
332          """Return true if the session or one of the maps was modified"""          """Return true if the session or one of the maps was modified"""
# Line 101  class Session(TitledObject, Modifiable): Line 344  class Session(TitledObject, Modifiable):
344          for map in self.maps:          for map in self.maps:
345              map.UnsetModified()              map.UnsetModified()
346    
347        def TreeInfo(self):
348            items = []
349            if self.filename is None:
350                items.append(_("Filename:"))
351            else:
352                items.append(_("Filename: %s") % self.filename)
353    
354            if self.WasModified():
355                items.append(_("Modified"))
356            else:
357                items.append(_("Unmodified"))
358    
359            items.extend(self.maps)
360            items.extend(self.extensions)
361    
362            return (_("Session: %s") % self.title, items)
363    
364    
365  def create_empty_session():  def create_empty_session():
366      """Return an empty session useful as a starting point"""      """Return an empty session useful as a starting point"""
367      import os      import os
368      session = Session('unnamed session')      session = Session(_('unnamed session'))
369      session.SetFilename(None)      session.SetFilename(None)
370      session.AddMap(Map('unnamed map'))      session.AddMap(Map(_('unnamed map')))
371      session.UnsetModified()      session.UnsetModified()
372      return session      return session
Legend:
Removed from v.128  
changed lines
  Added in v.1068
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26