feat: 增加任务栏的AM接口

增加任务栏的AM接口的访问模块

Log:
Influence: 任务栏
Task: https://pms.uniontech.com/task-view-133075.html
Change-Id: Ic5570bbae6fa4ff3ecc3d529b49200f7bcb1d63c
This commit is contained in:
donghualin 2022-06-22 10:06:16 +08:00
parent 7b31b5e107
commit 241dd68d30
7 changed files with 1346 additions and 1 deletions

3
debian/rules vendored
View File

@ -12,4 +12,5 @@ DEB_HOST_MULTIARCH ?= $(shell dpkg-architecture -qDEB_HOST_MULTIARCH)
override_dh_auto_configure:
dh_auto_configure -- \
-DHOST_MULTIARCH="$(DEB_HOST_MULTIARCH)"
-DHOST_MULTIARCH="$(DEB_HOST_MULTIARCH)" \
-DUSE_AM=YES

View File

@ -0,0 +1,378 @@
/*
* Copyright (C) 2022 ~ 2022 Deepin Technology Co., Ltd.
*
* Author: donghualin <donghualin@uniontech.com>
*
* Maintainer: donghualin <donghualin@uniontech.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "dockinterface.h"
#ifdef USE_AM
// 因为 types/dockrect.h 文件中定义了DockRect类而在此处也定义了DockRect
// 所以在此处先加上DOCKRECT_H宏(types/dockrect.h文件中定义的宏)来禁止包含types/dockrect.h头文件
// 否则会出现重复定义的错误
#define DOCKRECT_H
#include <com_deepin_dde_daemon_dock.h>
DockRect::DockRect()
: x(0)
, y(0)
, w(0)
, h(0)
{
}
QDebug operator<<(QDebug debug, const DockRect &rect)
{
debug << QString("DockRect(%1, %2, %3, %4)").arg(rect.x)
.arg(rect.y)
.arg(rect.w)
.arg(rect.h);
return debug;
}
DockRect::operator QRect() const
{
return QRect(x, y, w, h);
}
QDBusArgument &operator<<(QDBusArgument &arg, const DockRect &rect)
{
arg.beginStructure();
arg << rect.x << rect.y << rect.w << rect.h;
arg.endStructure();
return arg;
}
const QDBusArgument &operator>>(const QDBusArgument &arg, DockRect &rect)
{
arg.beginStructure();
arg >> rect.x >> rect.y >> rect.w >> rect.h;
arg.endStructure();
return arg;
}
void registerDockRectMetaType()
{
qRegisterMetaType<DockRect>("DockRect");
qDBusRegisterMetaType<DockRect>();
}
/*
* Implementation of interface class __Dock
*/
class DockPrivate
{
public:
DockPrivate() = default;
// begin member variables
int DisplayMode;
QStringList DockedApps;
QList<QDBusObjectPath> Entries;
DockRect FrontendWindowRect;
int HideMode;
int HideState;
uint HideTimeout;
uint IconSize;
double Opacity;
int Position;
uint ShowTimeout;
uint WindowSize;
uint WindowSizeEfficient;
uint WindowSizeFashion;
public:
QMap<QString, QDBusPendingCallWatcher *> m_processingCalls;
QMap<QString, QList<QVariant>> m_waittingCalls;
};
// 窗管中提供的ActiveWindow接口MinimizeWindow目前还在开发过程中因此关于这两个接口暂时使用v23的后端接口
// 等窗管完成了这几个接口后删除此处v20的接口改成v23提供的新接口即可
using DockInter = com::deepin::dde::daemon::Dock;
/**
* @brief DBUS接口是通过窗管获取的AM后端并未提供窗管的相关接口
* 使
*/
class WM : public QDBusAbstractInterface
{
public:
static inline const char *staticInterfaceName()
{ return "com.deepin.wm"; }
public:
explicit WM(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = Q_NULLPTR);
~WM();
public Q_SLOTS: // METHODS
inline QDBusPendingReply<> ActivateWindow(uint in0)
{
return m_dockInter->ActivateWindow(in0);
}
QDBusPendingReply<> MinimizeWindow(uint in0)
{
return m_dockInter->MinimizeWindow(in0);
}
inline QDBusPendingReply<> CancelPreviewWindow()
{
return asyncCallWithArgumentList(QStringLiteral("CancelPreviewWindow"), QList<QVariant>());
}
inline QDBusPendingReply<> PreviewWindow(uint in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
return asyncCallWithArgumentList(QStringLiteral("CancelPreviewWindow"), argumentList);
}
private:
DockInter *m_dockInter;
};
WM::WM(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent)
: QDBusAbstractInterface(service, path, staticInterfaceName(), connection, parent)
, m_dockInter(new DockInter("com.deepin.dde.daemon.Dock", "/com/deepin/dde/daemon/Dock", QDBusConnection::sessionBus(), this))
{
}
WM::~WM()
{
}
Dde_Dock::Dde_Dock(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent)
: QDBusAbstractInterface(service, path, staticInterfaceName(), connection, parent)
, d_ptr(new DockPrivate)
, m_wm(new WM("com.deepin.wm", "/com/deepin/wm", QDBusConnection::sessionBus(), this))
{
QDBusConnection::sessionBus().connect(this->service(), this->path(),
"org.freedesktop.DBus.Properties",
"PropertiesChanged","sa{sv}as",
this,
SLOT(onPropertyChanged(const QDBusMessage &)));
if (QMetaType::type("DockRect") == QMetaType::UnknownType)
registerDockRectMetaType();
}
Dde_Dock::~Dde_Dock()
{
qDeleteAll(d_ptr->m_processingCalls.values());
delete d_ptr;
}
void Dde_Dock::onPropertyChanged(const QDBusMessage& msg)
{
QList<QVariant> arguments = msg.arguments();
if (3 != arguments.count())
return;
QString interfaceName = msg.arguments().at(0).toString();
if (interfaceName != staticInterfaceName())
return;
QVariantMap changedProps = qdbus_cast<QVariantMap>(arguments.at(1).value<QDBusArgument>());
QStringList keys = changedProps.keys();
foreach(const QString &prop, keys) {
const QMetaObject* self = metaObject();
for (int i=self->propertyOffset(); i < self->propertyCount(); ++i) {
QMetaProperty p = self->property(i);
if (p.name() == prop)
Q_EMIT p.notifySignal().invoke(this);
}
}
}
int Dde_Dock::displayMode()
{
return qvariant_cast<int>(property("DisplayMode"));
}
void Dde_Dock::setDisplayMode(int value)
{
setProperty("DisplayMode", QVariant::fromValue(value));
}
QStringList Dde_Dock::dockedApps()
{
return qvariant_cast<QStringList>(property("DockedApps"));
}
QList<QDBusObjectPath> Dde_Dock::entries()
{
return qvariant_cast<QList<QDBusObjectPath>>(property("Entries"));
}
DockRect Dde_Dock::frontendWindowRect()
{
return qvariant_cast<DockRect>(property("FrontendWindowRect"));
}
int Dde_Dock::hideMode()
{
return qvariant_cast<int>(property("HideMode"));
}
void Dde_Dock::setHideMode(int value)
{
internalPropSet("HideMode", QVariant::fromValue(value));
}
int Dde_Dock::hideState()
{
return qvariant_cast<int>(property("HideState"));
}
uint Dde_Dock::hideTimeout()
{
return qvariant_cast<uint>(property("HideTimeout"));
}
void Dde_Dock::setHideTimeout(uint value)
{
setProperty("HideTimeout", QVariant::fromValue(value));
}
uint Dde_Dock::iconSize()
{
return qvariant_cast<uint>(property("IconSize"));
}
void Dde_Dock::setIconSize(uint value)
{
setProperty("IconSize", QVariant::fromValue(value));
}
double Dde_Dock::opacity()
{
return qvariant_cast<double>(property("Opacity"));
}
void Dde_Dock::setOpacity(double value)
{
setProperty("Opacity", QVariant::fromValue(value));
}
int Dde_Dock::position()
{
return qvariant_cast<int>(property("Position"));
}
void Dde_Dock::setPosition(int value)
{
setProperty("Position", QVariant::fromValue(value));
}
uint Dde_Dock::showTimeout()
{
return qvariant_cast<uint>(property("ShowTimeout"));
}
void Dde_Dock::setShowTimeout(uint value)
{
setProperty("ShowTimeout", QVariant::fromValue(value));
}
uint Dde_Dock::windowSize()
{
return qvariant_cast<uint>(property("WindowSize"));
}
void Dde_Dock::setWindowSize(uint value)
{
setProperty("WindowSize", QVariant::fromValue(value));
}
uint Dde_Dock::windowSizeEfficient()
{
return qvariant_cast<uint>(property("WindowSizeEfficient"));
}
void Dde_Dock::setWindowSizeEfficient(uint value)
{
setProperty("WindowSizeEfficient", QVariant::fromValue(value));
}
uint Dde_Dock::windowSizeFashion()
{
return qvariant_cast<uint>(property("WindowSizeFashion"));
}
void Dde_Dock::setWindowSizeFashion(uint value)
{
setProperty("WindowSizeFashion", QVariant::fromValue(value));
}
QDBusPendingReply<> Dde_Dock::ActivateWindow(uint in0)
{
return m_wm->ActivateWindow(in0);
}
QDBusPendingReply<> Dde_Dock::PreviewWindow(uint in0)
{
return m_wm->PreviewWindow(in0);
}
QDBusPendingReply<> Dde_Dock::CancelPreviewWindow()
{
return m_wm->CancelPreviewWindow();
}
QDBusPendingReply<> Dde_Dock::MinimizeWindow(uint in0)
{
return m_wm->MinimizeWindow(in0);
}
void Dde_Dock::CallQueued(const QString &callName, const QList<QVariant> &args)
{
if (d_ptr->m_waittingCalls.contains(callName)) {
d_ptr->m_waittingCalls[callName] = args;
return;
}
if (d_ptr->m_processingCalls.contains(callName)) {
d_ptr->m_waittingCalls.insert(callName, args);
} else {
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(asyncCallWithArgumentList(callName, args));
connect(watcher, &QDBusPendingCallWatcher::finished, this, &Dde_Dock::onPendingCallFinished);
d_ptr->m_processingCalls.insert(callName, watcher);
}
}
void Dde_Dock::onPendingCallFinished(QDBusPendingCallWatcher *w)
{
w->deleteLater();
const auto callName = d_ptr->m_processingCalls.key(w);
Q_ASSERT(!callName.isEmpty());
if (callName.isEmpty())
return;
d_ptr->m_processingCalls.remove(callName);
if (!d_ptr->m_waittingCalls.contains(callName))
return;
const auto args = d_ptr->m_waittingCalls.take(callName);
CallQueued(callName, args);
}
#endif

