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         qDebug()<<"1";
 235    }
 236
 237    /*! Sets settings for backbone: history_size, search_limit,
 238        searching backends (search_bookmarks, search_dictionaries)
 239        \param settings settings object with options set
 240        */
 241     void setSettings(Settings* settings);
 242
 243     /*! \return corresponding settings object with history_size, search_limit,
 244        searching backends (search_bookmarks, search_dictionaries)
 245        */
 246     Settings* settings();
 247
 248
 249
 250
 251
 252
 253 Q_SIGNALS:
 254     /*! emitted when backbone is ready to close - after getting stop signal it
 255         should kill all threads and so on */
 256     void closeOk();
 257
 258     //! emitted when there are search results ready to fetch
 259     void ready();
 260
 261     //! emitted when xml result is ready to fetch
 262     void xmlReady();
 263
 264     //! thrown when searches are stopped
 265     void searchCanceled();
 266
 267     //! emitted when bookmark list is ready to fetch
 268     void bookmarksReady();
 269
 270     /*! emitted by direct connection to plugins notifying signals
 271         \param Notify::NotifyType GUI may decide to show different types in
 272             different ways
 273         \param text of the notification
 274     */
 275     void notify(Notify::NotifyType, QString);
 276
 277     void bookmarkReady();
 278
 279     void bookmarkMode();
 280
 281 private Q_SLOTS:
 282     void bookmarksListReady();
 283
 284
 285 private:
 286     QHash<CommonDictInterface*, bool> _dicts; // List of dictionaries
 287     QList<CommonDictInterface*> _plugins;  // List of plugins
 288
 289
 290     QFuture<QList<Translation*> > _innerResult; //Res of concurrent word search
 291     QFuture<QString> _innerXmlResult;  // Result of xml search
 292     QFuture<QList<Translation*> > _innerBookmarks; //Res of search in bookmarks
 293     QFuture<QList<Translation*> > _innerListBookmarks; //Res of search in bookmarks
 294     QFuture<QStringList> _innerXmlBookmarks; //Xml result of bookmarks search
 295
 296     QMultiHash<QString, Translation*> _result; //Final result of word search
 297     QStringList _xmlResult; // Final result of xml search
 298     QList<Translation*> _bookmarksResult; // Final result of search in bookmarks
 299
 300
 301     // Keeps track of concurent computations
 302     QFutureWatcher<QList<Translation*> > _resultWatcher;
 303     QFutureWatcher<QList<Translation*> > _bookmarkWatcher;
 304     QFutureWatcher<QList<Translation*> > _bookmarkSearchWatcher;
 305     QFutureWatcher<QString> _xmlResultWatcher;
 306
 307
 308     QString _pluginPath;
 309     QString _configPath;
 310     QString _dir;
 311     int _historyLen;
 312     qreal _zoom;
 313
 314     bool dryRun; // mainly for testing - when true then doesn't bother configs etc
 315     bool stopped; // true when user stops searching/fetching
 316     bool bookmarkFin, dictFin; // informs whether given search type is ready
 317     bool _searchDicts, _searchBookmarks; // whether search performed in given source
 318
 319     Bookmarks _bookmarks;
 320
 321
 322     void init();
 323
 324     QStringList getFilesFromDir(QString dir, QStringList nameFilter);
 325     void loadPlugins(); //< locate and load plugins
 326     void loadPrefs(QString fileName);
 327     void loadDicts(QString fileName);
 328
 329     void saveState(QSettings*, Settings*, bool, uint);
 330     void addInternalDictionary(CommonDictInterface*, bool);
 331     void savePrefs(QSettings*);
 332
 333     CommonDictInterface* plugin(QString type); // searches for plugin of a given type
 334     QList<CommonDictInterface*> activeDicts();
 335     bool containsDict(uint hash) const;
 336     int _dictNum;
 337
 338     History* _history;
 339
 340     friend class BackboneTest;
 341
 342 };
 343
 344 #endif // BACKBONE_H