vcs.maemo.org Git - feedingit/blob - psa_harmattan/feedingit/deb_dist/feedingit-0.1.0/debian/feedingit/usr/share/feedingit/feedingit.py

   1 #!/usr/bin/python
   2
   3 import sys
   4
   5 from PySide import QtGui
   6 from PySide import QtDeclarative
   7 import os
   8 from os import mkdir, remove, stat, environ
   9 from os.path import isfile, isdir, exists
  10 import codecs
  11 import dbus
  12 # import python dbus GLib mainloop support
  13 import dbus.mainloop.glib
  14
  15 # Comment the line below if you don't want to use OpenGL for QML rendering or if it is not supported
  16 from PySide import QtOpenGL,  QtCore
  17
  18 from rss_sqlite import Listing
  19 CONFIGDIR = environ.get("HOME", "/home/user") + "/.feedingit/"
  20 #CONFIGDIR = "/home/user/.feedingit"
  21
  22 import logging
  23 logger = logging.getLogger(__name__)
  24
  25 import debugging
  26 debugging.init(dot_directory=".feedingit", program_name="feedingit-pyside")
  27
  28 from cgi import escape
  29 from re import sub
  30
  31 class Controller(QtCore.QObject):
  32
  33     def __init__(self, listing):
  34         QtCore.QObject.__init__(self)
  35         from XmlHandler import XmlHandler
  36         self._handler = XmlHandler(listing)
  37
  38     def update_progress(self, percent_complete,
  39                         completed, in_progress, queued,
  40                         bytes_downloaded, bytes_updated, bytes_per_second,
  41                         feed_updated):
  42         pass
  43
  44     def update_started(self):
  45         root.updateStarted()
  46
  47     def update_finished(self):
  48         root.updateFinished()
  49
  50     @QtCore.Slot(str,str, result=str)
  51     def getArticle(self, key, article):
  52        feed = listing.getFeed(key)
  53        try:
  54           file = codecs.open(feed.getContentLink(article), "r", "utf-8")
  55           html = file.read().replace("body", "body bgcolor='#ffffff'", 1)
  56           file.close()
  57        except:
  58           html = u"<html><body>Error retrieving article</body></html>"
  59        return html
  60
  61     @QtCore.Slot(str, result=str)
  62     def getFeedsXml(self, catid):
  63         return self._handler.generateFeedsXml(catid)
  64
  65     @QtCore.Slot(str,result=str)
  66     def getArticlesXml(self, key):
  67         #onlyUnread = arguments.get("onlyUnread","False")
  68         return self._handler.generateArticlesXml(key, config.getHideReadArticles())
  69
  70     @QtCore.Slot(result=str)
  71     def getCategoryXml(self):
  72         return self._handler.generateCategoryXml()
  73
  74     @QtCore.Slot(QtCore.QObject)
  75     def feedClicked(self, wrapper):
  76         #print 'User clicked on:', wrapper._key
  77         #articlesModel.updateModel(wrapper._key)
  78         pass
  79
  80     @QtCore.Slot(str)
  81     def updateFeed(self, key):
  82         listing.updateFeed(key)
  83
  84     @QtCore.Slot()
  85     def updateAll(self):
  86         for catid in listing.getListOfCategories():
  87             for feed in listing.getSortedListOfKeys("Manual", category=catid):
  88                 listing.updateFeed(feed)
  89
  90     @QtCore.Slot(str)
  91     def updateCategory(self, catid):
  92         for feed in listing.getSortedListOfKeys("Manual", category=catid):
  93             listing.updateFeed(feed)
  94
  95     @QtCore.Slot(str,str,str)
  96     def addFeed(self, title, url, catid):
  97         listing.addFeed(title,url, category=catid)
  98
  99     @QtCore.Slot(str)
 100     def addCategory(self, name):
 101         listing.addCategory(name)
 102
 103     @QtCore.Slot(str)
 104     def removeFeed(self, key):
 105         listing.removeFeed(key)
 106
 107     @QtCore.Slot(str)
 108     def removeCategory(self, catid):
 109         listing.removeCategory(catid)
 110
 111     @QtCore.Slot(str)
 112     def markAllAsRead(self, key):
 113         feed = listing.getFeed(key)
 114         feed.markAllAsRead()
 115
 116     @QtCore.Slot(str, str)
 117     def setEntryRead(self, key, articleid):
 118         feed = listing.getFeed(key)
 119         feed.setEntryRead(articleid)
 120         listing.updateUnread(key)
 121
 122     @QtCore.Slot(str, result=str)
 123     def getConfig(self, item):
 124         if (item == "hideReadFeed"):
 125             return "True"
 126         if (item == "hideReadArticles"):
 127             return "False"
 128         return ""
 129
 130     @QtCore.Slot(str, str)
 131     def populateFileDialog(self, path, type):
 132         import glob
 133         import os.path
 134         for file in glob.glob(path+type):
 135             logger.debug(file)
 136             root.addFileNotification(file, os.path.basename(file))
 137
 138     @QtCore.Slot(str, result=int)
 139     def importOpml(self, filename):
 140         from opml_lib import parseOpml
 141         file = open(filename, "r")
 142         feeds = parseOpml(file.read())
 143         file.close()
 144         for (title, url) in feeds:
 145             listing.addFeed(title, url)
 146         return len(feeds)
 147
 148     @QtCore.Slot(str, result=str)
 149     def exportOpml(self, filename="/home/user/MyDocs/feedingit-export.opml"):
 150         logger.debug("ExportOpmlData: %s" % filename)
 151         from opml_lib import getOpmlText
 152         try:
 153             str = getOpmlText(listing)
 154             file = open(filename, "w")
 155             file.write(str)
 156             file.close()
 157             return filename
 158         except:
 159             logger.debug("Error exporting: %s" % filename)
 160             return "error"
 161
 162     @QtCore.Slot(str, result=bool)
 163     def getBooleanSetting(self, setting):
 164         if (setting == "theme"):
 165             return config.getTheme()
 166         elif (setting == "imageCache" ):
 167             return config.getImageCache()
 168         elif (setting == "hideReadFeeds"):
 169             return config.getHideReadFeeds()
 170         elif (setting == "hideReadArticles"):
 171             return config.getHideReadArticles()
 172         elif (setting == "autoupdate"):
 173             return config.isAutoUpdateEnabled()
 174         else:
 175             return 'True'
 176
 177     @QtCore.Slot(str, bool)
 178     def setBooleanSetting(self, setting, value):
 179         if (setting == "theme"):
 180             config.setTheme(value)
 181         elif (setting == "imageCache" ):
 182             config.setImageCache(value)
 183         elif (setting == "hideReadFeeds"):
 184             config.setHideReadFeeds(value)
 185         elif (setting == "hideReadArticles"):
 186             config.setHideReadArticles(value)
 187         elif (setting == "autoupdate"):
 188             config.setAutoUpdateEnabled(value)
 189         config.saveConfig()
 190
 191 def main():
 192
 193     if not isdir(CONFIGDIR):
 194         try:
 195             mkdir(CONFIGDIR)
 196         except:
 197             logger.error("Error: Can't create configuration directory")
 198             from sys import exit
 199             exit(1)
 200
 201     from config import Config
 202     global config
 203     config = Config(None,CONFIGDIR+"config.ini")
 204
 205     global listing
 206     listing = Listing(config, CONFIGDIR)
 207
 208     import mainthread
 209     mainthread.init()
 210
 211     from jobmanager import JobManager
 212     JobManager(True)
 213
 214     app = QtGui.QApplication(sys.argv)
 215     view = QtDeclarative.QDeclarativeView()
 216
 217     controller = Controller(listing)
 218
 219     # listen on dbus for download update progress
 220     dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
 221     bus = dbus.SessionBus()
 222 #        bus.add_signal_receiver(handler_function=self.update_progress,
 223 #                                bus_name=None,
 224 #                                signal_name='UpdateProgress',
 225 #                                dbus_interface='org.marcoz.feedingit',
 226 #                                path='/org/marcoz/feedingit/update')
 227 #    bus.add_signal_receiver(handler_function=controller.update_started,
 228 #                            bus_name=None,
 229 #                            signal_name='UpdateStarted',
 230 #                            dbus_interface='org.marcoz.feedingit',
 231 #                            path='/org/marcoz/feedingit/update')
 232 #    bus.add_signal_receiver(handler_function=controller.update_finished,
 233 #                            bus_name=None,
 234 #                            signal_name='UpdateFinished',
 235 #                            dbus_interface='org.marcoz.feedingit',
 236 #                            path='/org/marcoz/feedingit/update')
 237
 238     global root
 239     rc = view.rootContext()
 240
 241     rc.setContextProperty('controller', controller)
 242
 243     # Comment the two lines below if you don't want to use OpenGL for QML rendering or if it is not supported
 244     #glw = QtOpenGL.QGLWidget()
 245     #view.setViewport(glw)
 246
 247     if os.path.exists('/usr/share/feedingit/qml'):
 248         glw = QtOpenGL.QGLWidget()
 249         view.setViewport(glw)
 250         view.setSource('/usr/share/feedingit/qml/main.qml')
 251         view.showFullScreen()
 252     else:
 253         view.setSource(os.path.join('qml','main.qml'))
 254         view.show()
 255         #view.setSource(os.path.join('qml','FeedingIt.qml'))
 256     root = view.rootObject()
 257
 258     #view.showFullScreen()
 259     #view.show()
 260     sys.exit(app.exec_())
 261
 262 if __name__ == "__main__":
 263
 264     main()