workspace/libs/plasma/dataenginemanager.cpp

   1 /*
   2  *   Copyright 2006-2007 Aaron Seigo <aseigo@kde.org>
   3  *
   4  *   This program is free software; you can redistribute it and/or modify
   5  *   it under the terms of the GNU Library General Public License as
   6  *   published by the Free Software Foundation; either version 2, or
   7  *   (at your option) any later version.
   8  *
   9  *   This program is distributed in the hope that it will be useful,
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *   GNU General Public License for more details
  13  *
  14  *   You should have received a copy of the GNU Library General Public
  15  *   License along with this program; if not, write to the
  16  *   Free Software Foundation, Inc.,
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #include "dataenginemanager.h"
  21 #include "scripting/scriptengine.h"
  22
  23 #include <KDebug>
  24 #include <KServiceTypeTrader>
  25
  26 namespace Plasma
  27 {
  28
  29 class NullEngine : public DataEngine
  30 {
  31     public:
  32         NullEngine(QObject* parent = 0)
  33             : DataEngine(parent)
  34         {
  35             setObjectName(i18n("Null Engine"));
  36             setValid(false);
  37
  38             // ref() ourselves to ensure we never get deleted
  39             ref();
  40         }
  41 };
  42
  43 class DataEngineManager::Private
  44 {
  45     public:
  46         Private()
  47             : nullEng(0)
  48         {}
  49
  50         ~Private()
  51         {
  52             foreach (Plasma::DataEngine* engine, engines) {
  53                 delete engine;
  54             }
  55             engines.clear();
  56             delete nullEng;
  57         }
  58
  59         DataEngine* nullEngine()
  60         {
  61             if (!nullEng) {
  62                 nullEng = new NullEngine;
  63             }
  64
  65             return nullEng;
  66         }
  67
  68         DataEngine::Dict engines;
  69         DataEngine* nullEng;
  70 };
  71
  72 class DataEngineManagerSingleton
  73 {
  74     public:
  75         DataEngineManager self;
  76 };
  77
  78 K_GLOBAL_STATIC(DataEngineManagerSingleton, privateDataEngineManagerSelf)
  79
  80 DataEngineManager* DataEngineManager::self()
  81 {
  82     return &privateDataEngineManagerSelf->self;
  83 }
  84
  85 DataEngineManager::DataEngineManager()
  86     : d(new Private())
  87 {
  88 }
  89
  90 DataEngineManager::~DataEngineManager()
  91 {
  92     delete d;
  93 }
  94
  95 Plasma::DataEngine* DataEngineManager::get(const QString& name) const
  96 {
  97     Plasma::DataEngine::Dict::const_iterator it = d->engines.find(name);
  98     if (it != d->engines.end()) {
  99         // ref and return the engine
 100         //Plasma::DataEngine *engine = *it;
 101         return *it;
 102     }
 103
 104     return d->nullEngine();
 105 }
 106
 107 Plasma::DataEngine* DataEngineManager::load(const QString& name)
 108 {
 109     Plasma::DataEngine* engine = 0;
 110     Plasma::DataEngine::Dict::const_iterator it = d->engines.find(name);
 111
 112     if (it != d->engines.end()) {
 113         engine = *it;
 114         engine->ref();
 115         return engine;
 116     }
 117
 118     // load the engine, add it to the engines
 119     QString constraint = QString("[X-Plasma-EngineName] == '%1'").arg(name);
 120     KService::List offers = KServiceTypeTrader::self()->query("Plasma/DataEngine",
 121                                                               constraint);
 122     QString error;
 123
 124     if (offers.isEmpty()) {
 125         kDebug() << "offers are empty for " << name << " with constraint " << constraint;
 126     } else {
 127         QVariantList allArgs;
 128         allArgs << offers.first()->storageId();
 129         QString language = offers.first()->property("X-Plasma-Language").toString();
 130         if (language.isEmpty()) {
 131             engine = offers.first()->createInstance<Plasma::DataEngine>(0, allArgs, &error);
 132         } else {
 133             engine = new DataEngine(0, offers.first());
 134         }
 135     }
 136
 137     if (!engine) {
 138         kDebug() << "Couldn't load engine \"" << name << "\". Error given: " << error;
 139         return d->nullEngine();
 140     }
 141
 142     d->engines[name] = engine;
 143     return engine;
 144 }
 145
 146 void DataEngineManager::unload(const QString& name)
 147 {
 148     Plasma::DataEngine::Dict::iterator it = d->engines.find(name);
 149
 150     if (it != d->engines.end()) {
 151         Plasma::DataEngine* engine = *it;
 152         engine->deref();
 153
 154         if (!engine->isUsed()) {
 155             d->engines.erase(it);
 156             delete engine;
 157         }
 158     }
 159 }
 160
 161 QStringList DataEngineManager::knownEngines()
 162 {
 163     QStringList engines;
 164     KService::List offers = KServiceTypeTrader::self()->query("Plasma/DataEngine");
 165     foreach (KService::Ptr service, offers) {
 166         engines.append(service->property("X-Plasma-EngineName").toString());
 167     }
 168
 169     return engines;
 170 }
 171
 172 } // namespace Plasma
 173
 174 #include "dataenginemanager.moc"