workspace/kwin/client.h

   1 /********************************************************************
   2  KWin - the KDE window manager
   3  This file is part of the KDE project.
   4
   5 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
   6 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 *********************************************************************/
  21
  22 #ifndef KWIN_CLIENT_H
  23 #define KWIN_CLIENT_H
  24
  25 #include <config-X11.h>
  26
  27 #include <QFrame>
  28 #include <QPixmap>
  29 #include <netwm.h>
  30 #include <kdebug.h>
  31 #include <assert.h>
  32 #include <kshortcut.h>
  33 #include <X11/X.h>
  34 #include <X11/Xlib.h>
  35 #include <X11/Xutil.h>
  36 #include <fixx11h.h>
  37
  38 #include "utils.h"
  39 #include "options.h"
  40 #include "workspace.h"
  41 #include "kdecoration.h"
  42 #include "rules.h"
  43 #include "toplevel.h"
  44
  45 #ifdef HAVE_XSYNC
  46 #include <X11/extensions/sync.h>
  47 #endif
  48
  49 // TODO: Cleanup the order of things in this .h file
  50
  51 class QProcess;
  52 class QTimer;
  53 class KStartupInfoData;
  54
  55 namespace KWin
  56 {
  57
  58 class Workspace;
  59 class Client;
  60 class Bridge;
  61
  62 class Client
  63     : public Toplevel
  64     {
  65     Q_OBJECT
  66     public:
  67         Client( Workspace* ws );
  68         Window wrapperId() const;
  69         Window decorationId() const;
  70
  71         const Client* transientFor() const;
  72         Client* transientFor();
  73         bool isTransient() const;
  74         bool groupTransient() const;
  75         bool wasOriginallyGroupTransient() const;
  76         ClientList mainClients() const; // Call once before loop , is not indirect
  77         ClientList allMainClients() const; // Call once before loop , is indirect
  78         bool hasTransient( const Client* c, bool indirect ) const;
  79         const ClientList& transients() const; // Is not indirect
  80         void checkTransient( Window w );
  81         Client* findModal( bool allow_itself = false );
  82         const Group* group() const;
  83         Group* group();
  84         void checkGroup( Group* gr = NULL, bool force = false );
  85         void changeClientLeaderGroup( Group* gr );
  86         const WindowRules* rules() const;
  87         void removeRule( Rules* r );
  88         void setupWindowRules( bool ignore_temporary );
  89         void applyWindowRules();
  90         void updateWindowRules();
  91         void updateFullscreenMonitors( NETFullscreenMonitors topology );
  92
  93         /**
  94          * Returns true for "special" windows and false for windows which are "normal"
  95          * (normal=window which has a border, can be moved by the user, can be closed, etc.)
  96          * true for Desktop, Dock, Splash, Override and TopMenu (and Toolbar??? - for now)
  97          * false for Normal, Dialog, Utility and Menu (and Toolbar??? - not yet) TODO
  98          */
  99         bool isSpecialWindow() const;
 100         bool hasNETSupport() const;
 101
 102         QSize minSize() const;
 103         QSize maxSize() const;
 104         virtual QPoint clientPos() const; // Inside of geometry()
 105         virtual QSize clientSize() const;
 106
 107         bool windowEvent( XEvent* e );
 108         virtual bool eventFilter( QObject* o, QEvent* e );
 109 #ifdef HAVE_XSYNC
 110         void syncEvent( XSyncAlarmNotifyEvent* e );
 111 #endif
 112
 113         bool manage( Window w, bool isMapped );
 114         void releaseWindow( bool on_shutdown = false );
 115         void destroyClient();
 116
 117         /// How to resize the window in order to obey constains (mainly aspect ratios)
 118         enum Sizemode
 119             {
 120             SizemodeAny,
 121             SizemodeFixedW, ///< Try not to affect width
 122             SizemodeFixedH, ///< Try not to affect height
 123             SizemodeMax ///< Try not to make it larger in either direction
 124             };
 125         QSize adjustedSize( const QSize&, Sizemode mode = SizemodeAny ) const;
 126         QSize adjustedSize() const;
 127
 128         QPixmap icon() const;
 129         QPixmap miniIcon() const;
 130
 131         bool isActive() const;
 132         void setActive( bool );
 133
 134         virtual int desktop() const;
 135         void setDesktop( int );
 136         void setOnAllDesktops( bool set );
 137
 138         /// Is not minimized and not hidden. I.e. normally visible on some virtual desktop.
 139         bool isShown( bool shaded_is_shown ) const;
 140         bool isHiddenInternal() const; // For compositing
 141
 142         bool isShade() const; // True only for ShadeNormal
 143         ShadeMode shadeMode() const; // Prefer isShade()
 144         void setShade( ShadeMode mode );
 145         bool isShadeable() const;
 146
 147         bool isMinimized() const;
 148         bool isMaximizable() const;
 149         QRect geometryRestore() const;
 150         MaximizeMode maximizeModeRestore() const;
 151         MaximizeMode maximizeMode() const;
 152         bool isMinimizable() const;
 153         void setMaximize( bool vertically, bool horizontally );
 154         QRect iconGeometry() const;
 155
 156         void setFullScreen( bool set, bool user );
 157         bool isFullScreen() const;
 158         bool isFullScreenable( bool fullscreen_hack = false ) const;
 159         bool isActiveFullScreen() const;
 160         bool userCanSetFullScreen() const;
 161         QRect geometryFSRestore() const { return geom_fs_restore; } // Only for session saving
 162         int fullScreenMode() const { return fullscreen_mode; } // only for session saving
 163
 164         bool noBorder() const;
 165         void setNoBorder( bool set );
 166         bool userCanSetNoBorder() const;
 167
 168         bool skipTaskbar( bool from_outside = false ) const;
 169         void setSkipTaskbar( bool set, bool from_outside );
 170
 171         bool skipPager() const;
 172         void setSkipPager( bool );
 173
 174         bool keepAbove() const;
 175         void setKeepAbove( bool );
 176         bool keepBelow() const;
 177         void setKeepBelow( bool );
 178         Layer layer() const;
 179         Layer belongsToLayer() const;
 180         void invalidateLayer();
 181         int sessionStackingOrder() const;
 182
 183         void setModal( bool modal );
 184         bool isModal() const;
 185
 186         // Auxiliary functions, depend on the windowType
 187         bool wantsTabFocus() const;
 188         bool wantsInput() const;
 189
 190         bool isResizable() const;
 191         bool isMovable() const;
 192         bool isMovableAcrossScreens() const;
 193         bool isCloseable() const; ///< May be closed by the user (May have a close button)
 194
 195         void takeActivity( int flags, bool handled, allowed_t ); // Takes ActivityFlags as arg (in utils.h)
 196         void takeFocus( allowed_t );
 197         void demandAttention( bool set = true );
 198
 199         void setMask( const QRegion& r, int mode = X::Unsorted );
 200         QRegion mask() const;
 201
 202         void updateDecoration( bool check_workspace_pos, bool force = false );
 203         bool checkBorderSizes( bool also_resize );
 204         void repaintDecoration();
 205
 206         void updateShape();
 207
 208         void setGeometry( int x, int y, int w, int h, ForceGeometry_t force = NormalGeometrySet );
 209         void setGeometry( const QRect& r, ForceGeometry_t force = NormalGeometrySet );
 210         void move( int x, int y, ForceGeometry_t force = NormalGeometrySet );
 211         void move( const QPoint& p, ForceGeometry_t force = NormalGeometrySet );
 212         /// plainResize() simply resizes
 213         void plainResize( int w, int h, ForceGeometry_t force = NormalGeometrySet );
 214         void plainResize( const QSize& s, ForceGeometry_t force = NormalGeometrySet );
 215         /// resizeWithChecks() resizes according to gravity, and checks workarea position
 216         void resizeWithChecks( int w, int h, ForceGeometry_t force = NormalGeometrySet );
 217         void resizeWithChecks( const QSize& s, ForceGeometry_t force = NormalGeometrySet );
 218         void keepInArea( QRect area, bool partial = false );
 219
 220         void growHorizontal();
 221         void shrinkHorizontal();
 222         void growVertical();
 223         void shrinkVertical();
 224
 225         bool providesContextHelp() const;
 226         KShortcut shortcut() const;
 227         void setShortcut( const QString& cut );
 228
 229         bool performMouseCommand( Options::MouseCommand, const QPoint& globalPos, bool handled = false );
 230
 231         QRect adjustedClientArea( const QRect& desktop, const QRect& area ) const;
 232
 233         Colormap colormap() const;
 234
 235         /// Updates visibility depending on being shaded, virtual desktop, etc.
 236         void updateVisibility();
 237         /// Hides a client - Basically like minimize, but without effects, it's simply hidden
 238         void hideClient( bool hide );
 239         bool hiddenPreview() const; ///< Window is mapped in order to get a window pixmap
 240
 241         virtual void setupCompositing();
 242         virtual void finishCompositing();
 243
 244         QString caption( bool full = true ) const;
 245         void updateCaption();
 246
 247         void keyPressEvent( uint key_code ); // FRAME ??
 248         void updateMouseGrab();
 249         Window moveResizeGrabWindow() const;
 250
 251         const QPoint calculateGravitation( bool invert, int gravity = 0 ) const; // FRAME public?
 252
 253         void NETMoveResize( int x_root, int y_root, NET::Direction direction );
 254         void NETMoveResizeWindow( int flags, int x, int y, int width, int height );
 255         void restackWindow( Window above, int detail, NET::RequestSource source, Time timestamp,
 256             bool send_event = false );
 257
 258         void gotPing( Time timestamp );
 259
 260         void checkWorkspacePosition();
 261         void updateUserTime( Time time = CurrentTime );
 262         Time userTime() const;
 263         bool hasUserTimeSupport() const;
 264         bool ignoreFocusStealing() const;
 265
 266         /// Does 'delete c;'
 267         static void deleteClient( Client* c, allowed_t );
 268
 269         static bool belongToSameApplication( const Client* c1, const Client* c2, bool active_hack = false );
 270         static bool sameAppWindowRoleMatch( const Client* c1, const Client* c2, bool active_hack );
 271         static void readIcons( Window win, QPixmap* icon, QPixmap* miniicon );
 272
 273         void minimize( bool avoid_animation = false );
 274         void unminimize( bool avoid_animation = false );
 275         void closeWindow();
 276         void killWindow();
 277         void maximize( MaximizeMode );
 278         void toggleShade();
 279         void showContextHelp();
 280         void cancelShadeHoverTimer();
 281         void cancelAutoRaise();
 282         void checkActiveModal();
 283         bool hasStrut() const;
 284
 285         bool isMove() const
 286             {
 287             return moveResizeMode && mode == PositionCenter;
 288             }
 289         bool isResize() const
 290             {
 291             return moveResizeMode && mode != PositionCenter;
 292             }
 293
 294         // Decorations <-> Effects
 295         QList<QRect> shadowQuads( ShadowType type ) const;
 296         double shadowOpacity( ShadowType type ) const;
 297         double shadowBrightness( ShadowType type ) const;
 298         double shadowSaturation( ShadowType type ) const;
 299
 300     private slots:
 301         void autoRaise();
 302         void shadeHover();
 303         void shadeUnhover();
 304         void shortcutActivated();
 305         void delayedMoveResize();
 306
 307     private:
 308         friend class Bridge; // FRAME
 309         virtual void processMousePressEvent( QMouseEvent* e );
 310
 311     private:
 312         // Use Workspace::createClient()
 313         virtual ~Client(); ///< Use destroyClient() or releaseWindow()
 314
 315         Position mousePosition( const QPoint& ) const;
 316         void updateCursor();
 317
 318         // Transparent stuff
 319         void drawbound( const QRect& geom );
 320         void clearbound();
 321         void doDrawbound( const QRect& geom, bool clear );
 322
 323         // Handlers for X11 events
 324         bool mapRequestEvent( XMapRequestEvent* e );
 325         void unmapNotifyEvent( XUnmapEvent* e );
 326         void destroyNotifyEvent( XDestroyWindowEvent* e );
 327         void configureRequestEvent( XConfigureRequestEvent* e );
 328         virtual void propertyNotifyEvent( XPropertyEvent* e );
 329         void clientMessageEvent( XClientMessageEvent* e );
 330         void enterNotifyEvent( XCrossingEvent* e );
 331         void leaveNotifyEvent( XCrossingEvent* e );
 332         void focusInEvent( XFocusInEvent* e );
 333         void focusOutEvent( XFocusOutEvent* e );
 334 #ifdef HAVE_XDAMAGE
 335         virtual void damageNotifyEvent( XDamageNotifyEvent* e );
 336 #endif
 337
 338         bool buttonPressEvent( Window w, int button, int state, int x, int y, int x_root, int y_root );
 339         bool buttonReleaseEvent( Window w, int button, int state, int x, int y, int x_root, int y_root );
 340         bool motionNotifyEvent( Window w, int state, int x, int y, int x_root, int y_root );
 341
 342         void processDecorationButtonPress( int button, int state, int x, int y, int x_root, int y_root );
 343
 344     protected:
 345         virtual void debug( kdbgstream& stream ) const;
 346         virtual bool shouldUnredirect() const;
 347
 348     private slots:
 349         void pingTimeout();
 350         void processKillerExited();
 351         void demandAttentionKNotify();
 352         void syncTimeout();
 353         void delayedSetShortcut();
 354
 355     private:
 356         void exportMappingState( int s ); // ICCCM 4.1.3.1, 4.1.4, NETWM 2.5.1
 357         bool isManaged() const; ///< Returns false if this client is not yet managed
 358         void updateAllowedActions( bool force = false );
 359         QSize sizeForClientSize( const QSize&, Sizemode mode = SizemodeAny, bool noframe = false ) const;
 360         QRect fullscreenMonitorsArea( NETFullscreenMonitors topology ) const;
 361         void changeMaximize( bool horizontal, bool vertical, bool adjust );
 362         void checkMaximizeGeometry();
 363         int checkFullScreenHack( const QRect& geom ) const; // 0 - None, 1 - One xinerama screen, 2 - Full area
 364         void updateFullScreenHack( const QRect& geom );
 365         void getWmNormalHints();
 366         void getMotifHints();
 367         void getIcons();
 368         void fetchName();
 369         void fetchIconicName();
 370         QString readName() const;
 371         void setCaption( const QString& s, bool force = false );
 372         bool hasTransientInternal( const Client* c, bool indirect, ConstClientList& set ) const;
 373         void finishWindowRules();
 374         void setShortcutInternal( const KShortcut& cut );
 375
 376         void updateWorkareaDiffs();
 377         void checkDirection( int new_diff, int old_diff, QRect& rect, const QRect& area );
 378         static int computeWorkareaDiff( int left, int right, int a_left, int a_right );
 379         void configureRequest( int value_mask, int rx, int ry, int rw, int rh, int gravity, bool from_tool );
 380         NETExtendedStrut strut() const;
 381         int checkShadeGeometry( int w, int h );
 382         void blockGeometryUpdates( bool block );
 383         void getSyncCounter();
 384         void sendSyncRequest();
 385
 386         bool startMoveResize();
 387         void finishMoveResize( bool cancel );
 388         void leaveMoveResize();
 389         void checkUnrestrictedMoveResize();
 390         void handleMoveResize( int x, int y, int x_root, int y_root );
 391         void startDelayedMoveResize();
 392         void stopDelayedMoveResize();
 393         void positionGeometryTip();
 394         void grabButton( int mod );
 395         void ungrabButton( int mod );
 396         void resetMaximize();
 397         void resizeDecoration( const QSize& s );
 398         void performMoveResize();
 399
 400         void pingWindow();
 401         void killProcess( bool ask, Time timestamp = CurrentTime );
 402         void updateUrgency();
 403         static void sendClientMessage( Window w, Atom a, Atom protocol,
 404             long data1 = 0, long data2 = 0, long data3 = 0 );
 405
 406         void embedClient( Window w, const XWindowAttributes& attr );
 407         void detectNoBorder();
 408         void destroyDecoration();
 409         void updateFrameExtents();
 410
 411         void internalShow( allowed_t );
 412         void internalHide( allowed_t );
 413         void internalKeep( allowed_t );
 414         void map( allowed_t );
 415         void unmap( allowed_t );
 416         void updateHiddenPreview();
 417
 418         void updateInputShape();
 419
 420         Time readUserTimeMapTimestamp( const KStartupInfoId* asn_id, const KStartupInfoData* asn_data,
 421             bool session ) const;
 422         Time readUserCreationTime() const;
 423         void startupIdChanged();
 424
 425         Window client;
 426         Window wrapper;
 427         KDecoration* decoration;
 428         Bridge* bridge;
 429         int desk;
 430         bool buttonDown;
 431         bool moveResizeMode;
 432         bool move_faked_activity;
 433         Window move_resize_grab_window;
 434         bool move_resize_has_keyboard_grab;
 435         bool unrestrictedMoveResize;
 436
 437         Position mode;
 438         QPoint moveOffset;
 439         QPoint invertedMoveOffset;
 440         QRect moveResizeGeom;
 441         QRect initialMoveResizeGeom;
 442         XSizeHints xSizeHint;
 443         void sendSyntheticConfigureNotify();
 444         enum MappingState
 445             {
 446             Withdrawn, ///< Not handled, as per ICCCM WithdrawnState
 447             Mapped, ///< The frame is mapped
 448             Unmapped, ///< The frame is not mapped
 449             Kept ///< The frame should be unmapped, but is kept (For compositing)
 450             };
 451         MappingState mapping_state;
 452         void readTransient();
 453         Window verifyTransientFor( Window transient_for, bool set );
 454         void addTransient( Client* cl );
 455         void removeTransient( Client* cl );
 456         void removeFromMainClients();
 457         void cleanGrouping();
 458         void checkGroupTransients();
 459         void setTransient( Window new_transient_for_id );
 460         Client* transient_for;
 461         Window transient_for_id;
 462         Window original_transient_for_id;
 463         ClientList transients_list; // SELI TODO: Make this ordered in stacking order?
 464         ShadeMode shade_mode;
 465         uint active : 1;
 466         uint deleting : 1; ///< True when doing cleanup and destroying the client
 467         uint keep_above : 1; ///< NET::KeepAbove (was stays_on_top)
 468         uint skip_taskbar : 1;
 469         uint original_skip_taskbar : 1; ///< Unaffected by KWin
 470         uint Pdeletewindow : 1; ///< Does the window understand the DeleteWindow protocol?
 471         uint Ptakefocus : 1;///< Does the window understand the TakeFocus protocol?
 472         uint Ptakeactivity : 1; ///< Does it support _NET_WM_TAKE_ACTIVITY
 473         uint Pcontexthelp : 1; ///< Does the window understand the ContextHelp protocol?
 474         uint Pping : 1; ///< Does it support _NET_WM_PING?
 475         uint input : 1; ///< Does the window want input in its wm_hints
 476         uint skip_pager : 1;
 477         uint motif_may_resize : 1;
 478         uint motif_may_move : 1;
 479         uint motif_may_close : 1;
 480         uint keep_below : 1; ///< NET::KeepBelow
 481         uint minimized : 1;
 482         uint hidden : 1; ///< Forcibly hidden by calling hide()
 483         uint modal : 1; ///< NET::Modal
 484         uint noborder : 1;
 485         uint app_noborder : 1; ///< The app requested no border using something (window type, motif hints)
 486         uint urgency : 1; ///< XWMHints, UrgencyHint
 487         uint ignore_focus_stealing : 1; ///< Don't apply focus stealing prevention to this client
 488         uint demands_attention : 1;
 489         WindowRules client_rules;
 490         void getWMHints();
 491         void readIcons();
 492         void getWindowProtocols();
 493         QPixmap icon_pix;
 494         QPixmap miniicon_pix;
 495         QCursor cursor;
 496         // DON'T reorder - Saved to config files !!!
 497         enum FullScreenMode
 498             {
 499             FullScreenNone,
 500             FullScreenNormal,
 501             FullScreenHack ///< Non-NETWM fullscreen (noborder and size of desktop)
 502             };
 503         FullScreenMode fullscreen_mode;
 504         MaximizeMode max_mode;
 505         QRect geom_restore;
 506         QRect geom_fs_restore;
 507         MaximizeMode maxmode_restore;
 508         int workarea_diff_x, workarea_diff_y;
 509         QTimer* autoRaiseTimer;
 510         QTimer* shadeHoverTimer;
 511         QTimer* delayedMoveResizeTimer;
 512         Colormap cmap;
 513         QString cap_normal, cap_iconic, cap_suffix;
 514         Group* in_group;
 515         Window window_group;
 516         Layer in_layer;
 517         QTimer* ping_timer;
 518         QProcess* process_killer;
 519         Time ping_timestamp;
 520         Time user_time;
 521         unsigned long allowed_actions;
 522         QSize client_size;
 523         int block_geometry_updates; // > 0 = New geometry is remembered, but not actually set
 524         enum PendingGeometry_t
 525             {
 526             PendingGeometryNone,
 527             PendingGeometryNormal,
 528             PendingGeometryForced
 529             };
 530         PendingGeometry_t pending_geometry_update;
 531         QRect geom_before_block;
 532         bool shade_geometry_change;
 533 #ifdef HAVE_XSYNC
 534         XSyncCounter sync_counter;
 535         XSyncValue sync_counter_value;
 536         XSyncAlarm sync_alarm;
 537 #endif
 538         QTimer* sync_timeout;
 539         bool sync_resize_pending;
 540         int border_left, border_right, border_top, border_bottom;
 541         QRegion _mask;
 542         static bool check_active_modal; ///< \see Client::checkActiveModal()
 543         KShortcut _shortcut;
 544         int sm_stacking_order;
 545         friend struct FetchNameInternalPredicate;
 546         friend struct CheckIgnoreFocusStealingProcedure;
 547         friend struct ResetupRulesProcedure;
 548         friend class GeometryUpdatesBlocker;
 549         QTimer* demandAttentionKNotifyTimer;
 550
 551         friend bool performTransiencyCheck();
 552     };
 553
 554 /**
 555  * Helper for Client::blockGeometryUpdates() being called in pairs (true/false)
 556  */
 557 class GeometryUpdatesBlocker
 558     {
 559     public:
 560         GeometryUpdatesBlocker( Client* c )
 561             : cl( c ) { cl->blockGeometryUpdates( true ); }
 562         ~GeometryUpdatesBlocker()
 563             { cl->blockGeometryUpdates( false ); }
 564
 565     private:
 566         Client* cl;
 567     };
 568
 569 /**
 570  * NET WM Protocol handler class
 571  */
 572 class WinInfo : public NETWinInfo2
 573     {
 574     private:
 575         typedef KWin::Client Client; // Because of NET::Client
 576
 577     public:
 578         WinInfo( Client* c, Display * display, Window window,
 579             Window rwin, const unsigned long pr[], int pr_size );
 580         virtual void changeDesktop(int desktop);
 581         virtual void changeFullscreenMonitors(NETFullscreenMonitors topology);
 582         virtual void changeState( unsigned long state, unsigned long mask );
 583         void disable();
 584
 585     private:
 586         Client * m_client;
 587     };
 588
 589 inline Window Client::wrapperId() const
 590     {
 591     return wrapper;
 592     }
 593
 594 inline Window Client::decorationId() const
 595     {
 596     return decoration != NULL ? decoration->widget()->winId() : None;
 597     }
 598
 599 inline const Client* Client::transientFor() const
 600     {
 601     return transient_for;
 602     }
 603
 604 inline Client* Client::transientFor()
 605     {
 606     return transient_for;
 607     }
 608
 609 inline bool Client::groupTransient() const
 610     {
 611     return transient_for_id == rootWindow();
 612     }
 613
 614 // Needed because verifyTransientFor() may set transient_for_id to root window,
 615 // if the original value has a problem (window doesn't exist, etc.)
 616 inline bool Client::wasOriginallyGroupTransient() const
 617     {
 618     return original_transient_for_id == rootWindow();
 619     }
 620
 621 inline bool Client::isTransient() const
 622     {
 623     return transient_for_id != None;
 624     }
 625
 626 inline const ClientList& Client::transients() const
 627     {
 628     return transients_list;
 629     }
 630
 631 inline const Group* Client::group() const
 632     {
 633     return in_group;
 634     }
 635
 636 inline Group* Client::group()
 637     {
 638     return in_group;
 639     }
 640
 641 inline bool Client::isMinimized() const
 642     {
 643     return minimized;
 644     }
 645
 646 inline bool Client::isActive() const
 647     {
 648     return active;
 649     }
 650
 651 inline bool Client::isShown( bool shaded_is_shown ) const
 652     {
 653     return !isMinimized() && ( !isShade() || shaded_is_shown ) && !hidden;
 654     }
 655
 656 inline bool Client::isHiddenInternal() const
 657     {
 658     return hidden;
 659     }
 660
 661 inline bool Client::isShade() const
 662     {
 663     return shade_mode == ShadeNormal;
 664     }
 665
 666 inline ShadeMode Client::shadeMode() const
 667     {
 668     return shade_mode;
 669     }
 670
 671 inline QPixmap Client::icon() const
 672     {
 673     return icon_pix;
 674     }
 675
 676 inline QPixmap Client::miniIcon() const
 677     {
 678     return miniicon_pix;
 679     }
 680
 681 inline QRect Client::geometryRestore() const
 682     {
 683     return geom_restore;
 684     }
 685
 686 inline Client::MaximizeMode Client::maximizeModeRestore() const
 687     {
 688     return maxmode_restore;
 689     }
 690
 691 inline Client::MaximizeMode Client::maximizeMode() const
 692     {
 693     return max_mode;
 694     }
 695
 696 inline bool Client::skipTaskbar( bool from_outside ) const
 697     {
 698     return from_outside ? original_skip_taskbar : skip_taskbar;
 699     }
 700
 701 inline bool Client::skipPager() const
 702     {
 703     return skip_pager;
 704     }
 705
 706 inline bool Client::keepAbove() const
 707     {
 708     return keep_above;
 709     }
 710
 711 inline bool Client::keepBelow() const
 712     {
 713     return keep_below;
 714     }
 715
 716 inline bool Client::isFullScreen() const
 717     {
 718     return fullscreen_mode != FullScreenNone;
 719     }
 720
 721 inline bool Client::isModal() const
 722     {
 723     return modal;
 724     }
 725
 726 inline bool Client::hasNETSupport() const
 727     {
 728     return info->hasNETSupport();
 729     }
 730
 731 inline Colormap Client::colormap() const
 732     {
 733     return cmap;
 734     }
 735
 736 inline void Client::invalidateLayer()
 737     {
 738     in_layer = UnknownLayer;
 739     }
 740
 741 inline int Client::sessionStackingOrder() const
 742     {
 743     return sm_stacking_order;
 744     }
 745
 746 inline bool Client::isManaged() const
 747     {
 748     return mapping_state != Withdrawn;
 749     }
 750
 751 inline QPoint Client::clientPos() const
 752     {
 753     return QPoint( border_left, border_top );
 754     }
 755
 756 inline QSize Client::clientSize() const
 757     {
 758     return client_size;
 759     }
 760
 761 inline void Client::setGeometry( const QRect& r, ForceGeometry_t force )
 762     {
 763     setGeometry( r.x(), r.y(), r.width(), r.height(), force );
 764     }
 765
 766 inline void Client::move( const QPoint& p, ForceGeometry_t force )
 767     {
 768     move( p.x(), p.y(), force );
 769     }
 770
 771 inline void Client::plainResize( const QSize& s, ForceGeometry_t force )
 772     {
 773     plainResize( s.width(), s.height(), force );
 774     }
 775
 776 inline void Client::resizeWithChecks( const QSize& s, ForceGeometry_t force )
 777     {
 778     resizeWithChecks( s.width(), s.height(), force );
 779     }
 780
 781 inline bool Client::hasUserTimeSupport() const
 782     {
 783     return info->userTime() != -1U;
 784     }
 785
 786 inline bool Client::ignoreFocusStealing() const
 787     {
 788     return ignore_focus_stealing;
 789     }
 790
 791 inline const WindowRules* Client::rules() const
 792     {
 793     return &client_rules;
 794     }
 795
 796 KWIN_PROCEDURE( CheckIgnoreFocusStealingProcedure, Client, cl->ignore_focus_stealing = options->checkIgnoreFocusStealing( cl ));
 797
 798 inline Window Client::moveResizeGrabWindow() const
 799     {
 800     return move_resize_grab_window;
 801     }
 802
 803 inline KShortcut Client::shortcut() const
 804     {
 805     return _shortcut;
 806     }
 807
 808 inline void Client::removeRule( Rules* rule )
 809     {
 810     client_rules.remove( rule );
 811     }
 812
 813 inline bool Client::hiddenPreview() const
 814     {
 815     return mapping_state == Kept;
 816     }
 817
 818 inline QList<QRect> Client::shadowQuads( ShadowType type ) const
 819     {
 820     if( KDecorationUnstable* decoration2 = dynamic_cast< KDecorationUnstable* >( decoration ))
 821         return decoration2->shadowQuads( type );
 822     return QList<QRect>();
 823     }
 824
 825 inline double Client::shadowOpacity( ShadowType type ) const
 826     {
 827     if( KDecorationUnstable* decoration2 = dynamic_cast< KDecorationUnstable* >( decoration ))
 828         return decoration2->shadowOpacity( type );
 829     return 1.0;
 830     }
 831
 832 inline double Client::shadowBrightness( ShadowType type ) const
 833     {
 834     if( KDecorationUnstable* decoration2 = dynamic_cast< KDecorationUnstable* >( decoration ))
 835         return decoration2->shadowBrightness( type );
 836     return 1.0;
 837     }
 838
 839 inline double Client::shadowSaturation( ShadowType type ) const
 840     {
 841     if( KDecorationUnstable* decoration2 = dynamic_cast< KDecorationUnstable* >( decoration ))
 842         return decoration2->shadowSaturation( type );
 843     return 1.0;
 844     }
 845
 846 KWIN_COMPARE_PREDICATE( WrapperIdMatchPredicate, Client, Window, cl->wrapperId() == value );
 847
 848 } // namespace
 849
 850 #endif