← Back to branch summary

~cosmin.lupu/+junk/penguintv

« back to all changes in this revision

Viewing changes to penguintv/FeedPropertiesDialog.py

  • Committer: cosmin.lupu at gmail
  • Date: 2010-04-27 16:47:43 UTC
  • Revision ID: cosmin.lupu@gmail.com-20100427164743-ds8xrqonipp5ovdf
initial packaging

Show diffs side-by-side

added added

removed removed

Lines of Context:
penguintv/FeedPropertiesDialog.py
 
1
# Written by Owen Williams
 
2
# see LICENSE for license information
 
3
 
 
4
import penguintv
 
5
import utils
 
6
from ptvDB import FeedAlreadyExists, FF_NOAUTODOWNLOAD, FF_NOSEARCH, \
 
7
                                  FF_NOAUTOEXPIRE, FF_NOTIFYUPDATES, FF_ADDNEWLINES, \
 
8
                                  FF_MARKASREAD, FF_NOKEEPDELETED 
 
9
import gtk
 
10
import time, datetime
 
11
from math import floor
 
12
 
 
13
 
 
14
class FeedPropertiesDialog(gtk.Dialog):
 
15
        def __init__(self,xml,app):
 
16
                gtk.Dialog.__init__(self)
 
17
                self._xml = xml
 
18
                self._app = app
 
19
 
 
20
                #self._window = xml.get_widget("window_feed_properties")
 
21
                contents = xml.get_widget("feed_prop_contents")
 
22
                p = contents.get_parent()
 
23
                contents.unparent()
 
24
                self.vbox.add(contents)
 
25
                gtk.Dialog.set_title(self, p.get_title())
 
26
                del p
 
27
 
 
28
                for key in dir(self.__class__):
 
29
                        if key[:3] == 'on_':
 
30
                                self._xml.signal_connect(key, getattr(self,key))
 
31
                                
 
32
                self.connect('delete-event', self.on_window_feed_properties_delete_event)
 
33
                                
 
34
                self._title_widget = xml.get_widget('title_entry')
 
35
                self._rss_widget = xml.get_widget('rss_entry')
 
36
                self._link_widget = xml.get_widget('link_entry')
 
37
                self._description_widget = xml.get_widget('description_label')
 
38
                self._last_poll_widget = xml.get_widget('last_poll_label')
 
39
                self._next_poll_widget = xml.get_widget('next_poll_label')
 
40
                self._edit_tags_widget = xml.get_widget('edit_tags_widget')
 
41
                self._cur_flags = 0
 
42
                self._old_title = ""
 
43
                self._old_rss = ""
 
44
                self._old_link = ""
 
45
                self._old_tags = []
 
46
                self._old_flags = 0
 
47
                
 
48
                self._feed_id=0
 
49
                                
 
50
        def show(self):
 
51
                if utils.RUNNING_HILDON:
 
52
                        self.resize(600,200)
 
53
                        self.show_all()
 
54
                self.set_transient_for(self._app.main_window.get_parent())
 
55
                self._xml.get_widget('notebook1').set_current_page(0)
 
56
                if not utils.HAS_SEARCH:
 
57
                        self._xml.get_widget('b_search').hide()
 
58
                if utils.RUNNING_SUGAR or not utils.HAS_STATUS_ICON:
 
59
                        self._xml.get_widget('b_notifyupdates').hide()
 
60
                #if not utils.USE_TAGGING
 
61
                #       self._edit_tags_widget.hide()
 
62
                self._title_widget.grab_focus()
 
63
                gtk.Dialog.show(self)
 
64
                
 
65
        def set_feedid(self, id):
 
66
                self._feed_id = id
 
67
        
 
68
        def set_title(self, title):
 
69
                if title is None:
 
70
                        title=""
 
71
                self._title_widget.set_text(title)
 
72
                self._old_title = title
 
73
                
 
74
        def set_rss(self, rss):
 
75
                if rss is None:
 
76
                        rss=""
 
77
                self._rss_widget.set_text(rss)
 
78
                self._old_rss = rss
 
79
                
 
80
        def set_description(self, desc):
 
81
                if desc is None:
 
82
                        desc = ""
 
83
                self._description_widget.set_text(desc)
 
84
                
 
85
        def set_link(self, link):
 
86
                if link is None:
 
87
                        link = ""
 
88
                self._link_widget.set_text(link)
 
89
                self._old_link = link
 
90
                
 
91
        def set_last_poll(self, lastpoll):
 
92
                self._last_poll_widget.set_text(time.strftime("%X",time.localtime(lastpoll)))
 
93
                
 
94
        def set_next_poll(self, nextpoll):
 
95
                if nextpoll <= time.time():
 
96
                        self._next_poll_widget.set_text(_("Momentarily"))
 
97
                else:
 
