window.h

Go to the documentation of this file.

/*
    KWin - the KDE window manager
    This file is part of the KDE project.
 
    SPDX-FileCopyrightText: 2015 Martin Gräßlin <mgraesslin@kde.org>
    SPDX-FileCopyrightText: 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
#pragma once
 
#include "cursor.h"
#include "options.h"
#include "rules.h"
#include "utils/common.h"
 
#include <functional>
#include <memory>
 
#include <NETWM>
 
#include <QElapsedTimer>
#include <QIcon>
#include <QKeySequence>
#include <QMatrix4x4>
#include <QObject>
#include <QPointer>
#include <QRectF>
#include <QTimer>
#include <QUuid>
 
class QMouseEvent;
 
namespace KDecoration2
{
class Decoration;
}
 
namespace KWin
{
class PlasmaWindowInterface;
class SurfaceInterface;
class Group;
class Output;
class ClientMachine;
class EffectWindow;
class Tile;
class Scene;
class Shadow;
class SurfaceItem;
class VirtualDesktop;
class WindowItem;
 
namespace Decoration
{
class DecoratedClientImpl;
class DecorationPalette;
}
 
class KWIN_EXPORT Window : public QObject
{
    Q_OBJECT
 
    Q_PROPERTY(QRectF bufferGeometry READ bufferGeometry)
 
    
    Q_PROPERTY(QRectF clientGeometry READ clientGeometry)
 
    Q_PROPERTY(QPointF pos READ pos)
 
    Q_PROPERTY(QSizeF size READ size)
 
    Q_PROPERTY(qreal x READ x NOTIFY frameGeometryChanged)
 
    Q_PROPERTY(qreal y READ y NOTIFY frameGeometryChanged)
 
    Q_PROPERTY(qreal width READ width NOTIFY frameGeometryChanged)
 
    Q_PROPERTY(qreal height READ height NOTIFY frameGeometryChanged)
 
    Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity NOTIFY opacityChanged)
 
    Q_PROPERTY(KWin::Output *output READ output NOTIFY outputChanged)
 
    Q_PROPERTY(QRectF rect READ rect)
    Q_PROPERTY(QString resourceName READ resourceName NOTIFY windowClassChanged)
    Q_PROPERTY(QString resourceClass READ resourceClass NOTIFY windowClassChanged)
    Q_PROPERTY(QString windowRole READ windowRole NOTIFY windowRoleChanged)
 
    Q_PROPERTY(bool desktopWindow READ isDesktop CONSTANT)
 
    Q_PROPERTY(bool dock READ isDock CONSTANT)
 
    Q_PROPERTY(bool toolbar READ isToolbar CONSTANT)
 
    Q_PROPERTY(bool menu READ isMenu CONSTANT)
 
    Q_PROPERTY(bool normalWindow READ isNormalWindow CONSTANT)
 
    Q_PROPERTY(bool dialog READ isDialog CONSTANT)
 
    Q_PROPERTY(bool splash READ isSplash CONSTANT)
 
    Q_PROPERTY(bool utility READ isUtility CONSTANT)
 
    Q_PROPERTY(bool dropdownMenu READ isDropdownMenu CONSTANT)
 
    Q_PROPERTY(bool popupMenu READ isPopupMenu CONSTANT)
 
    Q_PROPERTY(bool tooltip READ isTooltip CONSTANT)
 
    Q_PROPERTY(bool notification READ isNotification CONSTANT)
 
    Q_PROPERTY(bool criticalNotification READ isCriticalNotification CONSTANT)
 
    Q_PROPERTY(bool appletPopup READ isAppletPopup CONSTANT)
 
    Q_PROPERTY(bool onScreenDisplay READ isOnScreenDisplay CONSTANT)
 
    Q_PROPERTY(bool comboBox READ isComboBox CONSTANT)
 
    Q_PROPERTY(bool dndIcon READ isDNDIcon CONSTANT)
 
    Q_PROPERTY(int windowType READ windowType CONSTANT)
 
    Q_PROPERTY(bool managed READ isClient CONSTANT)
 
    Q_PROPERTY(bool deleted READ isDeleted CONSTANT)
 
    Q_PROPERTY(bool skipsCloseAnimation READ skipsCloseAnimation WRITE setSkipCloseAnimation NOTIFY skipCloseAnimationChanged)
 
    Q_PROPERTY(bool popupWindow READ isPopupWindow)
 
    Q_PROPERTY(bool outline READ isOutline)
 
    Q_PROPERTY(QUuid internalId READ internalId CONSTANT)
 
    Q_PROPERTY(int pid READ pid CONSTANT)
 
    Q_PROPERTY(int stackingOrder READ stackingOrder NOTIFY stackingOrderChanged)
 
    Q_PROPERTY(bool fullScreen READ isFullScreen WRITE setFullScreen NOTIFY fullScreenChanged)
 
    Q_PROPERTY(bool fullScreenable READ isFullScreenable)
 
    Q_PROPERTY(bool active READ isActive NOTIFY activeChanged)
 
    Q_PROPERTY(QList<KWin::VirtualDesktop *> desktops READ desktops WRITE setDesktops NOTIFY desktopsChanged)
 
    Q_PROPERTY(bool onAllDesktops READ isOnAllDesktops WRITE setOnAllDesktops NOTIFY desktopsChanged)
 
    Q_PROPERTY(QStringList activities READ activities WRITE setOnActivities NOTIFY activitiesChanged)
 
    Q_PROPERTY(bool skipTaskbar READ skipTaskbar WRITE setSkipTaskbar NOTIFY skipTaskbarChanged)
 
    Q_PROPERTY(bool skipPager READ skipPager WRITE setSkipPager NOTIFY skipPagerChanged)
 
    Q_PROPERTY(bool skipSwitcher READ skipSwitcher WRITE setSkipSwitcher NOTIFY skipSwitcherChanged)
 
    Q_PROPERTY(bool closeable READ isCloseable NOTIFY closeableChanged)
 
    Q_PROPERTY(QIcon icon READ icon NOTIFY iconChanged)
 
    Q_PROPERTY(bool keepAbove READ keepAbove WRITE setKeepAbove NOTIFY keepAboveChanged)
 
    Q_PROPERTY(bool keepBelow READ keepBelow WRITE setKeepBelow NOTIFY keepBelowChanged)
 
    Q_PROPERTY(bool shadeable READ isShadeable NOTIFY shadeableChanged)
 
    Q_PROPERTY(bool shade READ isShade WRITE setShade NOTIFY shadeChanged)
 
    Q_PROPERTY(bool minimizable READ isMinimizable)
 
    Q_PROPERTY(bool minimized READ isMinimized WRITE setMinimized NOTIFY minimizedChanged)
 
    Q_PROPERTY(QRectF iconGeometry READ iconGeometry)
 
    Q_PROPERTY(bool specialWindow READ isSpecialWindow)
 
    Q_PROPERTY(bool demandsAttention READ isDemandingAttention WRITE demandAttention NOTIFY demandsAttentionChanged)
 
    Q_PROPERTY(QString caption READ caption NOTIFY captionChanged)
 
    Q_PROPERTY(QSizeF minSize READ minSize)
 
    Q_PROPERTY(QSizeF maxSize READ maxSize)
 
    Q_PROPERTY(bool wantsInput READ wantsInput)
 
    Q_PROPERTY(bool transient READ isTransient NOTIFY transientChanged)
 
    Q_PROPERTY(KWin::Window *transientFor READ transientFor NOTIFY transientChanged)
 
    Q_PROPERTY(bool modal READ isModal NOTIFY modalChanged)
 
    Q_PROPERTY(QRectF frameGeometry READ frameGeometry WRITE moveResize NOTIFY frameGeometryChanged)
 
    Q_PROPERTY(bool move READ isInteractiveMove NOTIFY moveResizedChanged)
 
    Q_PROPERTY(bool resize READ isInteractiveResize NOTIFY moveResizedChanged)
 
    Q_PROPERTY(bool decorationHasAlpha READ decorationHasAlpha)
 
    Q_PROPERTY(bool noBorder READ noBorder WRITE setNoBorder)
 
    Q_PROPERTY(bool providesContextHelp READ providesContextHelp CONSTANT)
 
    Q_PROPERTY(bool maximizable READ isMaximizable)
 
    Q_PROPERTY(bool moveable READ isMovable)
 
    Q_PROPERTY(bool moveableAcrossScreens READ isMovableAcrossScreens)
 
    Q_PROPERTY(bool resizeable READ isResizable)
 
    Q_PROPERTY(QString desktopFileName READ desktopFileName NOTIFY desktopFileNameChanged)
 
    Q_PROPERTY(bool hasApplicationMenu READ hasApplicationMenu NOTIFY hasApplicationMenuChanged)
 
    Q_PROPERTY(bool applicationMenuActive READ applicationMenuActive NOTIFY applicationMenuActiveChanged)
 
    Q_PROPERTY(bool unresponsive READ unresponsive NOTIFY unresponsiveChanged)
 
    Q_PROPERTY(QString colorScheme READ colorScheme NOTIFY colorSchemeChanged)
 
    Q_PROPERTY(KWin::Layer layer READ layer)
 
    Q_PROPERTY(bool hidden READ isHidden NOTIFY hiddenChanged)
 
    Q_PROPERTY(KWin::Tile *tile READ tile WRITE setTile NOTIFY tileChanged)
 
    Q_PROPERTY(bool inputMethod READ isInputMethod)
 
public:
    ~Window() override;
 
    void ref();
    void unref();
 
    QRectF moveResizeGeometry() const;
 
    Output *moveResizeOutput() const;
    void setMoveResizeOutput(Output *output);
 
    QRectF bufferGeometry() const;
    QRectF frameGeometry() const;
    QRectF clientGeometry() const;
    QMargins frameMargins() const;
 
    virtual QSizeF minSize() const;
    virtual QSizeF maxSize() const;
    QSizeF size() const;
    QPointF pos() const;
    QRectF rect() const;
    qreal x() const;
    qreal y() const;
    qreal width() const;
    qreal height() const;
    bool isOnOutput(Output *output) const;
    bool isOnActiveOutput() const;
    Output *output() const;
    void setOutput(Output *output);
    QSizeF clientSize() const;
    QRectF visibleGeometry() const;
 
    QPointF mapToFrame(const QPointF &point) const;
    QPointF mapToLocal(const QPointF &point) const;
    QPointF mapFromLocal(const QPointF &point) const;
 
    virtual QPointF framePosToClientPos(const QPointF &point) const;
    virtual QPointF clientPosToFramePos(const QPointF &point) const;
    virtual QSizeF frameSizeToClientSize(const QSizeF &size) const;
    virtual QSizeF clientSizeToFrameSize(const QSizeF &size) const;
    QRectF frameRectToClientRect(const QRectF &rect) const;
    QRectF clientRectToFrameRect(const QRectF &rect) const;
 
    enum SizeMode {
        SizeModeAny,
        SizeModeFixedW, 
        SizeModeFixedH, 
        SizeModeMax 
    };
 
    virtual QSizeF constrainClientSize(const QSizeF &size, SizeMode mode = SizeModeAny) const;
    QSizeF constrainFrameSize(const QSizeF &size, SizeMode mode = SizeModeAny) const;
 
    void move(const QPointF &point);
    void resize(const QSizeF &size);
    void moveResize(const QRectF &rect);
 
    void growHorizontal();
    void shrinkHorizontal();
    void growVertical();
    void shrinkVertical();
 
    virtual QRectF resizeWithChecks(const QRectF &geometry, const QSizeF &s) = 0;
    void keepInArea(QRectF area, bool partial = false);
    QRectF keepInArea(QRectF geometry, QRectF area, bool partial = false);
 
    // prefer isXXX() instead
    virtual NET::WindowType windowType() const = 0;
    bool hasNETSupport() const;
    bool isDesktop() const;
    bool isDock() const;
    bool isToolbar() const;
    bool isMenu() const;
    bool isNormalWindow() const; // normal as in 'NET::Normal or NET::Unknown non-transient'
    bool isDialog() const;
    bool isSplash() const;
    bool isUtility() const;
    bool isDropdownMenu() const;
    bool isPopupMenu() const; // a context popup, not dropdown, not torn-off
    bool isTooltip() const;
    bool isNotification() const;
    bool isCriticalNotification() const;
    bool isAppletPopup() const;
    bool isOnScreenDisplay() const;
    bool isComboBox() const;
    bool isDNDIcon() const;
 
    virtual bool isLockScreen() const;
    virtual bool isInputMethod() const;
    virtual bool isOutline() const;
    virtual bool isInternal() const;
    virtual bool isPopupWindow() const;
 
    virtual bool isClient() const;
    bool isDeleted() const;
    virtual bool isUnmanaged() const;
 
    bool isLockScreenOverlay() const;
    void setLockScreenOverlay(bool allowed);
 
    QStringList desktopIds() const;
    QList<VirtualDesktop *> desktops() const;
    void setDesktops(QList<VirtualDesktop *> desktops);
    void enterDesktop(VirtualDesktop *desktop);
    void leaveDesktop(VirtualDesktop *desktop);
    bool isOnDesktop(VirtualDesktop *desktop) const;
    bool isOnCurrentDesktop() const;
    bool isOnAllDesktops() const;
    void setOnAllDesktops(bool set);
 
    virtual QStringList activities() const;
    bool isOnActivity(const QString &activity) const;
    bool isOnCurrentActivity() const;
    bool isOnAllActivities() const;
    void setOnActivity(const QString &activity, bool enable);
    void setOnActivities(const QStringList &newActivitiesList);
    void setOnAllActivities(bool all);
    virtual void updateActivities(bool includeTransients);
    void blockActivityUpdates(bool b = true);
 
    virtual void checkActivities(){};
 
    virtual QString windowRole() const;
    QString resourceName() const;
    QString resourceClass() const;
    QString wmClientMachine(bool use_localhost) const;
    ClientMachine *clientMachine() const;
    virtual bool isLocalhost() const;
    virtual pid_t pid() const;
 
    bool readyForPainting() const; // true if the window has been already painted its contents
    void setOpacity(qreal opacity);
    qreal opacity() const;
    virtual bool setupCompositing();
    virtual void finishCompositing();
    EffectWindow *effectWindow();
    const EffectWindow *effectWindow() const;
    SurfaceItem *surfaceItem() const;
    WindowItem *windowItem() const;
    void elevate(bool elevate);
 
    Shadow *shadow() const;
    void updateShadow();
    bool wantsShadowToBeRendered() const;
 
    bool skipsCloseAnimation() const;
    void setSkipCloseAnimation(bool set);
 
    SurfaceInterface *surface() const;
    void setSurface(SurfaceInterface *surface);
 
    QMatrix4x4 inputTransformation() const;
 
    virtual bool hitTest(const QPointF &point) const;
 
    virtual bool hasPopupGrab() const
    {
        return false;
    }
    virtual void popupDone(){};
 
    template<class T, class U>
    static T *findInList(const QList<T *> &list, std::function<bool(const U *)> func);
 
    QUuid internalId() const
    {
        return m_internalId;
    }
 
    int stackingOrder() const;
    void setStackingOrder(int order); 
 
    bool skipSwitcher() const
    {
        return m_skipSwitcher;
    }
    void setSkipSwitcher(bool set);
 
    bool skipTaskbar() const
    {
        return m_skipTaskbar;
    }
    void setSkipTaskbar(bool set);
    void setOriginalSkipTaskbar(bool set);
    bool originalSkipTaskbar() const
    {
        return m_originalSkipTaskbar;
    }
 
    bool skipPager() const
    {
        return m_skipPager;
    }
    void setSkipPager(bool set);
 
    const QIcon &icon() const
    {
        return m_icon;
    }
 
    bool isActive() const
    {
        return m_active;
    }
    void setActive(bool);
 
    bool keepAbove() const
    {
        return m_keepAbove;
    }
    void setKeepAbove(bool);
    bool keepBelow() const
    {
        return m_keepBelow;
    }
    void setKeepBelow(bool);
 
    void demandAttention(bool set = true);
    bool isDemandingAttention() const
    {
        return m_demandsAttention;
    }
 
    void cancelAutoRaise();
 
    virtual void updateMouseGrab();
    QString caption() const;
    virtual QString captionNormal() const = 0;
    virtual QString captionSuffix() const = 0;
    virtual bool isPlaceable() const;
    virtual bool isCloseable() const = 0;
    bool isShown() const;
    bool isHidden() const;
    void setHidden(bool hidden);
    bool isHiddenByShowDesktop() const;
    void setHiddenByShowDesktop(bool hidden);
    // TODO: remove boolean trap
    virtual Window *findModal(bool allow_itself = false) = 0;
    virtual bool isTransient() const;
    virtual bool hasTransientPlacementHint() const;
    virtual QRectF transientPlacement() const;
    const Window *transientFor() const;
    Window *transientFor();
    void setTransientFor(Window *transientFor);
    virtual bool hasTransient(const Window *transient, bool indirect) const;
    const QList<Window *> &transients() const; // Is not indirect
    virtual void addTransient(Window *transient);
    virtual void removeTransient(Window *transient);
    void removeTransientFromList(Window *cl);
    virtual QList<Window *> mainWindows() const; // Call once before loop , is not indirect
    QList<Window *> allMainWindows() const; // Call once before loop , is indirect
    bool isSpecialWindow() const;
    void sendToOutput(Output *output);
    const QKeySequence &shortcut() const
    {
        return _shortcut;
    }
    void setShortcut(const QString &cut);
 
    virtual QRectF iconGeometry() const;
 
    void setMinimized(bool set);
    bool isMinimized() const
    {
        return m_minimized;
    }
    virtual bool isMinimizable() const;
 
    bool isSuspended() const;
    void setSuspended(bool suspended);
 
    QRectF fullscreenGeometryRestore() const;
    virtual bool isFullScreenable() const;
    virtual bool isFullScreen() const;
    virtual bool isRequestedFullScreen() const;
    virtual void setFullScreen(bool set);
 
    bool wantsAdaptiveSync() const;
 
    QRectF geometryRestore() const;
    virtual bool isMaximizable() const;
    virtual MaximizeMode maximizeMode() const;
    virtual MaximizeMode requestedMaximizeMode() const;
    virtual void maximize(MaximizeMode mode);
    Q_INVOKABLE void setMaximize(bool vertically, bool horizontally);
 
    QPalette palette();
    const Decoration::DecorationPalette *decorationPalette();
 
    virtual bool isResizable() const = 0;
    virtual bool isMovable() const = 0;
    virtual bool isMovableAcrossScreens() const = 0;
 
    bool isShade() const
    {
        return shadeMode() == ShadeNormal;
    }
    ShadeMode shadeMode() const; // Prefer isShade()
    void setShade(bool set);
    void setShade(ShadeMode mode);
    void toggleShade();
    void cancelShadeHoverTimer();
    virtual bool isShadeable() const;
 
    const WindowRules *rules() const
    {
        return &m_rules;
    }
    void removeRule(Rules *r);
    void setupWindowRules();
    void finishWindowRules();
    void evaluateWindowRules();
    virtual void updateWindowRules(Rules::Types selection);
    virtual void applyWindowRules();
    virtual bool supportsWindowRules() const;
 
    bool wantsTabFocus() const;
    virtual bool takeFocus() = 0;
    virtual bool wantsInput() const = 0;
    virtual bool dockWantsInput() const;
    void checkWorkspacePosition(QRectF oldGeometry = QRectF(), const VirtualDesktop *oldDesktop = nullptr);
    virtual xcb_timestamp_t userTime() const;
 
    void keyPressEvent(uint key_code);
 
    virtual void pointerEnterEvent(const QPointF &globalPos);
    virtual void pointerLeaveEvent();
 
    // a helper for the workspace window packing. tests for screen validity and updates since in maximization case as with normal moving
    void packTo(qreal left, qreal top);
 
    Tile *tile() const;
    void setTile(Tile *tile);
 
    void setQuickTileMode(QuickTileMode mode, bool keyboard = false);
    QuickTileMode quickTileMode() const
    {
        return QuickTileMode(m_quickTileMode);
    }
 
    Layer layer() const;
    void updateLayer();
 
    bool isInteractiveMove() const
    {
        return isInteractiveMoveResize() && interactiveMoveResizeGravity() == Gravity::None;
    }
    bool isInteractiveResize() const
    {
        return isInteractiveMoveResize() && interactiveMoveResizeGravity() != Gravity::None;
    }
    CursorShape cursor() const
    {
        return m_interactiveMoveResize.cursor;
    }
    uint32_t interactiveMoveResizeCount() const;
 
    void updateInteractiveMoveResize(const QPointF &currentGlobalCursor);
    void endInteractiveMoveResize();
 
    virtual StrutRect strutRect(StrutArea area) const;
    StrutRects strutRects() const;
    virtual bool hasStrut() const;
 
    void setModal(bool modal);
    bool isModal() const;
 
    Options::MouseCommand getMouseCommand(Qt::MouseButton button, bool *handled) const;
    Options::MouseCommand getWheelCommand(Qt::Orientation orientation, bool *handled) const;
    bool performMouseCommand(Options::MouseCommand, const QPointF &globalPos);
 
    // decoration related
    Qt::Edge titlebarPosition() const;
    bool titlebarPositionUnderMouse() const;
    KDecoration2::Decoration *decoration()
    {
        return m_decoration.decoration.get();
    }
    const KDecoration2::Decoration *decoration() const
    {
        return m_decoration.decoration.get();
    }
    bool isDecorated() const
    {
        return m_decoration.decoration != nullptr;
    }
    Decoration::DecoratedClientImpl *decoratedClient() const;
    void setDecoratedClient(Decoration::DecoratedClientImpl *client);
    bool decorationHasAlpha() const;
    void triggerDecorationRepaint();
    void layoutDecorationRects(QRectF &left, QRectF &top, QRectF &right, QRectF &bottom) const;
    void processDecorationMove(const QPointF &localPos, const QPointF &globalPos);
    bool processDecorationButtonPress(QMouseEvent *event, bool ignoreMenu = false);
    void processDecorationButtonRelease(QMouseEvent *event);
 
    virtual void invalidateDecoration();
 
    virtual bool noBorder() const;
    virtual void setNoBorder(bool set);
    virtual bool userCanSetNoBorder() const;
    virtual void checkNoBorder();
 
    virtual bool providesContextHelp() const;
 
    virtual void showContextHelp();
 
    QRectF virtualKeyboardGeometry() const;
 
    virtual void setVirtualKeyboardGeometry(const QRectF &geo);
 
    virtual void showOnScreenEdge();
 
    QString desktopFileName() const
    {
        return m_desktopFileName;
    }
 
    static QString iconFromDesktopFile(const QString &fileName);
 
    static QString findDesktopFile(const QString &fileName);
 
    virtual void killWindow() = 0;
    virtual void destroyWindow() = 0;
 
    enum class SameApplicationCheck {
        RelaxedForActive = 1 << 0,
        AllowCrossProcesses = 1 << 1
    };
    Q_DECLARE_FLAGS(SameApplicationChecks, SameApplicationCheck)
    static bool belongToSameApplication(const Window *c1, const Window *c2, SameApplicationChecks checks = SameApplicationChecks());
    virtual bool belongsToDesktop() const;
 
    bool hasApplicationMenu() const;
    bool applicationMenuActive() const
    {
        return m_applicationMenuActive;
    }
    void setApplicationMenuActive(bool applicationMenuActive);
 
    QString applicationMenuServiceName() const
    {
        return m_applicationMenuServiceName;
    }
    QString applicationMenuObjectPath() const
    {
        return m_applicationMenuObjectPath;
    }
 
    void showApplicationMenu(int actionId);
 
    virtual QString preferredColorScheme() const;
    QString colorScheme() const;
    void setColorScheme(const QString &colorScheme);
 
    bool unresponsive() const;
 
    virtual bool groupTransient() const;
    virtual const Group *group() const;
    virtual Group *group();
 
    PlasmaWindowInterface *windowManagementInterface() const
    {
        return m_windowManagementInterface;
    }
 
    void setLastUsageSerial(quint32 serial);
    quint32 lastUsageSerial() const;
 
    void refOffscreenRendering();
    void unrefOffscreenRendering();
 
public Q_SLOTS:
    virtual void closeWindow() = 0;
 
protected Q_SLOTS:
    void setReadyForPainting();
 
Q_SIGNALS:
    void stackingOrderChanged();
    void shadeChanged();
    void opacityChanged(KWin::Window *window, qreal oldOpacity);
    void damaged(KWin::Window *window);
    void inputTransformationChanged();
    void closed();
    void windowShown(KWin::Window *window);
    void windowHidden(KWin::Window *window);
    void outputChanged();
    void skipCloseAnimationChanged();
    void windowRoleChanged();
    void windowClassChanged();
 
    void surfaceChanged();
 
    void shadowChanged();
 
    void bufferGeometryChanged(const QRectF &oldGeometry);
    void frameGeometryChanged(const QRectF &oldGeometry);
    void clientGeometryChanged(const QRectF &oldGeometry);
 
    void frameGeometryAboutToChange();
 
    void visibleGeometryChanged();
 
    void tileChanged(KWin::Tile *tile);
 
    void fullScreenChanged();
    void skipTaskbarChanged();
    void skipPagerChanged();
    void skipSwitcherChanged();
    void iconChanged();
    void activeChanged();
    void keepAboveChanged(bool);
    void keepBelowChanged(bool);
    void demandsAttentionChanged();
    void desktopsChanged();
    void activitiesChanged();
    void minimizedChanged();
    void paletteChanged(const QPalette &p);
    void colorSchemeChanged();
    void captionChanged();
    void captionNormalChanged();
    void maximizedAboutToChange(MaximizeMode mode);
    void maximizedChanged();
    void transientChanged();
    void modalChanged();
    void quickTileModeChanged();
    void moveResizedChanged();
    void moveResizeCursorChanged(CursorShape);
    void interactiveMoveResizeStarted();
    void interactiveMoveResizeStepped(const QRectF &geometry);
    void interactiveMoveResizeFinished();
    void closeableChanged(bool);
    void minimizeableChanged(bool);
    void shadeableChanged(bool);
    void maximizeableChanged(bool);
    void desktopFileNameChanged();
    void applicationMenuChanged();
    void hasApplicationMenuChanged(bool);
    void applicationMenuActiveChanged(bool);
    void unresponsiveChanged(bool);
    void decorationChanged();
    void hiddenChanged();
    void hiddenByShowDesktopChanged();
    void lockScreenOverlayChanged();
    void readyForPaintingChanged();
 
protected:
    Window();
 
    virtual std::unique_ptr<WindowItem> createItem(Scene *scene) = 0;
 
    void setResourceClass(const QString &name, const QString &className = QString());
    void setIcon(const QIcon &icon);
    void startAutoRaise();
    void autoRaise();
    bool isMostRecentlyRaised() const;
    void markAsDeleted();
    virtual bool acceptsFocus() const = 0;
    virtual void doSetActive();
    virtual void doSetKeepAbove();
    virtual void doSetKeepBelow();
    virtual void doSetShade(ShadeMode previousShadeMode);
    virtual void doSetDesktop();
    virtual void doSetOnActivities(const QStringList &activityList);
    virtual void doMinimize();
    virtual bool belongsToSameApplication(const Window *other, SameApplicationChecks checks) const = 0;
 
    virtual void doSetSkipTaskbar();
    virtual void doSetSkipPager();
    virtual void doSetSkipSwitcher();
    virtual void doSetDemandsAttention();
    virtual void doSetQuickTileMode();
    virtual void doSetHidden();
    virtual void doSetHiddenByShowDesktop();
    virtual void doSetSuspended();
 
    void setupWindowManagementInterface();
    void destroyWindowManagementInterface();
    void updateColorScheme();
    void ensurePalette();
    void handlePaletteChange();
 
    virtual Layer belongsToLayer() const;
    bool isActiveFullScreen() const;
 
    // electric border / quick tiling
    void setElectricBorderMode(QuickTileMode mode);
    QuickTileMode electricBorderMode() const
    {
        return m_electricMode;
    }
    void setElectricBorderMaximizing(bool maximizing);
    bool isElectricBorderMaximizing() const
    {
        return m_electricMaximizing;
    }
    void updateElectricGeometryRestore();
    QRectF quickTileGeometryRestore() const;
    QRectF quickTileGeometry(QuickTileMode mode, const QPointF &pos) const;
    void updateQuickTileMode(QuickTileMode newMode)
    {
        m_quickTileMode = newMode;
    }
 
    // geometry handling
    void checkOffscreenPosition(QRectF *geom, const QRectF &screenArea);
    int borderLeft() const;
    int borderRight() const;
    int borderTop() const;
    int borderBottom() const;
    void setGeometryRestore(const QRectF &rect);
    void setFullscreenGeometryRestore(const QRectF &geom);
 
    void blockGeometryUpdates(bool block);
    void blockGeometryUpdates();
    void unblockGeometryUpdates();
    bool areGeometryUpdatesBlocked() const;
    enum class MoveResizeMode : uint {
        None,
        Move = 0x1,
        Resize = 0x2,
        MoveResize = Move | Resize,
    };
    MoveResizeMode pendingMoveResizeMode() const;
    void setPendingMoveResizeMode(MoveResizeMode mode);
    virtual void moveResizeInternal(const QRectF &rect, MoveResizeMode mode) = 0;
 
    bool isInteractiveMoveResize() const
    {
        return m_interactiveMoveResize.enabled;
    }
    void setInteractiveMoveResize(bool enabled)
    {
        m_interactiveMoveResize.enabled = enabled;
    }
    bool isUnrestrictedInteractiveMoveResize() const
    {
        return m_interactiveMoveResize.unrestricted;
    }
    void setUnrestrictedInteractiveMoveResize(bool set)
    {
        m_interactiveMoveResize.unrestricted = set;
    }
    QPointF interactiveMoveOffset() const
    {
        return m_interactiveMoveResize.offset;
    }
    void setInteractiveMoveOffset(const QPointF &offset)
    {
        m_interactiveMoveResize.offset = offset;
    }
    QPointF invertedInteractiveMoveOffset() const
    {
        return m_interactiveMoveResize.invertedOffset;
    }
    void setInvertedInteractiveMoveOffset(const QPointF &offset)
    {
        m_interactiveMoveResize.invertedOffset = offset;
    }
    QRectF initialInteractiveMoveResizeGeometry() const
    {
        return m_interactiveMoveResize.initialGeometry;
    }
    void setMoveResizeGeometry(const QRectF &geo);
    Gravity interactiveMoveResizeGravity() const
    {
        return m_interactiveMoveResize.gravity;
    }
    void setInteractiveMoveResizeGravity(Gravity gravity)
    {
        m_interactiveMoveResize.gravity = gravity;
    }
    bool isInteractiveMoveResizePointerButtonDown() const
    {
        return m_interactiveMoveResize.buttonDown;
    }
    void setInteractiveMoveResizePointerButtonDown(bool down)
    {
        m_interactiveMoveResize.buttonDown = down;
    }
    Output *interactiveMoveResizeStartOutput() const
    {
        return m_interactiveMoveResize.startOutput;
    }
    void checkUnrestrictedInteractiveMoveResize();
    void updateCursor();
    void startDelayedInteractiveMoveResize();
    void stopDelayedInteractiveMoveResize();
    bool startInteractiveMoveResize();
    virtual bool doStartInteractiveMoveResize();
    virtual void doFinishInteractiveMoveResize();
    void finishInteractiveMoveResize(bool cancel);
    virtual void leaveInteractiveMoveResize();
    /*
     * Checks if the mouse cursor is near the edge of the screen and if so
     * activates quick tiling or maximization
     */
    void checkQuickTilingMaximizationZones(int xroot, int yroot);
    void resetQuickTilingMaximizationZones();
    virtual bool isWaitingForInteractiveMoveResizeSync() const;
    virtual void doInteractiveResizeSync(const QRectF &rect);
    void handleInteractiveMoveResize(qreal x, qreal y, qreal x_root, qreal y_root);
    void handleInteractiveMoveResize(const QPointF &local, const QPointF &global);
    void dontInteractiveMoveResize();
 
    virtual QSizeF resizeIncrements() const;
 
    Gravity mouseGravity() const;
 
    void setDecoration(std::shared_ptr<KDecoration2::Decoration> decoration);
    void startDecorationDoubleClickTimer();
    void invalidateDecorationDoubleClickTimer();
    void updateDecorationInputShape();
 
    void setDesktopFileName(const QString &name);
    QString iconFromDesktopFile() const;
 
    void updateApplicationMenuServiceName(const QString &serviceName);
    void updateApplicationMenuObjectPath(const QString &objectPath);
 
    void setUnresponsive(bool unresponsive);
 
    virtual void setShortcutInternal();
    QString shortcutCaptionSuffix() const;
    virtual void updateCaption() = 0;
 
    void startShadeHoverTimer();
    void startShadeUnhoverTimer();
    void shadeHover();
    void shadeUnhover();
 
    // The geometry that the window should be restored when the virtual keyboard closes
    QRectF keyboardGeometryRestore() const;
    void setKeyboardGeometryRestore(const QRectF &geom);
 
    QRectF moveToArea(const QRectF &geometry, const QRectF &oldArea, const QRectF &newArea);
    QRectF ensureSpecialStateGeometry(const QRectF &geometry);
 
    void cleanTabBox();
    void maybeSendFrameCallback();
 
    Output *m_output = nullptr;
    QRectF m_frameGeometry;
    QRectF m_clientGeometry;
    QRectF m_bufferGeometry;
    bool ready_for_painting;
    bool m_hidden = false;
    bool m_hiddenByShowDesktop = false;
 
    int m_refCount = 1;
    QUuid m_internalId;
    std::unique_ptr<WindowItem> m_windowItem;
    std::unique_ptr<Shadow> m_shadow;
    QString resource_name;
    QString resource_class;
    ClientMachine *m_clientMachine;
    bool m_skipCloseAnimation;
    QPointer<SurfaceInterface> m_surface;
    qreal m_opacity = 1.0;
    int m_stackingOrder = 0;
 
    bool m_skipTaskbar = false;
    bool m_originalSkipTaskbar = false;
    bool m_skipPager = false;
    bool m_skipSwitcher = false;
    QIcon m_icon;
    bool m_active = false;
    bool m_deleted = false;
    bool m_keepAbove = false;
    bool m_keepBelow = false;
    bool m_demandsAttention = false;
    bool m_minimized = false;
    bool m_suspended = false;
    QTimer *m_autoRaiseTimer = nullptr;
    QTimer *m_shadeHoverTimer = nullptr;
    ShadeMode m_shadeMode = ShadeNone;
    QList<VirtualDesktop *> m_desktops;
 
    QStringList m_activityList;
    int m_activityUpdatesBlocked = 0;
    bool m_blockedActivityUpdatesRequireTransients = false;
 
    QString m_colorScheme;
    std::shared_ptr<Decoration::DecorationPalette> m_palette;
    static QHash<QString, std::weak_ptr<Decoration::DecorationPalette>> s_palettes;
    static std::shared_ptr<Decoration::DecorationPalette> s_defaultPalette;
 
    PlasmaWindowInterface *m_windowManagementInterface = nullptr;
 
    Window *m_transientFor = nullptr;
    QList<Window *> m_transients;
    bool m_modal = false;
    Layer m_layer = UnknownLayer;
    QPointer<Tile> m_tile;
 
    // electric border/quick tiling
    QuickTileMode m_electricMode = QuickTileFlag::None;
    QRectF m_electricGeometryRestore;
    bool m_electricMaximizing = false;
    // The quick tile mode of this window.
    int m_quickTileMode = int(QuickTileFlag::None);
    QTimer *m_electricMaximizingDelay = nullptr;
 
    // geometry
    int m_blockGeometryUpdates = 0; // > 0 = New geometry is remembered, but not actually set
    MoveResizeMode m_pendingMoveResizeMode = MoveResizeMode::None;
    friend class GeometryUpdatesBlocker;
    Output *m_moveResizeOutput;
    QRectF m_moveResizeGeometry;
    QRectF m_keyboardGeometryRestore;
    QRectF m_maximizeGeometryRestore;
    QRectF m_fullscreenGeometryRestore;
    QRectF m_virtualKeyboardGeometry;
 
    struct
    {
        bool enabled = false;
        bool unrestricted = false;
        QPointF offset;
        QPointF invertedOffset;
        QRectF initialGeometry;
        QRectF initialGeometryRestore;
        Gravity gravity = Gravity::None;
        bool buttonDown = false;
        CursorShape cursor = Qt::ArrowCursor;
        Output *startOutput = nullptr;
        QTimer *delayedTimer = nullptr;
        uint32_t counter = 0;
        MaximizeMode initialMaximizeMode;
        QuickTileMode initialQuickTileMode;
    } m_interactiveMoveResize;
 
    struct
    {
        std::shared_ptr<KDecoration2::Decoration> decoration;
        QPointer<Decoration::DecoratedClientImpl> client;
        QElapsedTimer doubleClickTimer;
        QRegion inputRegion;
    } m_decoration;
    QString m_desktopFileName;
 
    bool m_applicationMenuActive = false;
    QString m_applicationMenuServiceName;
    QString m_applicationMenuObjectPath;
 
    bool m_unresponsive = false;
 
    QKeySequence _shortcut;
 
    WindowRules m_rules;
    quint32 m_lastUsageSerial = 0;
    bool m_lockScreenOverlay = false;
    uint32_t m_offscreenRenderCount = 0;
    QTimer m_offscreenFramecallbackTimer;
};
 
