vcs.maemo.org Git - mdictionary/blob - trunk/src/base/backbone/backbone.h

   1 /*******************************************************************************
   2
   3     This file is part of mDictionary.
   4
   5     mDictionary is free software: you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation, either version 3 of the License, or
   8     (at your option) any later version.
   9
  10     mDictionary is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with mDictionary.  If not, see <http://www.gnu.org/licenses/>.
  17
  18     Copyright 2010 Comarch S.A.
  19
  20 *******************************************************************************/
  21
  22 /*! /file backbone.cpp
  23 \brief Backbone/core main header \see Backbone
  24
  25
  26 \author Bartosz Szatkowski <bulislaw@linux.com>
  27 */
  28
  29 #ifndef BACKBONE_H
  30 #define BACKBONE_H
  31
  32 #include <QObject>
  33 #include <QList>
  34 #include <QHash>
  35 #include <QPluginLoader>
  36 #include <QFuture>
  37 #include <QtConcurrentRun>
  38 #include <QtConcurrentMap>
  39 #include <QFutureIterator>
  40 #include <QTimer>
  41 #include <QTime>
  42 #include <QDir>
  43 #include <QThread>
  44 #include <QSettings>
  45 #include <QFutureWatcher>
  46 #include "../../includes/CommonDictInterface.h"
  47 #include "../../includes/settings.h"
  48 #include "../../includes/translation.h"
  49 #include "../../includes/History.h"
  50 #include "Bookmarks.h"
  51
  52
  53 /*! Inner part of dictionary - glues together GUI and plugins
  54
  55   Backbone is responsible for managing plugins and dictionaries, starting
  56   new searches and threads, merging search results from multiple dictionaries.
  57
  58   Each plugin may live in multiple instances - each with its own dictionary,
  59   backbone must provide way to create them at start (with specific Settings) and
  60   distinguich each ditionary.
  61
  62 */
  63 class Backbone : public QObject
  64 {
  65     Q_OBJECT
  66
  67 public:
  68     /*!\param pluginPath path to plugins (leave blank for default)
  69       \param configPath path to folder with configuration files*/
  70     Backbone(QString pluginPath="", QString configPath="",
  71              bool dry = 0, QObject *parent = 0);
  72     ~Backbone();
  73     Backbone(const Backbone& b);
  74
  75     //! \return all loadded dictionaries with activity state flag
  76     QHash<CommonDictInterface*, bool> getDictionaries();
  77
  78     //! \return all loadded plugins
  79     QList<CommonDictInterface*> getPlugins();
  80
  81     //! \return history of performed searches
  82     History* history();
  83
  84     //! \return return search fesult
  85     QMultiHash<QString, Translation*> result();
  86
  87     //! \return maximum number of word that plugin could find
  88     int searchLimit() const;
  89
  90     //! \return final translation (after searching for html)
  91     QStringList htmls();
  92
  93
  94 public Q_SLOTS:
  95     //! stops all current searches
  96     void stopSearching();
  97
  98     /*! search for a word translation
  99        \param word to be translated
 100       */
 101     void search(QString word);
 102
 103     /*! sets active dictionaries (searches are performed only in active dicts
 104        \param List of dictionaris to be activated
 105       */
 106     void selectedDictionaries(QList<CommonDictInterface* >);
 107
 108     /*! adds new dictionary and activate it
 109       \param dict dictionary to be added
 110       \param active decides whether searches are perfomed in given dictionaries
 111       */
 112     void addDictionary(CommonDictInterface* dict, bool active = 1);
 113
 114
 115     //! stops all current activity - emiting signal \see closeOk
 116     void quit();
 117
 118
 119     /*! Fired with given interval during searches -
 120         checking if translation is ready
 121       */
 122     void translationReady();
 123
 124     /*! Fired with given interval during html searches -
 125         checking if html is ready
 126       */
 127     void htmlTranslationReady();
 128
 129     /*! Removes given dictionary
 130         \param dict dictionary to be deleted
 131       */
 132     void removeDictionary(CommonDictInterface* dict);
 133
 134     /*! saves plugins new state/configuration after each change */
 135     void dictUpdated();
 136
 137     /*! Performs search for final translation (html/xml) form
 138       \param list of Translation* to be searched for
 139       */
 140     void searchHtml(QList<Translation*>);
 141
 142
 143     /*! add bookmarks to given translations (translation object is fetched and
 144       added to bookmarks data base (key and translation stored in db)
 145       \param translation translation object  to be stored in db
 146       */
 147     void addBookmark(QList<Translation*> translations) {
 148         foreach(Translation* translation, translations)
 149             QtConcurrent::run(&bookmarks, &Bookmarks::add, translation);
 150     }
 151
 152
 153     /*! Remove bookmarks to given translatios
 154       \param translation remove bookmark to this translation
 155       */
 156     void removeBookmark(QList<Translation*> translations) {
 157         foreach(Translation* translation, translations)
 158             bookmarks.remove(translation);
 159     }
 160
 161
 162    /*! Searching for list of bookmarks may take some time, so i moved it to
 163        new thread (to avoid gui blocking), when ready bookmarksReady is emited
 164        and result is returned after calling getBookmarks()
 165        */
 166    void fetchBookmarks() {
 167        _bookmarksResult.clear();
 168        _innerBookmarks = QtConcurrent::run(bookmarks, &Bookmarks::list);
 169        _bookmarkWatcher.setFuture(_innerBookmarks);
 170    }
 171
 172    /*! \return list of all bookmarks
 173      */
 174    QList<Translation*> getBookmarks() {
 175        return _bookmarksResult;
 176    }
 177
 178
 179
 180 Q_SIGNALS:
 181     /*! emmited when backbone is ready to close - after getting stop signal it
 182         should kill all threads and so on */
 183     void closeOk();
 184
 185     //! emitted when there are search result ready to fetch
 186     void ready();
 187
 188     //! emitted when html result is ready to fetch
 189     void htmlReady();
 190
 191     //! throwed when searches are stopped
 192     void searchCanceled();
 193
 194     //! emmited when bookmark list is ready to fetch
 195     void bookmarksReady();
 196
 197 private Q_SLOTS:
 198     void bookmarksListReady();
 199
 200
 201 private:
 202     QHash<CommonDictInterface*, bool> _dicts;
 203     QList<CommonDictInterface*> _plugins;
 204     QFuture<QList<Translation*> > _innerResult;
 205     QFuture<QString> _innerHtmlResult;
 206     QFuture<QList<Translation*> > _innerBookmarks;
 207     QMultiHash<QString, Translation*> _result;
 208     QStringList _htmlResult;
 209     QList<Translation*> _bookmarksResult;
 210     //QTime _time;
 211     QString _pluginPath, _defaultPluginPath;
 212     QString _configPath;
 213     QString _defaultConfigPath;
 214     QFutureWatcher<QList<Translation*> > _resultWatcher;
 215     QFutureWatcher<QList<Translation*> > _bookmarkWatcher;
 216     QFutureWatcher<QString> _htmlResultWatcher;
 217     int _searchLimit, _defaultSearchLimit;
 218     int _activeSearchNum;
 219     int _historyLen, _defaultHistoryLen;
 220     bool dryRun;
 221     bool stopped;
 222     Bookmarks bookmarks;
 223
 224
 225     void init();
 226     QStringList getFilesFromDir(QString dir, QStringList nameFilter);
 227     void loadPlugins(); //< locate and load plugins
 228     void loadPrefs(QString fileName);
 229     void loadDicts(QString fileName, bool _default=false);
 230     void saveState(QSettings*, Settings*, bool, uint);
 231     void addInternalDictionary(CommonDictInterface*, bool);
 232     void savePrefs(QSettings*);
 233     void saveDefaultPrefs(QSettings*);
 234     CommonDictInterface* plugin(QString type); //< search for given type plugin
 235     QList<CommonDictInterface*> activeDicts();
 236
 237     //QList<Translation*> mapSearch(CommonDictInterface*) const;
 238
 239     History* _history;
 240
 241 };
 242
 243 #endif // BACKBONE_H