refactor(plasma_api): use macro for signal wrapping

Author: gikari

src/core/plasma-api/utils.hpp

@@ -45,3 +45,16 @@
         method.invoke(m_kwinImpl, Qt::DirectConnection, Q_RETURN_ARG(RET_TYPE, result), __VA_ARGS__);                                                          \
         return result;                                                                                                                                         \
     }
+
+/**
+ * Wrap simple signal to forward it from KWin Class
+ * @param SIGNATURE signal signature, that can be put inside SIGNAL Qt macro
+ */
+#define WRAP_SIGNAL(SIGNATURE) connect(m_kwinImpl, SIGNAL(SIGNATURE), this, SIGNAL(SIGNATURE))
+
+/**
+ * Wrap signal with KWin Type in signature. Signal should have a mapper, that
+ * must have the same signature as the signal.
+ * @param SIGNATURE signal signature, that can be put inside SIGNAL/SLOT Qt macro
+ */
+#define WRAP_SIGNAL_WITH_KWIN_TYPE(SIGNATURE) connect(m_kwinImpl, SIGNAL(SIGNATURE), this, SLOT(mapper_##SIGNATURE))

src/core/plasma-api/workspace.cpp

@@ -40,27 +40,16 @@ void Workspace::setActiveClient(std::optional<PlasmaApi::Window> client)
 
 void Workspace::wrapSignals()
 {
-    auto wrapSimpleSignal = [this](const char *signalSignature) {
-        auto signalsSignature = QMetaObject::normalizedSignature(signalSignature);
-        connect(m_kwinImpl, signalsSignature, this, signalsSignature);
-    };
-
-    auto wrapComplexSignal = [this](const char *implSignalSignature, const char *thisSignalSignature) {
-        auto implNormSignature = QMetaObject::normalizedSignature(implSignalSignature);
-        auto thisNormSignature = QMetaObject::normalizedSignature(thisSignalSignature);
-        connect(m_kwinImpl, implNormSignature, this, thisNormSignature);
-    };
-
-    wrapSimpleSignal(SIGNAL(numberScreensChanged(int)));
-    wrapSimpleSignal(SIGNAL(screenResized(int)));
-    wrapSimpleSignal(SIGNAL(currentActivityChanged(const QString &)));
-
-    wrapComplexSignal(SIGNAL(currentDesktopChanged(int, KWin::Window *)), SLOT(currentDesktopChangedTransformer(int, KWin::Window *)));
-    wrapComplexSignal(SIGNAL(clientAdded(KWin::Window *)), SLOT(clientAddedTransformer(KWin::Window *)));
-    wrapComplexSignal(SIGNAL(clientRemoved(KWin::Window *)), SLOT(clientRemovedTransformer(KWin::Window *)));
-    wrapComplexSignal(SIGNAL(clientMinimized(KWin::Window *)), SLOT(clientMinimizedTransformer(KWin::Window *)));
-    wrapComplexSignal(SIGNAL(clientUnminimized(KWin::Window *)), SLOT(clientUnminimizedTransformer(KWin::Window *)));
-    wrapComplexSignal(SIGNAL(clientMaximizeSet(KWin::Window *, bool, bool)), SLOT(clientMaximizeSetTransformer(KWin::Window *, bool, bool)));
+    WRAP_SIGNAL(numberScreensChanged(int));
+    WRAP_SIGNAL(screenResized(int));
+    WRAP_SIGNAL(currentActivityChanged(const QString &));
+
+    WRAP_SIGNAL_WITH_KWIN_TYPE(currentDesktopChanged(int, KWin::Window *));
+    WRAP_SIGNAL_WITH_KWIN_TYPE(clientAdded(KWin::Window *));
+    WRAP_SIGNAL_WITH_KWIN_TYPE(clientRemoved(KWin::Window *));
+    WRAP_SIGNAL_WITH_KWIN_TYPE(clientMinimized(KWin::Window *));
+    WRAP_SIGNAL_WITH_KWIN_TYPE(clientUnminimized(KWin::Window *));
+    WRAP_SIGNAL_WITH_KWIN_TYPE(clientMaximizeSet(KWin::Window *, bool, bool));
 };
 
 QRect Workspace::clientArea(ClientAreaOption option, int screen, int desktop)
@@ -87,38 +76,38 @@ std::vector<PlasmaApi::Window> Workspace::clientList() const
     return result;
 }
 
-void Workspace::currentDesktopChangedTransformer(int desktop, KWin::Window *kwinClient)
+void Workspace::mapper_currentDesktopChanged(int desktop, KWin::Window *kwinClient)
 {
     // Since we don't know the KWin internal implementation we have to use reinterpret_cast
     auto clientWrapper = Window(reinterpret_cast<QObject *>(kwinClient));
     Q_EMIT currentDesktopChanged(desktop, clientWrapper);
 };
 
-void Workspace::clientAddedTransformer(KWin::Window *kwinClient)
+void Workspace::mapper_clientAdded(KWin::Window *kwinClient)
 {
     auto clientWrapper = Window(reinterpret_cast<QObject *>(kwinClient));
     Q_EMIT clientAdded(clientWrapper);
 }
 
-void Workspace::clientRemovedTransformer(KWin::Window *kwinClient)
+void Workspace::mapper_clientRemoved(KWin::Window *kwinClient)
 {
     auto clientWrapper = Window(reinterpret_cast<QObject *>(kwinClient));
     Q_EMIT clientRemoved(clientWrapper);
 }
 
-void Workspace::clientMinimizedTransformer(KWin::Window *kwinClient)
+void Workspace::mapper_clientMinimized(KWin::Window *kwinClient)
 {
     auto clientWrapper = Window(reinterpret_cast<QObject *>(kwinClient));
     Q_EMIT clientMinimized(clientWrapper);
 }
 
-void Workspace::clientUnminimizedTransformer(KWin::Window *kwinClient)
+void Workspace::mapper_clientUnminimized(KWin::Window *kwinClient)
 {
     auto clientWrapper = Window(reinterpret_cast<QObject *>(kwinClient));
     Q_EMIT clientUnminimized(clientWrapper);
 }
 
-void Workspace::clientMaximizeSetTransformer(KWin::Window *kwinClient, bool h, bool v)
+void Workspace::mapper_clientMaximizeSet(KWin::Window *kwinClient, bool h, bool v)
 {
     auto clientWrapper = Window(reinterpret_cast<QObject *>(kwinClient));
     Q_EMIT clientMaximizeSet(clientWrapper, h, v);

src/core/plasma-api/workspace.hpp

@@ -67,12 +67,12 @@ class Workspace : public QObject
     Q_INVOKABLE std::vector<PlasmaApi::Window> clientList() const;
 
 private Q_SLOTS:
-    void currentDesktopChangedTransformer(int desktop, KWin::Window *kwinClient);
-    void clientAddedTransformer(KWin::Window *);
-    void clientRemovedTransformer(KWin::Window *);
-    void clientMinimizedTransformer(KWin::Window *);
-    void clientUnminimizedTransformer(KWin::Window *);
-    void clientMaximizeSetTransformer(KWin::Window *, bool h, bool v);
+    void mapper_currentDesktopChanged(int desktop, KWin::Window *kwinClient);
+    void mapper_clientAdded(KWin::Window *);
+    void mapper_clientRemoved(KWin::Window *);
+    void mapper_clientMinimized(KWin::Window *);
+    void mapper_clientUnminimized(KWin::Window *);
+    void mapper_clientMaximizeSet(KWin::Window *, bool h, bool v);
 
 Q_SIGNALS:
     void currentDesktopChanged(int desktop, PlasmaApi::Window kwinClient);