You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
lxqt-globalkeys-packaging/config/actions.cpp

681 lines
21 KiB

/* BEGIN_COMMON_COPYRIGHT_HEADER
* (c)LGPL2+
*
* LXDE-Qt - a lightweight, Qt based, desktop toolset
* http://razor-qt.org
*
* Copyright: 2013 Razor team
* Authors:
* Kuzma Shapran <kuzma.shapran@gmail.com>
*
* This program or library is free software; you can redistribute it
* and/or modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA
*
* END_COMMON_COPYRIGHT_HEADER */
#include "actions.h"
#include "org.lxqt.global_key_shortcuts.daemon.h"
Actions::Actions(QObject *parent)
: QObject(parent)
, mServiceWatcher(new QDBusServiceWatcher("org.lxqt.global_key_shortcuts", QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForOwnerChange, this))
, mMultipleActionsBehaviour(MULTIPLE_ACTIONS_BEHAVIOUR_FIRST)
{
connect(mServiceWatcher, SIGNAL(serviceUnregistered(QString)), this, SLOT(on_daemonDisappeared(QString)));
connect(mServiceWatcher, SIGNAL(serviceRegistered(QString)), this, SLOT(on_daemonAppeared(QString)));
mDaemonProxy = new org::lxqt::global_key_shortcuts::daemon("org.lxqt.global_key_shortcuts", "/daemon", QDBusConnection::sessionBus(), this);
connect(mDaemonProxy, SIGNAL(actionAdded(qulonglong)), this, SLOT(on_actionAdded(qulonglong)));
connect(mDaemonProxy, SIGNAL(actionEnabled(qulonglong, bool)), this, SLOT(on_actionEnabled(qulonglong, bool)));
connect(mDaemonProxy, SIGNAL(clientActionSenderChanged(qulonglong, QString)), this, SLOT(on_clientActionSenderChanged(qulonglong, QString)));
connect(mDaemonProxy, SIGNAL(actionModified(qulonglong)), this, SLOT(on_actionModified(qulonglong)));
connect(mDaemonProxy, SIGNAL(actionRemoved(qulonglong)), this, SLOT(on_actionRemoved(qulonglong)));
connect(mDaemonProxy, SIGNAL(actionShortcutChanged(qulonglong)), this, SLOT(on_actionShortcutChanged(qulonglong)));
connect(mDaemonProxy, SIGNAL(actionsSwapped(qulonglong, qulonglong)), this, SLOT(on_actionsSwapped(qulonglong, qulonglong)));
connect(mDaemonProxy, SIGNAL(multipleActionsBehaviourChanged(uint)), this, SLOT(on_multipleActionsBehaviourChanged(uint)));
QTimer::singleShot(0, this, SLOT(delayedInit()));
}
Actions::~Actions()
{
}
void Actions::delayedInit()
{
if (mDaemonProxy->isValid())
{
on_daemonAppeared(QString());
}
}
void Actions::on_daemonDisappeared(const QString &)
{
clear();
emit daemonDisappeared();
}
void Actions::on_daemonAppeared(const QString &)
{
init();
emit daemonAppeared();
}
void Actions::init()
{
clear();
mGeneralActionInfo = getAllActions();
GeneralActionInfos::const_iterator M = mGeneralActionInfo.constEnd();
for (GeneralActionInfos::const_iterator I = mGeneralActionInfo.constBegin(); I != M; ++I)
{
if (I.value().type == "client")
{
QString shortcut;
QString description;
bool enabled;
QDBusObjectPath path;
if (getClientActionInfoById(I.key(), shortcut, description, enabled, path))
{
ClientActionInfo info;
info.shortcut = shortcut;
info.description = description;
info.enabled = enabled;
info.path = path;
mClientActionInfo[I.key()] = info;
updateClientActionSender(I.key());
}
}
else if (I.value().type == "method")
{
QString shortcut;
QString description;
bool enabled;
QString service;
QDBusObjectPath path;
QString interface;
QString method;
if (getMethodActionInfoById(I.key(), shortcut, description, enabled, service, path, interface, method))
{
MethodActionInfo info;
info.shortcut = shortcut;
info.description = description;
info.enabled = enabled;
info.service = service;
info.path = path;
info.interface = interface;
info.method = method;
mMethodActionInfo[I.key()] = info;
}
}
else if (I.value().type == "command")
{
QString shortcut;
QString description;
bool enabled;
QString command;
QStringList arguments;
if (getCommandActionInfoById(I.key(), shortcut, description, enabled, command, arguments))
{
CommandActionInfo info;
info.shortcut = shortcut;
info.description = description;
info.enabled = enabled;
info.command = command;
info.arguments = arguments;
mCommandActionInfo[I.key()] = info;
}
}
}
mMultipleActionsBehaviour = static_cast<MultipleActionsBehaviour>(getMultipleActionsBehaviour());
}
void Actions::clear()
{
mGeneralActionInfo.clear();
mClientActionInfo.clear();
mMethodActionInfo.clear();
mCommandActionInfo.clear();
mMultipleActionsBehaviour = MULTIPLE_ACTIONS_BEHAVIOUR_FIRST;
}
QList<qulonglong> Actions::allActionIds() const
{
return mGeneralActionInfo.keys();
}
QPair<bool, GeneralActionInfo> Actions::actionById(qulonglong id) const
{
GeneralActionInfos::const_iterator I = mGeneralActionInfo.constFind(id);
if (I == mGeneralActionInfo.constEnd())
{
return qMakePair(false, GeneralActionInfo());
}
return qMakePair(true, I.value());
}
QList<qulonglong> Actions::allClientActionIds() const
{
return mClientActionInfo.keys();
}
QPair<bool, ClientActionInfo> Actions::clientActionInfoById(qulonglong id) const
{
ClientActionInfos::const_iterator I = mClientActionInfo.constFind(id);
if (I == mClientActionInfo.constEnd())
{
return qMakePair(false, ClientActionInfo());
}
return qMakePair(true, I.value());
}
QList<qulonglong> Actions::allMethodActionIds() const
{
return mMethodActionInfo.keys();
}
QPair<bool, MethodActionInfo> Actions::methodActionInfoById(qulonglong id) const
{
MethodActionInfos::const_iterator I = mMethodActionInfo.constFind(id);
if (I == mMethodActionInfo.constEnd())
{
return qMakePair(false, MethodActionInfo());
}
return qMakePair(true, I.value());
}
QList<qulonglong> Actions::allCommandActionIds() const
{
return mCommandActionInfo.keys();
}
QPair<bool, CommandActionInfo> Actions::commandActionInfoById(qulonglong id) const
{
CommandActionInfos::const_iterator I = mCommandActionInfo.constFind(id);
if (I == mCommandActionInfo.constEnd())
{
return qMakePair(false, CommandActionInfo());
}
return qMakePair(true, I.value());
}
MultipleActionsBehaviour Actions::multipleActionsBehaviour() const
{
return mMultipleActionsBehaviour;
}
void Actions::do_actionAdded(qulonglong id)
{
QString shortcut;
QString description;
bool enabled;
QString type;
QString info;
if (getActionById(id, shortcut, description, enabled, type, info))
{
GeneralActionInfo generalActionInfo;
generalActionInfo.shortcut = shortcut;
generalActionInfo.description = description;
generalActionInfo.enabled = enabled;
generalActionInfo.type = type;
generalActionInfo.info = info;
mGeneralActionInfo[id] = generalActionInfo;
}
if (type == "client")
{
QDBusObjectPath path;
if (getClientActionInfoById(id, shortcut, description, enabled, path))
{
ClientActionInfo clientActionInfo;
clientActionInfo.shortcut = shortcut;
clientActionInfo.description = description;
clientActionInfo.enabled = enabled;
clientActionInfo.path = path;
mClientActionInfo[id] = clientActionInfo;
}
}
else if (type == "method")
{
QString service;
QDBusObjectPath path;
QString interface;
QString method;
if (getMethodActionInfoById(id, shortcut, description, enabled, service, path, interface, method))
{
MethodActionInfo methodActionInfo;
methodActionInfo.shortcut = shortcut;
methodActionInfo.description = description;
methodActionInfo.enabled = enabled;
methodActionInfo.service = service;
methodActionInfo.path = path;
methodActionInfo.interface = interface;
methodActionInfo.method = method;
mMethodActionInfo[id] = methodActionInfo;
}
}
else if (type == "command")
{
QString command;
QStringList arguments;
if (getCommandActionInfoById(id, shortcut, description, enabled, command, arguments))
{
CommandActionInfo commandActionInfo;
commandActionInfo.shortcut = shortcut;
commandActionInfo.description = description;
commandActionInfo.enabled = enabled;
commandActionInfo.command = command;
commandActionInfo.arguments = arguments;
mCommandActionInfo[id] = commandActionInfo;
}
}
}
void Actions::on_actionAdded(qulonglong id)
{
do_actionAdded(id);
emit actionAdded(id);
}
void Actions::on_actionEnabled(qulonglong id, bool enabled)
{
GeneralActionInfos::iterator GI = mGeneralActionInfo.find(id);
if (GI != mGeneralActionInfo.end())
{
GI.value().enabled = enabled;
if (GI.value().type == "client")
{
ClientActionInfos::iterator DI = mClientActionInfo.find(id);
if (DI != mClientActionInfo.end())
{
DI.value().enabled = enabled;
}
}
else if (GI.value().type == "method")
{
MethodActionInfos::iterator MI = mMethodActionInfo.find(id);
if (MI != mMethodActionInfo.end())
{
MI.value().enabled = enabled;
}
}
else if (GI.value().type == "command")
{
CommandActionInfos::iterator CI = mCommandActionInfo.find(id);
if (CI != mCommandActionInfo.end())
{
CI.value().enabled = enabled;
}
}
}
emit actionEnabled(id, enabled);
}
void Actions::on_clientActionSenderChanged(qulonglong id, const QString &sender)
{
mClientActionSenders[id] = sender;
emit actionModified(id);
}
void Actions::on_actionModified(qulonglong id)
{
do_actionAdded(id);
emit actionModified(id);
}
void Actions::on_actionShortcutChanged(qulonglong id)
{
do_actionAdded(id);
emit actionModified(id);
}
void Actions::on_actionsSwapped(qulonglong id1, qulonglong id2)
{
GeneralActionInfos::iterator GI1 = mGeneralActionInfo.find(id1);
GeneralActionInfos::iterator GI2 = mGeneralActionInfo.find(id2);
if ((GI1 != mGeneralActionInfo.end()) && (GI2 != mGeneralActionInfo.end()))
{
bool swapped = false;
if (GI1.value().type == GI2.value().type)
{
if (GI1.value().type == "client")
{
ClientActionInfos::iterator DI1 = mClientActionInfo.find(id1);
ClientActionInfos::iterator DI2 = mClientActionInfo.find(id2);
if ((DI1 != mClientActionInfo.end()) && (DI2 != mClientActionInfo.end()))
{
ClientActionInfo clientActionInfo = DI1.value();
DI1.value() = DI2.value();
DI2.value() = clientActionInfo;
swapped = true;
}
}
else if (GI1.value().type == "method")
{
MethodActionInfos::iterator MI1 = mMethodActionInfo.find(id1);
MethodActionInfos::iterator MI2 = mMethodActionInfo.find(id2);
if ((MI1 != mMethodActionInfo.end()) && (MI2 != mMethodActionInfo.end()))
{
MethodActionInfo methodActionInfo = MI1.value();
MI1.value() = MI2.value();
MI2.value() = methodActionInfo;
swapped = true;
}
}
else if (GI1.value().type == "command")
{
CommandActionInfos::iterator CI1 = mCommandActionInfo.find(id1);
CommandActionInfos::iterator CI2 = mCommandActionInfo.find(id2);
if ((CI1 != mCommandActionInfo.end()) && (CI2 != mCommandActionInfo.end()))
{
CommandActionInfo commandActionInfo = CI1.value();
CI1.value() = CI2.value();
CI2.value() = commandActionInfo;
swapped = true;
}
}
}
if (swapped)
{
GeneralActionInfo generalActionInfo = GI1.value();
GI1.value() = GI2.value();
GI2.value() = generalActionInfo;
}
else
{
do_actionRemoved(id1);
do_actionRemoved(id2);
do_actionAdded(id1);
do_actionAdded(id2);
}
}
emit actionsSwapped(id1, id2);
}
void Actions::do_actionRemoved(qulonglong id)
{
mGeneralActionInfo.remove(id);
mClientActionInfo.remove(id);
mMethodActionInfo.remove(id);
mCommandActionInfo.remove(id);
}
void Actions::on_actionRemoved(qulonglong id)
{
do_actionRemoved(id);
emit actionRemoved(id);
}
void Actions::on_multipleActionsBehaviourChanged(uint behaviour)
{
mMultipleActionsBehaviour = static_cast<MultipleActionsBehaviour>(behaviour);
emit multipleActionsBehaviourChanged(mMultipleActionsBehaviour);
}
bool Actions::getClientActionInfoById(qulonglong id, QString &shortcut, QString &description, bool &enabled, QDBusObjectPath &path)
{
return mDaemonProxy->getClientActionInfoById(id, shortcut, description, enabled, path);
}
bool Actions::getMethodActionInfoById(qulonglong id, QString &shortcut, QString &description, bool &enabled, QString &service, QDBusObjectPath &path, QString &interface, QString &method)
{
return mDaemonProxy->getMethodActionInfoById(id, shortcut, description, enabled, service, path, interface, method);
}
bool Actions::getCommandActionInfoById(qulonglong id, QString &shortcut, QString &description, bool &enabled, QString &command, QStringList &arguments)
{
return mDaemonProxy->getCommandActionInfoById(id, shortcut, description, enabled, command, arguments);
}
QList<qulonglong> Actions::getAllActionIds()
{
QDBusPendingReply<QList<qulonglong> > reply = mDaemonProxy->getAllActionIds();
reply.waitForFinished();
if (reply.isError())
{
return QList<qulonglong>();
}
return reply.argumentAt<0>();
}
bool Actions::getActionById(qulonglong id, QString &shortcut, QString &description, bool &enabled, QString &type, QString &info)
{
return mDaemonProxy->getActionById(id, shortcut, description, enabled, type, info);
}
QMap<qulonglong, GeneralActionInfo> Actions::getAllActions()
{
QDBusPendingReply<QMap<qulonglong, GeneralActionInfo> > reply = mDaemonProxy->getAllActions();
reply.waitForFinished();
if (reply.isError())
{
return QMap<qulonglong, GeneralActionInfo>();
}
return reply.argumentAt<0>();
}
uint Actions::getMultipleActionsBehaviour()
{
QDBusPendingReply<uint> reply = mDaemonProxy->getMultipleActionsBehaviour();
reply.waitForFinished();
if (reply.isError())
{
return 0;
}
return reply.argumentAt<0>();
}
QPair<QString, qulonglong> Actions::addMethodAction(const QString &shortcut, const QString &service, const QDBusObjectPath &path, const QString &interface, const QString &method, const QString &description)
{
QDBusPendingReply<QString, qulonglong> reply = mDaemonProxy->addMethodAction(shortcut, service, path, interface, method, description);
reply.waitForFinished();
if (reply.isError())
{
return qMakePair<QString, qulonglong>(QString(), 0ull);
}
return qMakePair<QString, qulonglong>(reply.argumentAt<0>(), reply.argumentAt<1>());
}
QPair<QString, qulonglong> Actions::addCommandAction(const QString &shortcut, const QString &command, const QStringList &arguments, const QString &description)
{
QDBusPendingReply<QString, qulonglong> reply = mDaemonProxy->addCommandAction(shortcut, command, arguments, description);
reply.waitForFinished();
if (reply.isError())
{
return qMakePair<QString, qulonglong>(QString(), 0ull);
}
return qMakePair<QString, qulonglong>(reply.argumentAt<0>(), reply.argumentAt<1>());
}
bool Actions::modifyActionDescription(const qulonglong &id, const QString &description)
{
QDBusPendingReply<bool> reply = mDaemonProxy->modifyActionDescription(id, description);
reply.waitForFinished();
if (reply.isError())
{
return false;
}
return reply.argumentAt<0>();
}
bool Actions::modifyMethodAction(const qulonglong &id, const QString &service, const QDBusObjectPath &path, const QString &interface, const QString &method, const QString &description)
{
QDBusPendingReply<bool> reply = mDaemonProxy->modifyMethodAction(id, service, path, interface, method, description);
reply.waitForFinished();
if (reply.isError())
{
return false;
}
return reply.argumentAt<0>();
}
bool Actions::modifyCommandAction(const qulonglong &id, const QString &command, const QStringList &arguments, const QString &description)
{
QDBusPendingReply<bool> reply = mDaemonProxy->modifyCommandAction(id, command, arguments, description);
reply.waitForFinished();
if (reply.isError())
{
return false;
}
return reply.argumentAt<0>();
}
bool Actions::enableAction(qulonglong id, bool enabled)
{
QDBusPendingReply<bool> reply = mDaemonProxy->enableAction(id, enabled);
reply.waitForFinished();
if (reply.isError())
{
return false;
}
return reply.argumentAt<0>();
}
bool Actions::isActionEnabled(qulonglong id)
{
QDBusPendingReply<bool> reply = mDaemonProxy->isActionEnabled(id);
reply.waitForFinished();
if (reply.isError())
{
return false;
}
return reply.argumentAt<0>();
}
QString Actions::getClientActionSender(qulonglong id)
{
return mClientActionSenders[id];
}
QString Actions::updateClientActionSender(qulonglong id)
{
QDBusPendingReply<QString> reply = mDaemonProxy->getClientActionSender(id);
reply.waitForFinished();
if (reply.isError())
{
return QString();
}
QString sender = reply.argumentAt<0>();
mClientActionSenders[id] = sender;
return sender;
}
QString Actions::changeShortcut(const qulonglong &id, const QString &shortcut)
{
QDBusPendingReply<QString> reply = mDaemonProxy->changeShortcut(id, shortcut);
reply.waitForFinished();
if (reply.isError())
{
return QString();
}
return reply.argumentAt<0>();
}
bool Actions::swapActions(const qulonglong &id1, const qulonglong &id2)
{
QDBusPendingReply<bool> reply = mDaemonProxy->swapActions(id1, id2);
reply.waitForFinished();
if (reply.isError())
{
return false;
}
return reply.argumentAt<0>();
}
bool Actions::removeAction(const qulonglong &id)
{
QDBusPendingReply<bool> reply = mDaemonProxy->removeAction(id);
reply.waitForFinished();
if (reply.isError())
{
return false;
}
return reply.argumentAt<0>();
}
void Actions::setMultipleActionsBehaviour(const MultipleActionsBehaviour &behaviour)
{
QDBusPendingReply<bool> reply = mDaemonProxy->setMultipleActionsBehaviour(behaviour);
reply.waitForFinished();
}
void Actions::grabShortcut(uint timeout)
{
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(mDaemonProxy->grabShortcut(timeout), this);
connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher *)), this, SLOT(grabShortcutFinished(QDBusPendingCallWatcher *)));
}
void Actions::cancelShortcutGrab()
{
mDaemonProxy->cancelShortcutGrab();
}
void Actions::grabShortcutFinished(QDBusPendingCallWatcher *call)
{
QDBusPendingReply<QString, bool, bool, bool> reply = *call;
if (reply.isError())
{
emit grabShortcutFailed();
}
else
{
if (reply.argumentAt<1>())
{
emit grabShortcutFailed();
}
else
{
if (reply.argumentAt<2>())
{
emit grabShortcutCancelled();
}
else
{
if (reply.argumentAt<3>())
{
emit grabShortcutTimedout();
}
else
{
emit shortcutGrabbed(reply.argumentAt<0>());
}
}
}
}
call->deleteLater();
}