File indexing completed on 2024-04-28 15:22:24

 /*
     SPDX-FileCopyrightText: 2008 Michael Jansen <kde@michael-jansen.biz>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "globalshortcut.h"
 
 #include "kglobalshortcutinfo_p.h"
 
 #include "component.h"
 #include "globalshortcutcontext.h"
 #include "globalshortcutsregistry.h"
 #include "logging_p.h"
 
 #include <QKeySequence>
 
 GlobalShortcut::GlobalShortcut()
     : GlobalShortcut(QString{}, QString{}, nullptr)
 {
 }
 
 GlobalShortcut::GlobalShortcut(const QString &uniqueName, const QString &friendlyName, GlobalShortcutContext *context)
     : _isPresent(false)
     , _isRegistered(false)
     , _isFresh(true)
     , _registry(GlobalShortcutsRegistry::self())
     , _context(context)
     , _uniqueName(uniqueName)
     , _friendlyName(friendlyName)
 {
     if (_context) {
         _context->addShortcut(this);
     }
 }
 
 GlobalShortcut::~GlobalShortcut()
 {
     setInactive();
 }
 
 GlobalShortcut::operator KGlobalShortcutInfo() const
 {
     KGlobalShortcutInfo info;
     info.d->uniqueName = _uniqueName;
     info.d->friendlyName = _friendlyName;
     info.d->contextUniqueName = context()->uniqueName();
     info.d->contextFriendlyName = context()->friendlyName();
     info.d->componentUniqueName = context()->component()->uniqueName();
     info.d->componentFriendlyName = context()->component()->friendlyName();
     for (const QKeySequence &key : std::as_const(_keys)) {
         info.d->keys.append(key);
     }
     for (const QKeySequence &key : std::as_const(_defaultKeys)) {
         info.d->defaultKeys.append(key);
     }
     return info;
 }
 
 bool GlobalShortcut::isActive() const
 {
     return _isRegistered;
 }
 
 bool GlobalShortcut::isFresh() const
 {
     return _isFresh;
 }
 
 bool GlobalShortcut::isPresent() const
 {
     return _isPresent;
 }
 
 bool GlobalShortcut::isSessionShortcut() const
 {
     return uniqueName().startsWith(QLatin1String("_k_session:"));
 }
 
 void GlobalShortcut::setIsFresh(bool value)
 {
     _isFresh = value;
 }
 
 void GlobalShortcut::setIsPresent(bool value)
 {
     // (de)activate depending on old/new value
     _isPresent = value;
     if (_isPresent) {
         setActive();
     } else {
         setInactive();
     }
 }
 
 GlobalShortcutContext *GlobalShortcut::context()
 {
     return _context;
 }
 
 GlobalShortcutContext const *GlobalShortcut::context() const
 {
     return _context;
 }
 
 QString GlobalShortcut::uniqueName() const
 {
     return _uniqueName;
 }
 
 void GlobalShortcut::unRegister()
 {
     return _context->component()->unregisterShortcut(uniqueName());
 }
 
 QString GlobalShortcut::friendlyName() const
 {
     return _friendlyName;
 }
 
 void GlobalShortcut::setFriendlyName(const QString &name)
 {
     _friendlyName = name;
 }
 
 QList<QKeySequence> GlobalShortcut::keys() const
 {
     return _keys;
 }
 
 void GlobalShortcut::setKeys(const QList<QKeySequence> &newKeys)
 {
     bool active = _isRegistered;
     if (active) {
         setInactive();
     }
 
     _keys.clear();
 
     auto getKey = [this](const QKeySequence &key) {
         if (key.isEmpty()) {
             qCDebug(KGLOBALACCELD) << _uniqueName << "skipping because key is empty";
             return QKeySequence{};
         }
 
         if (_registry->getShortcutByKey(key) //
             || _registry->getShortcutByKey(key, KGlobalAccel::MatchType::Shadowed) //
             || _registry->getShortcutByKey(key, KGlobalAccel::MatchType::Shadows) //
         ) {
             qCDebug(KGLOBALACCELD) << _uniqueName << "skipping because key" << QKeySequence(key).toString() << "is already taken";
             return QKeySequence{};
         }
 
         return key;
     };
 
     std::transform(newKeys.cbegin(), newKeys.cend(), std::back_inserter(_keys), getKey);
 
     if (active) {
         setActive();
     }
 }
 
 QList<QKeySequence> GlobalShortcut::defaultKeys() const
 {
     return _defaultKeys;
 }
 
 void GlobalShortcut::setDefaultKeys(const QList<QKeySequence> &newKeys)
 {
     _defaultKeys = newKeys;
 }
 
 void GlobalShortcut::setActive()
 {
     if (!_isPresent || _isRegistered) {
         // The corresponding application is not present or the keys are
         // already grabbed
         return;
     }
 
     for (const QKeySequence &key : std::as_const(_keys)) {
         if (!key.isEmpty() && !_registry->registerKey(key, this)) {
             qCDebug(KGLOBALACCELD) << uniqueName() << ": Failed to register " << QKeySequence(key).toString();
         }
     }
 
     _isRegistered = true;
 }
 
 void GlobalShortcut::setInactive()
 {
     if (!_isRegistered) {
         // The keys are not grabbed currently
         return;
     }
 
     for (const QKeySequence &key : std::as_const(_keys)) {
         if (!key.isEmpty() && !_registry->unregisterKey(key, this)) {
             qCDebug(KGLOBALACCELD) << uniqueName() << ": Failed to unregister " << QKeySequence(key).toString();
         }
     }
 
     _isRegistered = false;
 }