vcs.maemo.org Git - mdictionary/blob - src/mdictionary/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 <QSet>
  36 #include <QPluginLoader>
  37 #include <QFuture>
  38 #include <QtConcurrentRun>
  39 #include <QtConcurrentMap>
  40 #include <QFutureIterator>
  41 #include <QTimer>
  42 #include <QTime>
  43 #include <QDir>
  44 #include <QThread>
  45 #include <QDebug>
  46 #include <QSettings>
  47 #include <QFutureWatcher>
  48 #include <QMultiMap>
  49 #include "../../include/CommonDictInterface.h"
  50 #include "../../include/settings.h"
  51 #include "../../include/translation.h"
  52 #include "../../include/History.h"
  53 #include "../../include/Notify.h"
  54 #include "ConfigGenerator.h"
  55 #include "Bookmarks.h"
  56
  57
  58 /*! Inner part of dictionary - glues together GUI and plugins, also kind of
  59     GoF facade (for GUI) cover few classes \see Bookmarks \see History
  60
  61   Backbone is responsible for managing plugins and dictionaries, starting
  62   new searches and threads, merging search results from multiple dictionaries.
  63
  64   Each plugin may live in multiple instances - each with its own dictionary,
  65   backbone must provide a way to create them at start (with specific Settings) and
  66   distinguish each ditionary.
  67
  68   Backbone also manages bookmarks and history: providing interface to GUI.
  69
  70   Backbone is also responsible for saving and spawning session via configs
  71   file (stored in ~/.mdictionary) -> configs are kind of tricky because
  72   mDictionary is delivered with two simple dicts -> it's necessary to separate default
  73   configs from user configs (updating/reinstalling app results in overwritten
  74   default config file), moreover config file there is general mdictionary
  75   configuration (apart from dictionaries and plugin ones).
  76
  77   Other modules may set some internal backbone behaviour via \see setSettings():
  78   Settings object with options given:
  79      * history_size - int, size of stored searches
  80      * search_limit - int, how many different words each dictionary may return
  81      * search_dictionaries - true/false, whether search in dictionaries
  82      * search_bookmarks - true/false, whether search in bookmarks
  83
  84     Searching schema:
  85         At first GUI should ask for a list of words matching a given pattern,
  86         then each Translation object is capable of finding its own final translation
  87
  88       List of words:
  89         - GUI calls search(...)
  90         - Backbone calls plugins searchWordList(...) in idealThreadCount()+1 threads
  91         - Backbone sets the FutureWatcher to be notified when plugins are done
  92         - Backbone fetches results from Future<..> and formats it for GUI, then
  93            emits ready()
  94         - GUI calls result()
  95
  96       Final translation:
  97          - GUI calls searchXml()
  98          - Backbone starts toXml for each translation object in separate threads
  99          - Backbone sets FutureWatcher to be notified after last toXml returns
 100          - Backbone fetches translation from Future<...> objects and calls
 101              xmlReady()
 102          - Gui calls xmlResult()
 103
 104 */
 105 class Backbone : public QObject
 106 {
 107     Q_OBJECT
 108
 109 public:
 110     /*! \param pluginPath path to plugins (leave blank for default)
 111         \param configPath path to folder with configuration files
 112         \param dry dry run is mode without paying attention to configuration etc
 113           mainly for testing
 114       */
 115     Backbone(QString pluginPath="", QString configPath="",
 116              bool dry = 0, QObject *parent = 0);
 117     ~Backbone();
 118     Backbone(const Backbone& b);
 119
 120     //! \return all loaded dictionaries with activity state flag
 121     QHash<CommonDictInterface*, bool> getDictionaries();
 122
 123     //! \return all loaded plugins
 124     QList<CommonDictInterface*> getPlugins();
 125
 126     //! \return history of performed searches
 127     History* history();
 128
 129     //! \return search fesult
 130     QMultiHash<QString, Translation*> result();
 131
 132     //! \return maximum number of words that plugin could find
 133     int searchLimit() const;
 134
 135     //! \return final translation (after searching for xml)
 136     QStringList xmls();
 137
 138     /*! maximum number of translations that each plugin may return; it must be
 139         public static because of QtConcurent::mapped restrictions about
 140         what kind of function may be used there see Qt docs */
 141     static int _searchLimit;
 142
 143
 144
 145 public Q_SLOTS:
 146     //! stops all current searches and emits searchCanceled signal
 147     void stopSearching();
 148
 149     /*! searches for a word translation
 150        \param word word to be translated
 151       */
 152     void search(QString word);
 153
 154     /*! sets active dictionaries (searches are performed only in active dicts)
 155        \param List of dictionaries to be activated
 156       */
 157     void selectedDictionaries(QList<CommonDictInterface*>);
 158
 159     /*! adds a new dictionary and activates it
 160       \param dict dictionary to be added
 161       \param active decides whether searches are perfomed in given dictionaries
 162       */
 163     void addDictionary(CommonDictInterface* dict, bool active = 1);
 164
 165
 166     //! stops all current activity - emitting signal \see closeOk
 167     void quit();
 168
 169
 170     /*! Fired by FutureWatcher when a list of words is ready (after calling search),
 171         fetch Future<...> to final result
 172       */
 173     void translationReady();
 174
 175     /*! Fired by FutureWatcher when search result is ready, fetch Future to
 176         final result
 177       */
 178     void xmlTranslationReady();
 179
 180     /*! Removes a given dictionary
 181         \param dict dictionary to be deleted
 182       */
 183     void removeDictionary(CommonDictInterface* dict);
 184
 185     /*! Saves plugins new state/configuration after each change */
 186     void dictUpdated();
 187
 188     /*! Performs search for final translation (xml) form
 189       \param list of Translation* to be searched for
 190       */
 191     void searchXml(QList<Translation*>);
 192
 193
 194     /*! adds bookmarks to given translations (translation object is fetched and
 195       added to bookmarks data base (key and translation stored in db))
 196       \param translations list of Translation objects to be stored in db
 197       */
 198     void addBookmark(QList<Translation*> translations);
 199
 200
 201     /*! Removes bookmarks to given translations
 202       \param translations remove bookmark to these translations
 203       */
 204     void removeBookmark(QList<Translation*> translations) {
 205         foreach(Translation* translation, translations)
 206             _bookmarks.remove(translation);
 207     }
 208
 209
 210
 211     /*! Removes all bookmarks
 212       */
 213     void removeAllBookmarks(){
 214         _bookmarks.clear();
 215     }
 216
 217
 218    /*! Searching a list of bookmarks may take some time, so it's moved to a
 219        new thread (to avoid GUI blocking), further it's consistent with ordinary
 220        searching a list of words (\see search)
 221        */
 222    void fetchBookmarks() {
 223         _result.clear();
 224
 225         stopped = false;
 226         dictFin = 1;
 227         bookmarkFin = 0;
 228
 229         _innerBookmarks = QtConcurrent::run(_bookmarks,
 230                 &Bookmarks::list);
 231         _bookmarkSearchWatcher.setFuture(_innerBookmarks);
 232
 233         Q_EMIT bookmarkMode();
 234    }
 235
 236    /*! Sets settings for backbone: history_size, search_limit,
 237        searching backends (search_bookmarks, search_dictionaries)
 238        \param settings settings object with options set
 239        */
 240     void setSettings(Settings* settings);
 241
 242     /*! \return corresponding settings object with history_size, search_limit,
 243        searching backends (search_bookmarks, search_dictionaries)
 244        */
 245     Settings* settings();
 246
 247
 248
 249
 250
 251
 252 Q_SIGNALS:
 253     /*! emitted when backbone is ready to close - after getting stop signal it
 254         should kill all threads and so on */
 255     void closeOk();
 256
 257     //! emitted when there are search results ready to fetch
 258     void ready();
 259
 260     //! emitted when xml result is ready to fetch
 261     void xmlReady();
 262
 263     //! thrown when searches are stopped
 264     void searchCanceled();
 265
 266     //! emitted when bookmark list is ready to fetch
 267     void bookmarksReady();
 268
 269     /*! emitted by direct connection to plugins notifying signals
 270         \param Notify::NotifyType GUI may decide to show different types in
 271             different ways
 272         \param text of the notification
 273     */
 274     void notify(Notify::NotifyType, QString);
 275
 276     void bookmarkReady();
 277
 278     void bookmarkMode();
 279
 280 private Q_SLOTS:
 281     void bookmarksListReady();
 282
 283
 284 private:
 285     QHash<CommonDictInterface*, bool> _dicts; // List of dictionaries
 286     QList<CommonDictInterface*> _plugins;  // List of plugins
 287
 288
 289     QFuture<QList<Translation*> > _innerResult; //Res of concurrent word search
 290     QFuture<QString> _innerXmlResult;  // Result of xml search
 291     QFuture<QList<Translation*> > _innerBookmarks; //Res of search in bookmarks
 292     QFuture<QList<Translation*> > _innerListBookmarks; //Res of search in bookmarks
 293     QFuture<QStringList> _innerXmlBookmarks; //Xml result of bookmarks search
 294
 295     QMultiHash<QString, Translation*> _result; //Final result of word search
 296     QStringList _xmlResult; // Final result of xml search
 297     QList<Translation*> _bookmarksResult; // Final result of search in bookmarks
 298
 299
 300     // Keeps track of concurent computations
 301     QFutureWatcher<QList<Translation*> > _resultWatcher;
 302     QFutureWatcher<QList<Translation*> > _bookmarkWatcher;
 303     QFutureWatcher<QList<Translation*> > _bookmarkSearchWatcher;
 304     QFutureWatcher<QString> _xmlResultWatcher;
 305
 306
 307     QString _pluginPath;
 308     QString _configPath;
 309     QString _dir;
 310     int _historyLen;
 311     qreal _zoom;
 312
 313     bool dryRun; // mainly for testing - when true then doesn't bother configs etc
 314     bool stopped; // true when user stops searching/fetching
 315     bool bookmarkFin, dictFin; // informs whether given search type is ready
 316     bool _searchDicts, _searchBookmarks; // whether search performed in given source
 317
 318     Bookmarks _bookmarks;
 319
 320
 321     void init();
 322
 323     QStringList getFilesFromDir(QString dir, QStringList nameFilter);
 324     void loadPlugins(); //< locate and load plugins
 325     void loadPrefs(QString fileName);
 326     void loadDicts(QString fileName);
 327
 328     void saveState(QSettings*, Settings*, bool, uint);
 329     void addInternalDictionary(CommonDictInterface*, bool);
 330     void savePrefs(QSettings*);
 331
 332     CommonDictInterface* plugin(QString type); // searches for plugin of a given type
 333     QList<CommonDictInterface*> activeDicts();
 334     bool containsDict(uint hash) const;
 335     int _dictNum;
 336
 337     History* _history;
 338
 339     friend class BackboneTest;
 340
 341 };
 342
 343 #endif // BACKBONE_H