runtime/kdedglobalaccel/globalshortcut.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 "globalshortcut.h"
  20
  21 #include "component.h"
  22 #include "globalshortcutcontext.h"
  23 #include "globalshortcutsregistry.h"
  24
  25 #include <kdebug.h>
  26
  27 #include <QtGui/QKeySequence>
  28
  29
  30 GlobalShortcut::GlobalShortcut()
  31         :   _isPresent(false)
  32             ,_isRegistered(false)
  33             ,_isFresh(true)
  34             ,_context(NULL)
  35             ,_uniqueName()
  36             ,_friendlyName()
  37             ,_keys()
  38             ,_defaultKeys()
  39     {}
  40
  41
  42 GlobalShortcut::GlobalShortcut(
  43         const QString &uniqueName,
  44         const QString &friendlyName,
  45         GlobalShortcutContext *context)
  46             :   _isPresent(false)
  47                 ,_isRegistered(false)
  48                 ,_isFresh(true)
  49                 ,_context(context)
  50                 ,_uniqueName(uniqueName)
  51                 ,_friendlyName(friendlyName)
  52                 ,_keys()
  53                 ,_defaultKeys()
  54     {
  55     context->addShortcut(this);
  56     }
  57
  58
  59 GlobalShortcut::~GlobalShortcut()
  60     {
  61     setInactive();
  62     _context->takeShortcut(this);
  63     }
  64
  65
  66 GlobalShortcut::operator KGlobalShortcutInfo () const
  67     {
  68     KGlobalShortcutInfo info;
  69     info.d->uniqueName = _uniqueName;
  70     info.d->friendlyName = _friendlyName;
  71     info.d->contextUniqueName = context()->uniqueName();
  72     info.d->contextFriendlyName = context()->friendlyName();
  73     info.d->componentUniqueName = context()->component()->uniqueName();
  74     info.d->componentFriendlyName = context()->component()->friendlyName();
  75     Q_FOREACH (int key, _keys)
  76         {
  77         info.d->keys.append(QKeySequence(key));
  78         }
  79     Q_FOREACH (int key, _defaultKeys)
  80         {
  81         info.d->defaultKeys.append(QKeySequence(key));
  82         }
  83     return info;
  84     }
  85
  86
  87 bool GlobalShortcut::isActive() const
  88     {
  89     return _isRegistered;
  90     }
  91
  92
  93 bool GlobalShortcut::isFresh() const
  94     {
  95     return _isFresh;
  96     }
  97
  98
  99 bool GlobalShortcut::isPresent() const
 100     {
 101     return _isPresent;
 102     }
 103
 104
 105 bool GlobalShortcut::isSessionShortcut() const
 106     {
 107     return uniqueName().startsWith("_k_session:");
 108     }
 109
 110
 111 void GlobalShortcut::setIsFresh(bool value)
 112     {
 113     _isFresh = value;
 114     }
 115
 116
 117 void GlobalShortcut::setIsPresent(bool value)
 118     {
 119     // (de)activate depending on old/new value
 120     _isPresent = value;
 121     value
 122         ? setActive()
 123         : setInactive();
 124     }
 125
 126
 127 GlobalShortcutContext *GlobalShortcut::context()
 128     {
 129     return _context;
 130     }
 131
 132
 133 GlobalShortcutContext const *GlobalShortcut::context() const
 134     {
 135     return _context;
 136     }
 137
 138
 139 QString GlobalShortcut::uniqueName() const
 140     {
 141     return _uniqueName;
 142     }
 143
 144
 145 QString GlobalShortcut::friendlyName() const
 146     {
 147     return _friendlyName;
 148     }
 149
 150
 151 void GlobalShortcut::setFriendlyName(const QString &name)
 152     {
 153     _friendlyName = name;
 154     }
 155
 156
 157 QList<int> GlobalShortcut::keys() const
 158     {
 159     return _keys;
 160     }
 161
 162
 163 void GlobalShortcut::setKeys(const QList<int> newKeys)
 164     {
 165     bool active = _isRegistered;
 166     if (active)
 167         {
 168         setInactive();
 169         }
 170
 171     _keys = QList<int>();
 172
 173     Q_FOREACH(int key, newKeys)
 174         {
 175         if (key!=0 && !GlobalShortcutsRegistry::self()->getShortcutByKey(key))
 176             {
 177             _keys.append(key);
 178             }
 179         else
 180             {
 181             kDebug() << _uniqueName << "skipping because key" << QKeySequence(key).toString() << "is already taken";
 182             _keys.append(0);
 183             }
 184         }
 185
 186     if (active)
 187         {
 188         setActive();
 189         }
 190     }
 191
 192
 193 QList<int> GlobalShortcut::defaultKeys() const
 194     {
 195     return _defaultKeys;
 196     }
 197
 198
 199 void GlobalShortcut::setDefaultKeys(const QList<int> newKeys)
 200     {
 201     _defaultKeys = newKeys;
 202     }
 203
 204
 205 void GlobalShortcut::setActive()
 206     {
 207     if (!_isPresent || _isRegistered)
 208         {
 209         // The corresponding application is not present or the keys are
 210         // already grabbed
 211         return;
 212         }
 213
 214     Q_FOREACH( int key, _keys)
 215         {
 216         if (key != 0 && !GlobalShortcutsRegistry::self()->registerKey(key, this))
 217             {
 218             kDebug() << uniqueName() << ": Failed to register " << QKeySequence(key).toString();
 219             }
 220         }
 221
 222     _isRegistered = true;
 223     }
 224
 225
 226 void GlobalShortcut::setInactive()
 227     {
 228     if (!_isRegistered)
 229         {
 230         // The keys are not grabbed currently
 231         return;
 232         }
 233
 234     Q_FOREACH( int key, _keys)
 235         {
 236         if (key != 0 && !GlobalShortcutsRegistry::self()->unregisterKey(key, this))
 237             {
 238             kDebug() << uniqueName() << ": Failed to unregister " << QKeySequence(key).toString();
 239             }
 240         }
 241
 242     _isRegistered = false;
 243     }
 244