class GeometryUpdatesBlocker
{
public:
    explicit GeometryUpdatesBlocker(Window *c)
        : cl(c)
    {
        cl->blockGeometryUpdates(true);
    }
    ~GeometryUpdatesBlocker()
    {
        cl->blockGeometryUpdates(false);
    }
 
private:
    Window *cl;
};
 
inline QRectF Window::bufferGeometry() const
{
    return m_bufferGeometry;
}
 
inline QRectF Window::clientGeometry() const
{
    return m_clientGeometry;
}
 
inline QSizeF Window::clientSize() const
{
    return m_clientGeometry.size();
}
 
inline QRectF Window::frameGeometry() const
{
    return m_frameGeometry;
}
 
inline QSizeF Window::size() const
{
    return m_frameGeometry.size();
}
 
inline QPointF Window::pos() const
{
    return m_frameGeometry.topLeft();
}
 
inline qreal Window::x() const
{
    return m_frameGeometry.x();
}
 
inline qreal Window::y() const
{
    return m_frameGeometry.y();
}
 
inline qreal Window::width() const
{
    return m_frameGeometry.width();
}
 
inline qreal Window::height() const
{
    return m_frameGeometry.height();
}
 
inline QRectF Window::rect() const
{
    return QRectF(0, 0, width(), height());
}
 