342
frame/dbus/dockinterface.h Normal file
View File

@ -0,0 +1,342 @@
/*
* Copyright (C) 2022 ~ 2022 Deepin Technology Co., Ltd.
*
* Author: donghualin <donghualin@uniontech.com>
*
* Maintainer: donghualin <donghualin@uniontech.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef DOCK_INTERFACE
#define DOCK_INTERFACE
#ifdef USE_AM
#include <QObject>
#include <QByteArray>
#include <QList>
#include <QMap>
#include <QString>
#include <QStringList>
#include <QVariant>
#include <QtDBus>
/*
* Proxy class for interface com.deepin.dde.daemon.Dock
*/
class DockPrivate;
class WM;
struct DockRect
{
public:
DockRect();
operator QRect() const;
friend QDebug operator<<(QDebug debug, const DockRect &rect);
friend const QDBusArgument &operator>>(const QDBusArgument &arg, DockRect &rect);
friend QDBusArgument &operator<<(QDBusArgument &arg, const DockRect &rect);
private:
int x;
int y;
uint w;
uint h;
};
Q_DECLARE_METATYPE(DockRect)
void registerDockRectMetaType();
class Dde_Dock : public QDBusAbstractInterface
{
Q_OBJECT
public:
static inline const char *staticInterfaceName()
{ return "org.deepin.dde.daemon.Dock1"; }
public:
explicit Dde_Dock(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = 0);
~Dde_Dock();
Q_PROPERTY(int DisplayMode READ displayMode WRITE setDisplayMode NOTIFY DisplayModeChanged)
int displayMode();
void setDisplayMode(int value);
Q_PROPERTY(QStringList DockedApps READ dockedApps NOTIFY DockedAppsChanged)
QStringList dockedApps();
Q_PROPERTY(QList<QDBusObjectPath> Entries READ entries NOTIFY EntriesChanged)
QList<QDBusObjectPath> entries();
Q_PROPERTY(DockRect FrontendWindowRect READ frontendWindowRect NOTIFY FrontendWindowRectChanged)
DockRect frontendWindowRect();
Q_PROPERTY(int HideMode READ hideMode WRITE setHideMode NOTIFY HideModeChanged)
int hideMode();
void setHideMode(int value);
Q_PROPERTY(int HideState READ hideState NOTIFY HideStateChanged)
int hideState();
Q_PROPERTY(uint HideTimeout READ hideTimeout WRITE setHideTimeout NOTIFY HideTimeoutChanged)
uint hideTimeout();
void setHideTimeout(uint value);
Q_PROPERTY(uint IconSize READ iconSize WRITE setIconSize NOTIFY IconSizeChanged)
uint iconSize();
void setIconSize(uint value);
Q_PROPERTY(double Opacity READ opacity WRITE setOpacity NOTIFY OpacityChanged)
double opacity();
void setOpacity(double value);
Q_PROPERTY(int Position READ position WRITE setPosition NOTIFY PositionChanged)
int position();
void setPosition(int value);
Q_PROPERTY(uint ShowTimeout READ showTimeout WRITE setShowTimeout NOTIFY ShowTimeoutChanged)
uint showTimeout();
void setShowTimeout(uint value);
Q_PROPERTY(uint WindowSize READ windowSize WRITE setWindowSize NOTIFY WindowSizeChanged)
uint windowSize();
void setWindowSize(uint value);
Q_PROPERTY(uint WindowSizeEfficient READ windowSizeEfficient WRITE setWindowSizeEfficient NOTIFY WindowSizeEfficientChanged)
uint windowSizeEfficient();
void setWindowSizeEfficient(uint value);
Q_PROPERTY(uint WindowSizeFashion READ windowSizeFashion WRITE setWindowSizeFashion NOTIFY WindowSizeFashionChanged)
uint windowSizeFashion();
void setWindowSizeFashion(uint value);
public Q_SLOTS: // METHODS
QDBusPendingReply<> ActivateWindow(uint in0);
QDBusPendingReply<> PreviewWindow(uint in0);
QDBusPendingReply<> CancelPreviewWindow();
QDBusPendingReply<> MinimizeWindow(uint in0);
inline void ActivateWindowQueued(uint in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
CallQueued(QStringLiteral("ActivateWindow"), argumentList);
}
inline QDBusPendingReply<> CloseWindow(uint in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
return asyncCallWithArgumentList(QStringLiteral("CloseWindow"), argumentList);
}
inline void CloseWindowQueued(uint in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
CallQueued(QStringLiteral("CloseWindow"), argumentList);
}
inline QDBusPendingReply<QStringList> GetDockedAppsDesktopFiles()
{
QList<QVariant> argumentList;
return asyncCallWithArgumentList(QStringLiteral("GetDockedAppsDesktopFiles"), argumentList);
}
inline QDBusPendingReply<QStringList> GetEntryIDs()
{
QList<QVariant> argumentList;
return asyncCallWithArgumentList(QStringLiteral("GetEntryIDs"), argumentList);
}
inline QDBusPendingReply<QString> GetPluginSettings()
{
QList<QVariant> argumentList;
return asyncCallWithArgumentList(QStringLiteral("GetPluginSettings"), argumentList);
}
inline QDBusPendingReply<bool> IsDocked(const QString &in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
return asyncCallWithArgumentList(QStringLiteral("IsDocked"), argumentList);
}
inline QDBusPendingReply<bool> IsOnDock(const QString &in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
return asyncCallWithArgumentList(QStringLiteral("IsOnDock"), argumentList);
}
inline QDBusPendingReply<> MergePluginSettings(const QString &in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
return asyncCallWithArgumentList(QStringLiteral("MergePluginSettings"), argumentList);
}
inline void MergePluginSettingsQueued(const QString &in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
CallQueued(QStringLiteral("MergePluginSettings"), argumentList);
}
inline QDBusPendingReply<> MoveEntry(int in0, int in1)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
return asyncCallWithArgumentList(QStringLiteral("MoveEntry"), argumentList);
}
inline void MoveEntryQueued(int in0, int in1)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
CallQueued(QStringLiteral("MoveEntry"), argumentList);
}
inline void MoveWindowQueued(uint in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
CallQueued(QStringLiteral("MoveWindow"), argumentList);
}
inline QDBusPendingReply<QString> QueryWindowIdentifyMethod(uint in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
return asyncCallWithArgumentList(QStringLiteral("QueryWindowIdentifyMethod"), argumentList);
}
inline QDBusPendingReply<> RemovePluginSettings(const QString &in0, const QStringList &in1)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
return asyncCallWithArgumentList(QStringLiteral("RemovePluginSettings"), argumentList);
}
inline void RemovePluginSettingsQueued(const QString &in0, const QStringList &in1)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
CallQueued(QStringLiteral("RemovePluginSettings"), argumentList);
}
inline QDBusPendingReply<bool> RequestDock(const QString &in0, int in1)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
return asyncCallWithArgumentList(QStringLiteral("RequestDock"), argumentList);
}
inline QDBusPendingReply<bool> RequestUndock(const QString &in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
return asyncCallWithArgumentList(QStringLiteral("RequestUndock"), argumentList);
}
inline QDBusPendingReply<> SetFrontendWindowRect(int in0, int in1, uint in2, uint in3)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2) << QVariant::fromValue(in3);
return asyncCallWithArgumentList(QStringLiteral("SetFrontendWindowRect"), argumentList);
}
inline void SetFrontendWindowRectQueued(int in0, int in1, uint in2, uint in3)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2) << QVariant::fromValue(in3);
CallQueued(QStringLiteral("SetFrontendWindowRect"), argumentList);
}
inline QDBusPendingReply<> SetPluginSettings(const QString &in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
return asyncCallWithArgumentList(QStringLiteral("SetPluginSettings"), argumentList);
}
inline void SetPluginSettingsQueued(const QString &in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
CallQueued(QStringLiteral("SetPluginSettings"), argumentList);
}
Q_SIGNALS: // SIGNALS
void DockAppSettingsSynced();
void EntryAdded(const QDBusObjectPath &in0, int in1);
void EntryRemoved(const QString &in0);
void PluginSettingsSynced();
void ServiceRestarted();
// begin property changed signals
void DisplayModeChanged(int value) const;
void DockedAppsChanged(const QStringList &value) const;
void EntriesChanged(const QList<QDBusObjectPath> &value) const;
void FrontendWindowRectChanged(DockRect value) const;
void HideModeChanged(int value) const;
void HideStateChanged(int value) const;
void HideTimeoutChanged(uint value) const;
void IconSizeChanged(uint value) const;
void OpacityChanged(double value) const;
void PositionChanged(int value) const;
void ShowTimeoutChanged(uint value) const;
void WindowSizeChanged(uint value) const;
void WindowSizeEfficientChanged(uint value) const;
void WindowSizeFashionChanged(uint value) const;
public Q_SLOTS:
void CallQueued(const QString &callName, const QList<QVariant> &args);
private Q_SLOTS:
void onPendingCallFinished(QDBusPendingCallWatcher *w);
void onPropertyChanged(const QDBusMessage& msg);
private:
DockPrivate *d_ptr;
WM *m_wm;
};
namespace org {
namespace deepin {
namespace dde {
namespace daemon {
typedef ::Dde_Dock DdeDock;
}
}
}
}
#endif // USE_AM
#endif // DOCK_INTERFACE

