#include "backbone.h"
#include <QDebug>
+int Backbone::_searchLimit;
+
+// Sadly QtConcurent mapped dont let me use something like calling method of
+// some class with supplied argument
QString mappedSearch;
QList<Translation*> mapSearch(CommonDictInterface *dict) {
if(dict)
- return dict->searchWordList(mappedSearch, 15);
+ return dict->searchWordList(mappedSearch, Backbone::_searchLimit);
return QList<Translation*>();
}
QThreadPool::globalInstance()->maxThreadCount()+1);
_history = new History(5, this);
+ _dictNum = 0;
}
-void Backbone::search(QString word) {
+void Backbone::search(QString word){
_result.clear();
mappedSearch = word.toLower();
stopped = false;
- dictFin = 0;
- bookmarkFin = 0;
+ dictFin = !_searchDicts;
+ bookmarkFin = !_searchBookmarks;
- _innerResult = QtConcurrent::mapped(activeDicts(), mapSearch);
- _resultWatcher.setFuture(_innerResult);
+ if (_searchDicts) {
+ _innerResult = QtConcurrent::mapped(activeDicts(), mapSearch);
+ _resultWatcher.setFuture(_innerResult);
+ }
- _innerBookmarks = QtConcurrent::run(bookmarks, &Bookmarks::searchWordList,
- word);
- _bookmarkSearchWatcher.setFuture(_innerBookmarks);
+ if(_searchBookmarks) {
+ _innerBookmarks = QtConcurrent::run(_bookmarks,
+ &Bookmarks::searchWordList, word);
+ _bookmarkSearchWatcher.setFuture(_innerBookmarks);
+ }
}
void Backbone::addInternalDictionary(CommonDictInterface* dict, bool active) {
- dict->setHash(_dicts.size()+1);
+ dict->setHash(++_dictNum);
_dicts[dict] = active;
connect(dict, SIGNAL(settingsChanged()), this, SLOT(dictUpdated()));
+ connect(dict, SIGNAL(notify(Notify::NotifyType,QString)), this,
+ SIGNAL(notify(Notify::NotifyType,QString)));
}
void Backbone::removeDictionary(CommonDictInterface *dict) {
_dicts.remove(dict);
+ delete dict;
dictUpdated();
}
void Backbone::translationReady() {
- if(_innerResult.isFinished() && !dictFin) {
+ if(!dictFin && _innerResult.isFinished()) {
dictFin = 1;
QFutureIterator<QList<Translation*> > it(_innerResult);
}
}
- if(_innerBookmarks.isFinished() && !bookmarkFin) {
+ if(!bookmarkFin && _innerBookmarks.isFinished()) {
bookmarkFin = 1;
QList<Translation*> list = _innerBookmarks.result();
- qDebug() << "translation bookmarks" << list.size();
foreach(Translation* trans, list)
_result.insert(trans->key().toLower(), trans);
}
- if(!stopped && _innerResult.isFinished() && _innerBookmarks.isFinished())
+ if(!stopped && bookmarkFin && dictFin)
Q_EMIT ready();
}
QDir plug(QDir::toNativeSeparators(dir));
if(!plug.exists()) {
qDebug() << plug.absolutePath() << " folder dosen't exists";
+ Q_EMIT notify(Notify::Warning,
+ QString("%1 folder dosen't exists.").arg(plug.path()));
return QStringList();
}
plug.setFilter(QDir::Files);
foreach(QString file, files) {
QPluginLoader loader(file);
if(!loader.load()) {
+ Q_EMIT notify(Notify::Error,
+ QString("%1 plugin cannot be loaded: %2.")
+ .arg(file).arg(loader.errorString()));
qDebug()<< file << " " << loader.errorString();
continue;
}
if(!confDir.exists()){
qDebug() << "Configuration file dosn't exists ("
<< file.filePath() << ")";
+ Q_EMIT notify(Notify::Warning,
+ QString("%1 configurationfile dosen't exists.")
+ .arg(file.filePath()));
return;
}
QSettings set(file.filePath(), QSettings::IniFormat);
_pluginPath = set.value("general/plugin_path", _pluginPath).toString();
- _historyLen = set.value("general/history_length", 10).toInt();
+ _historyLen = set.value("general/history_size", 10).toInt();
_searchLimit = set.value("general/search_limit", 15).toInt();
+ _searchBookmarks = set.value("general/search_bookmarks",1).toBool();
+ _searchDicts = set.value("general/search_dictionaries",1).toBool();
}
if(dryRun)
return;
set->setValue("general/plugin_path", _pluginPath);
- set->setValue("general/history_length", _historyLen);
+ set->setValue("general/history_size", _historyLen);
set->setValue("general/search_limit", _searchLimit);
+ set->setValue("general/search_bookmarks", _searchBookmarks);
+ set->setValue("general/search_dictionaries", _searchDicts);
}
if(dryRun)
return;
set->setValue("general/plugin_path", _defaultPluginPath);
- set->setValue("general/history_length", _defaultHistoryLen);
+ set->setValue("general/history_size", _defaultHistoryLen);
set->setValue("general/search_limit", _defaultSearchLimit);
}
if(!confDir.exists()){
qDebug() << "Configuration file dosn't exists ("
<< file.filePath() << ")";
+ Q_EMIT notify(Notify::Warning,
+ QString("%1 configurationfile dosen't exists.")
+ .arg(file.filePath()));
return;
}
qDebug() << "Config file error: "
<< set.value(dict + "/type", "").toString()
<< " dosen't exists";
+ Q_EMIT notify(Notify::Warning,
+ QString("Configuration file error. %2 plugin dosen't exists.")
+ .arg(set.value(dict + "/type", "").toString()));
continue;
}
Settings* plugSet = new Settings();
void Backbone::dictUpdated() {
if(dryRun)
return;
+ _history->setMaxSize(_historyLen);
QFileInfo file(QDir::toNativeSeparators(_configPath));
QDir confDir(file.dir());
if(!confDir.exists())
QList<TranslationPtr> dummy;
stopped = false;
- qDebug()<< "search html";
- foreach(Translation* tr, translations)
- dummy.append(TranslationPtr(tr));
- qDebug()<< "search html mapp " << dummy.size();
+ foreach(Translation* tr, translations) {
+ if(containsDict(tr->dict()) || !tr->dict())
+ dummy.append(TranslationPtr(tr));
+ }
_innerHtmlResult = QtConcurrent::mapped(dummy,
&TranslationPtr::toHtml);
_htmlResultWatcher.setFuture(_innerHtmlResult);
- qDebug()<< "search html after map";
}
void Backbone::htmlTranslationReady() {
_bookmarksResult = _innerBookmarks.result();
Q_EMIT bookmarksReady();
}
+
+
+
+
+void Backbone::setSettings(Settings *settings) {
+ _historyLen = settings->value("history_size").toInt();
+ _searchLimit = settings->value("search_limit").toInt();
+ if(settings->value("search_dictionaries") == "true")
+ _searchDicts = 1;
+ else
+ _searchDicts = 0;
+ if(settings->value("search_bookmarks") == "true")
+ _searchBookmarks = 1;
+ else
+ _searchBookmarks = 0;
+ dictUpdated();
+}
+
+
+
+
+Settings* Backbone::settings() {
+ Settings * settings = new Settings();
+ settings->setValue("history_size", QString("%1").arg(_historyLen));
+ settings->setValue("search_limit", QString("%1").arg(_searchLimit));
+ if(_searchBookmarks)
+ settings->setValue("search_bookmarks", "true");
+ else
+ settings->setValue("search_bookmarks", "false");
+
+ if(_searchDicts)
+ settings->setValue("search_dictionaries", "true");
+ else
+ settings->setValue("search_dictionaries", "false");
+ return settings;
+}
+
+
+bool Backbone::containsDict(uint hash) const {
+ QHashIterator<CommonDictInterface*, bool> it(_dicts);
+ if (!hash)
+ return false;
+ while(it.hasNext())
+ if(it.next().key()->hash() == hash)
+ return true;
+ return false;
+}