[mdictionary] / trunk / src / base / backbone / backbone.h

/*******************************************************************************

    This file is part of mDictionary.

    mDictionary is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    mDictionary is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with mDictionary.  If not, see <http://www.gnu.org/licenses/>.

    Copyright 2010 Comarch S.A.

*******************************************************************************/

// Created by Bartosz Szatkowski

#ifndef BACKBONE_H
#define BACKBONE_H

#include <QObject>
#include <QList>
#include <QHash>
#include <QPluginLoader>
#include <QFuture>
#include <QtConcurrentRun>
#include <QTimer>
#include <QTime>
#include <QDir>
#include <QSettings>
#include "../../includes/CommonDictInterface.h"
#include "../../includes/settings.h"
#include "../../includes/translation.h"
#include "../../includes/History.h"


/*! Inner part of dictionary - glues together GUI and plugins

  Backbone is responsible for managing plugins and dictionaries, starting
  new searches and threads, merging search results from multiple dictionaries.

  Each plugin may live in multiple instances - each with its own dictionary,
  backbone must provide way to create them at start (with specific Settings) and
  distinguich each ditionary.

*/
class Backbone : public QObject
{
    Q_OBJECT

public:
    /*!\param pluginPath path to plugins (leave blank for default)
      \param configPath path to folder with configuration files*/
    Backbone(QString pluginPath="", QString configPath="", QObject *parent = 0);
    ~Backbone();
    Backbone(const Backbone& b);

    //! \return all loadded dictionaries with activity state flag
    QHash<CommonDictInterface*, bool> getDictionaries();

    //! \return all loadded plugins
    QList<CommonDictInterface*> getPlugins();

    //! \return history of performed searches
    History* history();

    //! \return return search fesult
    QMultiHash<QString, Translation*> result();

    //! \return maximum number of word that plugin could find
    int searchLimit() const;

    //! \return number of active searches
    int activeSearches() const;

    /*! Performs search for final translation (html/xml) form
      \param list of Translation* to be searched for
      */
    void searchHtml(QList<Translation*>);

    //! \return final translation (after searching for html)
    QStringList htmls();


public Q_SLOTS:
    //! stops all current searches
    void stopSearching();

    /*! search for a word translation
       \param word to be translated
      */
    void search(QString word);

    /*! sets active dictionaries (searches are performed only in active dicts
       \param List of dictionaris to be activated
      */
    void selectedDictionaries(QList<CommonDictInterface* >);

    /*! adds new dictionary and activate it
      \param dict dictionary to be added
      \param active decides whether searches are perfomed in given dictionaries
      */
    void addDictionary(CommonDictInterface* dict, bool active = 1);


    //! stops all current activity - emiting signal \see closeOk
    void quit();


    /*! Fired with given interval during searches -
        checking if translation is ready
      */
    void translationReady();

    /*! Fired with given interval during html searches -
        checking if html is ready
      */
    void htmlTranslationReady();

    /*! Removes given dictionary
        \param dict dictionary to be deleted
      */
    void removeDictionary(CommonDictInterface* dict);

    /*! saves plugins new state/configuration after each change */
    void dictUpdated();

    // TODO addToBookmark(Translation*);
    // TODO removeFromBookmark(Translation*);

Q_SIGNALS:
    /*! emmited when backbone is ready to close - after getting stop signal it
        should kill all threads and so on */
    void closeOk();

    //! emitted when there are search result ready to fetch
    void ready();

    //! emitted when html result is ready to fetch
    void htmlReady();



private:
    QHash<CommonDictInterface*, bool> _dicts;
    QList<CommonDictInterface*> _plugins;
    QList<QFuture<QList<Translation*> > > _innerResult;
    QList<QFuture<QString> > _innerHtmlResult;
    QMultiHash<QString, Translation*> _result;
    QStringList _htmlResult;
    QTimer _timerSearch, _timerHtmlSearch;
    QTime _time;
    QString _pluginPath, _defaultPluginPath;
    QString _configPath;
    QString _defaultConfigPath;
    int _searchLimit, _defaultSearchLimit;
    int _activeSearchNum;
    int _interval; //Search fetching timer.timeout interval in msec
    int _historyLen, _defaultHistoryLen;
    bool dryRun;

    void init();
    QStringList getFilesFromDir(QString dir, QStringList nameFilter);
    void loadPlugins(); //< locate and load plugins
    void loadPrefs(QString fileName);
    void loadDicts(QString fileName, bool _default=false);
    void saveState(QSettings*, Settings*, bool, uint);
    void addInternalDictionary(CommonDictInterface*, bool);
    void savePrefs(QSettings*);
    void saveDefaultPrefs(QSettings*);
    CommonDictInterface* plugin(QString type); //< search for given type plugin

    History* _history;

};

#endif // BACKBONE_H