View File

@ -0,0 +1,290 @@
/*
* Copyright (C) 2022 ~ 2022 Deepin Technology Co., Ltd.
*
* Author: donghualin <donghualin@uniontech.com>
*
* Maintainer: donghualin <donghualin@uniontech.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "entryinterface.h"
/*
* Implementation of interface class __Entry
*/
#ifdef USE_AM
void registerWindowListMetaType()
{
qRegisterMetaType<WindowList>();
qDBusRegisterMetaType<WindowList>();
}
void registerWindowInfoMapMetaType()
{
registerWindowInfoMetaType();
qRegisterMetaType<WindowInfoMap>("WindowInfoMap");
qDBusRegisterMetaType<WindowInfoMap>();
}
void registerWindowInfoMetaType()
{
qRegisterMetaType<WindowInfo>("WindowInfo");
qDBusRegisterMetaType<WindowInfo>();
}
QDebug operator<<(QDebug argument, const WindowInfo &info)
{
argument << '(' << info.title << ',' << info.attention << ')';
return argument;
}
QDBusArgument &operator<<(QDBusArgument &argument, const WindowInfo &info)
{
argument.beginStructure();
argument << info.title << info.attention;
argument.endStructure();
return argument;
}
const QDBusArgument &operator>>(const QDBusArgument &argument, WindowInfo &info)
{
argument.beginStructure();
argument >> info.title >> info.attention;
argument.endStructure();
return argument;
}
bool WindowInfo::operator==(const WindowInfo &rhs) const
{
return attention == rhs.attention &&
title == rhs.title;
}
class EntryPrivate
{
public:
EntryPrivate() = default;
// begin member variables
uint CurrentWindow;
QString DesktopFile;
QString Icon;
QString Id;
bool IsActive;
bool IsDocked;
QString Menu;
QString Name;
WindowInfoMap WindowInfos;
public:
QMap<QString, QDBusPendingCallWatcher *> m_processingCalls;
QMap<QString, QList<QVariant>> m_waittingCalls;
};
Dock_Entry::Dock_Entry(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent)
: QDBusAbstractInterface(service, path, staticInterfaceName(), connection, parent)
, d_ptr(new EntryPrivate)
{
QDBusConnection::sessionBus().connect(this->service(), this->path(),
"org.freedesktop.DBus.Properties",
"PropertiesChanged","sa{sv}as",
this,
SLOT(onPropertyChanged(const QDBusMessage &)));
if (QMetaType::type("WindowList") == QMetaType::UnknownType)
registerWindowListMetaType();
if (QMetaType::type("WindowInfoMap") == QMetaType::UnknownType)
registerWindowInfoMapMetaType();
}
Dock_Entry::~Dock_Entry()
{
qDeleteAll(d_ptr->m_processingCalls.values());
delete d_ptr;
}
void Dock_Entry::onPropertyChanged(const QString &propName, const QVariant &value)
{
if (propName == QStringLiteral("CurrentWindow")) {
const uint &CurrentWindow = qvariant_cast<uint>(value);
if (d_ptr->CurrentWindow != CurrentWindow)
{
d_ptr->CurrentWindow = CurrentWindow;
Q_EMIT CurrentWindowChanged(d_ptr->CurrentWindow);
}
return;
}
if (propName == QStringLiteral("DesktopFile")) {
const QString &DesktopFile = qvariant_cast<QString>(value);
if (d_ptr->DesktopFile != DesktopFile) {
d_ptr->DesktopFile = DesktopFile;
Q_EMIT DesktopFileChanged(d_ptr->DesktopFile);
}
return;
}
if (propName == QStringLiteral("Icon")) {
const QString &Icon = qvariant_cast<QString>(value);
if (d_ptr->Icon != Icon)
{
d_ptr->Icon = Icon;
Q_EMIT IconChanged(d_ptr->Icon);
}
return;
}
if (propName == QStringLiteral("Id")) {
const QString &Id = qvariant_cast<QString>(value);
if (d_ptr->Id != Id) {
d_ptr->Id = Id;
Q_EMIT IdChanged(d_ptr->Id);
}
return;
}
if (propName == QStringLiteral("IsActive")) {
const bool &IsActive = qvariant_cast<bool>(value);
if (d_ptr->IsActive != IsActive) {
d_ptr->IsActive = IsActive;
Q_EMIT IsActiveChanged(d_ptr->IsActive);
}
return;
}
if (propName == QStringLiteral("IsDocked")) {
const bool &IsDocked = qvariant_cast<bool>(value);
if (d_ptr->IsDocked != IsDocked) {
d_ptr->IsDocked = IsDocked;
Q_EMIT IsDockedChanged(d_ptr->IsDocked);
}
return;
}
if (propName == QStringLiteral("Menu")) {
const QString &Menu = qvariant_cast<QString>(value);
if (d_ptr->Menu != Menu) {
d_ptr->Menu = Menu;
Q_EMIT MenuChanged(d_ptr->Menu);
}
return;
}
if (propName == QStringLiteral("Name")) {
const QString &Name = qvariant_cast<QString>(value);
if (d_ptr->Name != Name) {
d_ptr->Name = Name;
Q_EMIT NameChanged(d_ptr->Name);
}
return;
}
if (propName == QStringLiteral("WindowInfos")) {
const WindowInfoMap &WindowInfos = qvariant_cast<WindowInfoMap>(value);
if (d_ptr->WindowInfos != WindowInfos) {
d_ptr->WindowInfos = WindowInfos;
Q_EMIT WindowInfosChanged(d_ptr->WindowInfos);
}
return;
}
qWarning() << "property not handle: " << propName;
return;
}
uint Dock_Entry::currentWindow()
{
return qvariant_cast<uint>(property("CurrentWindow"));
}
QString Dock_Entry::desktopFile()
{
return qvariant_cast<QString>(property("DesktopFile"));
}
QString Dock_Entry::icon()
{
return qvariant_cast<QString>(property("Icon"));
}
QString Dock_Entry::id()
{
return qvariant_cast<QString>(property("Id"));
}
bool Dock_Entry::isActive()
{
return qvariant_cast<bool>(property("IsActive"));
}
bool Dock_Entry::isDocked()
{
return qvariant_cast<bool>(property("IsDocked"));
}
QString Dock_Entry::menu()
{
return qvariant_cast<QString>(property("Menu"));
}
QString Dock_Entry::name()
{
return qvariant_cast<QString>(property("Name"));
}
WindowInfoMap Dock_Entry::windowInfos()
{
return qvariant_cast<WindowInfoMap>(property("WindowInfos"));
}
void Dock_Entry::CallQueued(const QString &callName, const QList<QVariant> &args)
{
if (d_ptr->m_waittingCalls.contains(callName)) {
d_ptr->m_waittingCalls[callName] = args;
return;
}
if (d_ptr->m_processingCalls.contains(callName)) {
d_ptr->m_waittingCalls.insert(callName, args);
} else {
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(asyncCallWithArgumentList(callName, args));
connect(watcher, &QDBusPendingCallWatcher::finished, this, &Dock_Entry::onPendingCallFinished);
d_ptr->m_processingCalls.insert(callName, watcher);
}
}
void Dock_Entry::onPendingCallFinished(QDBusPendingCallWatcher *w)
{
w->deleteLater();
const auto callName = d_ptr->m_processingCalls.key(w);
Q_ASSERT(!callName.isEmpty());
if (callName.isEmpty())
return;
d_ptr->m_processingCalls.remove(callName);
if (!d_ptr->m_waittingCalls.contains(callName))
return;
const auto args = d_ptr->m_waittingCalls.take(callName);
CallQueued(callName, args);
}
#endif

