plasma/service.cpp

   1 /*
   2  *   Copyright 2008 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 "service.h"
  21 #include "private/service_p.h"
  22
  23 #include <QFile>
  24 #include <QTimer>
  25
  26 #include <kdebug.h>
  27 #include <kservice.h>
  28 #include <kservicetypetrader.h>
  29 #include <ksharedconfig.h>
  30 #include <kstandarddirs.h>
  31 #include <ktemporaryfile.h>
  32
  33 #include "configloader.h"
  34 #include "version.h"
  35 #include "private/configloader_p.h"
  36
  37 namespace Plasma
  38 {
  39
  40 Service::Service(QObject *parent)
  41     : QObject(parent),
  42       d(new ServicePrivate(this))
  43 {
  44 }
  45
  46 Service::Service(QObject *parent, const QVariantList &args)
  47     : QObject(parent),
  48       d(new ServicePrivate(this))
  49 {
  50     Q_UNUSED(args)
  51 }
  52
  53 Service::~Service()
  54 {
  55     delete d;
  56 }
  57
  58 Service *Service::load(const QString &name, QObject *parent)
  59 {
  60     //TODO: scripting API support
  61     if (name.isEmpty()) {
  62         return new NullService(QString(), parent);
  63     }
  64
  65     QString constraint = QString("[X-KDE-PluginInfo-Name] == '%1'").arg(name);
  66     KService::List offers = KServiceTypeTrader::self()->query("Plasma/Service", constraint);
  67
  68     if (offers.isEmpty()) {
  69         kDebug() << "offers is empty for " << name;
  70         return new NullService(name, parent);
  71     }
  72
  73     KService::Ptr offer = offers.first();
  74     QString error;
  75     QVariantList args;
  76     //args << name;
  77     Service *service = 0;
  78
  79     if (Plasma::isPluginVersionCompatible(KPluginLoader(*offer).pluginVersion())) {
  80         service = offer->createInstance<Plasma::Service>(parent, args, &error);
  81     }
  82
  83     if (!service) {
  84         kDebug() << "Couldn't load Service \"" << name << "\"! reason given: " << error;
  85         return new NullService(name, parent);
  86     }
  87
  88     if (service->name().isEmpty()) {
  89         service->setName(name);
  90     }
  91
  92     return service;
  93 }
  94
  95 void Service::setDestination(const QString &destination)
  96 {
  97     d->destination = destination;
  98 }
  99
 100 QString Service::destination() const
 101 {
 102     return d->destination;
 103 }
 104
 105 QStringList Service::operationNames() const
 106 {
 107     if (!d->config) {
 108         kDebug() << "No valid operations scheme has been registered";
 109         return QStringList();
 110     }
 111
 112     return d->config->groupList();
 113 }
 114
 115 KConfigGroup Service::operationDescription(const QString &operationName)
 116 {
 117     if (!d->config) {
 118         kDebug() << "No valid operations scheme has been registered";
 119         return KConfigGroup();
 120     }
 121
 122     d->config->writeConfig();
 123     KConfigGroup params(d->config->config(), operationName);
 124     //kDebug() << "operation" << operationName
 125     //         << "requested, has keys" << params.keyList() << "from"
 126     //         << d->config->config()->name();
 127     return params;
 128 }
 129
 130 ServiceJob *Service::startOperationCall(const KConfigGroup &description, QObject *parent)
 131 {
 132     // TODO: nested groups?
 133     ServiceJob *job = 0;
 134     QString op = description.isValid() ? description.name() : QString();
 135
 136     if (!d->config) {
 137         kDebug() << "No valid operations scheme has been registered";
 138     } else if (!op.isEmpty() && d->config->hasGroup(op)) {
 139         if (d->disabledOperations.contains(op)) {
 140             kDebug() << "Operation" << op << "is disabled";
 141         } else {
 142             QMap<QString, QVariant> params;
 143             foreach (const QString &key, description.keyList()) {
 144                 KConfigSkeletonItem *item = d->config->findItem(op, key);
 145                 if (item) {
 146                     params.insert(key, description.readEntry(key, item->property()));
 147                 }
 148             }
 149
 150             job = createJob(description.name(), params);
 151         }
 152     } else {
 153         kDebug() << "Not a valid group!";
 154     }
 155
 156     if (!job) {
 157         job = new NullServiceJob(destination(), op, this);
 158     }
 159
 160     job->setParent(parent ? parent : this);
 161     connect(job, SIGNAL(finished(KJob*)), this, SLOT(jobFinished(KJob*)));
 162     QTimer::singleShot(0, job, SLOT(slotStart()));
 163     return job;
 164 }
 165
 166 void Service::associateWidget(QWidget *widget, const QString &operation)
 167 {
 168     disassociateWidget(widget);
 169     d->associatedWidgets.insert(widget, operation);
 170     connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(associatedWidgetDestroyed(QObject*)));
 171
 172     widget->setEnabled(!d->disabledOperations.contains(operation));
 173 }
 174
 175 void Service::disassociateWidget(QWidget *widget)
 176 {
 177     disconnect(widget, SIGNAL(destroyed(QObject*)),
 178                this, SLOT(associatedWidgetDestroyed(QObject*)));
 179     d->associatedWidgets.remove(widget);
 180 }
 181
 182 void Service::associateWidget(QGraphicsWidget *widget, const QString &operation)
 183 {
 184     disassociateWidget(widget);
 185     d->associatedGraphicsWidgets.insert(widget, operation);
 186     connect(widget, SIGNAL(destroyed(QObject*)),
 187             this, SLOT(associatedGraphicsWidgetDestroyed(QObject*)));
 188
 189     widget->setEnabled(!d->disabledOperations.contains(operation));
 190 }
 191
 192 void Service::disassociateWidget(QGraphicsWidget *widget)
 193 {
 194     disconnect(widget, SIGNAL(destroyed(QObject*)),
 195                this, SLOT(associatedGraphicsWidgetDestroyed(QObject*)));
 196     d->associatedGraphicsWidgets.remove(widget);
 197 }
 198
 199 QString Service::name() const
 200 {
 201     return d->name;
 202 }
 203
 204 void Service::setName(const QString &name)
 205 {
 206     d->name = name;
 207
 208     // now reset the config, which may be based on our name
 209     delete d->config;
 210     d->config = 0;
 211
 212     delete d->tempFile;
 213     d->tempFile = 0;
 214
 215     registerOperationsScheme();
 216 }
 217
 218 void Service::setOperationEnabled(const QString &operation, bool enable)
 219 {
 220     if (!d->config || !d->config->hasGroup(operation)) {
 221         return;
 222     }
 223
 224     if (enable) {
 225         d->disabledOperations.remove(operation);
 226     } else {
 227         d->disabledOperations.insert(operation);
 228     }
 229
 230     {
 231         QHashIterator<QWidget *, QString> it(d->associatedWidgets);
 232         while (it.hasNext()) {
 233             it.next();
 234             if (it.value() == operation) {
 235                 it.key()->setEnabled(enable);
 236             }
 237         }
 238     }
 239
 240     {
 241         QHashIterator<QGraphicsWidget *, QString> it(d->associatedGraphicsWidgets);
 242         while (it.hasNext()) {
 243             it.next();
 244             if (it.value() == operation) {
 245                 it.key()->setEnabled(enable);
 246             }
 247         }
 248     }
 249 }
 250
 251 bool Service::isOperationEnabled(const QString &operation) const
 252 {
 253     return d->config && d->config->hasGroup(operation) && !d->disabledOperations.contains(operation);
 254 }
 255
 256 void Service::setOperationsScheme(QIODevice *xml)
 257 {
 258     delete d->config;
 259     delete d->tempFile;
 260
 261     //FIXME: make KSharedConfig and KConfigSkeleton not braindamaged in 4.2 and then get rid of the
 262     //       temp file object here
 263     d->tempFile = new KTemporaryFile;
 264     d->tempFile->open();
 265
 266     KSharedConfigPtr c = KSharedConfig::openConfig(d->tempFile->fileName(), KConfig::NoGlobals);
 267     d->config = new ConfigLoader(c, xml, this);
 268     d->config->d->setWriteDefaults(true);
 269
 270     emit operationsChanged();
 271
 272     {
 273         QHashIterator<QWidget *, QString> it(d->associatedWidgets);
 274         while (it.hasNext()) {
 275             it.next();
 276             it.key()->setEnabled(d->config->hasGroup(it.value()));
 277         }
 278     }
 279
 280     {
 281         QHashIterator<QGraphicsWidget *, QString> it(d->associatedGraphicsWidgets);
 282         while (it.hasNext()) {
 283             it.next();
 284             it.key()->setEnabled(d->config->hasGroup(it.value()));
 285         }
 286     }
 287 }
 288
 289 void Service::registerOperationsScheme()
 290 {
 291     if (d->config) {
 292         // we've already done our job. let's go home.
 293         return;
 294     }
 295
 296     if (d->name.isEmpty()) {
 297         kDebug() << "No name found";
 298         return;
 299     }
 300
 301     QString path = KStandardDirs::locate("data", "plasma/services/" + d->name + ".operations");
 302
 303     if (path.isEmpty()) {
 304         kDebug() << "Cannot find operations description:" << d->name << ".operations";
 305         return;
 306     }
 307
 308     QFile file(path);
 309     setOperationsScheme(&file);
 310 }
 311
 312 } // namespace Plasma
 313
 314 #include "service.moc"
 315