kwin/client.h

/********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.

Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>

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 <http://www.gnu.org/licenses/>.
*********************************************************************/

#ifndef KWIN_CLIENT_H
#define KWIN_CLIENT_H

#include <config-X11.h>

#include <QFrame>
#include <QPixmap>
#include <netwm.h>
#include <kdebug.h>
#include <assert.h>
#include <kshortcut.h>
#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <fixx11h.h>

// TODO: QScriptValue should be in the ifdef, but it breaks the build
#include <QScriptValue>
#ifdef KWIN_BUILD_SCRIPTING
#include "scripting/client.h"
#endif

#include "utils.h"
#include "options.h"
#include "workspace.h"
#include "kdecoration.h"
#include "rules.h"
#include "toplevel.h"
#include "clientgroup.h"

#ifdef HAVE_XSYNC
#include <X11/extensions/sync.h>
#endif

// TODO: Cleanup the order of things in this .h file

class QProcess;
class QTimer;
class KStartupInfoData;

#ifdef KWIN_BUILD_SCRIPTING
namespace SWrapper
{
class Client;
}

typedef QPair<SWrapper::Client*, QScriptValue> ClientResolution;
#endif

namespace KWin
{
namespace TabBox
{

class TabBoxClientImpl;
}


class Workspace;
class Client;
class Bridge;
class PaintRedirector;

class Client
    : public Toplevel
{
    Q_OBJECT
public:
    Client(Workspace* ws);
    Window wrapperId() const;
    Window decorationId() const;

    const Client* transientFor() const;
    Client* transientFor();
    bool isTransient() const;
    bool groupTransient() const;
    bool wasOriginallyGroupTransient() const;
    ClientList mainClients() const; // Call once before loop , is not indirect
    ClientList allMainClients() const; // Call once before loop , is indirect
    bool hasTransient(const Client* c, bool indirect) const;
    const ClientList& transients() const; // Is not indirect
    void checkTransient(Window w);
    Client* findModal(bool allow_itself = false);
    const Group* group() const;
    Group* group();
    void checkGroup(Group* gr = NULL, bool force = false);
    void changeClientLeaderGroup(Group* gr);
    const WindowRules* rules() const;
    void removeRule(Rules* r);
    void setupWindowRules(bool ignore_temporary);
    void applyWindowRules();
    void updateWindowRules();
    void updateFullscreenMonitors(NETFullscreenMonitors topology);

    /**
     * Returns true for "special" windows and false for windows which are "normal"
     * (normal=window which has a border, can be moved by the user, can be closed, etc.)
     * true for Desktop, Dock, Splash, Override and TopMenu (and Toolbar??? - for now)
     * false for Normal, Dialog, Utility and Menu (and Toolbar??? - not yet) TODO
     */
    bool isSpecialWindow() const;
    bool hasNETSupport() const;

#ifdef KWIN_BUILD_SCRIPTING
    /**
      * This is a public object with no wrappers or anything to keep it fast,
      * so in essence, direct access is allowed. Please be very careful while
      * using this object
      */
    QHash<QScriptEngine*, ClientResolution>* scriptCache;
#endif

    QSize minSize() const;
    QSize maxSize() const;
    virtual QPoint clientPos() const; // Inside of geometry()
    virtual QSize clientSize() const;
    virtual QRect visibleRect() const;

    bool windowEvent(XEvent* e);
    virtual bool eventFilter(QObject* o, QEvent* e);
#ifdef HAVE_XSYNC
    void syncEvent(XSyncAlarmNotifyEvent* e);
#endif

    bool manage(Window w, bool isMapped);
    void releaseWindow(bool on_shutdown = false);
    void destroyClient();

    /// How to resize the window in order to obey constains (mainly aspect ratios)
    enum Sizemode {
        SizemodeAny,
        SizemodeFixedW, ///< Try not to affect width
        SizemodeFixedH, ///< Try not to affect height
        SizemodeMax ///< Try not to make it larger in either direction
    };
    QSize adjustedSize(const QSize&, Sizemode mode = SizemodeAny) const;
    QSize adjustedSize() const;

    QPixmap icon() const;
    QPixmap icon(const QSize& size) const;
    QPixmap miniIcon() const;
    QPixmap bigIcon() const;
    QPixmap hugeIcon() const;

    bool isActive() const;
    void setActive(bool);

    virtual int desktop() const;
    void setDesktop(int);
    void setOnAllDesktops(bool set);

    virtual QStringList activities() const;
    void setOnActivity(const QString &activity, bool enable);
    void setOnAllActivities(bool set);
    void setOnActivities(QStringList newActivitiesList);
    void updateActivities(bool includeTransients);

    /// Is not minimized and not hidden. I.e. normally visible on some virtual desktop.
    bool isShown(bool shaded_is_shown) const;
    bool isHiddenInternal() const; // For compositing

    bool isShade() const; // True only for ShadeNormal
    ShadeMode shadeMode() const; // Prefer isShade()
    void setShade(ShadeMode mode);
    bool isShadeable() const;

    bool isMinimized() const;
    bool isMaximizable() const;
    QRect geometryRestore() const;
    MaximizeMode maximizeModeRestore() const;
    MaximizeMode maximizeMode() const;
    bool isMinimizable() const;
    void setMaximize(bool vertically, bool horizontally);
    QRect iconGeometry() const;

    void setFullScreen(bool set, bool user);
    bool isFullScreen() const;
    bool isFullScreenable(bool fullscreen_hack = false) const;
    bool isActiveFullScreen() const;
    bool userCanSetFullScreen() const;
    QRect geometryFSRestore() const {
        return geom_fs_restore;    // Only for session saving
    }
    int fullScreenMode() const {
        return fullscreen_mode;    // only for session saving
    }

    bool noBorder() const;
    void setNoBorder(bool set);
    bool userCanSetNoBorder() const;
    void checkNoBorder();

    bool skipTaskbar(bool from_outside = false) const;
    void setSkipTaskbar(bool set, bool from_outside);

    bool skipPager() const;
    void setSkipPager(bool);

    bool skipSwitcher() const;
    void setSkipSwitcher(bool set);

    bool keepAbove() const;
    void setKeepAbove(bool);
    bool keepBelow() const;
    void setKeepBelow(bool);
    Layer layer() const;
    Layer belongsToLayer() const;
    void invalidateLayer();
    int sessionStackingOrder() const;

    void setModal(bool modal);
    bool isModal() const;

    // Auxiliary functions, depend on the windowType
    bool wantsTabFocus() const;
    bool wantsInput() const;

    bool isResizable() const;
    bool isMovable() const;
    bool isMovableAcrossScreens() const;
    bool isCloseable() const; ///< May be closed by the user (May have a close button)

    void takeActivity(int flags, bool handled, allowed_t);   // Takes ActivityFlags as arg (in utils.h)
    void takeFocus(allowed_t);
    void demandAttention(bool set = true);

    void setMask(const QRegion& r, int mode = X::Unsorted);
    QRegion mask() const;

    void updateDecoration(bool check_workspace_pos, bool force = false);
    bool checkBorderSizes(bool also_resize);
    void triggerDecorationRepaint();

    void updateShape();

    void setGeometry(int x, int y, int w, int h, ForceGeometry_t force = NormalGeometrySet, bool emitJs = true);
    void setGeometry(const QRect& r, ForceGeometry_t force = NormalGeometrySet, bool emitJs = true);
    void move(int x, int y, ForceGeometry_t force = NormalGeometrySet);
    void move(const QPoint& p, ForceGeometry_t force = NormalGeometrySet);
    /// plainResize() simply resizes
    void plainResize(int w, int h, ForceGeometry_t force = NormalGeometrySet, bool emitJs = true);
    void plainResize(const QSize& s, ForceGeometry_t force = NormalGeometrySet, bool emitJs = true);
    /// resizeWithChecks() resizes according to gravity, and checks workarea position
    void resizeWithChecks(int w, int h, ForceGeometry_t force = NormalGeometrySet);
    void resizeWithChecks(const QSize& s, ForceGeometry_t force = NormalGeometrySet);
    void keepInArea(QRect area, bool partial = false);
    void setElectricBorderMode(QuickTileMode mode);
    QuickTileMode electricBorderMode() const;
    void setElectricBorderMaximizing(bool maximizing);
    bool isElectricBorderMaximizing() const;
    QRect electricBorderMaximizeGeometry(QPoint pos, int desktop);
    QSize sizeForClientSize(const QSize&, Sizemode mode = SizemodeAny, bool noframe = false) const;

    /** Set the quick tile mode ("snap") of this window.
     * This will also handle preserving and restoring of window geometry as necessary.
     * @param mode The tile mode (left/right) to give this window.
     */
    void setQuickTileMode(QuickTileMode mode, bool keyboard = false);

    void growHorizontal();
    void shrinkHorizontal();
    void growVertical();
    void shrinkVertical();

    bool providesContextHelp() const;
    KShortcut shortcut() const;
    void setShortcut(const QString& cut);

    WindowOperation mouseButtonToWindowOperation(Qt::MouseButtons button);
    bool performMouseCommand(Options::MouseCommand, const QPoint& globalPos, bool handled = false);

    QRect adjustedClientArea(const QRect& desktop, const QRect& area) const;

    Colormap colormap() const;

    /// Updates visibility depending on being shaded, virtual desktop, etc.
    void updateVisibility();
    /// Hides a client - Basically like minimize, but without effects, it's simply hidden
    void hideClient(bool hide);
    bool hiddenPreview() const; ///< Window is mapped in order to get a window pixmap

    virtual void setupCompositing();
    virtual void finishCompositing();
    inline bool isBlockingCompositing() { return blocks_compositing; }
    void updateCompositeBlocking(bool readProperty = false);

    QString caption(bool full = true) const;
    void updateCaption();

    void keyPressEvent(uint key_code);   // FRAME ??
    void updateMouseGrab();
    Window moveResizeGrabWindow() const;

    const QPoint calculateGravitation(bool invert, int gravity = 0) const;   // FRAME public?

    void NETMoveResize(int x_root, int y_root, NET::Direction direction);
    void NETMoveResizeWindow(int flags, int x, int y, int width, int height);
    void restackWindow(Window above, int detail, NET::RequestSource source, Time timestamp,
                       bool send_event = false);

    void gotPing(Time timestamp);

    void checkWorkspacePosition(QRect oldGeometry = QRect(), int oldDesktop = -2);
    void updateUserTime(Time time = CurrentTime);
    Time userTime() const;
    bool hasUserTimeSupport() const;
    bool ignoreFocusStealing() const;

    /// Does 'delete c;'
    static void deleteClient(Client* c, allowed_t);

    static bool belongToSameApplication(const Client* c1, const Client* c2, bool active_hack = false);
    static bool sameAppWindowRoleMatch(const Client* c1, const Client* c2, bool active_hack);
    static void readIcons(Window win, QPixmap* icon, QPixmap* miniicon, QPixmap* bigicon, QPixmap* hugeicon);

    void minimize(bool avoid_animation = false);
    void unminimize(bool avoid_animation = false);
    void closeWindow();
    void killWindow();
    void maximize(MaximizeMode);
    void toggleShade();
    void showContextHelp();
    void cancelShadeHoverTimer();
    void cancelAutoRaise();
    void checkActiveModal();
    StrutRect strutRect(StrutArea area) const;
    StrutRects strutRects() const;
    bool hasStrut() const;

    // Tabbing functions
    ClientGroup* clientGroup() const; // Returns a pointer to client_group
    void setClientGroup(ClientGroup* group);
    /*
    *   If shown is true the client is mapped and raised, if false
    *   the client is unmapped and hidden, this function is called
    *   when the tabbing group of the client switches its visible
    *   client.
    */
    void setClientShown(bool shown);
    /*
    *   When a click is done in the decoration and it calls the group
    *   to change the visible client it starts to move-resize the new
    *   client, this function stops it.
    */
    void dontMoveResize();

    /**
     * Whether or not the window has a strut that expands through the invisible area of
     * an xinerama setup where the monitors are not the same resolution.
     */
    bool hasOffscreenXineramaStrut() const;

    bool isMove() const {
        return moveResizeMode && mode == PositionCenter;
    }
    bool isResize() const {
        return moveResizeMode && mode != PositionCenter;
    }

    // Decorations <-> Effects
    const QPixmap *topDecoPixmap() const {
        return &decorationPixmapTop;
    }
    const QPixmap *leftDecoPixmap() const {
        return &decorationPixmapLeft;
    }
    const QPixmap *bottomDecoPixmap() const {
        return &decorationPixmapBottom;
    }
    const QPixmap *rightDecoPixmap() const {
        return &decorationPixmapRight;
    }

    int paddingLeft() const {
        return padding_left;
    }
    int paddingRight() const {
        return padding_right;
    }
    int paddingTop() const {
        return padding_top;
    }
    int paddingBottom() const {
        return padding_bottom;
    }

    bool decorationPixmapRequiresRepaint();
    void ensureDecorationPixmapsPainted();

    QRect decorationRect() const;

    QRect transparentRect() const;

    QRegion decorationPendingRegion() const;

    enum CoordinateMode {
        DecorationRelative, // Relative to the top left corner of the decoration
        WindowRelative      // Relative to the top left corner of the window
    };
    void layoutDecorationRects(QRect &left, QRect &top, QRect &right, QRect &bottom, CoordinateMode mode) const;

    TabBox::TabBoxClientImpl* tabBoxClient() const {
        return m_tabBoxClient;
    }

    //sets whether the client should be treated as a SessionInteract window
    void setSessionInteract(bool needed);

private slots:
    void autoRaise();
    void shadeHover();
    void shadeUnhover();
    void shortcutActivated();
    void delayedMoveResize();

private:
    friend class Bridge; // FRAME
    virtual void processMousePressEvent(QMouseEvent* e);

private:
    // Use Workspace::createClient()
    virtual ~Client(); ///< Use destroyClient() or releaseWindow()

    Position mousePosition(const QPoint&) const;
    void updateCursor();

    // Handlers for X11 events
    bool mapRequestEvent(XMapRequestEvent* e);
    void unmapNotifyEvent(XUnmapEvent* e);
    void destroyNotifyEvent(XDestroyWindowEvent* e);
    void configureRequestEvent(XConfigureRequestEvent* e);
    virtual void propertyNotifyEvent(XPropertyEvent* e);
    void clientMessageEvent(XClientMessageEvent* e);
    void enterNotifyEvent(XCrossingEvent* e);
    void leaveNotifyEvent(XCrossingEvent* e);
    void focusInEvent(XFocusInEvent* e);
    void focusOutEvent(XFocusOutEvent* e);
    virtual void damageNotifyEvent(XDamageNotifyEvent* e);

    bool buttonPressEvent(Window w, int button, int state, int x, int y, int x_root, int y_root);
    bool buttonReleaseEvent(Window w, int button, int state, int x, int y, int x_root, int y_root);
    bool motionNotifyEvent(Window w, int state, int x, int y, int x_root, int y_root);
    void checkQuickTilingMaximizationZones(int xroot, int yroot);

    bool processDecorationButtonPress(int button, int state, int x, int y, int x_root, int y_root,
                                      bool ignoreMenu = false);

protected:
    virtual void debug(QDebug& stream) const;
    virtual bool shouldUnredirect() const;

private slots:
    void delayedSetShortcut();
    void performMoveResize();
    void removeSyncSupport();
    void pingTimeout();
    void processKillerExited();
    void demandAttentionKNotify();
    void repaintDecorationPending();

    //Signals for the scripting interface
    //Signals make an excellent way for communication
    //in between objects as compared to simple function
    //calls
signals:
    void s_clientMoved();
    void clientManaging(KWin::Client*);
    void s_minimized();
    void s_unminimized();
    void maximizeSet(QPair<bool, bool>);
    void s_activated();
    void s_fullScreenSet(bool, bool);
    void clientMaximizedStateChanged(KWin::Client*, KDecorationDefines::MaximizeMode);
    void clientMinimized(KWin::Client* client, bool animate);
    void clientUnminimized(KWin::Client* client, bool animate);
    void clientStartUserMovedResized(KWin::Client*);
    void clientStepUserMovedResized(KWin::Client *, const QRect&);
    void clientFinishUserMovedResized(KWin::Client*);

    // To make workspace-client calls, a few slots are also
    // required
public slots:
    void sl_activated();

private:
    void exportMappingState(int s);   // ICCCM 4.1.3.1, 4.1.4, NETWM 2.5.1
    bool isManaged() const; ///< Returns false if this client is not yet managed
    void updateAllowedActions(bool force = false);
    QRect fullscreenMonitorsArea(NETFullscreenMonitors topology) const;
    void changeMaximize(bool horizontal, bool vertical, bool adjust);
    int checkFullScreenHack(const QRect& geom) const;   // 0 - None, 1 - One xinerama screen, 2 - Full area
    void updateFullScreenHack(const QRect& geom);
    void getWmNormalHints();
    void getMotifHints();
    void getIcons();
    void fetchName();
    void fetchIconicName();
    QString readName() const;
    void setCaption(const QString& s, bool force = false);
    bool hasTransientInternal(const Client* c, bool indirect, ConstClientList& set) const;
    void finishWindowRules();
    void setShortcutInternal(const KShortcut& cut);

    void configureRequest(int value_mask, int rx, int ry, int rw, int rh, int gravity, bool from_tool);
    NETExtendedStrut strut() const;
    int checkShadeGeometry(int w, int h);
    void blockGeometryUpdates(bool block);
    void getSyncCounter();
    void sendSyncRequest();
    bool startMoveResize();
    void finishMoveResize(bool cancel);
    void leaveMoveResize();
    void checkUnrestrictedMoveResize();
    void handleMoveResize(int x, int y, int x_root, int y_root);
    void startDelayedMoveResize();
    void stopDelayedMoveResize();
    void positionGeometryTip();
    void grabButton(int mod);
    void ungrabButton(int mod);
    void resetMaximize();
    void resizeDecoration(const QSize& s);

    void pingWindow();
    void killProcess(bool ask, Time timestamp = CurrentTime);
    void updateUrgency();
    static void sendClientMessage(Window w, Atom a, Atom protocol,
                                  long data1 = 0, long data2 = 0, long data3 = 0);

    void embedClient(Window w, const XWindowAttributes& attr);
    void detectNoBorder();
    void destroyDecoration();
    void updateFrameExtents();

    void internalShow(allowed_t);
    void internalHide(allowed_t);
    void internalKeep(allowed_t);
    void map(allowed_t);
    void unmap(allowed_t);
    void updateHiddenPreview();

    void updateInputShape();
    void repaintDecorationPixmap(QPixmap& pix, const QRect& r, const QPixmap& src, QRegion reg);
    void resizeDecorationPixmaps();

    Time readUserTimeMapTimestamp(const KStartupInfoId* asn_id, const KStartupInfoData* asn_data,
                                  bool session) const;
    Time readUserCreationTime() const;
    void startupIdChanged();

    void checkOffscreenPosition (QRect* geom, const QRect& screenArea);

    Window client;
    Window wrapper;
    KDecoration* decoration;
    Bridge* bridge;
    int desk;
    QStringList activityList;
    bool buttonDown;
    bool moveResizeMode;
    Window move_resize_grab_window;
    bool move_resize_has_keyboard_grab;
    bool unrestrictedMoveResize;

    Position mode;
    QPoint moveOffset;
    QPoint invertedMoveOffset;
    QRect moveResizeGeom;
    QRect initialMoveResizeGeom;
    XSizeHints xSizeHint;
    void sendSyntheticConfigureNotify();
    enum MappingState {
        Withdrawn, ///< Not handled, as per ICCCM WithdrawnState
        Mapped, ///< The frame is mapped
        Unmapped, ///< The frame is not mapped
        Kept ///< The frame should be unmapped, but is kept (For compositing)
    };
    MappingState mapping_state;

    /** The quick tile mode of this window.
     */
    int quick_tile_mode;
    QRect geom_pretile;

    void readTransient();
    Window verifyTransientFor(Window transient_for, bool set);
    void addTransient(Client* cl);
    void removeTransient(Client* cl);
    void removeFromMainClients();
    void cleanGrouping();
    void checkGroupTransients();
    void setTransient(Window new_transient_for_id);
    Client* transient_for;
    Window transient_for_id;
    Window original_transient_for_id;
    ClientList transients_list; // SELI TODO: Make this ordered in stacking order?
    ShadeMode shade_mode;
    uint active : 1;
    uint deleting : 1; ///< True when doing cleanup and destroying the client
    uint keep_above : 1; ///< NET::KeepAbove (was stays_on_top)
    uint skip_taskbar : 1;
    uint original_skip_taskbar : 1; ///< Unaffected by KWin
    uint Pdeletewindow : 1; ///< Does the window understand the DeleteWindow protocol?
    uint Ptakefocus : 1;///< Does the window understand the TakeFocus protocol?
    uint Ptakeactivity : 1; ///< Does it support _NET_WM_TAKE_ACTIVITY
    uint Pcontexthelp : 1; ///< Does the window understand the ContextHelp protocol?
    uint Pping : 1; ///< Does it support _NET_WM_PING?
    uint input : 1; ///< Does the window want input in its wm_hints
    uint skip_pager : 1;
    uint skip_switcher : 1;
    uint motif_may_resize : 1;
    uint motif_may_move : 1;
    uint motif_may_close : 1;
    uint keep_below : 1; ///< NET::KeepBelow
    uint minimized : 1;
    uint hidden : 1; ///< Forcibly hidden by calling hide()
    uint modal : 1; ///< NET::Modal
    uint noborder : 1;
    uint app_noborder : 1; ///< App requested no border via window type, shape extension, etc.
    uint motif_noborder : 1; ///< App requested no border via Motif WM hints
    uint urgency : 1; ///< XWMHints, UrgencyHint
    uint ignore_focus_stealing : 1; ///< Don't apply focus stealing prevention to this client
    uint demands_attention : 1;
    bool blocks_compositing;
    WindowRules client_rules;
    void getWMHints();
    void readIcons();
    void getWindowProtocols();
    QPixmap icon_pix;
    QPixmap miniicon_pix;
    QPixmap bigicon_pix;
    QPixmap hugeicon_pix;
    QCursor cursor;
    // DON'T reorder - Saved to config files !!!
    enum FullScreenMode {
        FullScreenNone,
        FullScreenNormal,
        FullScreenHack ///< Non-NETWM fullscreen (noborder and size of desktop)
    };
    FullScreenMode fullscreen_mode;
    MaximizeMode max_mode;
    QRect geom_restore;
    QRect geom_fs_restore;
    MaximizeMode maxmode_restore;
    QTimer* autoRaiseTimer;
    QTimer* shadeHoverTimer;
    QTimer* delayedMoveResizeTimer;
    Colormap cmap;
    QString cap_normal, cap_iconic, cap_suffix;
    Group* in_group;
    Window window_group;
    ClientGroup* client_group;
    Layer in_layer;
    QTimer* ping_timer;
    QProcess* process_killer;
    Time ping_timestamp;
    Time user_time;
    unsigned long allowed_actions;
    QSize client_size;
    int block_geometry_updates; // > 0 = New geometry is remembered, but not actually set
    enum PendingGeometry_t {
        PendingGeometryNone,
        PendingGeometryNormal,
        PendingGeometryForced
    };
    PendingGeometry_t pending_geometry_update;
    QRect geom_before_block;
    QRect deco_rect_before_block;
    bool shade_geometry_change;
#ifdef HAVE_XSYNC
    struct {
        XSyncCounter counter;
        XSyncValue value;
        XSyncAlarm alarm;
        QTimer *timeout, *failsafeTimeout;
        bool isPending;
    } syncRequest;
#endif
    int border_left, border_right, border_top, border_bottom;
    int padding_left, padding_right, padding_top, padding_bottom;
    QRegion _mask;
    static bool check_active_modal; ///< \see Client::checkActiveModal()
    KShortcut _shortcut;
    int sm_stacking_order;
    friend struct FetchNameInternalPredicate;
    friend struct CheckIgnoreFocusStealingProcedure;
    friend struct ResetupRulesProcedure;
    friend class GeometryUpdatesBlocker;
    QTimer* demandAttentionKNotifyTimer;
    QPixmap decorationPixmapLeft, decorationPixmapRight, decorationPixmapTop, decorationPixmapBottom;
    // we (instead of Qt) initialize the Pixmaps, and have to free them
    bool m_responsibleForDecoPixmap;
    PaintRedirector* paintRedirector;
    TabBox::TabBoxClientImpl* m_tabBoxClient;

    bool electricMaximizing;
    QuickTileMode electricMode;

    friend bool performTransiencyCheck();
#ifdef KWIN_BUILD_SCRIPTING
    friend class SWrapper::Client;
#endif

    void checkActivities();
    bool activitiesDefined; //whether the x property was actually set

    bool needsSessionInteract;
};

/**
 * Helper for Client::blockGeometryUpdates() being called in pairs (true/false)
 */
class GeometryUpdatesBlocker
{
public:
    GeometryUpdatesBlocker(Client* c)
        : cl(c) {
        cl->blockGeometryUpdates(true);
    }
    ~GeometryUpdatesBlocker() {
        cl->blockGeometryUpdates(false);
    }

private:
    Client* cl;
};

/**
 * NET WM Protocol handler class
 */
class WinInfo : public NETWinInfo2
{
private:
    typedef KWin::Client Client; // Because of NET::Client

public:
    WinInfo(Client* c, Display * display, Window window,
            Window rwin, const unsigned long pr[], int pr_size);
    virtual void changeDesktop(int desktop);
    virtual void changeFullscreenMonitors(NETFullscreenMonitors topology);
    virtual void changeState(unsigned long state, unsigned long mask);
    void disable();

private:
    Client * m_client;
};

inline Window Client::wrapperId() const
{
    return wrapper;
}

inline Window Client::decorationId() const
{
    return decoration != NULL ? decoration->widget()->winId() : None;
}

inline const Client* Client::transientFor() const
{
    return transient_for;
}

inline Client* Client::transientFor()
{
    return transient_for;
}

inline bool Client::groupTransient() const
{
    return transient_for_id == rootWindow();
}

// Needed because verifyTransientFor() may set transient_for_id to root window,
// if the original value has a problem (window doesn't exist, etc.)
inline bool Client::wasOriginallyGroupTransient() const
{
    return original_transient_for_id == rootWindow();
}

inline bool Client::isTransient() const
{
    return transient_for_id != None;
}

inline const ClientList& Client::transients() const
{
    return transients_list;
}

inline const Group* Client::group() const
{
    return in_group;
}

inline Group* Client::group()
{
    return in_group;
}

inline void Client::setClientGroup(ClientGroup* group)
{
    client_group = group;
}

inline ClientGroup* Client::clientGroup() const
{
    return client_group;
}

inline bool Client::isMinimized() const
{
    return minimized;
}

inline bool Client::isActive() const
{
    return active;
}

inline bool Client::isShown(bool shaded_is_shown) const
{
    return !isMinimized() && (!isShade() || shaded_is_shown) && !hidden &&
           (clientGroup() == NULL || clientGroup()->visible() == this);
}

inline bool Client::isHiddenInternal() const
{
    return hidden;
}

inline bool Client::isShade() const
{
    return shade_mode == ShadeNormal;
}

inline ShadeMode Client::shadeMode() const
{
    return shade_mode;
}

inline QPixmap Client::icon() const
{
    return icon_pix;
}

inline QPixmap Client::miniIcon() const
{
    return miniicon_pix;
}

inline QPixmap Client::bigIcon() const
{
    return bigicon_pix;
}

inline QPixmap Client::hugeIcon() const
{
    return hugeicon_pix;
}

inline QRect Client::geometryRestore() const
{
    return geom_restore;
}

inline Client::MaximizeMode Client::maximizeModeRestore() const
{
    return maxmode_restore;
}

inline Client::MaximizeMode Client::maximizeMode() const
{
    return max_mode;
}

inline bool Client::skipTaskbar(bool from_outside) const
{
    return from_outside ? original_skip_taskbar : skip_taskbar;
}

inline bool Client::skipPager() const
{
    return skip_pager;
}

inline bool Client::skipSwitcher() const
{
    return skip_switcher;
}

inline bool Client::keepAbove() const
{
    return keep_above;
}

inline bool Client::keepBelow() const
{
    return keep_below;
}

inline bool Client::isFullScreen() const
{
    return fullscreen_mode != FullScreenNone;
}

inline bool Client::isModal() const
{
    return modal;
}

inline bool Client::hasNETSupport() const
{
    return info->hasNETSupport();
}

inline Colormap Client::colormap() const
{
    return cmap;
}

inline void Client::invalidateLayer()
{
    in_layer = UnknownLayer;
}

inline int Client::sessionStackingOrder() const
{
    return sm_stacking_order;
}

inline bool Client::isManaged() const
{
    return mapping_state != Withdrawn;
}

inline QPoint Client::clientPos() const
{
    return QPoint(border_left, border_top);
}

inline QSize Client::clientSize() const
{
    return client_size;
}

inline QRect Client::visibleRect() const
{
    return Toplevel::visibleRect().adjusted(-padding_left, -padding_top, padding_right, padding_bottom);
}

inline void Client::setGeometry(const QRect& r, ForceGeometry_t force, bool emitJs)
{
    setGeometry(r.x(), r.y(), r.width(), r.height(), force, emitJs);
}

inline void Client::move(const QPoint& p, ForceGeometry_t force)
{
    move(p.x(), p.y(), force);
}

inline void Client::plainResize(const QSize& s, ForceGeometry_t force, bool emitJs)
{
    plainResize(s.width(), s.height(), force, emitJs);
}

inline void Client::resizeWithChecks(const QSize& s, ForceGeometry_t force)
{
    resizeWithChecks(s.width(), s.height(), force);
}

inline bool Client::hasUserTimeSupport() const
{
    return info->userTime() != -1U;
}

inline bool Client::ignoreFocusStealing() const
{
    return ignore_focus_stealing;
}

inline const WindowRules* Client::rules() const
{
    return &client_rules;
}

KWIN_PROCEDURE(CheckIgnoreFocusStealingProcedure, Client, cl->ignore_focus_stealing = options->checkIgnoreFocusStealing(cl));

inline Window Client::moveResizeGrabWindow() const
{
    return move_resize_grab_window;
}

inline KShortcut Client::shortcut() const
{
    return _shortcut;
}

inline void Client::removeRule(Rules* rule)
{
    client_rules.remove(rule);
}

inline bool Client::hiddenPreview() const
{
    return mapping_state == Kept;
}

KWIN_COMPARE_PREDICATE(WrapperIdMatchPredicate, Client, Window, cl->wrapperId() == value);

} // namespace

#endif