unipresent/common/UpManager.cpp

   1 /***************************************************************************
   2  *   This file is part of KWorship.                                        *
   3  *   Copyright 2008 James Hogan <james@albanarts.com>                      *
   4  *                                                                         *
   5  *   KWorship is free software: you can redistribute it and/or modify      *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation, either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   KWorship 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         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with KWorship.  If not, write to the Free Software Foundation,  *
  17  *   Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.   *
  18  ***************************************************************************/
  19
  20 /**
  21  * @file UpManager.cpp
  22  * @brief Overall unipresent manager.
  23  * @author James Hogan <james@albanarts.com>
  24  */
  25
  26 #include "UpManager.h"
  27 #include "UpManagerNode.h"
  28 #include "UpBackend.h"
  29 #include "UpPresentationsModel.h"
  30
  31 #include <KMimeType>
  32 #include <KServiceTypeTrader>
  33
  34 #include <cassert>
  35
  36 /// Singleton object.
  37 UpManager* UpManager::s_singleton = 0;
  38
  39 /*
  40  * Singleton access.
  41  */
  42
  43 /// Get the singleton object.
  44 UpManager* UpManager::self()
  45 {
  46   return s_singleton;
  47 }
  48
  49 /*
  50  * Constructors + destructor
  51  */
  52
  53 /// Primary constructor.
  54 UpManager::UpManager(QObject* parent)
  55 : QObject(parent)
  56 , m_backends()
  57 , m_presentationsModel(new UpPresentationsModel(this))
  58 , m_backendAssociations()
  59 , m_preferredBackends()
  60 {
  61   assert(s_singleton == 0);
  62   s_singleton = this;
  63
  64   m_presentationsModel->setRootNode(new UpManagerNode(0, this));
  65 }
  66
  67 /// Destructor.
  68 UpManager::~UpManager()
  69 {
  70   foreach(UpBackend* backend, m_backends)
  71   {
  72     backendRemoved(backend);
  73     delete backend;
  74   }
  75   s_singleton = 0;
  76 }
  77
  78 /*
  79  * Presentation management
  80  */
  81
  82 /// Get a list of presentations.
  83 QList<UpPresentation*> UpManager::presentations()
  84 {
  85   QList<UpPresentation*> presentations;
  86   foreach(UpBackend* backend, m_backends)
  87   {
  88     presentations << backend->presentations();
  89   }
  90   return presentations;
  91 }
  92
  93 /// Get a presentations model.
  94 UpPresentationsModel* UpManager::presentationsModel()
  95 {
  96   return m_presentationsModel;
  97 }
  98
  99 /// Open a new presentation.
 100 bool UpManager::openPresentation(const QUrl& url, bool* attemptFailed)
 101 {
 102   *attemptFailed = false;
 103   // This macro tries to open the url with the given backend
 104 #define TRY_BACKEND_OPEN_PRESENTATION(BACKEND) \
 105   do \
 106   { \
 107     if (0 != (BACKEND)) \
 108     { \
 109       bool loaded = (BACKEND)->openPresentation(url); \
 110       if (loaded) \
 111       { \
 112         return true; \
 113       } \
 114       *attemptFailed = true; \
 115     } \
 116   } while (0)
 117
 118   KSharedPtr<KMimeType> mimeType = KMimeType::findByUrl(url);
 119
 120   // Check if this mime type has a specific association
 121   QStringHashString::const_iterator it = m_backendAssociations.constFind(mimeType->name());
 122   if (it != m_backendAssociations.constEnd())
 123   {
 124     UpBackend* backend = backendById(*it);
 125     TRY_BACKEND_OPEN_PRESENTATION(backend);
 126   }
 127
 128   // Check if each preferred backend supports mime type
 129   foreach (QString backendId, m_preferredBackends)
 130   {
 131     UpBackend* backend = backendById(backendId);
 132     if (0 != backend)
 133     {
 134       QStringList supportedMimes = backend->mimeTypes();
 135       foreach (QString mime, supportedMimes)
 136       {
 137         if (mimeType->is(mime))
 138         {
 139           TRY_BACKEND_OPEN_PRESENTATION(backend);
 140         }
 141       }
 142     }
 143   }
 144
 145   // Check all backends if they support mimetype
 146   foreach (UpBackend* backend, m_backends)
 147   {
 148     QStringList supportedMimes = backend->mimeTypes();
 149     foreach (QString mime, supportedMimes)
 150     {
 151       if (mimeType->is(mime))
 152       {
 153         TRY_BACKEND_OPEN_PRESENTATION(backend);
 154       }
 155     }
 156   }
 157
 158   return false;
 159
 160 #undef TRY_BACKEND_OPEN_PRESENTATION
 161 }
 162
 163 /*
 164  * Backend management
 165  */
 166
 167 /// Get the number of backends.
 168 int UpManager::numBackends() const
 169 {
 170   return m_backends.size();
 171 }
 172
 173 /// Get a specific backend.
 174 UpBackend* UpManager::backendByIndex(int index)
 175 {
 176   return m_backends.at(index);
 177 }
 178
 179 /// Get a specific backend by name.
 180 UpBackend* UpManager::backendById(QString id)
 181 {
 182   /// @todo This could be more efficient
 183   foreach (UpBackend* backend, m_backends)
 184   {
 185     if (backend->id() == id)
 186     {
 187       return backend;
 188     }
 189   }
 190   return 0;
 191 }
 192
 193 /// Get a list of backends.
 194 QList<UpBackend*> UpManager::backends()
 195 {
 196   return m_backends;
 197 }
 198
 199 /// Add a backend object.
 200 void UpManager::addBackend(UpBackend* backend)
 201 {
 202   m_backends.push_back(backend);
 203   connect(backend, SIGNAL(loadedPresentation(UpPresentation*)), m_presentationsModel, SLOT(loadedPresentation(UpPresentation*)));
 204   connect(backend, SIGNAL(unloadedPresentation(UpPresentation*)), m_presentationsModel, SLOT(unloadedPresentation(UpPresentation*)));
 205   backendAdded(backend);
 206 }
 207
 208 #include <QtDebug>
 209 /// Load dynamic backend.
 210 void UpManager::loadBackends()
 211 {
 212   KService::List offers = KServiceTypeTrader::self()->query("UniPresent/Backend");
 213
 214   foreach (KService::Ptr service, offers)
 215   {
 216     qDebug() << "Found UniPresent backend: " << service->desktopEntryName();
 217     QString err;
 218     UpBackend* backend = service->createInstance<UpBackend>(this, QVariantList(), &err);
 219     if (backend)
 220     {
 221       qDebug() << "  Loaded successfully";
 222       addBackend(backend);
 223     }
 224     else
 225     {
 226       qDebug() << "  Could not be loaded: " << err;
 227     }
 228   }
 229 }