~mjz/awn-extras/to-do-two

« back to all changes in this revision

Viewing changes to applets/maintained/to-do/backends.py

  • Committer: Matt
  • Date: 2010-06-01 02:39:21 UTC
  • Revision ID: sharkbaitbobby@gmail.com-20100601023921-dboizxmmjtcugule
Full read/write, even across multiple applets!
Handle to-do.xml not existing, having errors, etc etc etc.

Show diffs side-by-side

added added

removed removed

Lines of Context:
22
22
import sys
23
23
from xml.dom import minidom
24
24
 
 
25
import gio
 
26
 
25
27
from awn.extras import _
26
28
 
 
29
config_dir = os.path.expanduser('~/.config/awn/applets')
 
30
 
27
31
 
28
32
class FileBackend:
29
33
    def __init__(self):
30
34
        self.path = os.path.expanduser('~/.config/awn/applets/to-do.xml')
 
35
        self.current_id = '-1'
 
36
 
 
37
        if not os.path.exists(config_dir):
 
38
            os.makedirs(config_dir)
 
39
 
 
40
        self.__lists_monitor = gio.File(self.path).monitor_file()
 
41
 
 
42
        def lists_changed_cb(monitor, file, other_file, event):
 
43
            if event == gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
 
44
                self.load_lists()
 
45
 
 
46
        self.__lists_monitor.connect('changed', lists_changed_cb)
31
47
 
32
48
        self.lists = {}
33
49
        self.__getitem__ = self.lists.__getitem__
34
50
        self.__setitem__ = self.lists.__setitem__
35
 
 
 
51
        self.__iter__ = self.lists.__iter__
 
52
 
 
53
        self.load_lists()
 
54
 
 
55
    def load_lists(self):
36
56
        if os.path.isfile(self.path):
37
57
            fp = open(self.path)
38
 
            self.doc = minidom.parseString(fp.read())
 
58
            content = fp.read()
39
59
            fp.close()
40
60
 
41
 
            for node in self.doc.documentElement.childNodes:
42
 
                if isinstance(node, minidom.Element):
43
 
                    li = List(node)
44
 
                    self[li['id']] = li
 
61
            try:
 
62
                self.doc = minidom.parseString(content)
 
63
    
 
64
                for node in self.doc.documentElement.childNodes:
 
65
                    if isinstance(node, minidom.Element):
 
66
                        li = List(node)
 
67
                        if li['id'] != self.current_id:
 
68
                            li.xml = content
 
69
                            li.backend = self
 
70
                            self[li['id']] = li
 
71
 
 
72
            except:
 
73
                pass
45
74
 
46
75
    def create_list(self):
47
76
        _id = 0
50
79
            if int(li['id']) > _id:
51
80
                _id = int(li['id'])
52
81
 
53
 
        return List({'id': str(_id + 1)})
 
82
        li = List({'id': str(_id + 1)})
 
83
 
 
84
        self[str(_id + 1)] = li
 
85
 
 
86
        return li
 
87
 
 
88
    def write(self):
 
89
        s = '<?xml version="1.0" encoding="UTF-8"?>\n<todo>'
 
90
 
 
91
        for _id, li in self.lists.items():
 
92
            p = ''
 
93
 
 
94
            for key, val in li.items():
 
95
                p += '\n%s=%s' % (key, ncd(str(val)))
 
96
 
 
97
            s += '<list>\n<attributes><![CDATA[id=%s%s]]></attributes>\n' % (_id, p)
 
98
 
 
99
            for child in li:
 
100
                if isinstance(child, Group):
 
101
                    p = ''
 
102
                    for key, val in child.items():
 
103
                        if p == '':
 
104
                            p += '%s=%s' % (key, ncd(str(val)))
 
105
                        else:
 
106
                            p += '\n%s=%s' % (key, ncd(str(val)))
 
107
 
 
108
                    s += '<group>\n<attributes><![CDATA[' + p + ']]></attributes>\n'
 
109
 
 
110
                    for item in child:
 
111
                        p = ''
 
112
                        for key, val in item.items():
 
113
                            if p == '':
 
114
                                p += '%s=%s' % (key, ncd(str(val)))
 
115
                            else:
 
116
                                p += '\n%s=%s' % (key, ncd(str(val)))
 