inline bool Window::readyForPainting() const
{
    return ready_for_painting;
}
 
inline bool Window::isDesktop() const
{
    return windowType() == NET::Desktop;
}
 
inline bool Window::isDock() const
{
    return windowType() == NET::Dock;
}
 
inline bool Window::isMenu() const
{
    return windowType() == NET::Menu;
}
 
inline bool Window::isToolbar() const
{
    return windowType() == NET::Toolbar;
}
 
inline bool Window::isSplash() const
{
    return windowType() == NET::Splash;
}
 
inline bool Window::isUtility() const
{
    return windowType() == NET::Utility;
}
 
inline bool Window::isDialog() const
{
    return windowType() == NET::Dialog;
}
 
inline bool Window::isNormalWindow() const
{
    return windowType() == NET::Normal;
}
 
inline bool Window::isDropdownMenu() const
{
    return windowType() == NET::DropdownMenu;
}
 
inline bool Window::isPopupMenu() const
{
    return windowType() == NET::PopupMenu;
}
 
inline bool Window::isTooltip() const
{
    return windowType() == NET::Tooltip;
}
 
inline bool Window::isNotification() const
{
    return windowType() == NET::Notification;
}
 
inline bool Window::isCriticalNotification() const
{
    return windowType() == NET::CriticalNotification;
}
 