275
frame/dbus/entryinterface.h Normal file
View File

@ -0,0 +1,275 @@
/*
* Copyright (C) 2022 ~ 2022 Deepin Technology Co., Ltd.
*
* Author: donghualin <donghualin@uniontech.com>
*
* Maintainer: donghualin <donghualin@uniontech.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef DOCK_ENTRY_H
#define DOCK_ENTRY_H
#ifdef USE_AM
#define WINDOWLIST_H
#define WINDOWINFOLIST_H
#include <QObject>
#include <QByteArray>
#include <QList>
#include <QMap>
#include <QString>
#include <QStringList>
#include <QVariant>
#include <DBusExtendedAbstractInterface>
#include <QtDBus>
typedef QList<quint32> WindowList;
void registerWindowListMetaType();
class WindowInfo
{
public:
friend QDebug operator<<(QDebug argument, const WindowInfo &info);
friend QDBusArgument &operator<<(QDBusArgument &argument, const WindowInfo &info);
friend const QDBusArgument &operator>>(const QDBusArgument &argument, WindowInfo &info);
bool operator==(const WindowInfo &rhs) const;
public:
bool attention;
QString title;
};
Q_DECLARE_METATYPE(WindowInfo)
typedef QMap<quint32, WindowInfo> WindowInfoMap;
Q_DECLARE_METATYPE(WindowInfoMap)
void registerWindowInfoMetaType();
void registerWindowInfoMapMetaType();
/*
* Proxy class for interface com.deepin.dde.daemon.Dock.Entry
*/
class EntryPrivate;
class Dock_Entry : public QDBusAbstractInterface
{
Q_OBJECT
public:
static inline const char *staticInterfaceName()
{ return "org.deepin.dde.daemon.Dock1.Entry"; }
public:
explicit Dock_Entry(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = 0);
~Dock_Entry();
Q_PROPERTY(uint CurrentWindow READ currentWindow NOTIFY CurrentWindowChanged)
uint currentWindow();
Q_PROPERTY(QString DesktopFile READ desktopFile NOTIFY DesktopFileChanged)
QString desktopFile();
Q_PROPERTY(QString Icon READ icon NOTIFY IconChanged)
QString icon();
Q_PROPERTY(QString Id READ id NOTIFY IdChanged)
QString id();
Q_PROPERTY(bool IsActive READ isActive NOTIFY IsActiveChanged)
bool isActive();
Q_PROPERTY(bool IsDocked READ isDocked NOTIFY IsDockedChanged)
bool isDocked();
Q_PROPERTY(QString Menu READ menu NOTIFY MenuChanged)
QString menu();
Q_PROPERTY(QString Name READ name NOTIFY NameChanged)
QString name();
Q_PROPERTY(WindowInfoMap WindowInfos READ windowInfos NOTIFY WindowInfosChanged)
WindowInfoMap windowInfos();
public Q_SLOTS: // METHODS
inline QDBusPendingReply<> Activate(uint in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
return asyncCallWithArgumentList(QStringLiteral("Activate"), argumentList);
}
inline void ActivateQueued(uint in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
CallQueued(QStringLiteral("Activate"), argumentList);
}
inline QDBusPendingReply<> Check()
{
QList<QVariant> argumentList;
return asyncCallWithArgumentList(QStringLiteral("Check"), argumentList);
}
inline void CheckQueued()
{
QList<QVariant> argumentList;
CallQueued(QStringLiteral("Check"), argumentList);
}
inline QDBusPendingReply<> ForceQuit()
{
QList<QVariant> argumentList;
return asyncCallWithArgumentList(QStringLiteral("ForceQuit"), argumentList);
}
inline void ForceQuitQueued()
{
QList<QVariant> argumentList;
CallQueued(QStringLiteral("ForceQuit"), argumentList);
}
inline QDBusPendingReply<WindowList> GetAllowedCloseWindows()
{
QList<QVariant> argumentList;
return asyncCallWithArgumentList(QStringLiteral("GetAllowedCloseWindows"), argumentList);
}
inline QDBusPendingReply<> HandleDragDrop(uint in0, const QStringList &in1)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
return asyncCallWithArgumentList(QStringLiteral("HandleDragDrop"), argumentList);
}
inline void HandleDragDropQueued(uint in0, const QStringList &in1)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
CallQueued(QStringLiteral("HandleDragDrop"), argumentList);
}
inline QDBusPendingReply<> HandleMenuItem(uint in0, const QString &in1)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
return asyncCallWithArgumentList(QStringLiteral("HandleMenuItem"), argumentList);
}
inline void HandleMenuItemQueued(uint in0, const QString &in1)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
CallQueued(QStringLiteral("HandleMenuItem"), argumentList);
}
inline QDBusPendingReply<> NewInstance(uint in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
return asyncCallWithArgumentList(QStringLiteral("NewInstance"), argumentList);
}
inline void NewInstanceQueued(uint in0)
{
QList<QVariant> argumentList;
argumentList << QVariant::fromValue(in0);
CallQueued(QStringLiteral("NewInstance"), argumentList);
}
inline QDBusPendingReply<> PresentWindows()
{
QList<QVariant> argumentList;
return asyncCallWithArgumentList(QStringLiteral("PresentWindows"), argumentList);
}
inline void PresentWindowsQueued()
{
QList<QVariant> argumentList;
CallQueued(QStringLiteral("PresentWindows"), argumentList);
}
inline QDBusPendingReply<> RequestDock()
{
QList<QVariant> argumentList;
return asyncCallWithArgumentList(QStringLiteral("RequestDock"), argumentList);
}
inline void RequestDockQueued()
{
QList<QVariant> argumentList;
CallQueued(QStringLiteral("RequestDock"), argumentList);
}
inline QDBusPendingReply<> RequestUndock()
{
QList<QVariant> argumentList;
return asyncCallWithArgumentList(QStringLiteral("RequestUndock"), argumentList);
}
inline void RequestUndockQueued()
{
QList<QVariant> argumentList;
CallQueued(QStringLiteral("RequestUndock"), argumentList);
}
Q_SIGNALS: // SIGNALS
// begin property changed signals
void IsActiveChanged(bool value) const;
void IsDockedChanged(bool value) const;
void MenuChanged(const QString &value) const;
void IconChanged(const QString &value) const;
void NameChanged(const QString &value) const;
void DesktopFileChanged(const QString &value) const;
void CurrentWindowChanged(uint32_t value) const;
void WindowInfosChanged(WindowInfoMap value) const;
void IdChanged(const QString &value) const;
private:
QVariant asyncProperty(const QString &propertyName);
public Q_SLOTS:
void CallQueued(const QString &callName, const QList<QVariant> &args);
private Q_SLOTS:
void onPendingCallFinished(QDBusPendingCallWatcher *w);
void onPropertyChanged(const QString &propName, const QVariant &value);
private:
EntryPrivate *d_ptr;
};
namespace org {
namespace deepin {
namespace dde {
namespace daemon {
namespace dock {
typedef ::Dock_Entry DockEntry;
}
}
}
}
}
#endif // USE_AM
#endif // DOCK_ENTRY_H