117
 
 
118
                        s += '<item><![CDATA[%s]]></item>' % p
 
119
 
 
120
                    s += '</group>\n'
 
121
 
 
122
                else:
 
123
                    p = ''
 
124
                    for key, val in child.items():
 
125
                        if p == '':
 
126
                            p += '%s=%s' % (key, ncd(str(val)))
 
127
                        else:
 
128
                            p += '\n%s=%s' % (key, ncd(str(val)))
 
129
 
 
130
                    s += '<item><![CDATA[%s]]></item>' % p
 
131
 
 
132
            s += '</list>'
 
133
 
 
134
        s += '</todo>'
 
135
 
 
136
        fp = open(self.path, 'w+')
 
137
        fp.write(s)
 
138
        fp.close()
54
139
 
55
140
class List:
56
141
    def __init__(self, data):
 
142
        self.xml = ''
57
143
        self.attributes = {}
58
144
        self.__getitem__ = self.attributes.__getitem__
59
145
        self.__setitem__ = self.attributes.__setitem__
 
146
        self.items = self.attributes.items
60
147
 
61
148
        self.children = []
62
149
        self.__iter__ = self.children.__iter__
88
175
        for k, v in data.items():
89
176
            self[k] = v
90
177
 
91
 
        defaults = {'name': _("To-Do List"), 'icon_colors': 'FF0000FF;008800FF;0000FFFF;FFFFFFFF',
 
178
        defaults = {'name': _("To-Do List"), 'icon_colors': '000000;444444;888888;FFFFFF',
92
179
                    'priority_colors': '008800;FFFFFF;FFFF00;000000;FF0000;FFFFFF',
93
 
                    'icon_mode': '0', 'confirm': '3', 'width': '250', 'use_width': '1'}
 
180
                    'icon_mode': '0', 'confirm': '3', 'width': '250', 'use_width': '1',
 
181
                    'alpha': '100'}
94
182
 
95
183
        for k, v in defaults.items():
96
184
            if k not in self.attributes:
112
200
 
113
201
        return num
114
202
 
 
203
    def remove(self, child):
 
204
        if isinstance(child, Group):
 
205
            self.groups.remove(child)
 
206
 
 
207
        self.children.remove(child)
 
208
 
 
209
        del child
 
210
 
115
211
    def write(self):
116
 
        pass
 
212
        self.backend.write()
117
213
 
118
214
class Group:
119
215
    def __init__(self, data):
120
216
        self.attributes = {}
121
217
        self.__getitem__ = self.attributes.__getitem__
122
218
        self.__setitem__ = self.attributes.__setitem__
 
219
        self.items = self.attributes.items
123
220
 
124
221
        self.children = []
125
222
        self.__iter__ = self.children.__iter__
140
237
                    self.attributes.update(parse_kv(node.childNodes[0].wholeText))
141
238
 
142
239
                elif node.tagName == 'item':
143
 
                    self.children.append(Item(node))
 
240
                    self.children.append(Item(node, self))
144
241
 
145
242
    def parse_dict(self, data):
146
243
        defaults = {'name': '', 'expanded': '1', 'details': ''}
147
244
        self.attributes.update(defaults)
148
245
        self.attributes.update(data)
149
246
 
 
247
    def remove(self, item):
 
248
        self.children.remove(item)
 
249
 
 
250
        del item
 
251
 
150
252
class Item:
151
253
    def __init__(self, data, group=None):
152
254
        self.attributes = {}
158
260
        elif isinstance(data, dict):
159
261
            self.parse_dict(data)
160
262
 
161
 
        if group is not None:
162
 
            group.add(self)
163
 
 
164
263
        self.__getitem__ = self.attributes.__getitem__
165
264
        self.__setitem__ = self.attributes.__setitem__
166
265
        self.__str__ = self.attributes.__str__
 
266
        self.items = self.attributes.items
167
267
 
168
268
    def parse_minidom(self, data):
169
269
        for node in data.childNodes:
189
289
 
190
290
    return d
191
291
 
 
292
def ncd(s):
 
293
    while ']]>' in s:
 
294
      s =  s.replace(']]>', ']>')
 
295
 
 
296
    return s
 
297
 
192
298
FileBackend()