inline bool Window::isAppletPopup() const
{
    return windowType() == NET::AppletPopup;
}
 
inline bool Window::isOnScreenDisplay() const
{
    return windowType() == NET::OnScreenDisplay;
}
 
inline bool Window::isComboBox() const
{
    return windowType() == NET::ComboBox;
}
 
inline bool Window::isDNDIcon() const
{
    return windowType() == NET::DNDIcon;
}
 
inline bool Window::isLockScreen() const
{
    return false;
}
 
inline bool Window::isInputMethod() const
{
    return false;
}
 
inline bool Window::isOutline() const
{
    return false;
}
 
inline bool Window::isInternal() const
{
    return false;
}
 
inline WindowItem *Window::windowItem() const
{
    return m_windowItem.get();
}
 
inline bool Window::isOnAllDesktops() const
{
    return desktops().isEmpty();
}
 
inline bool Window::isOnAllActivities() const
{
    return activities().isEmpty();
}
 
inline bool Window::isOnActivity(const QString &activity) const
{
    return activities().isEmpty() || activities().contains(activity);
}
 
inline QString Window::resourceName() const
{
    return resource_name; // it is always lowercase
}
 
inline QString Window::resourceClass() const
{
    return resource_class; // it is always lowercase
}
 
inline ClientMachine *Window::clientMachine() const
{
    return m_clientMachine;
}
 
