runtime/kdedglobalaccel/component.cpp

   1 /* Copyright (C) 2008 Michael Jansen <kde@michael-jansen.biz>
   2
   3    This library is free software; you can redistribute it and/or
   4    modify it under the terms of the GNU Library General Public
   5    License as published by the Free Software Foundation; either
   6    version 2 of the License, or (at your option) any later version.
   7
   8    This library is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11    Library General Public License for more details.
  12
  13    You should have received a copy of the GNU Library General Public License
  14    along with this library; see the file COPYING.LIB.  If not, write to
  15    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  16    Boston, MA 02110-1301, USA.
  17 */
  18
  19 #include "component.h"
  20
  21 #include "globalshortcut.h"
  22 #include "globalshortcutcontext.h"
  23 #include "globalshortcutsregistry.h"
  24
  25 #include <kdebug.h>
  26
  27 #include <QtCore/QStringList>
  28 #include <QtGui/QKeySequence>
  29
  30 static QList<int> keysFromString(const QString &str)
  31 {
  32     QList<int> ret;
  33     if (str == "none") {
  34         return ret;
  35     }
  36     QStringList strList = str.split('\t');
  37     foreach (const QString &s, strList) {
  38         int key = QKeySequence(s)[0];
  39         if (key != -1) {     //sanity check just in case
  40             ret.append(key);
  41         }
  42     }
  43     return ret;
  44 }
  45
  46
  47 static QString stringFromKeys(const QList<int> &keys)
  48 {
  49     if (keys.isEmpty()) {
  50         return "none";
  51     }
  52     QString ret;
  53     foreach (int key, keys) {
  54         ret.append(QKeySequence(key).toString());
  55         ret.append('\t');
  56     }
  57     ret.chop(1);
  58     return ret;
  59 }
  60
  61 namespace KdeDGlobalAccel {
  62
  63 Component::Component(
  64             const QString &uniqueName,
  65             const QString &friendlyName,
  66             GlobalShortcutsRegistry *registry)
  67     :   _uniqueName(uniqueName)
  68         ,_friendlyName(friendlyName)
  69         ,_registry(registry)
  70     {
  71     // Make sure we do no get uniquenames still containing the context
  72     Q_ASSERT(uniqueName.indexOf("|")==-1);
  73
  74     // Register ourselve with the registry
  75     if (_registry)
  76         {
  77         _registry->addComponent(this);
  78         }
  79
  80     createGlobalShortcutContext("default", "Default Context");
  81     _current = _contexts.value("default");
  82     }
  83
  84
  85 Component::~Component()
  86     {
  87     // Remove ourselve from the registry
  88     if (_registry)
  89         {
  90         _registry->takeComponent(this);
  91         }
  92
  93     // We delete all shortcuts from all contexts
  94     qDeleteAll(_contexts);
  95     }
  96
  97
  98 bool Component::activateGlobalShortcutContext(
  99         const QString &uniqueName)
 100     {
 101     if (!_contexts.value(uniqueName))
 102         {
 103         createGlobalShortcutContext(uniqueName, "TODO4");
 104         return false;
 105         }
 106
 107     // Deactivate the current contexts shortcuts
 108     deactivateShortcuts();
 109
 110     // Switch the context
 111     _current = _contexts.value(uniqueName);
 112
 113     return true;
 114     }
 115
 116
 117 void Component::activateShortcuts()
 118     {
 119     Q_FOREACH (GlobalShortcut *shortcut, _current->_actions)
 120         {
 121         shortcut->setActive();
 122         }
 123     }
 124
 125
 126 QList<GlobalShortcut*> Component::allShortcuts(const QString &contextName) const
 127     {
 128     GlobalShortcutContext *context = _contexts.value(contextName);
 129     if (context)
 130         {
 131         return context->_actions.values();
 132         }
 133     else
 134         {
 135         Q_ASSERT(false); // Unknown context
 136         return QList<GlobalShortcut*> ();
 137         }
 138     }
 139
 140
 141 QList<KGlobalShortcutInfo> Component::allShortcutInfos(const QString &contextName) const
 142     {
 143     QList<KGlobalShortcutInfo> rc;
 144
 145     GlobalShortcutContext *context = _contexts.value(contextName);
 146     if (!context)
 147         {
 148         Q_ASSERT(false); // Unknown context
 149         return rc;
 150         }
 151
 152     return context->allShortcutInfos();
 153     }
 154
 155
 156 bool Component::createGlobalShortcutContext(
 157         const QString &uniqueName,
 158         const QString &friendlyName)
 159     {
 160     if (_contexts.value(uniqueName))
 161         {
 162         kDebug() << "Shortcut Context " << uniqueName << "already exists for component " << _uniqueName;
 163         return false;
 164         }
 165     _contexts.insert(uniqueName, new GlobalShortcutContext(uniqueName, friendlyName, this));
 166     return true;
 167     }
 168
 169
 170 GlobalShortcutContext *Component::currentContext()
 171     {
 172     return _current;
 173     }
 174
 175
 176 QDBusObjectPath Component::dbusPath() const
 177     {
 178     QString dbusPath = _uniqueName;
 179     // Clean up for dbus usage: any non-alphanumeric char should be turned into '_'
 180     const int len = dbusPath.length();
 181     for ( int i = 0; i < len; ++i )
 182         {
 183         if ( !dbusPath[i].isLetterOrNumber() )
 184             dbusPath[i] = QLatin1Char('_');
 185         }
 186     // QDBusObjectPath could be a little bit easier to handle :-)
 187     return QDBusObjectPath( _registry->dbusPath().path()  + "/component/" + dbusPath);
 188     }
 189
 190
 191 void Component::deactivateShortcuts(bool temporarily)
 192     {
 193     Q_FOREACH (GlobalShortcut *shortcut, _current->_actions)
 194         {
 195         if (temporarily
 196                 && uniqueName() == "kwin"
 197                 && shortcut->uniqueName() == "Block Global Shortcuts")
 198             {
 199             continue;
 200             }
 201         shortcut->setInactive();
 202         }
 203     }
 204
 205
 206 QString Component::friendlyName() const
 207     {
 208     return _friendlyName;
 209     }
 210
 211
 212 GlobalShortcut *Component::getShortcutByKey(int key) const
 213     {
 214     return _current->getShortcutByKey(key);
 215     }
 216
 217
 218 QList<GlobalShortcut *> Component::getShortcutsByKey(int key) const
 219     {
 220     QList <GlobalShortcut *> rc;
 221     Q_FOREACH(GlobalShortcutContext *context, _contexts)
 222         {
 223         GlobalShortcut *sc = context->getShortcutByKey(key);
 224         if (sc) rc.append(sc);
 225         }
 226     return rc;
 227     }
 228
 229
 230 GlobalShortcut *Component::getShortcutByName(const QString &uniqueName, const QString &context) const
 231     {
 232     if (!_contexts.value(context))
 233         {
 234         return NULL;
 235         }
 236
 237     return _contexts.value(context)->_actions.value(uniqueName);
 238     }
 239
 240
 241 QStringList Component::getShortcutContexts() const
 242     {
 243     return _contexts.keys();
 244     }
 245
 246
 247 bool Component::isShortcutAvailable(
 248         int key,
 249         const QString &component,
 250         const QString &context) const
 251     {
 252     kDebug() << QKeySequence(key).toString() << component;
 253
 254     // if this component asks for the key. only check the keys in the same
 255     // context
 256     if (component==uniqueName())
 257         {
 258         Q_FOREACH(GlobalShortcut *sc, shortcutContext(context)->_actions)
 259             {
 260             if (sc->keys().contains(key)) return false;
 261             }
 262         }
 263     else
 264         {
 265         Q_FOREACH(GlobalShortcutContext *ctx, _contexts)
 266             {
 267             Q_FOREACH(GlobalShortcut *sc, ctx->_actions)
 268                 {
 269                 if (sc->keys().contains(key)) return false;
 270                 }
 271             }
 272         }
 273     return true;
 274     }
 275
 276
 277 void Component::loadSettings(KConfigGroup &configGroup)
 278     {
 279     // GlobalShortcutsRegistry::loadSettings handles contexts.
 280     Q_FOREACH (const QString &confKey, configGroup.keyList())
 281         {
 282         const QStringList entry = configGroup.readEntry(confKey, QStringList());
 283         if (entry.size() != 3)
 284             {
 285             continue;
 286             }
 287
 288         // The shortcut will register itself with us
 289         GlobalShortcut *shortcut = new GlobalShortcut(
 290                 confKey,
 291                 entry[2],
 292                 _current);
 293
 294         QList<int> keys = keysFromString(entry[0]);
 295         shortcut->setDefaultKeys(keysFromString(entry[1]));
 296         shortcut->setIsFresh(false);
 297
 298         Q_FOREACH (int key, keys)
 299             {
 300             if (key != 0)
 301                 {
 302                 if (GlobalShortcutsRegistry::self()->getShortcutByKey(key))
 303                     {
 304                     // The shortcut is already used. The config file is
 305                     // broken. Ignore the request.
 306                     keys.removeAll(key);
 307                     kWarning() << "Shortcut found twice in kglobalshortcutsrc.";
 308                     }
 309                 }
 310             }
 311         shortcut->setKeys(keys);
 312         }
 313     }
 314
 315
 316 void Component::setFriendlyName(const QString &name)
 317     {
 318     _friendlyName = name;
 319     }
 320
 321
 322 GlobalShortcutContext *Component::shortcutContext( const QString &contextName )
 323     {
 324     return _contexts.value(contextName);
 325     }
 326
 327 GlobalShortcutContext const *Component::shortcutContext( const QString &contextName ) const
 328     {
 329     return _contexts.value(contextName);
 330     }
 331
 332 QStringList Component::shortcutNames( const QString &contextName) const
 333     {
 334     GlobalShortcutContext *context = _contexts.value(contextName);
 335     if (!context)
 336         {
 337         Q_ASSERT(false); // Unknown context
 338         return QStringList();
 339         }
 340
 341     return context->_actions.keys();
 342     }
 343
 344
 345 QString Component::uniqueName() const
 346     {
 347     return _uniqueName;
 348     }
 349
 350
 351 void Component::writeSettings(KConfigGroup& configGroup) const
 352     {
 353     // If we don't delete the current content global shortcut
 354     // registrations will never not deleted after forgetGlobalShortcut()
 355     configGroup.deleteGroup();
 356
 357
 358     // Now wrote all contexts
 359     Q_FOREACH( GlobalShortcutContext *context, _contexts)
 360         {
 361         KConfigGroup contextGroup;
 362
 363         if (context->uniqueName() == "default")
 364             {
 365             contextGroup = configGroup;
 366             // Write the friendly name
 367             contextGroup.writeEntry("_k_friendly_name", friendlyName());
 368             }
 369         else
 370             {
 371             contextGroup = KConfigGroup(&configGroup, context->uniqueName());
 372             // Write the friendly name
 373             contextGroup.writeEntry("_k_friendly_name", context->friendlyName());
 374             }
 375
 376         // kDebug() << "writing group " << _uniqueName << ":" << context->uniqueName();
 377
 378         Q_FOREACH(const GlobalShortcut *shortcut, context->_actions)
 379             {
 380             // kDebug() << "writing" << shortcut->uniqueName();
 381
 382             // We do not write fresh shortcuts.
 383             // We do not write session shortcuts
 384             if (shortcut->isFresh() || shortcut->isSessionShortcut())
 385                 {
 386                 continue;
 387                 }
 388             // kDebug() << "really writing" << shortcut->uniqueName();
 389
 390             QStringList entry(stringFromKeys(shortcut->keys()));
 391             entry.append(stringFromKeys(shortcut->defaultKeys()));
 392             entry.append(shortcut->friendlyName());
 393
 394             contextGroup.writeEntry(shortcut->uniqueName(), entry);
 395             }
 396         }
 397     }
 398
 399 #include "moc_component.cpp"
 400
 401 } // namespace KdeDGlobalAccel
 402