98
                        delta = datetime.timedelta(seconds=nextpoll-time.time())
 
99
                        d = {'hours':int(floor(delta.seconds/3600)),
 
100
                                 'mins':int((delta.seconds-(floor(delta.seconds/3600)*3600))/60)}
 
101
                        self._next_poll_widget.set_text(_("in approx %(hours)sh %(mins)sm") % d)
 
102
                        
 
103
        def set_tags(self, tags):
 
104
                text = ""
 
105
                if tags:
 
106
                        for tag in tags:
 
107
                                text=text+tag+", "
 
108
                        text = text[0:-2]
 
109
                self._edit_tags_widget.set_text(text)
 
110
                self._old_tags = tags
 
111
                
 
112
        def set_flags(self, flags):
 
113
                self._old_flags = self._cur_flags = flags
 
114
        
 
115
                #reversed
 
116
                if flags & FF_NOAUTODOWNLOAD == FF_NOAUTODOWNLOAD:
 
117
                        self._xml.get_widget('b_autodownload').set_active(False)
 
118
                else:
 
119
                        self._xml.get_widget('b_autodownload').set_active(True)
 
120
                        
 
121
                #reversed
 
122
                if flags & FF_NOSEARCH == FF_NOSEARCH:
 
123
                        self._xml.get_widget('b_search').set_active(False)
 
124
                else:
 
125
                        self._xml.get_widget('b_search').set_active(True)
 
126
                        
 
127
                if flags & FF_NOAUTOEXPIRE == FF_NOAUTOEXPIRE:
 
128
                        self._xml.get_widget('b_noautoexpire').set_active(True)
 
129
                else:
 
130
                        self._xml.get_widget('b_noautoexpire').set_active(False)
 
131
                        
 
132
                if flags & FF_NOTIFYUPDATES == FF_NOTIFYUPDATES:
 
133
                        self._xml.get_widget('b_notifyupdates').set_active(True)
 
134
                else:
 
135
                        self._xml.get_widget('b_notifyupdates').set_active(False)
 
136
                        
 
137
                if flags & FF_ADDNEWLINES == FF_ADDNEWLINES:
 
138
                        self._xml.get_widget('b_addnewlines').set_active(True)
 
139
                else:
 
140
                        self._xml.get_widget('b_addnewlines').set_active(False)
 
141
                        
 
142
                if flags & FF_MARKASREAD == FF_MARKASREAD:
 
143
                        self._xml.get_widget('b_markasread').set_active(True)
 
144
                else:
 
145
                        self._xml.get_widget('b_markasread').set_active(False)
 
146
                        
 
147
                if flags & FF_NOKEEPDELETED == FF_NOKEEPDELETED:
 
148
                        self._xml.get_widget('b_nokeepdeleted').set_active(True)
 
149
                else:
 
150
                        self._xml.get_widget('b_nokeepdeleted').set_active(False)
 
151
 
 
152
        def on_window_feed_properties_delete_event(self, widget, event):
 
153
                return self.hide_on_delete()
 
154
                
 
155
        def on_b_autodownload_toggled(self, b_autodownload):
 
156
                # reverse the polarity!
 
157
                noautodownload = not b_autodownload.get_active()
 
158
                if noautodownload:
 
159
                        if not self._cur_flags & FF_NOAUTODOWNLOAD == FF_NOAUTODOWNLOAD:
 
160
                                self._cur_flags += FF_NOAUTODOWNLOAD
 
161
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
162
                else:
 
163
                        if self._cur_flags & FF_NOAUTODOWNLOAD == FF_NOAUTODOWNLOAD:
 
164
                                self._cur_flags -= FF_NOAUTODOWNLOAD
 
165
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
166
                                
 
167
        def on_b_search_toggled(self, b_search):
 
168
                # reverse the polarity!
 
169
                nosearch = not b_search.get_active()
 
170
                if nosearch:
 
171
                        if not self._cur_flags & FF_NOSEARCH == FF_NOSEARCH:
 
172
                                self._cur_flags += FF_NOSEARCH
 
173
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
174
                else:
 
175
                        if self._cur_flags & FF_NOSEARCH == FF_NOSEARCH:
 
176
                                self._cur_flags -= FF_NOSEARCH
 
177
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
178
                                
 
179
        def on_b_notifyupdates_toggled(self, b_notifyupdates):
 
180
                if b_notifyupdates.get_active():
 
181
                        if not self._cur_flags & FF_NOTIFYUPDATES == FF_NOTIFYUPDATES:
 
182
                                self._cur_flags += FF_NOTIFYUPDATES
 
183
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
184
                                self._app.emit('notify-tags-changed')
 
185
                else:
 
186
                        if self._cur_flags & FF_NOTIFYUPDATES == FF_NOTIFYUPDATES:
 
