workspace/plasma/applets/kickoff/core/urlitemlauncher.cpp

   1 /*
   2     Copyright 2007 Robert Knight <robertknight@gmail.com>
   3     Copyright 2007 Kevin Ottens <ervin@kde.org>
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License as published by the Free Software Foundation; either
   8     version 2 of the License, or (at your option) any later version.
   9
  10     This library 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 GNU
  13     Library General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public License
  16     along with this library; see the file COPYING.LIB.  If not, write to
  17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18     Boston, MA 02110-1301, USA.
  19 */
  20
  21 #include "urlitemlauncher.h"
  22
  23 // Qt
  24 #include <QFileInfo>
  25 #include <QHash>
  26 #include <QModelIndex>
  27
  28 // KDE
  29 #include <KDebug>
  30 #include <KRun>
  31 #include <KUrl>
  32 #include <Solid/Device>
  33 #include <Solid/StorageAccess>
  34
  35 // Local
  36 #include "core/models.h"
  37 #include "core/urlitemlauncher.h"
  38
  39 using namespace Kickoff;
  40
  41 class HandlerInfo
  42 {
  43 public:
  44     HandlerInfo() : type(UrlItemLauncher::ProtocolHandler) , handler(0) {}
  45     UrlItemLauncher::HandlerType type;
  46     UrlItemHandler *handler;
  47 };
  48
  49 class GenericItemHandler : public UrlItemHandler
  50 {
  51 public:
  52     virtual bool openUrl(const KUrl& url) {
  53         new KRun(url, 0);
  54         return true;
  55     }
  56 };
  57
  58 class UrlItemLauncher::Private
  59 {
  60 public:
  61     static QHash<QString, HandlerInfo> globalHandlers;
  62     static GenericItemHandler genericHandler;
  63
  64     static bool openUrl(const QString &urlString) {
  65         kDebug() << "Opening item with URL" << urlString;
  66
  67         KUrl url(urlString);
  68         HandlerInfo protocolHandler = globalHandlers[url.scheme()];
  69         if (protocolHandler.type == ProtocolHandler && protocolHandler.handler != 0) {
  70             return protocolHandler.handler->openUrl(url);
  71         }
  72
  73         QString extension = QFileInfo(url.path()).suffix();
  74         HandlerInfo extensionHandler = globalHandlers[extension];
  75         if (extensionHandler.type == ExtensionHandler && extensionHandler.handler != 0) {
  76             return extensionHandler.handler->openUrl(url);
  77         }
  78
  79         return genericHandler.openUrl(url);
  80     }
  81 };
  82
  83 QHash<QString, HandlerInfo> UrlItemLauncher::Private::globalHandlers;
  84 GenericItemHandler UrlItemLauncher::Private::genericHandler;
  85
  86 UrlItemLauncher::UrlItemLauncher(QObject *parent)
  87         : QObject(parent)
  88         , d(new Private)
  89 {
  90 }
  91
  92 UrlItemLauncher::~UrlItemLauncher()
  93 {
  94     delete d;
  95 }
  96
  97 bool UrlItemLauncher::openItem(const QModelIndex& index)
  98 {
  99     QString urlString = index.data(UrlRole).value<QString>();
 100     if (urlString.isEmpty()) {
 101         QString udi = index.data(DeviceUdiRole).toString();
 102         if (!udi.isEmpty()) {
 103             Solid::Device device(udi);
 104             Solid::StorageAccess *access = device.as<Solid::StorageAccess>();
 105
 106             if (access && !access->isAccessible()) {
 107                 connect(access, SIGNAL(setupDone(Solid::ErrorType, QVariant, QString)),
 108                         this, SLOT(onSetupDone(Solid::ErrorType, QVariant, QString)));
 109                 access->setup();
 110                 return true;
 111             }
 112         }
 113
 114         kDebug() << "Item" << index.data(Qt::DisplayRole) << "has no URL to open.";
 115         return false;
 116     }
 117
 118     return Private::openUrl(urlString);
 119 }
 120
 121 bool UrlItemLauncher::openUrl(const QString& url)
 122 {
 123     return Private::openUrl(url);
 124 }
 125
 126 void UrlItemLauncher::onSetupDone(Solid::ErrorType error, QVariant errorData, const QString &udi)
 127 {
 128     Q_UNUSED(errorData);
 129
 130     if (error != Solid::NoError) {
 131         return;
 132     }
 133
 134     Solid::Device device(udi);
 135     Solid::StorageAccess *access = device.as<Solid::StorageAccess>();
 136
 137     Q_ASSERT(access);
 138
 139     QString urlString = "file://" + access->filePath();
 140     Private::openUrl(urlString);
 141 }
 142
 143 // FIXME: the handlers are leaked, as they are added with each new Kickoff instance,
 144 //        but never deleted.
 145 void UrlItemLauncher::addGlobalHandler(HandlerType type, const QString& name, UrlItemHandler *handler)
 146 {
 147     HandlerInfo info;
 148     info.type = type;
 149     info.handler = handler;
 150     Private::globalHandlers.insert(name, info);
 151 }
 152
 153
 154 #include "urlitemlauncher.moc"