← Back to branch summary

~phoenix1987/gtumbler/uas

« back to all changes in this revision

Viewing changes to gtumbler/session.py

  • Committer: Gabriele N. Tornetta
  • Date: 2012-06-25 16:18:04 UTC
  • Revision ID: phoenix1987@gmail.com-20120625161804-qjyy0b6wc8svt5kx
quickly saved

Show diffs side-by-side

added added

removed removed

Lines of Context:
gtumbler/session.py
 
1
import shelve
 
2
import tempfile
 
3
import os
 
4
import collections
 
5
 
 
6
class TempContext:
 
7
        def __init__(self):
 
8
                self.tmp_files = []
 
9
                
 
10
        def __del__(self):
 
11
                self.clear()
 
12
                
 
13
        def new_file(self, ext = ''):
 
14
                fd, tmp = tempfile.mkstemp(ext)
 
15
                os.close(fd)
 
16
                self.tmp_files.append(tmp)
 
17
                return tmp
 
18
                
 
19
        def clear(self):
 
20
                for f in self.tmp_files:
 
21
                        try:
 
22
                                os.remove(f)
 
23
                        except OSError:
 
24
                                pass
 
25
 
 
26
## Singleton implementation of a registry class
 
27
#
 
28
class Session:
 
29
        __shared_state = {
 
30
                'doc_uid' : 0,
 
31
                'doc_dict' : {},
 
32
                'history' : collections.deque(maxlen=20),
 
33
                'future'  : [],
 
34
                'has_changed' : False,
 
35
                'filename' : None,
 
36
                'temp' : {}
 
37
        }
 
38
        
 
39
        def __init__(self, main_win = None):
 
40
                self.__dict__ = self.__shared_state
 
41
                if main_win: self.main = main_win
 
42
 
 
43
        def assign_uid(self):
 
44
                self.doc_uid += 1
 
45
                return self.doc_uid - 1
 
46
        
 
47
        def can_redo(self):
 
48
                can = bool(self.future)
 
49
                self.main.ui.tb_redo.set_sensitive(can)
 
50
                return can
 
51
        
 
52
        def can_undo(self):
 
53
                can = bool(self.history)
 
54
                self.main.ui.tb_undo.set_sensitive(can)
 
55
                return can
 
56
        
 
57
        def clear(self):
 
58
                self.doc_uid = 0
 
59
                self.doc_dict = {}
 
60
                self.history = collections.deque(maxlen=20),
 
61
                self.has_changed = True
 
62
 
 
63
        def do(self, cmd):
 
64
                cmd.do()
 
65
                self.history.append(cmd)
 
66
                self.future = []
 
67
                
 
68
                self.can_redo()
 
69
                return self.can_undo()
 
70
 
 
71
        def new(self):
 
72
                self.doc_uid = 0
 
73
                self.doc_dict = {}
 
74
                self.history = collections.deque(maxlen=20),
 
75
                self.has_changed = False
 
76
                self.filename = None
 
77
 
 
78
        def save(self, fn = None):
 
79
                if fn:
 
80
                        filename = fn
 
81
                        self.has_changed = True
 
82
                else: filename = self.filename
 
83
                if not filename: return False
 
84
                if not self.has_changed:
 
85
                        self.status("No changes need to be saved.")
 
86
                        return False
 
87
 
 
88
                try:
 
89
                        shelf = shelve.open(filename, 'n')
 
90
                        shelf['ls_doc'] = self.ls_doc
 
91
                        shelf['doc_dict'] = self.doc_dict
 
92
                        shelf['doc_uid'] = self.doc_uid
 
93
                        shelf['history'] = self.history
 
94
                        shelf.close()
 
95
                        self.filename = filename
 
96
                        self.status('File "%s" has been saved successfully.' % self.filename)
 
97
                except IOError:
 
98
                        self.status('Unable to save "%s".' % self.filename)
 
99
                        return False
 
100
                        
 
101
                self.has_changed = False
 
102
                return True
 
103
                
 
104
        def open(self, filename):
 
105
                shelf = shelve.open(filename)
 
106
                try:
 
107
                        model = shelf['ts_plot']
 
108
                        ##TODO: Probably a check on model is needed here
 
109
                        self.ls_plot = model
 
110
                        self.doc_dict = shelf['doc_dict']
 
111
                        self.doc_uid = shelf['doc_uid']
 
112
                        self.state = shelf['state'] if 'state' in shelf else ""
 
113
                        self.history = shelf['history'] if 'history' in shelf else []
 
114
                        
 
115
                        self.filename = filename
 
116
                        self.has_changed = False
 
117
                        
 
118
                except (KeyError, ValueError):
 
119
                        return False
 
120
 
 
121
                finally:
 
122
                        shelf.close()
 
123
                        self.status('File "%s" has been loaded successfully.' % self.filename)
 
124
 
 
125
                return True
 
126
 
 
127
        def redo(self):
 
128
                if not self.can_redo(): return False
 
129
                
 
130
                cmd = self.future.pop()
 
131
                cmd.redo()
 
132
                self.history.append(cmd)
 
133
                
 
134
                self.can_undo()
 
135
                return self.can_redo()
 
136
        
 
137
        def temp_new(self, name):
 
138
                self.temp[name] = TempContext()
 
139
                return self.temp[name]
 
140
                
 
141
        def temp_delete(self, name):
 
142
                del self.temp[name]
 
143
 
 
144
        def undo(self):
 
145
                if not self.can_undo(): return False
 
146
                
 
147
                cmd = self.history.pop()
 
148
                cmd.undo()
 
149
                self.future.append(cmd)
 
150
                
 
151
                self.can_redo()
 
152
                return self.can_undo()