template<class T, class U>
inline T *Window::findInList(const QList<T *> &list, std::function<bool(const U *)> func)
{
    static_assert(std::is_base_of<U, T>::value,
                  "U must be derived from T");
    const auto it = std::find_if(list.begin(), list.end(), func);
    if (it == list.end()) {
        return nullptr;
    }
    return *it;
}
 
inline bool Window::isPopupWindow() const
{
    switch (windowType()) {
    case NET::ComboBox:
    case NET::DropdownMenu:
    case NET::PopupMenu:
    case NET::Tooltip:
        return true;
 
    default:
        return false;
    }
}
 
inline const QList<Window *> &Window::transients() const
{
    return m_transients;
}
 
inline bool Window::areGeometryUpdatesBlocked() const
{
    return m_blockGeometryUpdates != 0;
}
 
inline void Window::blockGeometryUpdates()
{
    m_blockGeometryUpdates++;
}
 
inline void Window::unblockGeometryUpdates()
{
    m_blockGeometryUpdates--;
}
 
inline Window::MoveResizeMode Window::pendingMoveResizeMode() const
{
    return m_pendingMoveResizeMode;
}
 
inline void Window::setPendingMoveResizeMode(MoveResizeMode mode)
{
    m_pendingMoveResizeMode = MoveResizeMode(uint(m_pendingMoveResizeMode) | uint(mode));
}
 
KWIN_EXPORT QDebug operator<<(QDebug debug, const Window *window);
 
class KWIN_EXPORT WindowOffscreenRenderRef
{
public:
    WindowOffscreenRenderRef(Window *window);
    WindowOffscreenRenderRef() = default;
    ~WindowOffscreenRenderRef();
 
private:
    QPointer<Window> m_window;
};
 
} // namespace KWin
 
Q_DECLARE_METATYPE(KWin::Window *)
Q_DECLARE_METATYPE(QList<KWin::Window *>)
Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::Window::SameApplicationChecks)