#
# Copyright (c) 2007-2008 INdT.
+# Copyright (c) 2011 Neal H. Walfield
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# ============================================================================
__appname__ = 'FeedingIt'
__author__ = 'Yves Marcoz'
-__version__ = '0.6.2'
+__version__ = '0.9.1~woodchuck'
__description__ = 'A simple RSS Reader for Maemo 5'
# ============================================================================
# import gtkhtml2
# has_webkit=False
from os.path import isfile, isdir, exists
-from os import mkdir, remove, stat
+from os import mkdir, remove, stat, environ
import gobject
from aboutdialog import HeAboutDialog
from portrait import FremantleRotation
from updatedbus import UpdateServerObject, get_lock
from config import Config
from cgi import escape
+import weakref
-from rss import Listing
+from rss_sqlite import Listing
from opml import GetOpmlData, ExportOpmlData
-from urllib2 import install_opener, build_opener
+import mainthread
+from jobmanager import JobManager
from socket import setdefaulttimeout
timeout = 5
setdefaulttimeout(timeout)
del timeout
+import xml.sax
+
LIST_ICON_SIZE = 32
LIST_ICON_BORDER = 10
import style
-MARKUP_TEMPLATE = '<span font_desc="%s" foreground="%s">%%s</span>'
+MARKUP_TEMPLATE= '<span font_desc="%s" foreground="%s">%%s</span>'
+MARKUP_TEMPLATE_ENTRY_UNREAD = '<span font_desc="%s %%s" foreground="%s">%%s</span>'
+MARKUP_TEMPLATE_ENTRY = '<span font_desc="%s italic %%s" foreground="%s">%%s</span>'
# Build the markup template for the Maemo 5 text style
head_font = style.get_font_desc('SystemFont')
sub_font = style.get_font_desc('SmallSystemFont')
-head_color = style.get_color('ButtonTextColor')
+#head_color = style.get_color('ButtonTextColor')
+head_color = style.get_color('DefaultTextColor')
sub_color = style.get_color('DefaultTextColor')
active_color = style.get_color('ActiveTextColor')
+bg_color = style.get_color('DefaultBackgroundColor').to_string()
+c1=hex(min(int(bg_color[1:5],16)+10000, 65535))[2:6]
+c2=hex(min(int(bg_color[5:9],16)+10000, 65535))[2:6]
+c3=hex(min(int(bg_color[9:],16)+10000, 65535))[2:6]
+bg_color = "#" + c1 + c2 + c3
+
+
head = MARKUP_TEMPLATE % (head_font.to_string(), head_color.to_string())
normal_sub = MARKUP_TEMPLATE % (sub_font.to_string(), sub_color.to_string())
+entry_head = MARKUP_TEMPLATE_ENTRY % (head_font.get_family(), head_color.to_string())
+entry_normal_sub = MARKUP_TEMPLATE_ENTRY % (sub_font.get_family(), sub_color.to_string())
+
active_head = MARKUP_TEMPLATE % (head_font.to_string(), active_color.to_string())
active_sub = MARKUP_TEMPLATE % (sub_font.to_string(), active_color.to_string())
+entry_active_head = MARKUP_TEMPLATE_ENTRY_UNREAD % (head_font.get_family(), active_color.to_string())
+entry_active_sub = MARKUP_TEMPLATE_ENTRY_UNREAD % (sub_font.get_family(), active_color.to_string())
+
FEED_TEMPLATE = '\n'.join((head, normal_sub))
FEED_TEMPLATE_UNREAD = '\n'.join((head, active_sub))
-ENTRY_TEMPLATE = head
-ENTRY_TEMPLATE_UNREAD = active_head
+ENTRY_TEMPLATE = entry_head
+ENTRY_TEMPLATE_UNREAD = entry_active_head
##
# Removes HTML or XML character references and entities from a text string.
return sub("&#?\w+;", fixup, text)
-class AddWidgetWizard(hildon.WizardDialog):
-
- def __init__(self, parent, urlIn, titleIn=None):
- # Create a Notebook
- self.notebook = gtk.Notebook()
+class AddWidgetWizard(gtk.Dialog):
+ def __init__(self, parent, listing, urlIn, categories, titleIn=None, isEdit=False, currentCat=1):
+ gtk.Dialog.__init__(self)
+ self.set_transient_for(parent)
+
+ #self.category = categories[0]
+ self.category = currentCat
+
+ if isEdit:
+ self.set_title('Edit RSS feed')
+ else:
+ self.set_title('Add new RSS feed')
+
+ if isEdit:
+ self.btn_add = self.add_button('Save', 2)
+ else:
+ self.btn_add = self.add_button('Add', 2)
+
+ self.set_default_response(2)
self.nameEntry = hildon.Entry(gtk.HILDON_SIZE_AUTO)
- self.nameEntry.set_placeholder("Enter Feed Name")
- vbox = gtk.VBox(False,10)
- label = gtk.Label("Enter Feed Name:")
- vbox.pack_start(label)
- vbox.pack_start(self.nameEntry)
- if not titleIn == None:
+ self.nameEntry.set_placeholder('Feed name')
+ # If titleIn matches urlIn, there is no title.
+ if not titleIn == None and titleIn != urlIn:
self.nameEntry.set_text(titleIn)
- self.notebook.append_page(vbox, None)
-
+ self.nameEntry.select_region(-1, -1)
+
self.urlEntry = hildon.Entry(gtk.HILDON_SIZE_AUTO)
- self.urlEntry.set_placeholder("Enter a URL")
+ self.urlEntry.set_placeholder('Feed URL')
self.urlEntry.set_text(urlIn)
- self.urlEntry.select_region(0,-1)
+ self.urlEntry.select_region(-1, -1)
+ self.urlEntry.set_activates_default(True)
+
+ self.table = gtk.Table(3, 2, False)
+ self.table.set_col_spacings(5)
+ label = gtk.Label('Name:')
+ label.set_alignment(1., .5)
+ self.table.attach(label, 0, 1, 0, 1, gtk.FILL)
+ self.table.attach(self.nameEntry, 1, 2, 0, 1)
+ label = gtk.Label('URL:')
+ label.set_alignment(1., .5)
+ self.table.attach(label, 0, 1, 1, 2, gtk.FILL)
+ self.table.attach(self.urlEntry, 1, 2, 1, 2)
+ selector = self.create_selector(categories, listing)
+ picker = hildon.PickerButton(gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ picker.set_selector(selector)
+ picker.set_title("Select category")
+ #picker.set_text(listing.getCategoryTitle(self.category), None) #, "Subtitle")
+ picker.set_name('HildonButton-finger')
+ picker.set_alignment(0,0,1,1)
- vbox = gtk.VBox(False,10)
- label = gtk.Label("Enter Feed URL:")
- vbox.pack_start(label)
- vbox.pack_start(self.urlEntry)
- self.notebook.append_page(vbox, None)
-
- labelEnd = gtk.Label("Success")
+ self.table.attach(picker, 0, 2, 2, 3, gtk.FILL)
- self.notebook.append_page(labelEnd, None)
-
- hildon.WizardDialog.__init__(self, parent, "Add Feed", self.notebook)
-
- # Set a handler for "switch-page" signal
- #self.notebook.connect("switch_page", self.on_page_switch, self)
-
- # Set a function to decide if user can go to next page
- self.set_forward_page_func(self.some_page_func)
-
+ self.vbox.pack_start(self.table)
+
self.show_all()
-
+
def getData(self):
- return (self.nameEntry.get_text(), self.urlEntry.get_text())
-
- def on_page_switch(self, notebook, page, num, dialog):
- return True
-
- def some_page_func(self, nb, current, userdata):
- # Validate data for 1st page
- if current == 0:
- return len(self.nameEntry.get_text()) != 0
- elif current == 1:
- # Check the url is not null, and starts with http
- return ( (len(self.urlEntry.get_text()) != 0) and (self.urlEntry.get_text().lower().startswith("http")) )
- elif current != 2:
- return False
+ return (self.nameEntry.get_text(), self.urlEntry.get_text(), self.category)
+
+ def create_selector(self, choices, listing):
+ #self.pickerDialog = hildon.PickerDialog(self.parent)
+ selector = hildon.TouchSelector(text=True)
+ index = 0
+ self.map = {}
+ for item in choices:
+ title = listing.getCategoryTitle(item)
+ iter = selector.append_text(str(title))
+ if self.category == item:
+ selector.set_active(0, index)
+ self.map[title] = item
+ index += 1
+ selector.connect("changed", self.selection_changed)
+ #self.pickerDialog.set_selector(selector)
+ return selector
+
+ def selection_changed(self, selector, button):
+ current_selection = selector.get_current_text()
+ if current_selection:
+ self.category = self.map[current_selection]
+
+class AddCategoryWizard(gtk.Dialog):
+ def __init__(self, parent, titleIn=None, isEdit=False):
+ gtk.Dialog.__init__(self)
+ self.set_transient_for(parent)
+
+ if isEdit:
+ self.set_title('Edit Category')
else:
- return True
-
-class Download(Thread):
- def __init__(self, listing, key, config):
- Thread.__init__(self)
- self.listing = listing
- self.key = key
- self.config = config
-
- def run (self):
- (use_proxy, proxy) = self.config.getProxy()
- key_lock = get_lock(self.key)
- if key_lock != None:
- if use_proxy:
- self.listing.updateFeed(self.key, self.config.getExpiry(), proxy=proxy, imageCache=self.config.getImageCache() )
- else:
- self.listing.updateFeed(self.key, self.config.getExpiry(), imageCache=self.config.getImageCache() )
- del key_lock
+ self.set_title('Add Category')
+
+ if isEdit:
+ self.btn_add = self.add_button('Save', 2)
+ else:
+ self.btn_add = self.add_button('Add', 2)
+
+ self.set_default_response(2)
+
+ self.nameEntry = hildon.Entry(gtk.HILDON_SIZE_AUTO)
+ self.nameEntry.set_placeholder('Category name')
+ if not titleIn == None:
+ self.nameEntry.set_text(titleIn)
+ self.nameEntry.select_region(-1, -1)
+
+ self.table = gtk.Table(1, 2, False)
+ self.table.set_col_spacings(5)
+ label = gtk.Label('Name:')
+ label.set_alignment(1., .5)
+ self.table.attach(label, 0, 1, 0, 1, gtk.FILL)
+ self.table.attach(self.nameEntry, 1, 2, 0, 1)
+ #label = gtk.Label('URL:')
+ #label.set_alignment(1., .5)
+ #self.table.attach(label, 0, 1, 1, 2, gtk.FILL)
+ #self.table.attach(self.urlEntry, 1, 2, 1, 2)
+ self.vbox.pack_start(self.table)
+ self.show_all()
+
+ def getData(self):
+ return self.nameEntry.get_text()
class DownloadBar(gtk.ProgressBar):
- def __init__(self, parent, listing, listOfKeys, config, single=False):
-
- update_lock = get_lock("update_lock")
- if update_lock != None:
- gtk.ProgressBar.__init__(self)
- self.listOfKeys = listOfKeys[:]
- self.listing = listing
- self.total = len(self.listOfKeys)
- self.config = config
- self.current = 0
- self.single = single
- (use_proxy, proxy) = self.config.getProxy()
- if use_proxy:
- opener = build_opener(proxy)
- opener.addheaders = [('User-agent', USER_AGENT)]
- install_opener(opener)
- else:
- opener = build_opener()
- opener.addheaders = [('User-agent', USER_AGENT)]
- install_opener(opener)
-
- if self.total>0:
- self.set_text("Updating...")
- self.fraction = 0
- self.set_fraction(self.fraction)
- self.show_all()
- # Create a timeout
- self.timeout_handler_id = gobject.timeout_add(50, self.update_progress_bar)
-
- def update_progress_bar(self):
- #self.progress_bar.pulse()
- if activeCount() < 4:
- x = activeCount() - 1
- k = len(self.listOfKeys)
- fin = self.total - k - x
- fraction = float(fin)/float(self.total) + float(x)/(self.total*2.)
- #print x, k, fin, fraction
- self.set_fraction(fraction)
-
- if len(self.listOfKeys)>0:
- self.current = self.current+1
- key = self.listOfKeys.pop()
- #if self.single == True:
- # Check if the feed is being displayed
- download = Download(self.listing, key, self.config)
- download.start()
- return True
- elif activeCount() > 1:
- return True
+ @classmethod
+ def class_init(cls):
+ if hasattr (cls, 'class_init_done'):
+ return
+
+ jm = JobManager ()
+ jm.stats_hook_register (cls.update_progress,
+ run_in_main_thread=True)
+
+ cls.downloadbars = []
+ # Total number of jobs we are monitoring.
+ cls.total = 0
+ # Number of jobs complete (of those that we are monitoring).
+ cls.done = 0
+ # Percent complete.
+ cls.progress = 0
+
+ cls.class_init_done = True
+
+ def __init__(self, parent):
+ self.class_init ()
+
+ gtk.ProgressBar.__init__(self)
+
+ self.downloadbars.append(weakref.ref (self))
+ self.set_fraction(0)
+ self.__class__.update_bars()
+ self.show_all()
+
+ @classmethod
+ def downloading(cls):
+ return hasattr (cls, 'jobs_at_start')
+
+ @classmethod
+ def update_progress(cls, jm, old_stats, new_stats, updated_feed):
+ if not cls.downloading():
+ cls.jobs_at_start = old_stats['jobs-completed']
+
+ if not cls.downloadbars:
+ return
+
+ if new_stats['jobs-in-progress'] + new_stats['jobs-queued'] == 0:
+ del cls.jobs_at_start
+ for ref in cls.downloadbars:
+ bar = ref ()
+ if bar is None:
+ # The download bar disappeared.
+ cls.downloadbars.remove (ref)
+ else:
+ bar.emit("download-done", None)
+ return
+
+ # This should never be called if new_stats['jobs'] is 0, but
+ # just in case...
+ cls.total = max (1, new_stats['jobs'] - cls.jobs_at_start)
+ cls.done = new_stats['jobs-completed'] - cls.jobs_at_start
+ cls.progress = 1 - (new_stats['jobs-in-progress'] / 2.
+ + new_stats['jobs-queued']) / cls.total
+ cls.update_bars()
+
+ if updated_feed:
+ for ref in cls.downloadbars:
+ bar = ref ()
+ if bar is None:
+ # The download bar disappeared.
+ cls.downloadbars.remove (ref)
+ else:
+ bar.emit("download-done", updated_feed)
+
+ @classmethod
+ def update_bars(cls):
+ # In preparation for i18n/l10n
+ def N_(a, b, n):
+ return (a if n == 1 else b)
+
+ text = (N_('Updated %d of %d feeds ', 'Updated %d of %d feeds',
+ cls.total)
+ % (cls.done, cls.total))
+
+ for ref in cls.downloadbars:
+ bar = ref ()
+ if bar is None:
+ # The download bar disappeared.
+ cls.downloadbars.remove (ref)
else:
- #self.waitingWindow.destroy()
- #self.destroy()
- try:
- del self.update_lock
- except:
- pass
- self.emit("download-done", "success")
- return False
- return True
-
-
-class SortList(gtk.Dialog):
- def __init__(self, parent, listing):
- gtk.Dialog.__init__(self, "Organizer", parent)
+ bar.set_text(text)
+ bar.set_fraction(cls.progress)
+
+class SortList(hildon.StackableWindow):
+ def __init__(self, parent, listing, feedingit, after_closing, category=None):
+ hildon.StackableWindow.__init__(self)
+ self.set_transient_for(parent)
+ if category:
+ self.isEditingCategories = False
+ self.category = category
+ self.set_title(listing.getCategoryTitle(category))
+ else:
+ self.isEditingCategories = True
+ self.set_title('Categories')
self.listing = listing
-
- self.vbox2 = gtk.VBox(False, 10)
-
+ self.feedingit = feedingit
+ self.after_closing = after_closing
+ if after_closing:
+ self.connect('destroy', lambda w: self.after_closing())
+ self.vbox2 = gtk.VBox(False, 2)
+
button = hildon.GtkButton(gtk.HILDON_SIZE_FINGER_HEIGHT)
- button.set_label("Move Up")
+ button.set_image(gtk.image_new_from_icon_name('keyboard_move_up', gtk.ICON_SIZE_BUTTON))
button.connect("clicked", self.buttonUp)
self.vbox2.pack_start(button, expand=False, fill=False)
-
+
button = hildon.GtkButton(gtk.HILDON_SIZE_FINGER_HEIGHT)
- button.set_label("Move Down")
+ button.set_image(gtk.image_new_from_icon_name('keyboard_move_down', gtk.ICON_SIZE_BUTTON))
button.connect("clicked", self.buttonDown)
self.vbox2.pack_start(button, expand=False, fill=False)
+ self.vbox2.pack_start(gtk.Label(), expand=True, fill=False)
+
button = hildon.GtkButton(gtk.HILDON_SIZE_FINGER_HEIGHT)
- button.set_label("Add Feed")
+ button.set_image(gtk.image_new_from_icon_name('general_add', gtk.ICON_SIZE_BUTTON))
button.connect("clicked", self.buttonAdd)
self.vbox2.pack_start(button, expand=False, fill=False)
button = hildon.GtkButton(gtk.HILDON_SIZE_FINGER_HEIGHT)
- button.set_label("Edit Feed")
+ button.set_image(gtk.image_new_from_icon_name('general_information', gtk.ICON_SIZE_BUTTON))
button.connect("clicked", self.buttonEdit)
self.vbox2.pack_start(button, expand=False, fill=False)
-
+
button = hildon.GtkButton(gtk.HILDON_SIZE_FINGER_HEIGHT)
- button.set_label("Delete")
+ button.set_image(gtk.image_new_from_icon_name('general_delete', gtk.ICON_SIZE_BUTTON))
button.connect("clicked", self.buttonDelete)
self.vbox2.pack_start(button, expand=False, fill=False)
-
+
#button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
#button.set_label("Done")
#button.connect("clicked", self.buttonDone)
self.displayFeeds()
self.hbox2.pack_end(self.vbox2, expand=False)
self.set_default_size(-1, 600)
- self.vbox.pack_start(self.hbox2)
+ self.add(self.hbox2)
+
+ menu = hildon.AppMenu()
+ button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
+ button.set_label("Import from OPML")
+ button.connect("clicked", self.feedingit.button_import_clicked)
+ menu.append(button)
+
+ button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
+ button.set_label("Export to OPML")
+ button.connect("clicked", self.feedingit.button_export_clicked)
+ menu.append(button)
+ self.set_app_menu(menu)
+ menu.show_all()
self.show_all()
#self.connect("destroy", self.buttonDone)
#rect = self.treeview.get_visible_rect()
#y = rect.y+rect.height
self.treestore = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
- for key in self.listing.getListOfFeeds():
- item = self.treestore.append([self.listing.getFeedTitle(key), key])
- if key == selected:
- selectedItem = item
+ if self.isEditingCategories:
+ for key in self.listing.getListOfCategories():
+ item = self.treestore.append([self.listing.getCategoryTitle(key), key])
+ if key == selected:
+ selectedItem = item
+ else:
+ for key in self.listing.getListOfFeeds(category=self.category):
+ item = self.treestore.append([self.listing.getFeedTitle(key), key])
+ if key == selected:
+ selectedItem = item
self.treeview.set_model(self.treestore)
if not selected == None:
self.treeview.get_selection().select_iter(selectedItem)
def buttonUp(self, button):
key = self.getSelectedItem()
if not key == None:
- self.listing.moveUp(key)
+ if self.isEditingCategories:
+ self.listing.moveCategoryUp(key)
+ else:
+ self.listing.moveUp(key)
self.refreshList(key, -10)
def buttonDown(self, button):
key = self.getSelectedItem()
if not key == None:
- self.listing.moveDown(key)
+ if self.isEditingCategories:
+ self.listing.moveCategoryDown(key)
+ else:
+ self.listing.moveDown(key)
self.refreshList(key, 10)
def buttonDelete(self, button):
key = self.getSelectedItem()
- if not key == None:
- self.listing.removeFeed(key)
- self.refreshList()
+
+ message = 'Really remove this feed and its entries?'
+ dlg = hildon.hildon_note_new_confirmation(self, message)
+ response = dlg.run()
+ dlg.destroy()
+ if response == gtk.RESPONSE_OK:
+ if self.isEditingCategories:
+ self.listing.removeCategory(key)
+ else:
+ self.listing.removeFeed(key)
+ self.refreshList()
def buttonEdit(self, button):
key = self.getSelectedItem()
- if not key == None:
- wizard = AddWidgetWizard(self, self.listing.getFeedUrl(key), self.listing.getFeedTitle(key))
- ret = wizard.run()
- if ret == 2:
- (title, url) = wizard.getData()
- if (not title == '') and (not url == ''):
- self.listing.editFeed(key, title, url)
- wizard.destroy()
- self.refreshList()
+
+ if key == 'ArchivedArticles':
+ message = 'Cannot edit the archived articles feed.'
+ hildon.hildon_banner_show_information(self, '', message)
+ return
+ if self.isEditingCategories:
+ if key is not None:
+ SortList(self.parent, self.listing, self.feedingit, None, category=key)
+ else:
+ if key is not None:
+ wizard = AddWidgetWizard(self, self.listing, self.listing.getFeedUrl(key), self.listing.getListOfCategories(), self.listing.getFeedTitle(key), True, currentCat=self.category)
+ ret = wizard.run()
+ if ret == 2:
+ (title, url, category) = wizard.getData()
+ if url != '':
+ self.listing.editFeed(key, title, url, category=category)
+ self.refreshList()
+ wizard.destroy()
def buttonDone(self, *args):
self.destroy()
def buttonAdd(self, button, urlIn="http://"):
- wizard = AddWidgetWizard(self, urlIn)
- ret = wizard.run()
- if ret == 2:
- (title, url) = wizard.getData()
- if (not title == '') and (not url == ''):
- self.listing.addFeed(title, url)
+ if self.isEditingCategories:
+ wizard = AddCategoryWizard(self)
+ ret = wizard.run()
+ if ret == 2:
+ title = wizard.getData()
+ if (not title == ''):
+ self.listing.addCategory(title)
+ else:
+ wizard = AddWidgetWizard(self, self.listing, urlIn, self.listing.getListOfCategories())
+ ret = wizard.run()
+ if ret == 2:
+ (title, url, category) = wizard.getData()
+ if url:
+ self.listing.addFeed(title, url, category=category)
wizard.destroy()
self.refreshList()
contentLink = self.feed.getContentLink(self.id)
self.feed.setEntryRead(self.id)
#if key=="ArchivedArticles":
+ self.loadedArticle = False
if contentLink.startswith("/home/user/"):
- self.view.open("file://" + contentLink)
+ self.view.open("file://%s" % contentLink)
+ self.currentUrl = self.feed.getExternalLink(self.id)
else:
- self.view.load_html_string('This article has not been downloaded yet. Click <a href="%s">here</a> to view online.' % contentLink, "text/html", "utf-8", self.contentLink)
+ self.view.load_html_string('This article has not been downloaded yet. Click <a href="%s">here</a> to view online.' % contentLink, contentLink)
+ self.currentUrl = "%s" % contentLink
self.view.connect("motion-notify-event", lambda w,ev: True)
self.view.connect('load-started', self.load_started)
self.view.connect('load-finished', self.load_finished)
- #else:
- #self.view.load_html_string(self.text, contentLink) # "text/html", "utf-8", self.link)
self.view.set_zoom_level(float(config.getArtFontSize())/10.)
- #else:
- # if not key == "ArchivedArticles":
- # Do not download images if the feed is "Archived Articles"
- # self.document.connect("request-url", self._signal_request_url)
-
- # self.document.clear()
- # self.document.open_stream("text/html")
- # self.document.write_stream(self.text)
- # self.document.close_stream()
menu = hildon.AppMenu()
# Create a button and add it to the menu
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Allow Horizontal Scrolling")
+ button.set_label("Allow horizontal scrolling")
button.connect("clicked", self.horiz_scrolling_button)
menu.append(button)
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Open in Browser")
- button.connect("clicked", self._signal_link_clicked, self.feed.getExternalLink(self.id))
+ button.set_label("Open in browser")
+ button.connect("clicked", self.open_in_browser)
menu.append(button)
if key == "ArchivedArticles":
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Remove from Archived Articles")
+ button.set_label("Remove from archived articles")
button.connect("clicked", self.remove_archive_button)
else:
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Add to Archived Articles")
+ button.set_label("Add to archived articles")
button.connect("clicked", self.archive_button)
menu.append(button)
self.set_app_menu(menu)
menu.show_all()
- #self.event_box = gtk.EventBox()
- #self.event_box.add(self.pannable_article)
self.add(self.pannable_article)
-
self.pannable_article.show_all()
self.destroyId = self.connect("destroy", self.destroyWindow)
+ #self.view.connect('navigation-policy-decision-requested', self.navigation_policy_decision)
+ ## Still using an old version of WebKit, so using navigation-requested signal
+ self.view.connect('navigation-requested', self.navigation_requested)
+
self.view.connect("button_press_event", self.button_pressed)
self.gestureId = self.view.connect("button_release_event", self.button_released)
- #self.timeout_handler_id = gobject.timeout_add(300, self.reloadArticle)
+
+ #def navigation_policy_decision(self, wv, fr, req, action, decision):
+ def navigation_requested(self, wv, fr, req):
+ if self.config.getOpenInExternalBrowser():
+ self.open_in_browser(None, req.get_uri())
+ return True
+ else:
+ return False
def load_started(self, *widget):
hildon.hildon_gtk_window_set_progress_indicator(self, 1)
def load_finished(self, *widget):
hildon.hildon_gtk_window_set_progress_indicator(self, 0)
+ frame = self.view.get_main_frame()
+ if self.loadedArticle:
+ self.currentUrl = frame.get_uri()
+ else:
+ self.loadedArticle = True
def button_pressed(self, window, event):
#print event.x, event.y
self.emit("article-previous", self.id)
elif (x<-15):
self.emit("article-next", self.id)
- #print x, y
- #print "Released"
-
- #def gesture(self, widget, direction, startx, starty):
- # if (direction == 3):
- # self.emit("article-next", self.index)
- # if (direction == 2):
- # self.emit("article-previous", self.index)
- #print startx, starty
- #self.timeout_handler_id = gobject.timeout_add(200, self.destroyWindow)
def destroyWindow(self, *args):
self.disconnect(self.destroyId)
def remove_archive_button(self, *widget):
self.set_for_removal = True
-
- #def reloadArticle(self, *widget):
- # if threading.activeCount() > 1:
- # Image thread are still running, come back in a bit
- # return True
- # else:
- # for (stream, imageThread) in self.images:
- # imageThread.join()
- # stream.write(imageThread.data)
- # stream.close()
- # return False
- # self.show_all()
-
- def _signal_link_clicked(self, object, link):
+
+ def open_in_browser(self, object, link=None):
import dbus
bus = dbus.SessionBus()
proxy = bus.get_object("com.nokia.osso_browser", "/com/nokia/osso_browser/request")
iface = dbus.Interface(proxy, 'com.nokia.osso_browser')
- iface.open_new_window(link)
-
- #def _signal_request_url(self, object, url, stream):
- #print url
- # self.imageDownloader.queueImage(url, stream)
- #imageThread = GetImage(url)
- #imageThread.start()
- #self.images.append((stream, imageThread))
-
+ if link == None:
+ iface.open_new_window(self.currentUrl)
+ else:
+ iface.open_new_window(link)
class DisplayFeed(hildon.StackableWindow):
def __init__(self, listing, feed, title, key, config, updateDbusHandler):
self.feedTitle = title
self.set_title(title)
self.key=key
+ self.current = list()
self.config = config
self.updateDbusHandler = updateDbusHandler
menu = hildon.AppMenu()
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Update Feed")
+ button.set_label("Update feed")
button.connect("clicked", self.button_update_clicked)
menu.append(button)
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Mark All As Read")
+ button.set_label("Mark all as read")
button.connect("clicked", self.buttonReadAllClicked)
menu.append(button)
if key=="ArchivedArticles":
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Purge Read Articles")
+ button.set_label("Delete read articles")
button.connect("clicked", self.buttonPurgeArticles)
menu.append(button)
self.set_app_menu(menu)
menu.show_all()
+ self.main_vbox = gtk.VBox(False, 0)
+ self.add(self.main_vbox)
+
+ self.pannableFeed = None
self.displayFeed()
+
+ if DownloadBar.downloading ():
+ self.show_download_bar ()
self.connect('configure-event', self.on_configure_event)
self.connect("destroy", self.destroyWindow)
# Fix up the column width for wrapping the text when the window is
# resized (i.e. orientation changed)
- self.markup_renderer.set_property('wrap-width', event.width-10)
+ self.markup_renderer.set_property('wrap-width', event.width-20)
+ it = self.feedItems.get_iter_first()
+ while it is not None:
+ markup = self.feedItems.get_value(it, FEED_COLUMN_MARKUP)
+ self.feedItems.set_value(it, FEED_COLUMN_MARKUP, markup)
+ it = self.feedItems.iter_next(it)
def destroyWindow(self, *args):
#self.feed.saveUnread(CONFIGDIR)
- gobject.idle_add(self.feed.saveUnread, CONFIGDIR)
- self.listing.updateUnread(self.key, self.feed.getNumberOfUnreadItems())
+ self.listing.updateUnread(self.key)
self.emit("feed-closed", self.key)
self.destroy()
#gobject.idle_add(self.feed.saveFeed, CONFIGDIR)
return escape(unescape(title).replace("<em>","").replace("</em>","").replace("<nobr>","").replace("</nobr>","").replace("<wbr>",""))
def displayFeed(self):
+ if self.pannableFeed:
+ self.pannableFeed.destroy()
+
self.pannableFeed = hildon.PannableArea()
self.pannableFeed.set_property('hscrollbar-policy', gtk.POLICY_NEVER)
self.feedItems = gtk.ListStore(str, str)
- self.feedList = gtk.TreeView(self.feedItems)
- self.feedList.connect('row-activated', self.on_feedList_row_activated)
- self.pannableFeed.add(self.feedList)
+ #self.feedList = gtk.TreeView(self.feedItems)
+ self.feedList = hildon.GtkTreeView(gtk.HILDON_UI_MODE_NORMAL)
+ self.feedList.set_rules_hint(True)
+
+ selection = self.feedList.get_selection()
+ selection.set_mode(gtk.SELECTION_NONE)
+ #selection.connect("changed", lambda w: True)
+
+ self.feedList.set_model(self.feedItems)
+ self.feedList.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_HORIZONTAL)
+
+
+ self.feedList.set_hover_selection(False)
+ #self.feedList.set_property('enable-grid-lines', True)
+ #self.feedList.set_property('hildon-mode', 1)
+ #self.pannableFeed.connect("motion-notify-event", lambda w,ev: True)
+
+ #self.feedList.connect('row-activated', self.on_feedList_row_activated)
+
+ vbox= gtk.VBox(False, 10)
+ vbox.pack_start(self.feedList)
+
+ self.pannableFeed.add_with_viewport(vbox)
self.markup_renderer = gtk.CellRendererText()
self.markup_renderer.set_property('wrap-mode', pango.WRAP_WORD_CHAR)
- self.markup_renderer.set_property('wrap-width', 780)
+ self.markup_renderer.set_property('background', bg_color) #"#333333")
+ (width, height) = self.get_size()
+ self.markup_renderer.set_property('wrap-width', width-20)
+ self.markup_renderer.set_property('ypad', 8)
+ self.markup_renderer.set_property('xpad', 5)
markup_column = gtk.TreeViewColumn('', self.markup_renderer, \
markup=FEED_COLUMN_MARKUP)
self.feedList.append_column(markup_column)
#self.pannableFeed.set_property("mov-mode", hildon.MOVEMENT_MODE_BOTH)
-
- for id in self.feed.getIds():
- if not ( self.feed.isEntryRead(id) and self.config.getHideReadArticles() ):
- #title = self.feed.getTitle(id)
+ hideReadArticles = self.config.getHideReadArticles()
+ if hideReadArticles:
+ articles = self.feed.getIds(onlyUnread=True)
+ else:
+ articles = self.feed.getIds()
+
+ hasArticle = False
+ self.current = list()
+ for id in articles:
+ isRead = False
+ try:
+ isRead = self.feed.isEntryRead(id)
+ except:
+ pass
+ if not ( isRead and hideReadArticles ):
title = self.fix_title(self.feed.getTitle(id))
-
- if self.feed.isEntryRead(id):
- markup = ENTRY_TEMPLATE % title
+ self.current.append(id)
+ if isRead:
+ markup = ENTRY_TEMPLATE % (self.config.getFontSize(), title)
else:
- markup = ENTRY_TEMPLATE_UNREAD % title
+ markup = ENTRY_TEMPLATE_UNREAD % (self.config.getFontSize(), title)
self.feedItems.append((markup, id))
+ hasArticle = True
+ if hasArticle:
+ self.feedList.connect('hildon-row-tapped', self.on_feedList_row_activated)
+ else:
+ markup = ENTRY_TEMPLATE % (self.config.getFontSize(), "No Articles To Display")
+ self.feedItems.append((markup, ""))
- self.add(self.pannableFeed)
+ self.main_vbox.pack_start(self.pannableFeed)
self.show_all()
def clear(self):
self.pannableFeed.destroy()
#self.remove(self.pannableFeed)
- def on_feedList_row_activated(self, treeview, path, column):
+ def on_feedList_row_activated(self, treeview, path): #, column):
+ selection = self.feedList.get_selection()
+ selection.set_mode(gtk.SELECTION_SINGLE)
+ self.feedList.get_selection().select_path(path)
model = treeview.get_model()
iter = model.get_iter(path)
key = model.get_value(iter, FEED_COLUMN_KEY)
# Emulate legacy "button_clicked" call via treeview
- self.button_clicked(treeview, key)
+ gobject.idle_add(self.button_clicked, treeview, key)
+ #return True
def button_clicked(self, button, index, previous=False, next=False):
#newDisp = DisplayArticle(self.feedTitle, self.feed.getArticle(index), self.feed.getLink(index), index, self.key, self.listing, self.config)
def buttonPurgeArticles(self, *widget):
self.clear()
self.feed.purgeReadArticles()
- self.feed.saveUnread(CONFIGDIR)
- self.feed.saveFeed(CONFIGDIR)
+ #self.feed.saveFeed(CONFIGDIR)
self.displayFeed()
def destroyArticle(self, handle):
k = self.feedItems.get_value(it, FEED_COLUMN_KEY)
if k == key:
title = self.fix_title(self.feed.getTitle(key))
- markup = ENTRY_TEMPLATE % title
+ markup = ENTRY_TEMPLATE % (self.config.getFontSize(), title)
self.feedItems.set_value(it, FEED_COLUMN_MARKUP, markup)
break
it = self.feedItems.iter_next(it)
def nextArticle(self, object, index):
self.mark_item_read(index)
id = self.feed.getNextId(index)
- self.button_clicked(object, id, next=True)
+ while id not in self.current and id != index:
+ id = self.feed.getNextId(id)
+ if id != index:
+ self.button_clicked(object, id, next=True)
def previousArticle(self, object, index):
self.mark_item_read(index)
id = self.feed.getPreviousId(index)
- self.button_clicked(object, id, previous=True)
+ while id not in self.current and id != index:
+ id = self.feed.getPreviousId(id)
+ if id != index:
+ self.button_clicked(object, id, previous=True)
def onArticleClosed(self, object, index):
+ selection = self.feedList.get_selection()
+ selection.set_mode(gtk.SELECTION_NONE)
self.mark_item_read(index)
def onArticleDeleted(self, object, index):
self.clear()
self.feed.removeArticle(index)
- self.feed.saveUnread(CONFIGDIR)
- self.feed.saveFeed(CONFIGDIR)
+ #self.feed.saveFeed(CONFIGDIR)
self.displayFeed()
def button_update_clicked(self, button):
- #bar = DownloadBar(self, self.listing, [self.key,], self.config )
+ self.listing.updateFeed (self.key, priority=-1)
+
+ def show_download_bar(self):
if not type(self.downloadDialog).__name__=="DownloadBar":
- self.pannableFeed.destroy()
- self.vbox = gtk.VBox(False, 10)
- self.downloadDialog = DownloadBar(self.window, self.listing, [self.key,], self.config, single=True )
- self.downloadDialog.connect("download-done", self.onDownloadsDone)
- self.vbox.pack_start(self.downloadDialog, expand=False, fill=False)
- self.add(self.vbox)
+ self.downloadDialog = DownloadBar(self.window)
+ self.downloadDialog.connect("download-done", self.onDownloadDone)
+ self.main_vbox.pack_end(self.downloadDialog,
+ expand=False, fill=False)
self.show_all()
-
- def onDownloadsDone(self, *widget):
- self.vbox.destroy()
- self.feed = self.listing.getFeed(self.key)
- self.displayFeed()
- self.updateDbusHandler.ArticleCountUpdated()
+ def onDownloadDone(self, widget, feed):
+ if feed == self.feed or feed is None:
+ self.downloadDialog.destroy()
+ self.downloadDialog = False
+ self.feed = self.listing.getFeed(self.key)
+ self.displayFeed()
+ self.updateDbusHandler.ArticleCountUpdated()
+
def buttonReadAllClicked(self, button):
- for index in self.feed.getIds():
- self.feed.setEntryRead(index)
- self.mark_item_read(index)
+ #self.clear()
+ self.feed.markAllAsRead()
+ it = self.feedItems.get_iter_first()
+ while it is not None:
+ k = self.feedItems.get_value(it, FEED_COLUMN_KEY)
+ title = self.fix_title(self.feed.getTitle(k))
+ markup = ENTRY_TEMPLATE % (self.config.getFontSize(), title)
+ self.feedItems.set_value(it, FEED_COLUMN_MARKUP, markup)
+ it = self.feedItems.iter_next(it)
+ #self.displayFeed()
+ #for index in self.feed.getIds():
+ # self.feed.setEntryRead(index)
+ # self.mark_item_read(index)
class FeedingIt:
self.window.set_title(__appname__)
hildon.hildon_gtk_window_set_progress_indicator(self.window, 1)
self.mainVbox = gtk.VBox(False,10)
-
- self.pannableListing = hildon.PannableArea()
- self.mainVbox.pack_start(self.pannableListing)
-
- self.feedItems = gtk.ListStore(gtk.gdk.Pixbuf, str, str)
- self.feedList = gtk.TreeView(self.feedItems)
- self.feedList.connect('row-activated', self.on_feedList_row_activated)
- self.pannableListing.add(self.feedList)
-
- icon_renderer = gtk.CellRendererPixbuf()
- icon_renderer.set_property('width', LIST_ICON_SIZE + 2*LIST_ICON_BORDER)
- icon_column = gtk.TreeViewColumn('', icon_renderer, \
- pixbuf=COLUMN_ICON)
- self.feedList.append_column(icon_column)
-
- markup_renderer = gtk.CellRendererText()
- markup_column = gtk.TreeViewColumn('', markup_renderer, \
- markup=COLUMN_MARKUP)
- self.feedList.append_column(markup_column)
+
+ if isfile(CONFIGDIR+"/feeds.db"):
+ self.introLabel = gtk.Label("Loading...")
+ else:
+ self.introLabel = gtk.Label("Updating database to new format...\nThis can take several minutes.")
+
+ self.mainVbox.pack_start(self.introLabel)
self.window.add(self.mainVbox)
self.window.show_all()
self.config = Config(self.window, CONFIGDIR+"config.ini")
gobject.idle_add(self.createWindow)
+
+ # This is set to try when the user interacts with the program.
+ # If, after an update is complete, we discover that the
+ # environment variable DBUS_STARTED_ADDRESS is set and
+ # self.had_interaction is False, we quit.
+ self.had_interaction = False
def createWindow(self):
+ self.category = 0
+
self.app_lock = get_lock("app_lock")
if self.app_lock == None:
- self.pannableListing.set_label("Update in progress, please wait.")
+ try:
+ self.stopButton.set_sensitive(True)
+ except:
+ self.stopButton = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ self.stopButton.set_text("Stop update","")
+ self.stopButton.connect("clicked", self.stop_running_update)
+ self.mainVbox.pack_end(self.stopButton, expand=False, fill=False)
+ self.window.show_all()
+ self.introLabel.set_label("Update in progress, please wait.")
gobject.timeout_add_seconds(3, self.createWindow)
return False
- self.listing = Listing(CONFIGDIR)
-
+ try:
+ self.stopButton.destroy()
+ except:
+ pass
+ self.listing = Listing(self.config, CONFIGDIR)
+
self.downloadDialog = False
- self.orientation = FremantleRotation(__appname__, main_window=self.window, app=self)
- self.orientation.set_mode(self.config.getOrientation())
+ try:
+ self.orientation = FremantleRotation(__appname__, main_window=self.window, app=self)
+ self.orientation.set_mode(self.config.getOrientation())
+ except:
+ print "Could not start rotation manager"
menu = hildon.AppMenu()
# Create a button and add it to the menu
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Update All Feeds")
+ button.set_label("Update feeds")
button.connect("clicked", self.button_update_clicked, "All")
menu.append(button)
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Mark All As Read")
+ button.set_label("Mark all as read")
button.connect("clicked", self.button_markAll)
menu.append(button)
-
+
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Organize Feeds")
+ button.set_label("Add new feed")
+ button.connect("clicked", lambda b: self.addFeed())
+ menu.append(button)
+
+ button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
+ button.set_label("Manage subscriptions")
button.connect("clicked", self.button_organize_clicked)
menu.append(button)
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Preferences")
+ button.set_label("Settings")
button.connect("clicked", self.button_preferences_clicked)
menu.append(button)
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Import Feeds")
- button.connect("clicked", self.button_import_clicked)
- menu.append(button)
-
- button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- button.set_label("Export Feeds")
- button.connect("clicked", self.button_export_clicked)
- menu.append(button)
-
- button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
button.set_label("About")
button.connect("clicked", self.button_about_clicked)
menu.append(button)
self.window.set_app_menu(menu)
menu.show_all()
- self.feedWindow = hildon.StackableWindow()
- self.articleWindow = hildon.StackableWindow()
+ #self.feedWindow = hildon.StackableWindow()
+ #self.articleWindow = hildon.StackableWindow()
+ self.introLabel.destroy()
+ self.pannableListing = hildon.PannableArea()
+ self.feedItems = gtk.TreeStore(gtk.gdk.Pixbuf, str, str)
+ self.feedList = gtk.TreeView(self.feedItems)
+ self.feedList.connect('row-activated', self.on_feedList_row_activated)
+ #self.feedList.set_enable_tree_lines(True)
+ #self.feedList.set_show_expanders(True)
+ self.pannableListing.add(self.feedList)
+
+ icon_renderer = gtk.CellRendererPixbuf()
+ icon_renderer.set_property('width', LIST_ICON_SIZE + 2*LIST_ICON_BORDER)
+ icon_column = gtk.TreeViewColumn('', icon_renderer, \
+ pixbuf=COLUMN_ICON)
+ self.feedList.append_column(icon_column)
+
+ markup_renderer = gtk.CellRendererText()
+ markup_column = gtk.TreeViewColumn('', markup_renderer, \
+ markup=COLUMN_MARKUP)
+ self.feedList.append_column(markup_column)
+ self.mainVbox.pack_start(self.pannableListing)
+ self.mainVbox.show_all()
self.displayListing()
self.autoupdate = False
self.checkAutoUpdate()
+
hildon.hildon_gtk_window_set_progress_indicator(self.window, 0)
- gobject.idle_add(self.enableDbus)
+ gobject.idle_add(self.late_init)
- def enableDbus(self):
+ def job_manager_update(self, jm, old_stats, new_stats, updated_feed):
+ if (not self.downloadDialog
+ and new_stats['jobs-in-progress'] + new_stats['jobs-queued'] > 0):
+ self.updateDbusHandler.UpdateStarted()
+
+ self.downloadDialog = DownloadBar(self.window)
+ self.downloadDialog.connect("download-done", self.onDownloadDone)
+ self.mainVbox.pack_end(self.downloadDialog, expand=False, fill=False)
+ self.mainVbox.show_all()
+
+ if self.__dict__.get ('disp', None):
+ self.disp.show_download_bar ()
+
+ def onDownloadDone(self, widget, feed):
+ if feed is None:
+ self.downloadDialog.destroy()
+ self.downloadDialog = False
+ self.displayListing()
+ self.updateDbusHandler.UpdateFinished()
+ self.updateDbusHandler.ArticleCountUpdated()
+
+ if not self.had_interaction and 'DBUS_STARTER_ADDRESS' in environ:
+ print "Update complete. No interaction, started by dbus: quitting."
+ self.quit()
+ def stop_running_update(self, button):
+ self.stopButton.set_sensitive(False)
+ import dbus
+ bus=dbus.SessionBus()
+ remote_object = bus.get_object("org.marcoz.feedingit", # Connection name
+ "/org/marcoz/feedingit/update" # Object's path
+ )
+ iface = dbus.Interface(remote_object, 'org.marcoz.feedingit')
+ iface.StopUpdate()
+
+ def increase_download_parallelism(self):
+ # The system has been idle for a while. Enable parallel
+ # downloads.
+ JobManager().num_threads = 4
+ gobject.source_remove (self.increase_download_parallelism_id)
+ del self.increase_download_parallelism_id
+ return False
+
+ def system_inactivity_ind(self, idle):
+ # The system's idle state changed.
+ if (self.am_idle and idle) or (not self.am_idle and not idle):
+ # No change.
+ return
+
+ if not idle:
+ if hasattr (self, 'increase_download_parallelism_id'):
+ gobject.source_remove (self.increase_download_parallelism_id)
+ del self.increase_download_parallelism_id
+ else:
+ self.increase_download_parallelism_id = \
+ gobject.timeout_add_seconds(
+ 60, self.increase_download_parallelism)
+
+ if not idle:
+ JobManager().num_threads = 1
+
+ self.am_idle = idle
+
+ def late_init(self):
self.dbusHandler = ServerObject(self)
self.updateDbusHandler = UpdateServerObject(self)
+ jm = JobManager()
+ jm.stats_hook_register (self.job_manager_update,
+ run_in_main_thread=True)
+ jm.num_threads = 1
+ self.am_idle = False
+ JobManager(True)
+
+ import dbus
+ bus = dbus.SystemBus()
+ proxy = bus.get_object('com.nokia.mce',
+ '/com/nokia/mce/signal')
+ iface = dbus.Interface(proxy, 'com.nokia.mce.signal')
+ iface.connect_to_signal('system_inactivity_ind',
+ self.system_inactivity_ind)
+
def button_markAll(self, button):
+ self.had_interaction = True
for key in self.listing.getListOfFeeds():
feed = self.listing.getFeed(key)
- for id in feed.getIds():
- feed.setEntryRead(id)
- feed.saveUnread(CONFIGDIR)
- self.listing.updateUnread(key, feed.getNumberOfUnreadItems())
+ feed.markAllAsRead()
+ #for id in feed.getIds():
+ # feed.setEntryRead(id)
+ self.listing.updateUnread(key)
self.displayListing()
def button_about_clicked(self, button):
+ self.had_interaction = True
HeAboutDialog.present(self.window, \
__appname__, \
ABOUT_ICON, \
ABOUT_DONATE)
def button_export_clicked(self, button):
+ self.had_interaction = True
opml = ExportOpmlData(self.window, self.listing)
def button_import_clicked(self, button):
+ self.had_interaction = True
opml = GetOpmlData(self.window)
feeds = opml.getData()
for (title, url) in feeds:
self.displayListing()
def addFeed(self, urlIn="http://"):
- wizard = AddWidgetWizard(self.window, urlIn)
+ self.had_interaction = True
+ wizard = AddWidgetWizard(self.window, self.listing, urlIn, self.listing.getListOfCategories())
ret = wizard.run()
if ret == 2:
- (title, url) = wizard.getData()
- if (not title == '') and (not url == ''):
- self.listing.addFeed(title, url)
+ (title, url, category) = wizard.getData()
+ if url:
+ self.listing.addFeed(title, url, category=category)
wizard.destroy()
self.displayListing()
def button_organize_clicked(self, button):
- org = SortList(self.window, self.listing)
- org.run()
- org.destroy()
- self.listing.saveConfig()
- self.displayListing()
-
+ self.had_interaction = True
+ def after_closing():
+ self.displayListing()
+ SortList(self.window, self.listing, self, after_closing)
+
def button_update_clicked(self, button, key):
- if not type(self.downloadDialog).__name__=="DownloadBar":
- self.updateDbusHandler.UpdateStarted()
- self.downloadDialog = DownloadBar(self.window, self.listing, self.listing.getListOfFeeds(), self.config )
- self.downloadDialog.connect("download-done", self.onDownloadsDone)
- self.mainVbox.pack_end(self.downloadDialog, expand=False, fill=False)
- self.mainVbox.show_all()
+ self.had_interaction = True
+ for k in self.listing.getListOfFeeds():
+ self.listing.updateFeed (k)
#self.displayListing()
def onDownloadsDone(self, *widget):
self.updateDbusHandler.ArticleCountUpdated()
def button_preferences_clicked(self, button):
+ self.had_interaction = True
dialog = self.config.createDialog()
dialog.connect("destroy", self.prefsClosed)
else:
return False
+ def saveExpandedLines(self):
+ self.expandedLines = []
+ model = self.feedList.get_model()
+ model.foreach(self.checkLine)
+
+ def checkLine(self, model, path, iter, data = None):
+ if self.feedList.row_expanded(path):
+ self.expandedLines.append(path)
+
+ def restoreExpandedLines(self):
+ model = self.feedList.get_model()
+ model.foreach(self.restoreLine)
+
+ def restoreLine(self, model, path, iter, data = None):
+ if path in self.expandedLines:
+ self.feedList.expand_row(path, False)
+
def displayListing(self):
icon_theme = gtk.icon_theme_get_default()
default_pixbuf = icon_theme.load_icon(ABOUT_ICON, LIST_ICON_SIZE, \
gtk.ICON_LOOKUP_USE_BUILTIN)
+ self.saveExpandedLines()
+
self.feedItems.clear()
- for key in self.listing.getListOfFeeds():
- unreadItems = self.listing.getFeedNumberOfUnreadItems(key)
- if unreadItems > 0 or not self.config.getHideReadFeeds():
- title = self.listing.getFeedTitle(key)
+ hideReadFeed = self.config.getHideReadFeeds()
+ order = self.config.getFeedSortOrder()
+
+ categories = self.listing.getListOfCategories()
+ if len(categories) > 1:
+ showCategories = True
+ else:
+ showCategories = False
+
+ for categoryId in categories:
+
+ title = self.listing.getCategoryTitle(categoryId)
+ keys = self.listing.getSortedListOfKeys(order, onlyUnread=hideReadFeed, category=categoryId)
+
+ if showCategories and len(keys)>0:
+ category = self.feedItems.append(None, (None, title, categoryId))
+ #print "catID" + str(categoryId) + " " + str(self.category)
+ if categoryId == self.category:
+ #print categoryId
+ expandedRow = category
+
+ for key in keys:
+ unreadItems = self.listing.getFeedNumberOfUnreadItems(key)
+ title = xml.sax.saxutils.escape(self.listing.getFeedTitle(key))
updateTime = self.listing.getFeedUpdateTime(key)
-
+ if updateTime == 0:
+ updateTime = "Never"
subtitle = '%s / %d unread items' % (updateTime, unreadItems)
-
if unreadItems:
markup = FEED_TEMPLATE_UNREAD % (title, subtitle)
else:
markup = FEED_TEMPLATE % (title, subtitle)
-
+
try:
icon_filename = self.listing.getFavicon(key)
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(icon_filename, \
- LIST_ICON_SIZE, LIST_ICON_SIZE)
+ LIST_ICON_SIZE, LIST_ICON_SIZE)
except:
pixbuf = default_pixbuf
-
- self.feedItems.append((pixbuf, markup, key))
+
+ if showCategories:
+ self.feedItems.append(category, (pixbuf, markup, key))
+ else:
+ self.feedItems.append(None, (pixbuf, markup, key))
+
+
+ self.restoreExpandedLines()
+ #try:
+
+ # self.feedList.expand_row(self.feeItems.get_path(expandedRow), True)
+ #except:
+ # pass
def on_feedList_row_activated(self, treeview, path, column):
+ self.had_interaction = True
model = treeview.get_model()
iter = model.get_iter(path)
key = model.get_value(iter, COLUMN_KEY)
-
+
+ try:
+ #print "Key: " + str(key)
+ catId = int(key)
+ self.category = catId
+ if treeview.row_expanded(path):
+ treeview.collapse_row(path)
+ #else:
+ # treeview.expand_row(path, True)
+ #treeview.collapse_all()
+ #treeview.expand_row(path, False)
+ #for i in range(len(path)):
+ # self.feedList.expand_row(path[:i+1], False)
+ #self.show_confirmation_note(self.window, "Working")
+ #return True
+ except:
+ if key:
+ self.openFeed(key)
+
+ def openFeed(self, key):
try:
self.feed_lock
except:
# If feed_lock doesn't exist, we can open the feed, else we do nothing
- self.feed_lock = get_lock(key)
- self.disp = DisplayFeed(self.listing, self.listing.getFeed(key), \
- self.listing.getFeedTitle(key), key, \
- self.config, self.updateDbusHandler)
- self.disp.connect("feed-closed", self.onFeedClosed)
+ if key != None:
+ self.feed_lock = get_lock(key)
+ self.disp = DisplayFeed(self.listing, self.listing.getFeed(key), \
+ self.listing.getFeedTitle(key), key, \
+ self.config, self.updateDbusHandler)
+ self.disp.connect("feed-closed", self.onFeedClosed)
+
+ def openArticle(self, key, id):
+ try:
+ self.feed_lock
+ except:
+ # If feed_lock doesn't exist, we can open the feed, else we do nothing
+ if key != None:
+ self.feed_lock = get_lock(key)
+ self.disp = DisplayFeed(self.listing, self.listing.getFeed(key), \
+ self.listing.getFeedTitle(key), key, \
+ self.config, self.updateDbusHandler)
+ self.disp.button_clicked(None, id)
+ self.disp.connect("feed-closed", self.onFeedClosed)
+
def onFeedClosed(self, object, key):
#self.listing.saveConfig()
#self.updateDbusHandler.ArticleCountUpdated()
def onFeedClosedTimeout(self):
- self.listing.saveConfig()
del self.feed_lock
self.updateDbusHandler.ArticleCountUpdated()
-
+
+ def quit(self, *args):
+ self.window.hide()
+
+ if hasattr (self, 'app_lock'):
+ del self.app_lock
+
+ # Wait until all slave threads have properly exited before
+ # terminating the mainloop.
+ jm = JobManager()
+ jm.quit ()
+ stats = jm.stats()
+ if stats['jobs-in-progress'] == 0 and stats['jobs-queued'] == 0:
+ gtk.main_quit ()
+ else:
+ gobject.timeout_add(500, self.quit)
+
+ return False
+
def run(self):
- self.window.connect("destroy", gtk.main_quit)
+ self.window.connect("destroy", self.quit)
gtk.main()
- self.listing.saveConfig()
- del self.app_lock
def prefsClosed(self, *widget):
- self.orientation.set_mode(self.config.getOrientation())
+ try:
+ self.orientation.set_mode(self.config.getOrientation())
+ except:
+ pass
self.displayListing()
self.checkAutoUpdate()
def stopUpdate(self):
# Not implemented in the app (see update_feeds.py)
try:
- self.downloadDialog.listOfKeys = []
+ JobManager().cancel ()
except:
pass
return status
if __name__ == "__main__":
+ mainthread.init ()
+
gobject.signal_new("feed-closed", DisplayFeed, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("article-closed", DisplayArticle, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("article-deleted", DisplayArticle, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
projects / feedingit / blobdiff