187
                                self._cur_flags -= FF_NOTIFYUPDATES
 
188
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
189
                                self._app.emit('notify-tags-changed')
 
190
                                
 
191
        def on_b_noautoexpire_toggled(self, b_noautoexpire):
 
192
                if b_noautoexpire.get_active():
 
193
                        if not self._cur_flags & FF_NOAUTOEXPIRE == FF_NOAUTOEXPIRE:
 
194
                                self._cur_flags += FF_NOAUTOEXPIRE
 
195
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
196
                else:
 
197
                        if self._cur_flags & FF_NOAUTOEXPIRE == FF_NOAUTOEXPIRE:
 
198
                                self._cur_flags -= FF_NOAUTOEXPIRE
 
199
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
200
                                
 
201
        def on_b_nokeepdeleted_toggled(self, b_nokeepdeleted):
 
202
                if b_nokeepdeleted.get_active():
 
203
                        if not self._cur_flags & FF_NOKEEPDELETED == FF_NOKEEPDELETED:
 
204
                                self._cur_flags += FF_NOKEEPDELETED
 
205
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
206
                else:
 
207
                        if self._cur_flags & FF_NOKEEPDELETED == FF_NOKEEPDELETED:
 
208
                                self._cur_flags -= FF_NOKEEPDELETED
 
209
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
210
                                
 
211
        def on_b_addnewlines_toggled(self, b_addnewlines):
 
212
                if b_addnewlines.get_active():
 
213
                        if not self._cur_flags & FF_ADDNEWLINES == FF_ADDNEWLINES:
 
214
                                self._cur_flags += FF_ADDNEWLINES
 
215
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
216
                                self._app.emit('render-ops-updated')
 
217
                else:
 
218
                        if self._cur_flags & FF_ADDNEWLINES == FF_ADDNEWLINES:
 
219
                                self._cur_flags -= FF_ADDNEWLINES
 
220
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
221
                                self._app.emit('render-ops-updated')
 
222
                                
 
223
        def on_b_markasread_toggled(self, b_markasread):
 
224
                if b_markasread.get_active():
 
225
                        if not self._cur_flags & FF_MARKASREAD == FF_MARKASREAD:
 
226
                                self._cur_flags += FF_MARKASREAD
 
227
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
228
                                self._app.emit('render-ops-updated')
 
229
                else:
 
230
                        if self._cur_flags & FF_MARKASREAD == FF_MARKASREAD:
 
231
                                self._cur_flags -= FF_MARKASREAD
 
232
                                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
233
                                self._app.emit('render-ops-updated')
 
234
                
 
235
        def on_save_values_activate(self, event):
 
236
                new_title = self._title_widget.get_text()
 
237
 
 
238
                if new_title != self._old_title:
 
239
                        #self._app.db.set_feed_name(self._feed_id,new_title)
 
240
                        self._app.rename_feed(self._feed_id, new_title)
 
241
                        self._old_title = new_title
 
242
                new_rss = self._rss_widget.get_text()
 
243
 
 
244
                if new_rss != self._old_rss:
 
245
                        try:
 
246
                                self._app.db.set_feed_url(self._feed_id, new_rss)
 
247
                                self._old_rss = new_rss
 
248
                        except FeedAlreadyExists:
 
249
                                dialog = gtk.Dialog(title=_("URL Already in Use"), parent=None, flags=gtk.DIALOG_MODAL, buttons=(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
 
250
                                label = gtk.Label(_("A feed already exists with that URL.  Please use a different URL."))
 
251
                                dialog.vbox.pack_start(label, True, True, 0)
 
252
                                label.show()
 
253
                                response = dialog.run()
 
254
                                dialog.hide()
 
255
                                del dialog
 
256
                                
 
257
                                self._rss_widget.grab_focus()
 
258
                                return False
 
259
                new_link = self._link_widget.get_text()
 
260
 
 
261
                if new_link != self._old_link:
 
262
                        self._app.db.set_feed_link(self._feed_id, new_link)
 
263
                        self._old_link = new_link
 
264
 
 
265
                tags=[tag.strip() for tag in self._edit_tags_widget.get_text().split(',')]
 
266
                self._app.apply_tags_to_feed(self._feed_id, self._old_tags, tags)
 
267
                
 
268
                self._app.db.set_flags_for_feed(self._feed_id, self._cur_flags)
 
269
                return True
 
270
                
 
271
        def on_close_button_clicked(self,event):
 
272
                self._finish()
 
273
                
 
274
        def on_revert_button_clicked(self, event):
 
275
                self.set_title(self._old_title)
 
276
                self.set_rss(self._old_rss)
 
277
                self.set_link(self._old_link)
 
278
                self.set_flags(self._old_flags)
 
279
                
 
280
        def _finish(self):
 
281
                if self.on_save_values_activate(None):
 
282
                        self.hide()