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