diff options
Diffstat (limited to 'twin/client.h')
| -rw-r--r-- | twin/client.h | 997 |
1 files changed, 997 insertions, 0 deletions
diff --git a/twin/client.h b/twin/client.h new file mode 100644 index 000000000..ec94a994d --- /dev/null +++ b/twin/client.h @@ -0,0 +1,997 @@ +/***************************************************************** + 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> + +You can Freely distribute this program under the GNU General Public +License. See the file "COPYING" for the exact licensing terms. +******************************************************************/ + +#ifndef KWIN_CLIENT_H +#define KWIN_CLIENT_H + +#include <tqframe.h> +#include <tqvbox.h> +#include <tqpixmap.h> +#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> + +#include "utils.h" +#include "options.h" +#include "workspace.h" +#include "kdecoration.h" +#include "rules.h" + +class TQTimer; +class KProcess; +class KStartupInfoData; + +namespace KWinInternal +{ + +class Workspace; +class Client; +class WinInfo; +class SessionInfo; +class Bridge; + +class Client : public TQObject, public KDecorationDefines + { + Q_OBJECT + public: + Client( Workspace *ws ); + Window window() const; + Window frameId() const; + Window wrapperId() const; + Window decorationId() const; + + Workspace* workspace() const; + const Client* transientFor() const; + Client* transientFor(); + bool isTransient() const; + bool isModalSystemNotification() const; + bool groupTransient() const; + bool wasOriginallyGroupTransient() const; + ClientList mainClients() const; // call once before loop , is not indirect + bool hasTransient( const Client* c, bool indirect ) const; + const ClientList& transients() const; // is not indirect + void checkTransient( Window w ); + Client* findModal(); + const Group* group() const; + Group* group(); + void checkGroup( Group* gr = NULL, bool force = false ); + void changeClientLeaderGroup( Group* gr ); + // prefer isXXX() instead + NET::WindowType windowType( bool direct = false, int supported_types = SUPPORTED_WINDOW_TYPES_MASK ) const; + const WindowRules* rules() const; + void removeRule( Rules* r ); + void setupWindowRules( bool ignore_temporary ); + void applyWindowRules(); + void updateWindowRules(); + + TQRect geometry() const; + TQSize size() const; + TQSize minSize() const; + TQSize maxSize() const; + TQPoint pos() const; + TQRect rect() const; + int x() const; + int y() const; + int width() const; + int height() const; + TQPoint clientPos() const; // inside of geometry() + TQSize clientSize() const; + + bool windowEvent( XEvent* e ); + virtual bool eventFilter( TQObject* o, TQEvent* e ); + + bool manage( Window w, bool isMapped ); + + void releaseWindow( bool on_shutdown = false ); + + enum Sizemode // how to resize the window in order to obey constains (mainly aspect ratios) + { + SizemodeAny, + SizemodeFixedW, // try not to affect width + SizemodeFixedH, // try not to affect height + SizemodeMax // try not to make it larger in either direction + }; + TQSize adjustedSize( const TQSize&, Sizemode mode = SizemodeAny ) const; + TQSize adjustedSize() const; + + TQPixmap icon() const; + TQPixmap miniIcon() const; + + bool isActive() const; + void setActive( bool, bool updateOpacity = true ); + + int desktop() const; + void setDesktop( int ); + bool isOnDesktop( int d ) const; + bool isOnCurrentDesktop() const; + bool isOnAllDesktops() const; + void setOnAllDesktops( bool set ); + + bool isOnScreen( int screen ) const; // true if it's at least partially there + int screen() const; // the screen where the center is + + // !isMinimized() && not hidden, i.e. normally visible on some virtual desktop + bool isShown( bool shaded_is_shown ) const; + + 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; + TQRect geometryRestore() const; + MaximizeMode maximizeModeRestore() const; + MaximizeMode maximizeMode() const; + bool isMinimizable() const; + void setMaximize( bool vertically, bool horizontally ); + + void setFullScreen( bool set, bool user ); + bool isFullScreen() const; + bool isFullScreenable( bool fullscreen_hack = false ) const; + bool userCanSetFullScreen() const; + TQRect geometryFSRestore() const { return geom_fs_restore; } // only for session saving + int fullScreenMode() const { return fullscreen_mode; } // only for session saving + + bool isUserNoBorder() const; + void setUserNoBorder( bool set ); + bool userCanSetNoBorder() const; + bool noBorder() const; + + bool skipTaskbar( bool from_outside = false ) const; + void setSkipTaskbar( bool set, bool from_outside ); + + bool skipPager() const; + void setSkipPager( bool ); + + bool keepAbove() const; + void setKeepAbove( bool ); + bool keepBelow() const; + void setKeepBelow( bool ); + Layer layer() const; + Layer belongsToLayer() const; + void invalidateLayer(); + + void setModal( bool modal ); + bool isModal() const; + + // auxiliary functions, depend on the windowType + bool wantsTabFocus() const; + bool wantsInput() const; + bool hasNETSupport() const; + bool isMovable() const; + bool isDesktop() const; + bool isDock() const; + bool isToolbar() const; + bool isTopMenu() const; + bool isMenu() const; + bool isNormalWindow() const; // normal as in 'NET::Normal or NET::Unknown non-transient' + bool isDialog() const; + bool isSplash() const; + bool isUtility() const; + // 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 isResizable() 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 TQRegion& r, int mode = X::Unsorted ); + TQRegion mask() const; + + void updateDecoration( bool check_workspace_pos, bool force = false ); + void checkBorderSizes(); + + // drop shadow + bool isShadowed() const; + void setShadowed(bool shadowed); + Window shadowId() const; + // Aieee, a friend function! Unpleasant, yes, but it's needed by + // raiseClient() to redraw a window's shadow when it is active prior to + // being raised. + friend void Workspace::raiseClient(Client *); + // Wouldn't you know it, friend functions breed. This one's needed to + // enable a DCOP function that causes all shadows obscuring a changed + // window to be redrawn. + friend void Workspace::updateOverlappingShadows(WId); + + // tqshape extensions + bool tqshape() const; + void updateShape(); + + void setGeometry( int x, int y, int w, int h, ForceGeometry_t force = NormalGeometrySet ); + void setGeometry( const TQRect& r, ForceGeometry_t force = NormalGeometrySet ); + void move( int x, int y, ForceGeometry_t force = NormalGeometrySet ); + void move( const TQPoint & p, ForceGeometry_t force = NormalGeometrySet ); + // plainResize() simply resizes + void plainResize( int w, int h, ForceGeometry_t force = NormalGeometrySet ); + void plainResize( const TQSize& s, ForceGeometry_t force = NormalGeometrySet ); + // resizeWithChecks() resizes according to gravity, and checks workarea position + void resizeWithChecks( int w, int h, ForceGeometry_t force = NormalGeometrySet ); + void resizeWithChecks( const TQSize& s, ForceGeometry_t force = NormalGeometrySet ); + void keepInArea( TQRect area, bool partial = false ); + + void growHorizontal(); + void shrinkHorizontal(); + void growVertical(); + void shrinkVertical(); + + bool providesContextHelp() const; + KShortcut shortcut() const; + void setShortcut( const TQString& cut ); + + bool performMouseCommand( Options::MouseCommand, TQPoint globalPos, bool handled = false ); + + TQCString windowRole() const; + TQCString sessionId(); + TQCString resourceName() const; + TQCString resourceClass() const; + TQCString wmCommand(); + TQCString wmClientMachine( bool use_localhost ) const; + Window wmClientLeader() const; + pid_t pid() const; + + TQRect adjustedClientArea( const TQRect& desktop, const TQRect& 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 ); + + TQString caption( bool full = true ) const; + void updateCaption(); + + void keyPressEvent( uint key_code ); // FRAME ?? + void updateMouseGrab(); + Window moveResizeGrabWindow() const; + + const TQPoint 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 ); + + static TQCString staticWindowRole(WId); + static TQCString staticSessionId(WId); + static TQCString staticWmCommand(WId); + static TQCString staticWmClientMachine(WId); + static Window staticWmClientLeader(WId); + + void checkWorkspacePosition(); + 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 resourceMatch( const Client* c1, const Client* c2 ); + static bool belongToSameApplication( const Client* c1, const Client* c2, bool active_hack = false ); + static void readIcons( Window win, TQPixmap* icon, TQPixmap* miniicon ); + + void minimize( bool avoid_animation = false ); + void unminimize( bool avoid_animation = false ); + void closeWindow(); + void killWindow(); + void maximize( MaximizeMode ); + void toggleShade(); + void showContextHelp(); + void cancelShadeHover(); + void cancelAutoRaise(); + void destroyClient(); + void checkActiveModal(); + void setOpacity(bool translucent, uint opacity = 0); + void setShadowSize(uint shadowSize); + void updateOpacity(); + void updateShadowSize(); + bool hasCustomOpacity(){return custom_opacity;} + void setCustomOpacityFlag(bool custom = true); + bool getWindowOpacity(); + int opacityPercentage(); + void checkAndSetInitialRuledOpacity(); + uint ruleOpacityInactive(); + uint ruleOpacityActive(); + unsigned int opacity(); + bool isBMP(); + void setBMP(bool b); + bool touches(const Client* c); + void setShapable(bool b); + bool hasStrut() const; + + private slots: + void autoRaise(); + void shadeHover(); + void shortcutActivated(); + void updateOpacityCache(); + + + private: + friend class Bridge; // FRAME + virtual void processMousePressEvent( TQMouseEvent* e ); + + private: // TODO cleanup the order of things in the .h file + // use Workspace::createClient() + virtual ~Client(); // use destroyClient() or releaseWindow() + + Position mousePosition( const TQPoint& ) const; + void setCursor( Position m ); + void setCursor( const TQCursor& c ); + + void animateMinimizeOrUnminimize( bool minimize ); + TQPixmap animationPixmap( int w ); + // transparent stuff + void drawbound( const TQRect& geom ); + void clearbound(); + void doDrawbound( const TQRect& geom, bool clear ); + + // handlers for X11 events + bool mapRequestEvent( XMapRequestEvent* e ); + void unmapNotifyEvent( XUnmapEvent*e ); + void destroyNotifyEvent( XDestroyWindowEvent*e ); + void configureRequestEvent( XConfigureRequestEvent* e ); + void propertyNotifyEvent( XPropertyEvent* e ); + void clientMessageEvent( XClientMessageEvent* e ); + void enterNotifyEvent( XCrossingEvent* e ); + void leaveNotifyEvent( XCrossingEvent* e ); + void focusInEvent( XFocusInEvent* e ); + void focusOutEvent( XFocusOutEvent* 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 ); + + // drop shadows + void drawIntersectingShadows(); + void drawOverlappingShadows(bool waitForMe); + TQRegion getExposedRegion(TQRegion occludedRegion, int x, int y, + int w, int h, int thickness, int xOffset, int yOffset); + void imposeCachedShadow(TQPixmap &pixmap, TQRegion exposed); + void imposeRegionShadow(TQPixmap &pixmap, TQRegion occluded, + TQRegion exposed, int thickness, double maxOpacity = 0.75); + + void processDecorationButtonPress( int button, int state, int x, int y, int x_root, int y_root ); + + private slots: + void pingTimeout(); + void processKillerExited(); + void demandAttentionKNotify(); + void drawShadow(); + void drawShadowAfter(Client *after); + void drawDelayedShadow(); + void removeShadow(); + + signals: + void shadowDrawn(); + + + private: + // ICCCM 4.1.3.1, 4.1.4 , NETWM 2.5.1 + void setMappingState( int s ); + int mappingState() const; + bool isIconicState() const; + bool isNormalState() const; + bool isManaged() const; // returns false if this client is not yet managed + void updateAllowedActions( bool force = false ); + TQSize sizeForClientSize( const TQSize&, Sizemode mode = SizemodeAny, bool noframe = false ) const; + void changeMaximize( bool horizontal, bool vertical, bool adjust ); + void checkMaximizeGeometry(); + int checkFullScreenHack( const TQRect& geom ) const; // 0 - none, 1 - one xinerama screen, 2 - full area + void updateFullScreenHack( const TQRect& geom ); + void getWmNormalHints(); + void getMotifHints(); + void getIcons(); + void getWmClientLeader(); + void getWmClientMachine(); + void fetchName(); + void fetchIconicName(); + TQString readName() const; + void setCaption( const TQString& s, bool force = false ); + bool hasTransientInternal( const Client* c, bool indirect, ConstClientList& set ) const; + void finishWindowRules(); + void setShortcutInternal( const KShortcut& cut ); + + void updateWorkareaDiffs(); + void checkDirection( int new_diff, int old_diff, TQRect& rect, const TQRect& area ); + static int computeWorkareaDiff( int left, int right, int a_left, int a_right ); + 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 postponeGeometryUpdates( bool postpone ); + + bool startMoveResize(); + void finishMoveResize( bool cancel ); + void leaveMoveResize(); + void checkUnrestrictedMoveResize(); + void handleMoveResize( int x, int y, int x_root, int y_root ); + void positionGeometryTip(); + void grabButton( int mod ); + void ungrabButton( int mod ); + void resetMaximize(); + void resizeDecoration( const TQSize& s ); + void setDecoHashProperty(uint topHeight, uint rightWidth, uint bottomHeight, uint leftWidth); + void unsetDecoHashProperty(); + + 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 detectShapable(); + void destroyDecoration(); + void updateFrameExtents(); + + void rawShow(); // just shows it + void rawHide(); // just hides it + + Time readUserTimeMapTimestamp( const KStartupInfoId* asn_id, const KStartupInfoData* asn_data, + bool session ) const; + Time readUserCreationTime() const; + static bool sameAppWindowRoleMatch( const Client* c1, const Client* c2, bool active_hack ); + void startupIdChanged(); + + Window client; + Window wrapper; + Window frame; + KDecoration* decoration; + Workspace* wspace; + Bridge* bridge; + int desk; + bool buttonDown; + bool moveResizeMode; + bool move_faked_activity; + Window move_resize_grab_window; + bool unrestrictedMoveResize; + bool isMove() const + { + return moveResizeMode && mode == PositionCenter; + } + bool isResize() const + { + return moveResizeMode && mode != PositionCenter; + } + + Position mode; + TQPoint moveOffset; + TQPoint invertedMoveOffset; + TQRect moveResizeGeom; + TQRect initialMoveResizeGeom; + XSizeHints xSizeHint; + void sendSyntheticConfigureNotify(); + int mapping_state; + 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 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 is_tqshape :1; + 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 motif_noborder : 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 user_noborder : 1; + uint urgency : 1; // XWMHints, UrgencyHint + uint ignore_focus_stealing : 1; // don't apply focus stealing prevention to this client + uint demands_attention : 1; + WindowRules client_rules; + void getWMHints(); + void readIcons(); + void getWindowProtocols(); + TQPixmap icon_pix; + TQPixmap miniicon_pix; + TQCursor cursor; + // FullScreenHack - non-NETWM fullscreen (noborder,size of desktop) + // DON'T reorder - saved to config files !!! + enum FullScreenMode { FullScreenNone, FullScreenNormal, FullScreenHack }; + FullScreenMode fullscreen_mode; + MaximizeMode max_mode; + TQRect geom_restore; + TQRect geom_fs_restore; + MaximizeMode maxmode_restore; + int workarea_diff_x, workarea_diff_y; + WinInfo* info; + TQTimer* autoRaiseTimer; + TQTimer* shadeHoverTimer; + Colormap cmap; + TQCString resource_name; + TQCString resource_class; + TQCString client_machine; + TQString cap_normal, cap_iconic, cap_suffix; + WId wmClientLeaderWin; + TQCString window_role; + Group* in_group; + Window window_group; + Layer in_layer; + TQTimer* ping_timer; + KProcess* process_killer; + Time ping_timestamp; + Time user_time; + unsigned long allowed_actions; + TQRect frame_geometry; + TQSize client_size; + int postpone_geometry_updates; // >0 - new geometry is remembered, but not actually set + bool pending_geometry_update; + bool shade_geometry_change; + int border_left, border_right, border_top, border_bottom; + + Client* shadowAfterClient; + TQWidget* shadowWidget; + TQMemArray<double> activeOpacityCache; + TQMemArray<double> inactiveOpacityCache; + TQMemArray<double>* opacityCache; + TQRegion tqshapeBoundingRegion; + TQTimer* shadowDelayTimer; + bool shadowMe; + + TQRegion _mask; + static bool check_active_modal; // see Client::checkActiveModal() + KShortcut _shortcut; + friend struct FetchNameInternalPredicate; + friend struct CheckIgnoreFocusStealingProcedure; + friend struct ResetupRulesProcedure; + friend class GeometryUpdatesPostponer; + void show() { assert( false ); } // SELI remove after Client is no longer TQWidget + void hide() { assert( false ); } + uint opacity_; + uint savedOpacity_; + bool custom_opacity; + uint rule_opacity_active; //translucency rules + uint rule_opacity_inactive; //dto. + //int shadeOriginalHeight; + bool isBMP_; + TQTimer* demandAttentionKNotifyTimer; + + friend bool performTransiencyCheck(); + }; + +// helper for Client::postponeGeometryUpdates() being called in pairs (true/false) +class GeometryUpdatesPostponer + { + public: + GeometryUpdatesPostponer( Client* c ) + : cl( c ) { cl->postponeGeometryUpdates( true ); } + ~GeometryUpdatesPostponer() + { cl->postponeGeometryUpdates( false ); } + private: + Client* cl; + }; + + +// NET WM Protocol handler class +class WinInfo : public NETWinInfo + { + private: + typedef KWinInternal::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 changeState( unsigned long state, unsigned long mask ); + private: + Client * m_client; + }; + +inline Window Client::window() const + { + return client; + } + +inline Window Client::frameId() const + { + return frame; + } + +inline Window Client::wrapperId() const + { + return wrapper; + } + +inline Window Client::decorationId() const + { + return decoration != NULL ? decoration->widget()->winId() : None; + } + +inline Workspace* Client::workspace() const + { + return wspace; + } + +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 == workspace()->rootWin(); + } + +// 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 == workspace()->rootWin(); + } + +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 int Client::mappingState() const + { + return mapping_state; + } + +inline TQCString Client::resourceName() const + { + return resource_name; // it is always lowercase + } + +inline TQCString Client::resourceClass() const + { + return resource_class; // it is always lowercase + } + +inline +bool Client::isMinimized() const + { + return minimized; + } + +inline bool Client::isActive() const + { + return active; + } + +/*! + Returns the virtual desktop within the workspace() the client window + is located in, 0 if it isn't located on any special desktop (not mapped yet), + or NET::OnAllDesktops. Do not use desktop() directly, use + isOnDesktop() instead. + */ +inline int Client::desktop() const + { + return desk; + } + +inline bool Client::isOnAllDesktops() const + { + return desk == NET::OnAllDesktops; + } +/*! + Returns whether the client is on the virtual desktop \a d. + This is always TRUE for onAllDesktops clients. + */ +inline bool Client::isOnDesktop( int d ) const + { + return desk == d || /*desk == 0 ||*/ isOnAllDesktops(); + } + +inline +bool Client::isShown( bool shaded_is_shown ) const + { + return !isMinimized() && ( !isShade() || shaded_is_shown ) && !hidden; + } + +inline +bool Client::isShade() const + { + return shade_mode == ShadeNormal; + } + +inline +ShadeMode Client::shadeMode() const + { + return shade_mode; + } + +inline TQPixmap Client::icon() const + { + return icon_pix; + } + +inline TQPixmap Client::miniIcon() const + { + return miniicon_pix; + } + +inline TQRect 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::keepBelow() const + { + return keep_below; + } + +inline bool Client::tqshape() const + { + return is_tqshape; + } + + +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 pid_t Client::pid() const + { + return info->pid(); + } + +inline void Client::invalidateLayer() + { + in_layer = UnknownLayer; + } + +inline bool Client::isIconicState() const + { + return mapping_state == IconicState; + } + +inline bool Client::isNormalState() const + { + return mapping_state == NormalState; + } + +inline bool Client::isManaged() const + { + return mapping_state != WithdrawnState; + } + +inline TQCString Client::windowRole() const + { + return window_role; + } + +inline TQRect Client::geometry() const + { + return frame_geometry; + } + +inline TQSize Client::size() const + { + return frame_geometry.size(); + } + +inline TQPoint Client::pos() const + { + return frame_geometry.topLeft(); + } + +inline int Client::x() const + { + return frame_geometry.x(); + } + +inline int Client::y() const + { + return frame_geometry.y(); + } + +inline int Client::width() const + { + return frame_geometry.width(); + } + +inline int Client::height() const + { + return frame_geometry.height(); + } + +inline TQRect Client::rect() const + { + return TQRect( 0, 0, width(), height()); + } + +inline TQPoint Client::clientPos() const + { + return TQPoint( border_left, border_top ); + } + +inline TQSize Client::clientSize() const + { + return client_size; + } + +inline void Client::setGeometry( const TQRect& r, ForceGeometry_t force ) + { + setGeometry( r.x(), r.y(), r.width(), r.height(), force ); + } + +inline void Client::move( const TQPoint & p, ForceGeometry_t force ) + { + move( p.x(), p.y(), force ); + } + +inline void Client::plainResize( const TQSize& s, ForceGeometry_t force ) + { + plainResize( s.width(), s.height(), force ); + } + +inline bool Client::isShadowed() const + { + return shadowMe; + } + +inline Window Client::shadowId() const + { + return shadowWidget != NULL ? shadowWidget->winId() : None; + } + +inline void Client::resizeWithChecks( const TQSize& 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, 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 bool Client::isBMP() + { + return isBMP_; + } + +inline void Client::setBMP(bool b) + { + isBMP_ = b; + } + +inline void Client::removeRule( Rules* rule ) + { + client_rules.remove( rule ); + } + +#ifdef NDEBUG +inline +kndbgstream& operator<<( kndbgstream& stream, const Client* ) { return stream; } +inline +kndbgstream& operator<<( kndbgstream& stream, const ClientList& ) { return stream; } +inline +kndbgstream& operator<<( kndbgstream& stream, const ConstClientList& ) { return stream; } +#else +kdbgstream& operator<<( kdbgstream& stream, const Client* ); +kdbgstream& operator<<( kdbgstream& stream, const ClientList& ); +kdbgstream& operator<<( kdbgstream& stream, const ConstClientList& ); +#endif + +KWIN_COMPARE_PREDICATE( WindowMatchPredicate, Window, cl->window() == value ); +KWIN_COMPARE_PREDICATE( FrameIdMatchPredicate, Window, cl->frameId() == value ); +KWIN_COMPARE_PREDICATE( WrapperIdMatchPredicate, Window, cl->wrapperId() == value ); + +} // namespace + +#endif |