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