58
frame/util/dbusutil.h Normal file
View File

@ -0,0 +1,58 @@
/*
* Copyright (C) 2022 ~ 2022 Deepin Technology Co., Ltd.
*
* Author: donghualin <donghualin@uniontech.com>
*
* Maintainer: donghualin <donghualin@uniontech.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef DBUSUTIL_H
#define DBUSUTIL_H
#ifdef USE_AM
#include "dockinterface.h"
#include "entryinterface.h"
#else
#include <com_deepin_dde_daemon_dock.h>
#include <com_deepin_dde_daemon_dock_entry.h>
#endif
#ifdef USE_AM
using DockInter = org::deepin::dde::daemon::DdeDock;
using DockEntryInter = org::deepin::dde::daemon::dock::DockEntry;
#else
using DockInter = com::deepin::dde::daemon::Dock;
using DockEntryInter = com::deepin::dde::daemon::dock::Entry;
#endif
inline const QString dockServiceName()
{
#ifdef USE_AM
return QString("org.deepin.dde.daemon.Dock1");
#else
return QString("com.deepin.dde.daemon.Dock");
#endif
}
inline const QString dockServicePath()
{
#ifdef USE_AM
return QString("/org/deepin/dde/daemon/Dock1");
#else
return QString("/com/deepin/dde/daemon/Dock");
#endif
}
#endif // DBUSUTIL_H

View File

@ -12,6 +12,7 @@ file(GLOB_RECURSE SRCS "*.h" "*.cpp" "../../widgets/*.h" "../../widgets/*.cpp"
"../../frame/dbus/sni/*.h" "../../frame/dbus/sni/*.cpp"
"../../frame/dbus/dbusmenu.h" "../../frame/dbus/dbusmenu.cpp"
"../../frame/dbus/dbusmenumanager.h" "../../frame/dbus/dbusmenumanager.cpp"
"../../frame/dbus/dockinterface.h" "../../frame/dbus/dockinterface.cpp"
"../../widgets/*.h" "../../widgets/*.cpp"
"../../frame/util/imageutil.h" "../../frame/util/imageutil.cpp"
"../../frame/util/menudialog.h" "../../frame/util/menudialog.cpp"