diff --git a/scripting/workspace_wrapper.cpp b/scripting/workspace_wrapper.cpp index 9a40a0ec5..79f133e42 100644 --- a/scripting/workspace_wrapper.cpp +++ b/scripting/workspace_wrapper.cpp @@ -1,378 +1,386 @@ /******************************************************************** KWin - the KDE window manager This file is part of the KDE project. Copyright (C) 2010 Rohan Prabhu Copyright (C) 2011, 2012 Martin Gräßlin 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 2 of the License, or (at your option) 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 . *********************************************************************/ #include "workspace_wrapper.h" #include "../x11client.h" #include "../outline.h" #include "../screens.h" #include "../xdgshellclient.h" #include "../virtualdesktops.h" #include "../wayland_server.h" #include "../workspace.h" #ifdef KWIN_BUILD_ACTIVITIES #include "../activities.h" #endif #include #include namespace KWin { WorkspaceWrapper::WorkspaceWrapper(QObject* parent) : QObject(parent) { KWin::Workspace *ws = KWin::Workspace::self(); KWin::VirtualDesktopManager *vds = KWin::VirtualDesktopManager::self(); connect(ws, &Workspace::desktopPresenceChanged, this, &WorkspaceWrapper::desktopPresenceChanged); connect(ws, &Workspace::currentDesktopChanged, this, &WorkspaceWrapper::currentDesktopChanged); connect(ws, &Workspace::clientAdded, this, &WorkspaceWrapper::clientAdded); connect(ws, &Workspace::clientAdded, this, &WorkspaceWrapper::setupClientConnections); connect(ws, &Workspace::clientRemoved, this, &WorkspaceWrapper::clientRemoved); connect(ws, &Workspace::clientActivated, this, &WorkspaceWrapper::clientActivated); connect(vds, SIGNAL(countChanged(uint,uint)), SIGNAL(numberDesktopsChanged(uint))); connect(vds, SIGNAL(layoutChanged(int,int)), SIGNAL(desktopLayoutChanged())); connect(ws, &Workspace::clientDemandsAttentionChanged, this, &WorkspaceWrapper::clientDemandsAttentionChanged); #ifdef KWIN_BUILD_ACTIVITIES if (KWin::Activities *activities = KWin::Activities::self()) { connect(activities, SIGNAL(currentChanged(QString)), SIGNAL(currentActivityChanged(QString))); connect(activities, SIGNAL(added(QString)), SIGNAL(activitiesChanged(QString))); connect(activities, SIGNAL(added(QString)), SIGNAL(activityAdded(QString))); connect(activities, SIGNAL(removed(QString)), SIGNAL(activitiesChanged(QString))); connect(activities, SIGNAL(removed(QString)), SIGNAL(activityRemoved(QString))); } #endif connect(screens(), &Screens::sizeChanged, this, &WorkspaceWrapper::virtualScreenSizeChanged); connect(screens(), &Screens::geometryChanged, this, &WorkspaceWrapper::virtualScreenGeometryChanged); connect(screens(), &Screens::countChanged, this, [this] (int previousCount, int currentCount) { Q_UNUSED(previousCount) emit numberScreensChanged(currentCount); } ); connect(QApplication::desktop(), SIGNAL(resized(int)), SIGNAL(screenResized(int))); if (waylandServer()) { connect(waylandServer(), &WaylandServer::shellClientAdded, this, &WorkspaceWrapper::clientAdded); connect(waylandServer(), &WaylandServer::shellClientAdded, this, &WorkspaceWrapper::setupAbstractClientConnections); } foreach (KWin::X11Client *client, ws->clientList()) { setupClientConnections(client); } } int WorkspaceWrapper::currentDesktop() const { return VirtualDesktopManager::self()->current(); } int WorkspaceWrapper::numberOfDesktops() const { return VirtualDesktopManager::self()->count(); } void WorkspaceWrapper::setCurrentDesktop(int desktop) { VirtualDesktopManager::self()->setCurrent(desktop); } void WorkspaceWrapper::setNumberOfDesktops(int count) { VirtualDesktopManager::self()->setCount(count); } AbstractClient *WorkspaceWrapper::activeClient() const { return workspace()->activeClient(); } QString WorkspaceWrapper::currentActivity() const { #ifdef KWIN_BUILD_ACTIVITIES if (!Activities::self()) { return QString(); } return Activities::self()->current(); #else return QString(); #endif } QStringList WorkspaceWrapper::activityList() const { #ifdef KWIN_BUILD_ACTIVITIES if (!Activities::self()) { return QStringList(); } return Activities::self()->all(); #else return QStringList(); #endif } #define SLOTWRAPPER(name) \ void WorkspaceWrapper::name( ) { \ Workspace::self()->name(); \ } SLOTWRAPPER(slotSwitchToNextScreen) SLOTWRAPPER(slotWindowToNextScreen) SLOTWRAPPER(slotToggleShowDesktop) SLOTWRAPPER(slotWindowMaximize) SLOTWRAPPER(slotWindowMaximizeVertical) SLOTWRAPPER(slotWindowMaximizeHorizontal) SLOTWRAPPER(slotWindowMinimize) SLOTWRAPPER(slotWindowShade) SLOTWRAPPER(slotWindowRaise) SLOTWRAPPER(slotWindowLower) SLOTWRAPPER(slotWindowRaiseOrLower) SLOTWRAPPER(slotActivateAttentionWindow) SLOTWRAPPER(slotWindowPackLeft) SLOTWRAPPER(slotWindowPackRight) SLOTWRAPPER(slotWindowPackUp) SLOTWRAPPER(slotWindowPackDown) SLOTWRAPPER(slotWindowGrowHorizontal) SLOTWRAPPER(slotWindowGrowVertical) SLOTWRAPPER(slotWindowShrinkHorizontal) SLOTWRAPPER(slotWindowShrinkVertical) SLOTWRAPPER(slotIncreaseWindowOpacity) SLOTWRAPPER(slotLowerWindowOpacity) SLOTWRAPPER(slotWindowOperations) SLOTWRAPPER(slotWindowClose) SLOTWRAPPER(slotWindowMove) SLOTWRAPPER(slotWindowResize) SLOTWRAPPER(slotWindowAbove) SLOTWRAPPER(slotWindowBelow) SLOTWRAPPER(slotWindowOnAllDesktops) SLOTWRAPPER(slotWindowFullScreen) SLOTWRAPPER(slotWindowNoBorder) SLOTWRAPPER(slotWindowToNextDesktop) SLOTWRAPPER(slotWindowToPreviousDesktop) SLOTWRAPPER(slotWindowToDesktopRight) SLOTWRAPPER(slotWindowToDesktopLeft) SLOTWRAPPER(slotWindowToDesktopUp) SLOTWRAPPER(slotWindowToDesktopDown) #undef SLOTWRAPPER #define SLOTWRAPPER(name,modes) \ void WorkspaceWrapper::name() { \ Workspace::self()->quickTileWindow(modes); \ } SLOTWRAPPER(slotWindowQuickTileLeft, QuickTileFlag::Left) SLOTWRAPPER(slotWindowQuickTileRight, QuickTileFlag::Right) SLOTWRAPPER(slotWindowQuickTileTop, QuickTileFlag::Top) SLOTWRAPPER(slotWindowQuickTileBottom, QuickTileFlag::Bottom) SLOTWRAPPER(slotWindowQuickTileTopLeft, QuickTileFlag::Top | QuickTileFlag::Left) SLOTWRAPPER(slotWindowQuickTileTopRight, QuickTileFlag::Top | QuickTileFlag::Right) SLOTWRAPPER(slotWindowQuickTileBottomLeft, QuickTileFlag::Bottom | QuickTileFlag::Left) SLOTWRAPPER(slotWindowQuickTileBottomRight, QuickTileFlag::Bottom | QuickTileFlag::Right) #undef SLOTWRAPPER #define SLOTWRAPPER(name,direction) \ void WorkspaceWrapper::name() { \ Workspace::self()->switchWindow(Workspace::direction); \ } SLOTWRAPPER(slotSwitchWindowUp, DirectionNorth) SLOTWRAPPER(slotSwitchWindowDown, DirectionSouth) SLOTWRAPPER(slotSwitchWindowRight, DirectionEast) SLOTWRAPPER(slotSwitchWindowLeft, DirectionWest) #undef SLOTWRAPPER #define SLOTWRAPPER(name,direction) \ void WorkspaceWrapper::name( ) { \ VirtualDesktopManager::self()->moveTo(options->isRollOverDesktops()); \ } SLOTWRAPPER(slotSwitchDesktopNext,DesktopNext) SLOTWRAPPER(slotSwitchDesktopPrevious,DesktopPrevious) SLOTWRAPPER(slotSwitchDesktopRight,DesktopRight) SLOTWRAPPER(slotSwitchDesktopLeft,DesktopLeft) SLOTWRAPPER(slotSwitchDesktopUp,DesktopAbove) SLOTWRAPPER(slotSwitchDesktopDown,DesktopBelow) #undef SLOTWRAPPER void WorkspaceWrapper::setActiveClient(KWin::AbstractClient* client) { KWin::Workspace::self()->activateClient(client); } QSize WorkspaceWrapper::workspaceSize() const { return QSize(workspaceWidth(), workspaceHeight()); } QSize WorkspaceWrapper::displaySize() const { return screens()->displaySize(); } int WorkspaceWrapper::displayWidth() const { return displaySize().width(); } int WorkspaceWrapper::displayHeight() const { return displaySize().height(); } QRect WorkspaceWrapper::clientArea(ClientAreaOption option, const QPoint &p, int desktop) const { return Workspace::self()->clientArea(static_cast(option), p, desktop); } QRect WorkspaceWrapper::clientArea(ClientAreaOption option, const KWin::AbstractClient *c) const { return Workspace::self()->clientArea(static_cast(option), c); } QRect WorkspaceWrapper::clientArea(ClientAreaOption option, int screen, int desktop) const { return Workspace::self()->clientArea(static_cast(option), screen, desktop); } QString WorkspaceWrapper::desktopName(int desktop) const { return VirtualDesktopManager::self()->name(desktop); } QString WorkspaceWrapper::supportInformation() const { return Workspace::self()->supportInformation(); } void WorkspaceWrapper::setupAbstractClientConnections(AbstractClient *client) { connect(client, &AbstractClient::clientMinimized, this, &WorkspaceWrapper::clientMinimized); connect(client, &AbstractClient::clientUnminimized, this, &WorkspaceWrapper::clientUnminimized); connect(client, qOverload(&AbstractClient::clientMaximizedStateChanged), this, &WorkspaceWrapper::clientMaximizeSet); } void WorkspaceWrapper::setupClientConnections(X11Client *client) { setupAbstractClientConnections(client); connect(client, &X11Client::clientManaging, this, &WorkspaceWrapper::clientManaging); connect(client, &X11Client::clientFullScreenSet, this, &WorkspaceWrapper::clientFullScreenSet); } void WorkspaceWrapper::showOutline(const QRect &geometry) { outline()->show(geometry); } void WorkspaceWrapper::showOutline(int x, int y, int width, int height) { outline()->show(QRect(x, y, width, height)); } void WorkspaceWrapper::hideOutline() { outline()->hide(); } X11Client *WorkspaceWrapper::getClient(qulonglong windowId) { return Workspace::self()->findClient(Predicate::WindowMatch, windowId); } QSize WorkspaceWrapper::desktopGridSize() const { return VirtualDesktopManager::self()->grid().size(); } int WorkspaceWrapper::desktopGridWidth() const { return desktopGridSize().width(); } int WorkspaceWrapper::desktopGridHeight() const { return desktopGridSize().height(); } int WorkspaceWrapper::workspaceHeight() const { return desktopGridHeight() * displayHeight(); } int WorkspaceWrapper::workspaceWidth() const { return desktopGridWidth() * displayWidth(); } int WorkspaceWrapper::numScreens() const { return screens()->count(); } int WorkspaceWrapper::activeScreen() const { return screens()->current(); } QRect WorkspaceWrapper::virtualScreenGeometry() const { return screens()->geometry(); } QSize WorkspaceWrapper::virtualScreenSize() const { return screens()->size(); } +void WorkspaceWrapper::sendClientToScreen(AbstractClient *client, int screen) +{ + if (screen < 0 || screen >= screens()->count()) { + return; + } + workspace()->sendClientToScreen(client, screen); +} + QtScriptWorkspaceWrapper::QtScriptWorkspaceWrapper(QObject* parent) : WorkspaceWrapper(parent) {} QList QtScriptWorkspaceWrapper::clientList() const { return workspace()->allClientList(); } QQmlListProperty DeclarativeScriptWorkspaceWrapper::clients() { return QQmlListProperty(this, nullptr, &DeclarativeScriptWorkspaceWrapper::countClientList, &DeclarativeScriptWorkspaceWrapper::atClientList); } int DeclarativeScriptWorkspaceWrapper::countClientList(QQmlListProperty *clients) { Q_UNUSED(clients) return workspace()->allClientList().size(); } KWin::AbstractClient *DeclarativeScriptWorkspaceWrapper::atClientList(QQmlListProperty *clients, int index) { Q_UNUSED(clients) return workspace()->allClientList().at(index); } DeclarativeScriptWorkspaceWrapper::DeclarativeScriptWorkspaceWrapper(QObject* parent) : WorkspaceWrapper(parent) {} } // KWin diff --git a/scripting/workspace_wrapper.h b/scripting/workspace_wrapper.h index c4024c215..b3c40affe 100644 --- a/scripting/workspace_wrapper.h +++ b/scripting/workspace_wrapper.h @@ -1,380 +1,385 @@ /******************************************************************** KWin - the KDE window manager This file is part of the KDE project. Copyright (C) 2010 Rohan Prabhu Copyright (C) 2012 Martin Gräßlin 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 2 of the License, or (at your option) 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 . *********************************************************************/ #ifndef KWIN_SCRIPTING_WORKSPACE_WRAPPER_H #define KWIN_SCRIPTING_WORKSPACE_WRAPPER_H #include #include #include #include #include #include namespace KWin { // forward declarations class AbstractClient; class X11Client; class WorkspaceWrapper : public QObject { Q_OBJECT Q_ENUMS(ClientAreaOption) Q_ENUMS(ElectricBorder) Q_PROPERTY(int currentDesktop READ currentDesktop WRITE setCurrentDesktop NOTIFY currentDesktopChanged) Q_PROPERTY(KWin::AbstractClient *activeClient READ activeClient WRITE setActiveClient NOTIFY clientActivated) // TODO: write and notify? Q_PROPERTY(QSize desktopGridSize READ desktopGridSize NOTIFY desktopLayoutChanged) Q_PROPERTY(int desktopGridWidth READ desktopGridWidth NOTIFY desktopLayoutChanged) Q_PROPERTY(int desktopGridHeight READ desktopGridHeight NOTIFY desktopLayoutChanged) Q_PROPERTY(int workspaceWidth READ workspaceWidth) Q_PROPERTY(int workspaceHeight READ workspaceHeight) Q_PROPERTY(QSize workspaceSize READ workspaceSize) /** * The number of desktops currently used. Minimum number of desktops is 1, maximum 20. */ Q_PROPERTY(int desktops READ numberOfDesktops WRITE setNumberOfDesktops NOTIFY numberDesktopsChanged) /** * The same of the display, that is all screens. * @deprecated since 5.0 use virtualScreenSize */ Q_PROPERTY(QSize displaySize READ displaySize) /** * The width of the display, that is width of all combined screens. * @deprecated since 5.0 use virtualScreenSize */ Q_PROPERTY(int displayWidth READ displayWidth) /** * The height of the display, that is height of all combined screens. * @deprecated since 5.0 use virtualScreenSize */ Q_PROPERTY(int displayHeight READ displayHeight) Q_PROPERTY(int activeScreen READ activeScreen) Q_PROPERTY(int numScreens READ numScreens NOTIFY numberScreensChanged) Q_PROPERTY(QString currentActivity READ currentActivity NOTIFY currentActivityChanged) Q_PROPERTY(QStringList activities READ activityList NOTIFY activitiesChanged) /** * The bounding size of all screens combined. Overlapping areas * are not counted multiple times. * @see virtualScreenGeometry */ Q_PROPERTY(QSize virtualScreenSize READ virtualScreenSize NOTIFY virtualScreenSizeChanged) /** * The bounding geometry of all outputs combined. Always starts at (0,0) and has * virtualScreenSize as it's size. * @see virtualScreenSize */ Q_PROPERTY(QRect virtualScreenGeometry READ virtualScreenGeometry NOTIFY virtualScreenGeometryChanged) private: Q_DISABLE_COPY(WorkspaceWrapper) Q_SIGNALS: void desktopPresenceChanged(KWin::AbstractClient *client, int desktop); void currentDesktopChanged(int desktop, KWin::AbstractClient *client); void clientAdded(KWin::AbstractClient *client); void clientRemoved(KWin::AbstractClient *client); void clientManaging(KWin::X11Client *client); void clientMinimized(KWin::AbstractClient *client); void clientUnminimized(KWin::AbstractClient *client); void clientRestored(KWin::X11Client *client); void clientMaximizeSet(KWin::AbstractClient *client, bool h, bool v); void killWindowCalled(KWin::X11Client *client); void clientActivated(KWin::AbstractClient *client); void clientFullScreenSet(KWin::X11Client *client, bool fullScreen, bool user); void clientSetKeepAbove(KWin::X11Client *client, bool keepAbove); /** * Signal emitted whenever the number of desktops changed. * To get the current number of desktops use the property desktops. * @param oldNumberOfDesktops The previous number of desktops. */ void numberDesktopsChanged(uint oldNumberOfDesktops); /** * Signal emitted whenever the layout of virtual desktops changed. * That is desktopGrid(Size/Width/Height) will have new values. * @since 4.11 */ void desktopLayoutChanged(); /** * The demands attention state for Client @p c changed to @p set. * @param c The Client for which demands attention changed * @param set New value of demands attention */ void clientDemandsAttentionChanged(KWin::AbstractClient *client, bool set); /** * Signal emitted when the number of screens changes. * @param count The new number of screens */ void numberScreensChanged(int count); /** * This signal is emitted when the size of @p screen changes. * Don't forget to fetch an updated client area. */ void screenResized(int screen); /** * Signal emitted whenever the current activity changed. * @param id id of the new activity */ void currentActivityChanged(const QString &id); /** * Signal emitted whenever the list of activities changed. * @param id id of the new activity */ void activitiesChanged(const QString &id); /** * This signal is emitted when a new activity is added * @param id id of the new activity */ void activityAdded(const QString &id); /** * This signal is emitted when the activity * is removed * @param id id of the removed activity */ void activityRemoved(const QString &id); /** * Emitted whenever the virtualScreenSize changes. * @see virtualScreenSize() * @since 5.0 */ void virtualScreenSizeChanged(); /** * Emitted whenever the virtualScreenGeometry changes. * @see virtualScreenGeometry() * @since 5.0 */ void virtualScreenGeometryChanged(); public: //------------------------------------------------------------------ //enums copy&pasted from kwinglobals.h because qtscript is evil enum ClientAreaOption { ///< geometry where a window will be initially placed after being mapped PlacementArea, ///< window movement snapping area? ignore struts MovementArea, ///< geometry to which a window will be maximized MaximizeArea, ///< like MaximizeArea, but ignore struts - used e.g. for topmenu MaximizeFullArea, ///< area for fullscreen windows FullScreenArea, ///< whole workarea (all screens together) WorkArea, ///< whole area (all screens together), ignore struts FullArea, ///< one whole screen, ignore struts ScreenArea }; enum ElectricBorder { ElectricTop, ElectricTopRight, ElectricRight, ElectricBottomRight, ElectricBottom, ElectricBottomLeft, ElectricLeft, ElectricTopLeft, ELECTRIC_COUNT, ElectricNone }; protected: explicit WorkspaceWrapper(QObject* parent = nullptr); public: #define GETTERSETTERDEF( rettype, getter, setter ) \ rettype getter() const; \ void setter( rettype val ); GETTERSETTERDEF(int, numberOfDesktops, setNumberOfDesktops) GETTERSETTERDEF(int, currentDesktop, setCurrentDesktop) GETTERSETTERDEF(KWin::AbstractClient*, activeClient, setActiveClient) #undef GETTERSETTERDEF QSize desktopGridSize() const; int desktopGridWidth() const; int desktopGridHeight() const; int workspaceWidth() const; int workspaceHeight() const; QSize workspaceSize() const; int displayWidth() const; int displayHeight() const; QSize displaySize() const; int activeScreen() const; int numScreens() const; QString currentActivity() const; QStringList activityList() const; QSize virtualScreenSize() const; QRect virtualScreenGeometry() const; /** * Returns the geometry a Client can use with the specified option. * This method should be preferred over other methods providing screen sizes as the * various options take constraints such as struts set on panels into account. * This method is also multi screen aware, but there are also options to get full areas. * @param option The type of area which should be considered * @param screen The screen for which the area should be considered * @param desktop The desktop for which the area should be considered, in general there should not be a difference * @returns The specified screen geometry */ Q_SCRIPTABLE QRect clientArea(ClientAreaOption option, int screen, int desktop) const; /** * Overloaded method for convenience. * @param option The type of area which should be considered * @param point The coordinates which have to be included in the area * @param desktop The desktop for which the area should be considered, in general there should not be a difference * @returns The specified screen geometry */ Q_SCRIPTABLE QRect clientArea(ClientAreaOption option, const QPoint& point, int desktop) const; /** * Overloaded method for convenience. * @param client The Client for which the area should be retrieved * @returns The specified screen geometry */ Q_SCRIPTABLE QRect clientArea(ClientAreaOption option, const KWin::AbstractClient *client) const; /** * Returns the name for the given @p desktop. */ Q_SCRIPTABLE QString desktopName(int desktop) const; /** * Provides support information about the currently running KWin instance. */ Q_SCRIPTABLE QString supportInformation() const; /** * Finds the Client with the given @p windowId. * @param windowId The window Id of the Client * @return The found Client or @c null */ Q_SCRIPTABLE KWin::X11Client *getClient(qulonglong windowId); public Q_SLOTS: // all the available key bindings void slotSwitchDesktopNext(); void slotSwitchDesktopPrevious(); void slotSwitchDesktopRight(); void slotSwitchDesktopLeft(); void slotSwitchDesktopUp(); void slotSwitchDesktopDown(); void slotSwitchToNextScreen(); void slotWindowToNextScreen(); void slotToggleShowDesktop(); void slotWindowMaximize(); void slotWindowMaximizeVertical(); void slotWindowMaximizeHorizontal(); void slotWindowMinimize(); void slotWindowShade(); void slotWindowRaise(); void slotWindowLower(); void slotWindowRaiseOrLower(); void slotActivateAttentionWindow(); void slotWindowPackLeft(); void slotWindowPackRight(); void slotWindowPackUp(); void slotWindowPackDown(); void slotWindowGrowHorizontal(); void slotWindowGrowVertical(); void slotWindowShrinkHorizontal(); void slotWindowShrinkVertical(); void slotWindowQuickTileLeft(); void slotWindowQuickTileRight(); void slotWindowQuickTileTop(); void slotWindowQuickTileBottom(); void slotWindowQuickTileTopLeft(); void slotWindowQuickTileTopRight(); void slotWindowQuickTileBottomLeft(); void slotWindowQuickTileBottomRight(); void slotSwitchWindowUp(); void slotSwitchWindowDown(); void slotSwitchWindowRight(); void slotSwitchWindowLeft(); void slotIncreaseWindowOpacity(); void slotLowerWindowOpacity(); void slotWindowOperations(); void slotWindowClose(); void slotWindowMove(); void slotWindowResize(); void slotWindowAbove(); void slotWindowBelow(); void slotWindowOnAllDesktops(); void slotWindowFullScreen(); void slotWindowNoBorder(); void slotWindowToNextDesktop(); void slotWindowToPreviousDesktop(); void slotWindowToDesktopRight(); void slotWindowToDesktopLeft(); void slotWindowToDesktopUp(); void slotWindowToDesktopDown(); + /** + * Sends the AbstractClient to the given @p screen. + */ + void sendClientToScreen(KWin::AbstractClient *client, int screen); + /** * Shows an outline at the specified @p geometry. * If an outline is already shown the outline is moved to the new position. * Use hideOutline to remove the outline again. */ void showOutline(const QRect &geometry); /** * Overloaded method for convenience. */ void showOutline(int x, int y, int width, int height); /** * Hides the outline previously shown by showOutline. */ void hideOutline(); private Q_SLOTS: void setupAbstractClientConnections(AbstractClient *client); void setupClientConnections(X11Client *client); }; class QtScriptWorkspaceWrapper : public WorkspaceWrapper { Q_OBJECT public: /** * List of Clients currently managed by KWin. */ Q_INVOKABLE QList clientList() const; explicit QtScriptWorkspaceWrapper(QObject* parent = nullptr); }; class DeclarativeScriptWorkspaceWrapper : public WorkspaceWrapper { Q_OBJECT Q_PROPERTY(QQmlListProperty clients READ clients) public: QQmlListProperty clients(); static int countClientList(QQmlListProperty *clients); static KWin::AbstractClient *atClientList(QQmlListProperty *clients, int index); explicit DeclarativeScriptWorkspaceWrapper(QObject* parent = nullptr); }; } #endif