/***************************************************************** 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. ******************************************************************/ #include "client.h" #include <math.h> #include <tqapplication.h> #include <tqpainter.h> #include <tqdatetime.h> #include <tqimage.h> #include <tqfile.h> #include <kprocess.h> #include <unistd.h> #include <kstandarddirs.h> #include <tqwhatsthis.h> #include <twin.h> #include <kiconloader.h> #include <tdelocale.h> #include <stdlib.h> #include "bridge.h" #include "group.h" #include "workspace.h" #include "atoms.h" #include "notifications.h" #include "rules.h" #include <X11/extensions/shape.h> // put all externs before the namespace statement to allow the linker // to resolve them properly extern Atom tqt_wm_state; extern Atom tqt_window_role; extern Atom tqt_sm_client_id; // wait 200 ms before drawing shadow after move/resize static const int SHADOW_DELAY = 200; namespace KWinInternal { /* TODO: Remove this once X has real translucency. * * A list of the regions covered by all shadows and the Clients to which they * belong. Used to redraw shadows when a window overlapping or underlying a * shadow is moved, resized, or hidden. */ struct ShadowRegion { TQRegion region; Client *client; }; static TQValueList<ShadowRegion> shadowRegions; /* Creating a client: - only by calling Workspace::createClient() - it creates a new client and calls manage() for it Destroying a client: - destroyClient() - only when the window itself has been destroyed - releaseWindow() - the window is kept, only the client itself is destroyed */ /*! \class Client client.h \brief The Client class encapsulates a window decoration frame. */ /*! This ctor is "dumb" - it only initializes data. All the real initialization is done in manage(). */ Client::Client( Workspace *ws ) : TQObject( NULL ), client( None ), wrapper( None ), frame( None ), decoration( NULL ), wspace( ws ), bridge( new Bridge( this )), move_faked_activity( false ), move_resize_grab_window( None ), transient_for( NULL ), transient_for_id( None ), original_transient_for_id( None ), in_group( NULL ), window_group( None ), in_layer( UnknownLayer ), ping_timer( NULL ), process_killer( NULL ), process_resumer( NULL ), user_time( CurrentTime ), // not known yet allowed_actions( 0 ), postpone_geometry_updates( 0 ), pending_geometry_update( false ), shade_geometry_change( false ), border_left( 0 ), border_right( 0 ), border_top( 0 ), border_bottom( 0 ), opacity_( 0 ), demandAttentionKNotifyTimer( NULL ) // SELI do all as initialization { autoRaiseTimer = 0; shadeHoverTimer = 0; shadowDelayTimer = new TQTimer(this); opacityCache = &activeOpacityCache; shadowAfterClient = NULL; shadowWidget = NULL; shadowMe = true; connect(shadowDelayTimer, TQT_SIGNAL(timeout()), TQT_SLOT(drawShadow())); // set the initial mapping state mapping_state = WithdrawnState; desk = 0; // no desktop yet mode = PositionCenter; buttonDown = FALSE; moveResizeMode = FALSE; info = NULL; shade_mode = ShadeNone; active = FALSE; deleting = false; keep_above = FALSE; keep_below = FALSE; is_shape = FALSE; motif_noborder = false; motif_may_move = TRUE; motif_may_resize = TRUE; motif_may_close = TRUE; fullscreen_mode = FullScreenNone; skip_taskbar = FALSE; original_skip_taskbar = false; minimized = false; hidden = false; modal = false; noborder = false; user_noborder = false; urgency = false; ignore_focus_stealing = false; demands_attention = false; check_active_modal = false; Pdeletewindow = 0; Ptakefocus = 0; Ptakeactivity = 0; Pcontexthelp = 0; Pping = 0; input = FALSE; skip_pager = FALSE; max_mode = MaximizeRestore; maxmode_restore = MaximizeRestore; cmap = None; frame_geometry = TQRect( 0, 0, 100, 100 ); // so that decorations don't start with size being (0,0) client_size = TQSize( 100, 100 ); custom_opacity = false; rule_opacity_active = 0; //translucency rules rule_opacity_inactive = 0; //dito. // SELI initialize xsizehints?? } /*! "Dumb" destructor. */ Client::~Client() { assert(!moveResizeMode); assert( client == None ); assert( frame == None && wrapper == None ); assert( decoration == NULL ); assert( postpone_geometry_updates == 0 ); assert( !check_active_modal ); delete info; delete bridge; } // use destroyClient() or releaseWindow(), Client instances cannot be deleted directly void Client::deleteClient( Client* c, allowed_t ) { delete c; } /*! Releases the window. The client has done its job and the window is still existing. */ void Client::releaseWindow( bool on_shutdown ) { assert( !deleting ); deleting = true; workspace()->discardUsedWindowRules( this, true ); // remove ForceTemporarily rules StackingUpdatesBlocker blocker( workspace()); if (!custom_opacity) setOpacity(FALSE); if (moveResizeMode) leaveMoveResize(); removeShadow(); drawIntersectingShadows(); finishWindowRules(); ++postpone_geometry_updates; // grab X during the release to make removing of properties, setting to withdrawn state // and repareting to root an atomic operation (http://lists.kde.org/?l=kde-devel&m=116448102901184&w=2) grabXServer(); setMappingState( WithdrawnState ); setModal( false ); // otherwise its mainwindow wouldn't get focus hidden = true; // so that it's not considered visible anymore (can't use hideClient(), it would set flags) if( !on_shutdown ) workspace()->clientHidden( this ); XUnmapWindow( tqt_xdisplay(), frameId()); // destroying decoration would cause ugly visual effect destroyDecoration(); cleanGrouping(); if( !on_shutdown ) { workspace()->removeClient( this, Allowed ); // only when the window is being unmapped, not when closing down KWin // (NETWM sections 5.5,5.7) info->setDesktop( 0 ); desk = 0; info->setState( 0, info->state()); // reset all state flags } XDeleteProperty( tqt_xdisplay(), client, atoms->kde_net_wm_user_creation_time); XDeleteProperty( tqt_xdisplay(), client, atoms->net_frame_extents ); XDeleteProperty( tqt_xdisplay(), client, atoms->kde_net_wm_frame_strut ); XReparentWindow( tqt_xdisplay(), client, workspace()->rootWin(), x(), y()); XRemoveFromSaveSet( tqt_xdisplay(), client ); XSelectInput( tqt_xdisplay(), client, NoEventMask ); if( on_shutdown ) { // map the window, so it can be found after another WM is started XMapWindow( tqt_xdisplay(), client ); // TODO preserve minimized, shaded etc. state? } else { // Make sure it's not mapped if the app unmapped it (#65279). The app // may do map+unmap before we initially map the window by calling rawShow() from manage(). XUnmapWindow( tqt_xdisplay(), client ); } client = None; XDestroyWindow( tqt_xdisplay(), wrapper ); wrapper = None; XDestroyWindow( tqt_xdisplay(), frame ); frame = None; --postpone_geometry_updates; // don't use GeometryUpdatesBlocker, it would now set the geometry checkNonExistentClients(); deleteClient( this, Allowed ); ungrabXServer(); } // like releaseWindow(), but this one is called when the window has been already destroyed // (e.g. the application closed it) void Client::destroyClient() { assert( !deleting ); deleting = true; workspace()->discardUsedWindowRules( this, true ); // remove ForceTemporarily rules StackingUpdatesBlocker blocker( workspace()); if (moveResizeMode) leaveMoveResize(); removeShadow(); drawIntersectingShadows(); finishWindowRules(); ++postpone_geometry_updates; setModal( false ); hidden = true; // so that it's not considered visible anymore workspace()->clientHidden( this ); destroyDecoration(); cleanGrouping(); workspace()->removeClient( this, Allowed ); client = None; // invalidate XDestroyWindow( tqt_xdisplay(), wrapper ); wrapper = None; XDestroyWindow( tqt_xdisplay(), frame ); frame = None; --postpone_geometry_updates; // don't use GeometryUpdatesBlocker, it would now set the geometry checkNonExistentClients(); deleteClient( this, Allowed ); } void Client::updateDecoration( bool check_workspace_pos, bool force ) { if( !force && (( decoration == NULL && noBorder()) || ( decoration != NULL && !noBorder()))) return; bool do_show = false; postponeGeometryUpdates( true ); if( force ) destroyDecoration(); if( !noBorder()) { setMask( TQRegion()); // reset shape mask decoration = workspace()->createDecoration( bridge ); // TODO check decoration's minimum size? decoration->init(); decoration->widget()->installEventFilter( this ); XReparentWindow( tqt_xdisplay(), decoration->widget()->winId(), frameId(), 0, 0 ); decoration->widget()->lower(); decoration->borders( border_left, border_right, border_top, border_bottom ); options->onlyDecoTranslucent ? setDecoHashProperty(border_top, border_right, border_bottom, border_left): unsetDecoHashProperty(); int save_workarea_diff_x = workarea_diff_x; int save_workarea_diff_y = workarea_diff_y; move( calculateGravitation( false )); plainResize( sizeForClientSize( clientSize()), ForceGeometrySet ); workarea_diff_x = save_workarea_diff_x; workarea_diff_y = save_workarea_diff_y; do_show = true; } else destroyDecoration(); if( check_workspace_pos ) checkWorkspacePosition(); postponeGeometryUpdates( false ); if( do_show ) decoration->widget()->show(); updateFrameExtents(); updateOpacityCache(); } void Client::destroyDecoration() { if( decoration != NULL ) { delete decoration; decoration = NULL; TQPoint grav = calculateGravitation( true ); border_left = border_right = border_top = border_bottom = 0; setMask( TQRegion()); // reset shape mask int save_workarea_diff_x = workarea_diff_x; int save_workarea_diff_y = workarea_diff_y; plainResize( sizeForClientSize( clientSize()), ForceGeometrySet ); move( grav ); workarea_diff_x = save_workarea_diff_x; workarea_diff_y = save_workarea_diff_y; } } void Client::checkBorderSizes() { if( decoration == NULL ) return; int new_left, new_right, new_top, new_bottom; decoration->borders( new_left, new_right, new_top, new_bottom ); if( new_left == border_left && new_right == border_right && new_top == border_top && new_bottom == border_bottom ) return; GeometryUpdatesPostponer blocker( this ); move( calculateGravitation( true )); border_left = new_left; border_right = new_right; border_top = new_top; border_bottom = new_bottom; if (border_left != new_left || border_right != new_right || border_top != new_top || border_bottom != new_bottom) options->onlyDecoTranslucent ? setDecoHashProperty(new_top, new_right, new_bottom, new_left): unsetDecoHashProperty(); move( calculateGravitation( false )); plainResize( sizeForClientSize( clientSize()), ForceGeometrySet ); checkWorkspacePosition(); } void Client::detectNoBorder() { if( Shape::hasShape( window())) { noborder = true; return; } switch( windowType()) { case NET::Desktop : case NET::Dock : case NET::TopMenu : case NET::Splash : noborder = true; break; case NET::Unknown : case NET::Normal : case NET::Toolbar : case NET::Menu : case NET::Dialog : case NET::Utility : noborder = false; break; default: assert( false ); } // NET::Override is some strange beast without clear definition, usually // just meaning "noborder", so let's treat it only as such flag, and ignore it as // a window type otherwise (SUPPORTED_WINDOW_TYPES_MASK doesn't include it) if( info->windowType( SUPPORTED_WINDOW_TYPES_MASK | NET::OverrideMask ) == NET::Override ) noborder = true; } void Client::detectShapable() { if( Shape::hasShape( window())) return; switch( windowType()) { case NET::Desktop : case NET::Dock : case NET::TopMenu : case NET::Splash : break; case NET::Unknown : case NET::Normal : case NET::Toolbar : case NET::Menu : case NET::Dialog : case NET::Utility : setShapable(FALSE); break; default: assert( false ); } } void Client::updateFrameExtents() { NETStrut strut; strut.left = border_left; strut.right = border_right; strut.top = border_top; strut.bottom = border_bottom; info->setFrameExtents( strut ); } // Resizes the decoration, and makes sure the decoration widget gets resize event // even if the size hasn't changed. This is needed to make sure the decoration // re-layouts (e.g. when options()->moveResizeMaximizedWindows() changes, // the decoration may turn on/off some borders, but the actual size // of the decoration stays the same). void Client::resizeDecoration( const TQSize& s ) { if( decoration == NULL ) return; TQSize oldsize = decoration->widget()->size(); decoration->resize( s ); if( oldsize == s ) { TQResizeEvent e( s, oldsize ); TQApplication::sendEvent( decoration->widget(), &e ); } if (!moveResizeMode && options->shadowEnabled(isActive())) { // If the user is manually resizing, let Client::leaveMoveResize() // decide when to redraw the shadow updateOpacityCache(); } } bool Client::noBorder() const { return noborder || isFullScreen() || user_noborder || motif_noborder; } bool Client::userCanSetNoBorder() const { return !noborder && !isFullScreen() && !isShade(); } bool Client::isUserNoBorder() const { return user_noborder; } void Client::setUserNoBorder( bool set ) { if( !userCanSetNoBorder()) return; set = rules()->checkNoBorder( set ); if( user_noborder == set ) return; user_noborder = set; updateDecoration( true, false ); updateWindowRules(); } bool Client::isModalSystemNotification() const { unsigned char *data = 0; Atom actual; int format, result; unsigned long n, left; result = XGetWindowProperty(tqt_xdisplay(), window(), atoms->net_wm_system_modal_notification, 0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left, /*(unsigned char **)*/ &data); if (result == Success && data && format == 32 ) { return TRUE; } return FALSE; } void Client::updateShape() { // workaround for #19644 - shaped windows shouldn't have decoration if( shape() && !noBorder()) { noborder = true; updateDecoration( true ); } updateOpacityCache(); if ( shape() ) { XShapeCombineShape(tqt_xdisplay(), frameId(), ShapeBounding, clientPos().x(), clientPos().y(), window(), ShapeBounding, ShapeSet); setShapable(TRUE); } // !shape() mask setting is done in setMask() when the decoration // calls it or when the decoration is created/destroyed if( Shape::version() >= 0x11 ) // 1.1, has input shape support { // There appears to be no way to find out if a window has input // shape set or not, so always propagate the input shape // (it's the same like the bounding shape by default). // Also, build the shape using a helper window, not directly // in the frame window, because the sequence set-shape-to-frame, // remove-shape-of-client, add-input-shape-of-client has the problem // that after the second step there's a hole in the input shape // until the real shape of the client is added and that can make // the window lose focus (which is a problem with mouse focus policies) static Window helper_window = None; if( helper_window == None ) helper_window = XCreateSimpleWindow( tqt_xdisplay(), tqt_xrootwin(), 0, 0, 1, 1, 0, 0, 0 ); XResizeWindow( tqt_xdisplay(), helper_window, width(), height()); XShapeCombineShape( tqt_xdisplay(), helper_window, ShapeInput, 0, 0, frameId(), ShapeBounding, ShapeSet ); XShapeCombineShape( tqt_xdisplay(), helper_window, ShapeInput, clientPos().x(), clientPos().y(), window(), ShapeBounding, ShapeSubtract ); XShapeCombineShape( tqt_xdisplay(), helper_window, ShapeInput, clientPos().x(), clientPos().y(), window(), ShapeInput, ShapeUnion ); XShapeCombineShape( tqt_xdisplay(), frameId(), ShapeInput, 0, 0, helper_window, ShapeInput, ShapeSet ); } } void Client::setMask( const TQRegion& reg, int mode ) { _mask = reg; if( reg.isNull()) XShapeCombineMask( tqt_xdisplay(), frameId(), ShapeBounding, 0, 0, None, ShapeSet ); else if( mode == X::Unsorted ) XShapeCombineRegion( tqt_xdisplay(), frameId(), ShapeBounding, 0, 0, reg.handle(), ShapeSet ); else { TQMemArray< TQRect > rects = reg.rects(); XRectangle* xrects = new XRectangle[ rects.count() ]; for( unsigned int i = 0; i < rects.count(); ++i ) { xrects[ i ].x = rects[ i ].x(); xrects[ i ].y = rects[ i ].y(); xrects[ i ].width = rects[ i ].width(); xrects[ i ].height = rects[ i ].height(); } XShapeCombineRectangles( tqt_xdisplay(), frameId(), ShapeBounding, 0, 0, xrects, rects.count(), ShapeSet, mode ); delete[] xrects; } updateShape(); } TQRegion Client::mask() const { if( _mask.isEmpty()) return TQRegion( 0, 0, width(), height()); return _mask; } void Client::setShapable(bool b) { long tmp = b?1:0; XChangeProperty(tqt_xdisplay(), frameId(), atoms->net_wm_window_shapable, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &tmp, 1L); } void Client::hideClient( bool hide ) { if( hidden == hide ) return; hidden = hide; updateVisibility(); } /*! Returns whether the window is minimizable or not */ bool Client::isMinimizable() const { if( isSpecialWindow()) return false; if( isModalSystemNotification()) return false; if( isTransient()) { // #66868 - let other xmms windows be minimized when the mainwindow is minimized bool shown_mainwindow = false; ClientList mainclients = mainClients(); for( ClientList::ConstIterator it = mainclients.begin(); it != mainclients.end(); ++it ) { if( (*it)->isShown( true )) shown_mainwindow = true; } if( !shown_mainwindow ) return true; } // this is here because kicker's taskbar doesn't provide separate entries // for windows with an explicitly given parent // TODO perhaps this should be redone if( transientFor() != NULL ) return false; if( !wantsTabFocus()) // SELI - NET::Utility? why wantsTabFocus() - skiptaskbar? ? return false; return true; } /*! Returns whether the window is kept above or not */ bool Client::keepAbove() const { if( isModalSystemNotification()) return true; return keep_above; } /*! Minimizes this client plus its transients */ void Client::minimize( bool avoid_animation ) { if ( !isMinimizable() || isMinimized()) return; if (isShade()) // NETWM restriction - KWindowInfo::isMinimized() == Hidden && !Shaded info->setState(0, NET::Shaded); Notify::raise( Notify::Minimize ); // SELI mainClients().isEmpty() ??? - and in unminimize() too if ( mainClients().isEmpty() && isOnCurrentDesktop() && isShown( true ) && !avoid_animation ) animateMinimizeOrUnminimize( true ); // was visible or shaded minimized = true; updateVisibility(); updateAllowedActions(); workspace()->updateMinimizedOfTransients( this ); updateWindowRules(); workspace()->updateFocusChains( this, Workspace::FocusChainMakeLast ); } void Client::unminimize( bool avoid_animation ) { if (!queryUserSuspendedResume()) return; if( !isMinimized()) return; if (isShade()) // NETWM restriction - KWindowInfo::isMinimized() == Hidden && !Shaded info->setState(NET::Shaded, NET::Shaded); Notify::raise( Notify::UnMinimize ); minimized = false; if( isOnCurrentDesktop() && isShown( true )) { if( mainClients().isEmpty() && !avoid_animation ) animateMinimizeOrUnminimize( FALSE ); } updateVisibility(); updateAllowedActions(); workspace()->updateMinimizedOfTransients( this ); updateWindowRules(); } extern bool blockAnimation; void Client::animateMinimizeOrUnminimize( bool minimize ) { if ( blockAnimation ) return; if ( !options->animateMinimize ) return; if( decoration != NULL && decoration->animateMinimize( minimize )) return; // decoration did it // the function is a bit tricky since it will ensure that an // animation action needs always the same time regardless of the // performance of the machine or the X-Server. float lf,rf,tf,bf,step; int speed = options->animateMinimizeSpeed; if ( speed > 10 ) speed = 10; if ( speed < 0 ) speed = 0; step = 40. * (11 - speed ); NETRect r = info->iconGeometry(); TQRect icongeom( r.pos.x, r.pos.y, r.size.width, r.size.height ); if ( !icongeom.isValid() ) return; TQPixmap pm = animationPixmap( minimize ? width() : icongeom.width() ); TQRect before, after; if ( minimize ) { before = TQRect( x(), y(), width(), pm.height() ); after = TQRect( icongeom.x(), icongeom.y(), icongeom.width(), pm.height() ); } else { before = TQRect( icongeom.x(), icongeom.y(), icongeom.width(), pm.height() ); after = TQRect( x(), y(), width(), pm.height() ); } lf = (after.left() - before.left())/step; rf = (after.right() - before.right())/step; tf = (after.top() - before.top())/step; bf = (after.bottom() - before.bottom())/step; grabXServer(); TQRect area = before; TQRect area2; TQPixmap pm2; TQTime t; t.start(); float diff; TQPainter p ( workspace()->desktopWidget() ); bool need_to_clear = FALSE; TQPixmap pm3; do { if (area2 != area) { pm = animationPixmap( area.width() ); pm2 = TQPixmap::grabWindow( tqt_xrootwin(), area.x(), area.y(), area.width(), area.height() ); p.drawPixmap( area.x(), area.y(), pm ); if ( need_to_clear ) { p.drawPixmap( area2.x(), area2.y(), pm3 ); need_to_clear = FALSE; } area2 = area; } XFlush(tqt_xdisplay()); XSync( tqt_xdisplay(), FALSE ); diff = t.elapsed(); if (diff > step) diff = step; area.setLeft(before.left() + int(diff*lf)); area.setRight(before.right() + int(diff*rf)); area.setTop(before.top() + int(diff*tf)); area.setBottom(before.bottom() + int(diff*bf)); if (area2 != area ) { if ( area2.intersects( area ) ) p.drawPixmap( area2.x(), area2.y(), pm2 ); else { // no overlap, we can clear later to avoid flicker pm3 = pm2; need_to_clear = TRUE; } } } while ( t.elapsed() < step); if (area2 == area || need_to_clear ) p.drawPixmap( area2.x(), area2.y(), pm2 ); p.end(); ungrabXServer(); } /*! The pixmap shown during (un)minimalization animation */ TQPixmap Client::animationPixmap( int w ) { TQFont font = options->font(isActive()); TQFontMetrics fm( font ); TQPixmap pm( w, fm.lineSpacing() ); pm.fill( options->color(Options::ColorTitleBar, isActive() || isMinimized() ) ); TQPainter p( &pm ); p.setPen(options->color(Options::ColorFont, isActive() || isMinimized() )); p.setFont(options->font(isActive())); p.drawText( pm.rect(), AlignLeft|AlignVCenter|SingleLine, caption() ); return pm; } bool Client::isShadeable() const { return !isSpecialWindow() && !noBorder(); } void Client::setShade( ShadeMode mode ) { if( !isShadeable()) return; if( isModalSystemNotification()) return; mode = rules()->checkShade( mode ); if( shade_mode == mode ) return; bool was_shade = isShade(); ShadeMode was_shade_mode = shade_mode; shade_mode = mode; if( was_shade == isShade()) { if( decoration != NULL ) // decoration may want to update after e.g. hover-shade changes decoration->shadeChange(); return; // no real change in shaded state } if( shade_mode == ShadeNormal ) { if ( isShown( true ) && isOnCurrentDesktop()) Notify::raise( Notify::ShadeUp ); } else if( shade_mode == ShadeNone ) { if( isShown( true ) && isOnCurrentDesktop()) Notify::raise( Notify::ShadeDown ); } assert( decoration != NULL ); // noborder windows can't be shaded GeometryUpdatesPostponer blocker( this ); // decorations may turn off some borders when shaded decoration->borders( border_left, border_right, border_top, border_bottom ); int as = options->animateShade? 10 : 1; // TODO all this unmapping, resizing etc. feels too much duplicated from elsewhere if ( isShade()) { // shade_mode == ShadeNormal // we're about to shade, texx xcompmgr to prepare long _shade = 1; XChangeProperty(tqt_xdisplay(), frameId(), atoms->net_wm_window_shade, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &_shade, 1L); // shade int h = height(); shade_geometry_change = true; TQSize s( sizeForClientSize( TQSize( clientSize()))); s.setHeight( border_top + border_bottom ); XSelectInput( tqt_xdisplay(), wrapper, ClientWinMask ); // avoid getting UnmapNotify XUnmapWindow( tqt_xdisplay(), wrapper ); XUnmapWindow( tqt_xdisplay(), client ); XSelectInput( tqt_xdisplay(), wrapper, ClientWinMask | SubstructureNotifyMask ); //as we hid the unmap event, xcompmgr didn't recognize the client wid has vanished, so we'll extra inform it //done xcompmgr workaround // FRAME repaint( FALSE ); // bool wasStaticContents = testWFlags( WStaticContents ); // setWFlags( WStaticContents ); int step = TQMAX( 4, QABS( h - s.height() ) / as )+1; do { h -= step; XResizeWindow( tqt_xdisplay(), frameId(), s.width(), h ); resizeDecoration( TQSize( s.width(), h )); TQApplication::syncX(); } while ( h > s.height() + step ); // if ( !wasStaticContents ) // clearWFlags( WStaticContents ); plainResize( s ); shade_geometry_change = false; if( isActive()) { if( was_shade_mode == ShadeHover ) workspace()->activateNextClient( this ); else workspace()->focusToNull(); } // tell xcompmgr shade's done _shade = 2; XChangeProperty(tqt_xdisplay(), frameId(), atoms->net_wm_window_shade, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &_shade, 1L); } else { int h = height(); shade_geometry_change = true; TQSize s( sizeForClientSize( clientSize())); // FRAME bool wasStaticContents = testWFlags( WStaticContents ); // setWFlags( WStaticContents ); int step = TQMAX( 4, QABS( h - s.height() ) / as )+1; do { h += step; XResizeWindow( tqt_xdisplay(), frameId(), s.width(), h ); resizeDecoration( TQSize( s.width(), h )); // assume a border // we do not have time to wait for X to send us paint events // FRAME repaint( 0, h - step-5, width(), step+5, TRUE); TQApplication::syncX(); } while ( h < s.height() - step ); // if ( !wasStaticContents ) // clearWFlags( WStaticContents ); shade_geometry_change = false; plainResize( s ); if( shade_mode == ShadeHover || shade_mode == ShadeActivated ) setActive( TRUE ); XMapWindow( tqt_xdisplay(), wrapperId()); XMapWindow( tqt_xdisplay(), window()); XDeleteProperty (tqt_xdisplay(), client, atoms->net_wm_window_shade); if (options->shadowEnabled(false)) { for (ClientList::ConstIterator it = transients().begin(); it != transients().end(); ++it) { (*it)->removeShadow(); (*it)->drawDelayedShadow(); } } if ( isActive() ) workspace()->requestFocus( this ); } checkMaximizeGeometry(); info->setState( (isShade() && !isMinimized()) ? NET::Shaded : 0, NET::Shaded ); info->setState( isShown( false ) ? 0 : NET::Hidden, NET::Hidden ); updateVisibility(); updateAllowedActions(); workspace()->updateMinimizedOfTransients( this ); decoration->shadeChange(); updateWindowRules(); } void Client::shadeHover() { setShade( ShadeHover ); cancelShadeHover(); } void Client::cancelShadeHover() { delete shadeHoverTimer; shadeHoverTimer = 0; } void Client::toggleShade() { // if the mode is ShadeHover or ShadeActive, cancel shade too setShade( shade_mode == ShadeNone ? ShadeNormal : ShadeNone ); } void Client::updateVisibility() { if( deleting ) return; bool show = true; if( hidden ) { setMappingState( IconicState ); info->setState( NET::Hidden, NET::Hidden ); setSkipTaskbar( true, false ); // also hide from taskbar rawHide(); show = false; } else { setSkipTaskbar( original_skip_taskbar, false ); } if( minimized ) { setMappingState( IconicState ); info->setState( NET::Hidden, NET::Hidden ); rawHide(); show = false; } if( show ) info->setState( 0, NET::Hidden ); if( !isOnCurrentDesktop()) { setMappingState( IconicState ); rawHide(); show = false; } if( show ) { bool belongs_to_desktop = false; for( ClientList::ConstIterator it = group()->members().begin(); it != group()->members().end(); ++it ) if( (*it)->isDesktop()) { belongs_to_desktop = true; break; } if( !belongs_to_desktop && workspace()->showingDesktop()) workspace()->resetShowingDesktop( true ); if( isShade()) setMappingState( IconicState ); else setMappingState( NormalState ); rawShow(); } } void Client::setShadowed(bool shadowed) { bool wasShadowed; wasShadowed = isShadowed(); shadowMe = options->shadowEnabled(isActive()) ? shadowed : false; if (shadowMe) { if (!wasShadowed) drawShadow(); } else { if (wasShadowed) { removeShadow(); if (!activeOpacityCache.isNull()) activeOpacityCache.resize(0); if (!inactiveOpacityCache.isNull()) inactiveOpacityCache.resize(0); } } } void Client::updateOpacityCache() { if (!activeOpacityCache.isNull()) activeOpacityCache.resize(0); if (!inactiveOpacityCache.isNull()) inactiveOpacityCache.resize(0); if (!moveResizeMode) { // If the user is manually resizing, let Client::finishMoveResize() // decide when to redraw the shadow removeShadow(); drawIntersectingShadows(); if (options->shadowEnabled(isActive())) drawDelayedShadow(); } } /*! Redraw shadows that were previously occluding or occluded by this window, to avoid visual glitches. */ void Client::drawIntersectingShadows() { //Client *reshadowClient; TQRegion region; //TQPtrList<Client> reshadowClients; TQValueList<Client *> reshadowClients; TQValueListIterator<ShadowRegion> it; TQValueListIterator<Client *> it2; if (!options->shadowEnabled(false)) // No point in redrawing overlapping/overlapped shadows if only the // active window has a shadow. return; region = shapeBoundingRegion; // Generate list of Clients whose shadows need to be redrawn. That is, // those that are currently intersecting or intersected by other windows or // shadows. for (it = shadowRegions.begin(); it != shadowRegions.end(); ++it) if ((isOnAllDesktops() || (*it).client->isOnCurrentDesktop()) && !(*it).region.intersect(region).isEmpty()) reshadowClients.append((*it).client); // Redraw shadows for each of the Clients in the list generated above for (it2 = reshadowClients.begin(); it2 != reshadowClients.end(); ++it2) { (*it2)->removeShadow(); (*it2)->drawDelayedShadow(); } } /*! Redraw shadows that are above the current window in the stacking order. Furthermore, redraw them in the same order as they come in the stacking order from bottom to top. */ void Client::drawOverlappingShadows(bool waitForMe) { Client *aClient; TQRegion region; TQValueList<Client *> reshadowClients; ClientList stacking_order; ClientList::ConstIterator it; TQValueListIterator<ShadowRegion> it2; TQValueListIterator<Client *> it3; if (!options->shadowEnabled(false)) // No point in redrawing overlapping/overlapped shadows if only the // active window has a shadow. return; region = shapeBoundingRegion; stacking_order = workspace()->stackingOrder(); for (it = stacking_order.fromLast(); it != stacking_order.end(); --it) { // Find the position of this window in the stacking order. if ((*it) == this) break; } ++it; while (it != stacking_order.end()) { if ((*it)->windowType() == NET::Dock) { // This function is only interested in windows whose shadows don't // have weird stacking rules. ++it; continue; } // Generate list of Clients whose shadows need to be redrawn. That is, // those that are currently overlapping or overlapped by other windows // or shadows. The list should be in order from bottom to top in the // stacking order. for (it2 = shadowRegions.begin(); it2 != shadowRegions.end(); ++it2) { if ((*it2).client == (*it)) { if ((isOnAllDesktops() || (*it2).client->isOnCurrentDesktop()) && !(*it2).region.intersect(region).isEmpty()) reshadowClients.append((*it2).client); } } ++it; } // Redraw shadows for each of the Clients in the list generated above for (it3 = reshadowClients.begin(); it3 != reshadowClients.end(); ++it3) { (*it3)->removeShadow(); if (it3 == reshadowClients.begin()) { if (waitForMe) (*it3)->drawShadowAfter(this); else (*it3)->drawDelayedShadow(); } else { --it3; aClient = (*it3); ++it3; (*it3)->drawShadowAfter(aClient); } } } /*! Draw shadow after some time has elapsed, to give recently exposed windows a chance to repaint before a shadow gradient is drawn over them. */ void Client::drawDelayedShadow() { shadowDelayTimer->stop(); shadowDelayTimer->start(SHADOW_DELAY, true); } /*! Draw shadow immediately after the specified Client's shadow finishes drawing. */ void Client::drawShadowAfter(Client *after) { shadowAfterClient = after; connect(after, TQT_SIGNAL(shadowDrawn()), TQT_SLOT(drawShadow())); } /*! Draw a shadow under this window and XShape the shadow accordingly. */ void Client::drawShadow() { Window shadows[2]; XRectangle *shapes; int i, count, ordering; // If we are waiting for another Client's shadow to be drawn, stop waiting now if (shadowAfterClient != NULL) { disconnect(shadowAfterClient, TQT_SIGNAL(shadowDrawn()), this, TQT_SLOT(drawShadow())); shadowAfterClient = NULL; } if (!isOnCurrentDesktop()) return; /* Store this window's ShapeBoundingRegion even if shadows aren't drawn for * this type of window. Otherwise, drawIntersectingShadows() won't update * properly when this window is moved/resized/hidden/closed. */ shapes = XShapeGetRectangles(tqt_xdisplay(), frameId(), ShapeBounding, &count, &ordering); if (!shapes) // XShape extension not supported shapeBoundingRegion = TQRegion(x(), y(), width(), height()); else { shapeBoundingRegion = TQRegion(); for (i = 0; i < count; i++) { // Translate XShaped window into a TQRegion TQRegion shapeRectangle(shapes[i].x, shapes[i].y, shapes[i].width, shapes[i].height); shapeBoundingRegion += shapeRectangle; } if (isShade()) // Since XResize() doesn't change a window's XShape regions, ensure that // shapeBoundingRegion is not taller than the window's shaded height, // or the bottom shadow will appear to be missing shapeBoundingRegion &= TQRegion(0, 0, width(), height()); shapeBoundingRegion.translate(x(), y()); } if (!isShadowed() || hidden || isMinimized() || maximizeMode() == MaximizeFull || !options->shadowWindowType(windowType())) { XFree(shapes); // Tell whatever Clients are listening that this Client's shadow has been drawn. // It hasn't, but there's no sense waiting for something that won't happen. emit shadowDrawn(); return; } removeShadow(); TQMemArray<QRgb> pixelData; TQPixmap shadowPixmap; TQRect shadow; TQRegion exposedRegion; ShadowRegion shadowRegion; int thickness, xOffset, yOffset; thickness = options->shadowThickness(isActive()); xOffset = options->shadowXOffset(isActive()); yOffset = options->shadowYOffset(isActive()); opacityCache = active? &activeOpacityCache : &inactiveOpacityCache; shadow.setRect(x() - thickness + xOffset, y() - thickness + yOffset, width() + thickness * 2, height() + thickness * 2); shadowPixmap.resize(shadow.size()); // Create a fake drop-down shadow effect via blended Xwindows shadowWidget = new TQWidget(0, 0, (WFlags)(WStyle_Customize | WX11BypassWM)); shadowWidget->setGeometry(shadow); XSelectInput(tqt_xdisplay(), shadowWidget->winId(), ButtonPressMask | ButtonReleaseMask | StructureNotifyMask); shadowWidget->installEventFilter(this); if (!shapes) { // XShape extension not supported exposedRegion = getExposedRegion(shapeBoundingRegion, shadow.x(), shadow.y(), shadow.width(), shadow.height(), thickness, xOffset, yOffset); shadowRegion.region = exposedRegion; shadowRegion.client = this; shadowRegions.append(shadowRegion); if (opacityCache->isNull()) imposeRegionShadow(shadowPixmap, shapeBoundingRegion, exposedRegion, thickness, options->shadowOpacity(isActive())); else imposeCachedShadow(shadowPixmap, exposedRegion); } else { TQMemArray<TQRect> exposedRects; TQMemArray<TQRect>::Iterator it, itEnd; XRectangle *shadowShapes; exposedRegion = getExposedRegion(shapeBoundingRegion, shadow.x(), shadow.y(), shadow.width(), shadow.height(), thickness, xOffset, yOffset); shadowRegion.region = exposedRegion; shadowRegion.client = this; shadowRegions.append(shadowRegion); // XShape the shadow exposedRects = exposedRegion.rects(); i = 0; itEnd = exposedRects.end(); shadowShapes = new XRectangle[exposedRects.count()]; for (it = exposedRects.begin(); it != itEnd; ++it) { shadowShapes[i].x = (*it).x(); shadowShapes[i].y = (*it).y(); shadowShapes[i].width = (*it).width(); shadowShapes[i].height = (*it).height(); i++; } XShapeCombineRectangles(tqt_xdisplay(), shadowWidget->winId(), ShapeBounding, -x() + thickness - xOffset, -y() + thickness - yOffset, shadowShapes, i, ShapeSet, Unsorted); delete [] shadowShapes; if (opacityCache->isNull()) imposeRegionShadow(shadowPixmap, shapeBoundingRegion, exposedRegion, thickness, options->shadowOpacity(isActive())); else imposeCachedShadow(shadowPixmap, exposedRegion); } XFree(shapes); // Set the background pixmap //shadowPixmap.convertFromImage(shadowImage); shadowWidget->setErasePixmap(shadowPixmap); // Restack shadows under this window so that shadows drawn for a newly // focused (but not raised) window don't overlap any windows above it. if (isDock()) { ClientList stacking_order = workspace()->stackingOrder(); for (ClientList::ConstIterator it = stacking_order.begin(); it != stacking_order.end(); ++it) if ((*it)->isDesktop()) { ++it; shadows[0] = (*it)->frameId(); shadows[1] = shadowWidget->winId(); } } else { shadows[0] = frameId(); if (shadowWidget != NULL) shadows[1] = shadowWidget->winId(); } XRestackWindows(tqt_xdisplay(), shadows, 2); // Don't use TQWidget::show() so we don't confuse QEffects, thus causing // broken focus. XMapWindow(tqt_xdisplay(), shadowWidget->winId()); // Tell whatever Clients are listening that this Client's shadow has been drawn. emit shadowDrawn(); } /*! Remove shadow under this window. */ void Client::removeShadow() { TQValueList<ShadowRegion>::Iterator it; shadowDelayTimer->stop(); if (shadowWidget != NULL) { for (it = shadowRegions.begin(); it != shadowRegions.end(); ++it) if ((*it).client == this) { shadowRegions.remove(it); break; } delete shadowWidget; shadowWidget = NULL; } } /*! Calculate regions in which the shadow will be visible given the window's origin, height and width and the shadow's thickness, and X- and Y-offsets. */ TQRegion Client::getExposedRegion(TQRegion occludedRegion, int x, int y, int w, int h, int thickness, int xOffset, int yOffset) { TQRegion exposedRegion; exposedRegion = TQRegion(x, y, w, h); exposedRegion -= occludedRegion; if (thickness > 0) { // Limit exposedRegion to include only where a shadow of the specified // thickness will be drawn TQMemArray<TQRect> occludedRects; TQMemArray<TQRect>::Iterator it, itEnd; TQRegion shadowRegion; occludedRects = occludedRegion.rects(); itEnd = occludedRects.end(); for (it = occludedRects.begin(); it != itEnd; ++it) { // Expand each of the occluded region's shape rectangles to contain // where a shadow of the specified thickness will be drawn. Create // a new TQRegion that contains the expanded occluded region it->setTop(it->top() - thickness + yOffset); it->setLeft(it->left() - thickness + xOffset); it->setRight(it->right() + thickness + xOffset); it->setBottom(it->bottom() + thickness + yOffset); shadowRegion += TQRegion(*it); } exposedRegion -= exposedRegion - shadowRegion; } return exposedRegion; } /*! Draw shadow gradient around this window using cached opacity values. */ void Client::imposeCachedShadow(TQPixmap &pixmap, TQRegion exposed) { QRgb pixel; double opacity; int red, green, blue, pixelRed, pixelGreen, pixelBlue; int subW, subH, w, x, y, zeroX, zeroY; TQImage image; TQMemArray<TQRect>::Iterator it, itEnd; TQMemArray<TQRect> rectangles; TQPixmap subPixmap; Window rootWindow; int thickness, windowX, windowY, xOffset, yOffset; rectangles = exposed.rects(); rootWindow = tqt_xrootwin(); thickness = options->shadowThickness(isActive()); windowX = this->x(); windowY = this->y(); xOffset = options->shadowXOffset(isActive()); yOffset = options->shadowYOffset(isActive()); options->shadowColour(isActive()).rgb(&red, &green, &blue); w = pixmap.width(); itEnd = rectangles.end(); for (it = rectangles.begin(); it != itEnd; ++it) { subW = (*it).width(); subH = (*it).height(); subPixmap = TQPixmap::grabWindow(rootWindow, (*it).x(), (*it).y(), subW, subH); zeroX = (*it).x() - windowX + thickness - xOffset; zeroY = (*it).y() - windowY + thickness - yOffset; image = subPixmap.convertToImage(); for (x = 0; x < subW; x++) { for (y = 0; y < subH; y++) { opacity = (*(opacityCache))[(zeroY + y) * w + zeroX + x]; pixel = image.pixel(x, y); pixelRed = tqRed(pixel); pixelGreen = tqGreen(pixel); pixelBlue = tqBlue(pixel); image.setPixel(x, y, tqRgb((int)(pixelRed + (red - pixelRed) * opacity), (int)(pixelGreen + (green - pixelGreen) * opacity), (int)(pixelBlue + (blue - pixelBlue) * opacity))); } } subPixmap.convertFromImage(image); bitBlt(&pixmap, zeroX, zeroY, &subPixmap); } } /*! Draw shadow around this window using calculated opacity values. */ void Client::imposeRegionShadow(TQPixmap &pixmap, TQRegion occluded, TQRegion exposed, int thickness, double maxOpacity) { register int distance, intersectCount, i, j, x, y; QRgb pixel; double decay, factor, opacity; int red, green, blue, pixelRed, pixelGreen, pixelBlue; int lineIntersects, maxIntersects, maxY; int irBottom, irLeft, irRight, irTop, yIncrement; int subW, subH, w, h, zeroX, zeroY; TQImage image; TQMemArray<TQRect>::Iterator it, itEnd; TQMemArray<TQRect> rectangles; TQPixmap subPixmap; Window rootWindow; int windowX, windowY, xOffset, yOffset; rectangles = exposed.rects(); rootWindow = tqt_xrootwin(); windowX = this->x(); windowY = this->y(); xOffset = options->shadowXOffset(isActive()); yOffset = options->shadowYOffset(isActive()); options->shadowColour(isActive()).rgb(&red, &green, &blue); maxIntersects = thickness * thickness * 4 + (thickness * 4) + 1; lineIntersects = thickness * 2 + 1; factor = maxIntersects / maxOpacity; decay = (lineIntersects / 0.0125 - factor) / pow((double)maxIntersects, 3.0); w = pixmap.width(); h = pixmap.height(); xOffset = options->shadowXOffset(isActive()); yOffset = options->shadowYOffset(isActive()); opacityCache->resize(0); opacityCache->resize(w * h); occluded.translate(-windowX + thickness, -windowY + thickness); itEnd = rectangles.end(); for (it = rectangles.begin(); it != itEnd; ++it) { subW = (*it).width(); subH = (*it).height(); subPixmap = TQPixmap::grabWindow(rootWindow, (*it).x(), (*it).y(), subW, subH); maxY = subH; zeroX = (*it).x() - windowX + thickness - xOffset; zeroY = (*it).y() - windowY + thickness - yOffset; image = subPixmap.convertToImage(); intersectCount = 0; opacity = -1; y = 0; yIncrement = 1; for (x = 0; x < subW; x++) { irLeft = zeroX + x - thickness; irRight = zeroX + x + thickness; while (y != maxY) { // horizontal row about to leave the intersect region, not // necessarily the top row irTop = zeroY + y - thickness * yIncrement; // horizontal row that just came into the intersect region, // not necessarily the bottom row irBottom = zeroY + y + thickness * yIncrement; if (opacity == -1) { // If occluded pixels caused an intersect count to be // skipped, recount it intersectCount = 0; for (j = irTop; j != irBottom; j += yIncrement) { // irTop is not necessarily larger than irBottom and // yIncrement isn't necessarily positive for (i = irLeft; i <= irRight; i++) { if (occluded.contains(TQPoint(i, j))) intersectCount++; } } } else { if (intersectCount < 0) intersectCount = 0; for (i = irLeft; i <= irRight; i++) { if (occluded.contains(TQPoint(i, irBottom))) intersectCount++; } } distance = maxIntersects - intersectCount; opacity = intersectCount / (factor + pow((double)distance, 3.0) * decay); (*(opacityCache))[(zeroY + y) * w + zeroX + x] = opacity; pixel = image.pixel(x, y); pixelRed = tqRed(pixel); pixelGreen = tqGreen(pixel); pixelBlue = tqBlue(pixel); image.setPixel(x, y, tqRgb((int)(pixelRed + (red - pixelRed) * opacity), (int)(pixelGreen + (green - pixelGreen) * opacity), (int)(pixelBlue + (blue - pixelBlue) * opacity))); for (i = irLeft; i <= irRight; i++) { if (occluded.contains(TQPoint(i, irTop))) intersectCount--; } y += yIncrement; } y -= yIncrement; irTop += yIncrement; for (j = irTop; j != irBottom; j += yIncrement) { if (occluded.contains(TQPoint(irLeft, j))) intersectCount--; } irRight++; for (j = irTop; j != irBottom; j += yIncrement) { if (occluded.contains(TQPoint(irRight, j))) intersectCount++; } yIncrement *= -1; if (yIncrement < 0) // Scan Y-axis bottom-up for next X-coordinate iteration maxY = -1; else // Scan Y-axis top-down for next X-coordinate iteration maxY = subH; } subPixmap.convertFromImage(image); bitBlt(&pixmap, zeroX, zeroY, &subPixmap); } } /*! Sets the client window's mapping state. Possible values are WithdrawnState, IconicState, NormalState. */ void Client::setMappingState(int s) { assert( client != None ); assert( !deleting || s == WithdrawnState ); if( mapping_state == s ) return; bool was_unmanaged = ( mapping_state == WithdrawnState ); mapping_state = s; if( mapping_state == WithdrawnState ) { XDeleteProperty( tqt_xdisplay(), window(), tqt_wm_state ); return; } assert( s == NormalState || s == IconicState ); unsigned long data[2]; data[0] = (unsigned long) s; data[1] = (unsigned long) None; XChangeProperty(tqt_xdisplay(), window(), tqt_wm_state, tqt_wm_state, 32, PropModeReplace, (unsigned char *)data, 2); if( was_unmanaged ) // manage() did postpone_geometry_updates = 1, now it's ok to finally set the geometry postponeGeometryUpdates( false ); } /*! Reimplemented to map the managed window in the window wrapper. Proper mapping state should be set before showing the client. */ void Client::rawShow() { if( decoration != NULL ) decoration->widget()->show(); // not really necessary, but let it know the state XMapWindow( tqt_xdisplay(), frame ); if( !isShade()) { XMapWindow( tqt_xdisplay(), wrapper ); XMapWindow( tqt_xdisplay(), client ); } if (options->shadowEnabled(isActive())) drawDelayedShadow(); } /*! Reimplemented to unmap the managed window in the window wrapper. Also informs the workspace. Proper mapping state should be set before hiding the client. */ void Client::rawHide() { // Here it may look like a race condition, as some other client might try to unmap // the window between these two XSelectInput() calls. However, they're supposed to // use XWithdrawWindow(), which also sends a synthetic event to the root window, // which won't be missed, so this shouldn't be a problem. The chance the real UnmapNotify // will be missed is also very minimal, so I don't think it's needed to grab the server // here. removeShadow(); drawIntersectingShadows(); XSelectInput( tqt_xdisplay(), wrapper, ClientWinMask ); // avoid getting UnmapNotify XUnmapWindow( tqt_xdisplay(), frame ); XUnmapWindow( tqt_xdisplay(), wrapper ); XUnmapWindow( tqt_xdisplay(), client ); XSelectInput( tqt_xdisplay(), wrapper, ClientWinMask | SubstructureNotifyMask ); if( decoration != NULL ) decoration->widget()->hide(); // not really necessary, but let it know the state workspace()->clientHidden( this ); } void Client::sendClientMessage(Window w, Atom a, Atom protocol, long data1, long data2, long data3) { XEvent ev; long mask; memset(&ev, 0, sizeof(ev)); ev.xclient.type = ClientMessage; ev.xclient.window = w; ev.xclient.message_type = a; ev.xclient.format = 32; ev.xclient.data.l[0] = protocol; ev.xclient.data.l[1] = GET_QT_X_TIME(); ev.xclient.data.l[2] = data1; ev.xclient.data.l[3] = data2; ev.xclient.data.l[4] = data3; mask = 0L; if (w == tqt_xrootwin()) mask = SubstructureRedirectMask; /* magic! */ XSendEvent(tqt_xdisplay(), w, False, mask, &ev); } /* Returns whether the window may be closed (have a close button) */ bool Client::isCloseable() const { if( isModalSystemNotification()) return false; return rules()->checkCloseable( motif_may_close && !isSpecialWindow()); } /*! Closes the window by either sending a delete_window message or using XKill. */ void Client::closeWindow() { if( !isCloseable()) return; // Update user time, because the window may create a confirming dialog. updateUserTime(); if ( Pdeletewindow ) { Notify::raise( Notify::Close ); sendClientMessage( window(), atoms->wm_protocols, atoms->wm_delete_window); pingWindow(); } else { // client will not react on wm_delete_window. We have not choice // but destroy his connection to the XServer. killWindow(); } } /*! Kills the window via XKill */ void Client::killWindow() { kdDebug( 1212 ) << "Client::killWindow():" << caption() << endl; // not sure if we need an Notify::Kill or not.. until then, use // Notify::Close Notify::raise( Notify::Close ); if( isDialog()) Notify::raise( Notify::TransDelete ); if( isNormalWindow()) Notify::raise( Notify::Delete ); killProcess( false ); // always kill this client at the server XKillClient(tqt_xdisplay(), window() ); destroyClient(); } // send a ping to the window using _NET_WM_PING if possible // if it doesn't respond within a reasonable time, it will be // killed void Client::pingWindow() { if( !Pping ) return; // can't ping :( if( options->killPingTimeout == 0 ) return; // turned off if( ping_timer != NULL ) return; // pinging already ping_timer = new TQTimer( this ); connect( ping_timer, TQT_SIGNAL( timeout()), TQT_SLOT( pingTimeout())); ping_timer->start( options->killPingTimeout, true ); ping_timestamp = GET_QT_X_TIME(); workspace()->sendPingToWindow( window(), ping_timestamp ); } void Client::gotPing( Time timestamp ) { // just plain compare is not good enough because of 64bit and truncating and whatnot if( NET::timestampCompare( timestamp, ping_timestamp ) != 0 ) return; delete ping_timer; ping_timer = NULL; if( process_killer != NULL ) { process_killer->kill(); delete process_killer; process_killer = NULL; } } void Client::pingTimeout() { kdDebug( 1212 ) << "Ping timeout:" << caption() << endl; delete ping_timer; ping_timer = NULL; killProcess( true, ping_timestamp ); } void Client::killProcess( bool ask, Time timestamp ) { if( process_killer != NULL ) return; Q_ASSERT( !ask || timestamp != CurrentTime ); TQCString machine = wmClientMachine( true ); pid_t pid = info->pid(); if( pid <= 0 || machine.isEmpty()) // needed properties missing return; kdDebug( 1212 ) << "Kill process:" << pid << "(" << machine << ")" << endl; if( !ask ) { if( machine != "localhost" ) { TDEProcess proc; proc << "xon" << machine << "kill" << pid; proc.start( TDEProcess::DontCare ); } else ::kill( pid, SIGTERM ); } else { // SELI TODO handle the window created by handler specially (on top,urgent?) process_killer = new TDEProcess( this ); *process_killer << TDEStandardDirs::findExe( "twin_killer_helper" ) << "--pid" << TQCString().setNum( pid ) << "--hostname" << machine << "--windowname" << caption().utf8() << "--applicationname" << resourceClass() << "--wid" << TQCString().setNum( window()) << "--timestamp" << TQCString().setNum( timestamp ); connect( process_killer, TQT_SIGNAL( processExited( TDEProcess* )), TQT_SLOT( processKillerExited())); if( !process_killer->start( TDEProcess::NotifyOnExit )) { delete process_killer; process_killer = NULL; return; } } } bool Client::isSuspendable() const { bool cansuspend = true; if( skipTaskbar() || skipPager() ) return false; TQCString machine = wmClientMachine( true ); pid_t pid = info->pid(); if( pid <= 0 || machine.isEmpty()) // needed properties missing return false; kdDebug( 1212 ) << "Check suspendable process:" << pid << "(" << machine << ")" << endl; if( machine != "localhost" ) { return false; } else { TQFile procStatFile(TQString("/proc/%1/stat").arg(pid)); if (procStatFile.open(IO_ReadOnly)) { TQByteArray statRaw = procStatFile.readAll(); procStatFile.close(); TQString statString(statRaw); TQStringList statFields = TQStringList::split(" ", statString, TRUE); TQString tcomm = statFields[1]; TQString state = statFields[2]; if( state != "T" ) { // Make sure no windows of this process are special for ( ClientList::ConstIterator it = workspace()->clients.begin(); it != workspace()->clients.end(); ++it) { Client* nextclient = *it; pid_t nextpid = nextclient->info->pid(); TQCString nextmachine = nextclient->wmClientMachine( true ); if( nextpid > 0 && (!nextmachine.isEmpty())) { if( ( nextmachine == "localhost" ) && ( pid == nextpid ) ) { if( nextclient->skipTaskbar() || nextclient->skipPager() ) cansuspend = false; } } } // Process exception list TQString execname(tcomm); execname.truncate(execname.length()-1); execname = execname.remove(0,1); // FIXME This list should not be hardcoded if( (execname == "kdesktop") || (execname == "kicker") ) return false; else return cansuspend; } else { return false; } } else { return false; } } } bool Client::isResumeable() const { TQCString machine = wmClientMachine( true ); pid_t pid = info->pid(); if( pid <= 0 || machine.isEmpty()) // needed properties missing return false; kdDebug( 1212 ) << "Check resumeable process:" << pid << "(" << machine << ")" << endl; if( machine != "localhost" ) { return false; } else { TQFile procStatFile(TQString("/proc/%1/stat").arg(pid)); if (procStatFile.open(IO_ReadOnly)) { TQByteArray statRaw = procStatFile.readAll(); procStatFile.close(); TQString statString(statRaw); TQStringList statFields = TQStringList::split(" ", statString, TRUE); TQString tcomm = statFields[1]; TQString state = statFields[2]; if( state == "T" ) { return true; } else { return false; } } else { return false; } } } bool Client::queryUserSuspendedResume() { if (isResumeable()) { if (process_resumer != NULL) { return false; } // FIXME We should display a busy cursor until twin_resumer_helper loads process_resumer = new TDEProcess( this ); *process_resumer << TDEStandardDirs::findExe( "twin_resumer_helper" ) << "--pid" << TQCString().setNum( info->pid() ) << "--hostname" << wmClientMachine( true ) << "--windowname" << caption().utf8() << "--applicationname" << resourceClass() << "--wid" << TQCString().setNum( window()); connect( process_resumer, TQT_SIGNAL( processExited( TDEProcess* )), TQT_SLOT( processResumerExited())); if( !process_resumer->start( TDEProcess::NotifyOnExit )) { delete process_resumer; process_resumer = NULL; return true; } return false; } else { return true; } } void Client::suspendWindow() { TQCString machine = wmClientMachine( true ); pid_t pid = info->pid(); if( pid <= 0 || machine.isEmpty()) // needed properties missing return; kdDebug( 1212 ) << "Suspend process:" << pid << "(" << machine << ")" << endl; if( machine != "localhost" ) { return; } else { for ( ClientList::ConstIterator it = workspace()->clients.begin(); it != workspace()->clients.end(); ++it) { Client* nextclient = *it; pid_t nextpid = nextclient->info->pid(); TQCString nextmachine = nextclient->wmClientMachine( true ); if( nextpid > 0 && (!nextmachine.isEmpty())) { if( ( nextmachine == "localhost" ) && ( pid == nextpid ) ) { TQString newCaption = TQString(readName()).append(" <").append(i18n("Suspended")).append(">"); nextclient->info->setVisibleName(newCaption.utf8()); nextclient->info->setVisibleIconName(newCaption.utf8()); nextclient->minimized_before_suspend = nextclient->isMinimized(); nextclient->minimize(true); } } } ::kill( pid, SIGSTOP ); } } void Client::resumeWindow() { TQCString machine = wmClientMachine( true ); pid_t pid = info->pid(); if( pid <= 0 || machine.isEmpty()) // needed properties missing return; kdDebug( 1212 ) << "Resume process:" << pid << "(" << machine << ")" << endl; if( machine != "localhost" ) { return; } else { ::kill( pid, SIGCONT ); for ( ClientList::ConstIterator it = workspace()->clients.begin(); it != workspace()->clients.end(); ++it) { Client* nextclient = *it; pid_t nextpid = nextclient->info->pid(); TQCString nextmachine = nextclient->wmClientMachine( true ); if( nextpid > 0 && (!nextmachine.isEmpty())) { if( ( nextmachine == "localhost" ) && ( pid == nextpid ) ) { if (!nextclient->minimized_before_suspend) { nextclient->unminimize(true); } nextclient->updateCaption(); } } } } } void Client::processKillerExited() { kdDebug( 1212 ) << "Killer exited" << endl; delete process_killer; process_killer = NULL; } void Client::processResumerExited() { kdDebug( 1212 ) << "Resumer exited" << endl; // 0 means the user clicked Resume; 2 means that the resumer dialog failed to launch somehow if ((process_resumer->exitStatus() == 0) || (process_resumer->exitStatus() == 2)) { resumeWindow(); takeFocus( Allowed ); } delete process_resumer; process_resumer = NULL; } void Client::setSkipTaskbar( bool b, bool from_outside ) { int was_wants_tab_focus = wantsTabFocus(); if( from_outside ) { b = rules()->checkSkipTaskbar( b ); original_skip_taskbar = b; } if ( b == skipTaskbar() ) return; skip_taskbar = b; info->setState( b?NET::SkipTaskbar:0, NET::SkipTaskbar ); updateWindowRules(); if( was_wants_tab_focus != wantsTabFocus()) workspace()->updateFocusChains( this, isActive() ? Workspace::FocusChainMakeFirst : Workspace::FocusChainUpdate ); } void Client::setSkipPager( bool b ) { b = rules()->checkSkipPager( b ); if ( b == skipPager() ) return; skip_pager = b; info->setState( b?NET::SkipPager:0, NET::SkipPager ); updateWindowRules(); } void Client::setModal( bool m ) { // Qt-3.2 can have even modal normal windows :( if( modal == m ) return; modal = m; if( !modal ) return; // changing modality for a mapped window is weird (?) // _NET_WM_STATE_MODAL should possibly rather be _NET_WM_WINDOW_TYPE_MODAL_DIALOG } void Client::setDesktop( int desktop ) { if( desktop != NET::OnAllDesktops ) // do range check desktop = KMAX( 1, KMIN( workspace()->numberOfDesktops(), desktop )); desktop = rules()->checkDesktop( desktop ); if( desk == desktop ) return; int was_desk = desk; desk = desktop; info->setDesktop( desktop ); if(( was_desk == NET::OnAllDesktops ) != ( desktop == NET::OnAllDesktops )) { // onAllDesktops changed if ( isShown( true )) Notify::raise( isOnAllDesktops() ? Notify::OnAllDesktops : Notify::NotOnAllDesktops ); workspace()->updateOnAllDesktopsOfTransients( this ); } if( decoration != NULL ) decoration->desktopChange(); workspace()->updateFocusChains( this, Workspace::FocusChainMakeFirst ); updateVisibility(); updateWindowRules(); } void Client::setOnAllDesktops( bool b ) { if(( b && isOnAllDesktops()) || ( !b && !isOnAllDesktops())) return; if( b ) setDesktop( NET::OnAllDesktops ); else setDesktop( workspace()->currentDesktop()); } bool Client::isOnCurrentDesktop() const { return isOnDesktop( workspace()->currentDesktop()); } int Client::screen() const { if( !options->xineramaEnabled ) return 0; return workspace()->screenNumber( geometry().center()); } bool Client::isOnScreen( int screen ) const { if( !options->xineramaEnabled ) return screen == 0; return workspace()->screenGeometry( screen ).intersects( geometry()); } // performs activation and/or raising of the window void Client::takeActivity( int flags, bool handled, allowed_t ) { if( !handled || !Ptakeactivity ) { if( flags & ActivityFocus ) takeFocus( Allowed ); if( flags & ActivityRaise ) workspace()->raiseClient( this ); return; } #ifndef NDEBUG static Time previous_activity_timestamp; static Client* previous_client; if( previous_activity_timestamp == GET_QT_X_TIME() && previous_client != this ) { kdDebug( 1212 ) << "Repeated use of the same X timestamp for activity" << endl; kdDebug( 1212 ) << kdBacktrace() << endl; } previous_activity_timestamp = GET_QT_X_TIME(); previous_client = this; #endif workspace()->sendTakeActivity( this, GET_QT_X_TIME(), flags ); } // performs the actual focusing of the window using XSetInputFocus and WM_TAKE_FOCUS void Client::takeFocus( allowed_t ) { #ifndef NDEBUG static Time previous_focus_timestamp; static Client* previous_client; if( previous_focus_timestamp == GET_QT_X_TIME() && previous_client != this ) { kdDebug( 1212 ) << "Repeated use of the same X timestamp for focus" << endl; kdDebug( 1212 ) << kdBacktrace() << endl; } previous_focus_timestamp = GET_QT_X_TIME(); previous_client = this; #endif if ( rules()->checkAcceptFocus( input )) { XSetInputFocus( tqt_xdisplay(), window(), RevertToPointerRoot, GET_QT_X_TIME() ); // Work around opacity bug bool activePrev = active; active = true; updateOpacity(); active = activePrev; } if ( Ptakefocus ) { sendClientMessage(window(), atoms->wm_protocols, atoms->wm_take_focus); } workspace()->setShouldGetFocus( this ); } /*! Returns whether the window provides context help or not. If it does, you should show a help menu item or a help button like '?' and call contextHelp() if this is invoked. \sa contextHelp() */ bool Client::providesContextHelp() const { if (isModalSystemNotification()) return false; return Pcontexthelp; } /*! Invokes context help on the window. Only works if the window actually provides context help. \sa providesContextHelp() */ void Client::showContextHelp() { if ( Pcontexthelp ) { sendClientMessage(window(), atoms->wm_protocols, atoms->net_wm_context_help); TQWhatsThis::enterWhatsThisMode(); // SELI? } } /*! Fetches the window's caption (WM_NAME property). It will be stored in the client's caption(). */ void Client::fetchName() { setCaption( readName()); } TQString Client::readName() const { if ( info->name() && info->name()[ 0 ] != '\0' ) return TQString::fromUtf8( info->name() ); else return KWin::readNameProperty( window(), XA_WM_NAME ); } KWIN_COMPARE_PREDICATE( FetchNameInternalPredicate, const Client*, (!cl->isSpecialWindow() || cl->isToolbar()) && cl != value && cl->caption() == value->caption()); void Client::setCaption( const TQString& s, bool force ) { if ( s != cap_normal || force ) { bool reset_name = force; for( unsigned int i = 0; i < s.length(); ++i ) if( !s[ i ].isPrint()) s[ i ] = ' '; cap_normal = s; bool was_suffix = ( !cap_suffix.isEmpty()); TQString machine_suffix; if( wmClientMachine( false ) != "localhost" && !isLocalMachine( wmClientMachine( false ))) machine_suffix = " <@" + wmClientMachine( true ) + ">"; TQString shortcut_suffix = !shortcut().isNull() ? ( " {" + shortcut().toString() + "}" ) : ""; cap_suffix = machine_suffix + shortcut_suffix; if ( ( !isSpecialWindow() || isToolbar()) && workspace()->findClient( FetchNameInternalPredicate( this ))) { int i = 2; do { cap_suffix = machine_suffix + " <" + TQString::number(i) + ">" + shortcut_suffix; i++; } while ( workspace()->findClient( FetchNameInternalPredicate( this ))); info->setVisibleName( caption().utf8() ); reset_name = false; } if(( (was_suffix && cap_suffix.isEmpty()) || reset_name )) // if it was new window, it may have old value still set, if the window is reused { info->setVisibleName( "" ); // remove info->setVisibleIconName( "" ); // remove } else if( !cap_suffix.isEmpty() && !cap_iconic.isEmpty()) // keep the same suffix in iconic name if it's set info->setVisibleIconName( ( cap_iconic + cap_suffix ).utf8() ); if( isManaged() && decoration != NULL ) decoration->captionChange(); } } void Client::updateCaption() { setCaption( cap_normal, true ); } void Client::fetchIconicName() { TQString s; if ( info->iconName() && info->iconName()[ 0 ] != '\0' ) s = TQString::fromUtf8( info->iconName() ); else s = KWin::readNameProperty( window(), XA_WM_ICON_NAME ); if ( s != cap_iconic ) { bool was_set = !cap_iconic.isEmpty(); cap_iconic = s; if( !cap_suffix.isEmpty()) { if( !cap_iconic.isEmpty()) // keep the same suffix in iconic name if it's set info->setVisibleIconName( ( s + cap_suffix ).utf8() ); else if( was_set ) info->setVisibleIconName( "" ); //remove } } } /*!\reimp */ TQString Client::caption( bool full ) const { return full ? cap_normal + cap_suffix : cap_normal; } void Client::getWMHints() { XWMHints *hints = XGetWMHints(tqt_xdisplay(), window() ); input = true; window_group = None; urgency = false; if ( hints ) { if( hints->flags & InputHint ) input = hints->input; if( hints->flags & WindowGroupHint ) window_group = hints->window_group; urgency = ( hints->flags & UrgencyHint ) ? true : false; // true/false needed, it's uint bitfield XFree( (char*)hints ); } checkGroup(); updateUrgency(); updateAllowedActions(); // group affects isMinimizable() } void Client::getMotifHints() { bool mnoborder, mresize, mmove, mminimize, mmaximize, mclose; Motif::readFlags( client, mnoborder, mresize, mmove, mminimize, mmaximize, mclose ); motif_noborder = mnoborder; if( !hasNETSupport()) // NETWM apps should set type and size constraints { motif_may_resize = mresize; // this should be set using minsize==maxsize, but oh well motif_may_move = mmove; } else motif_may_resize = motif_may_move = true; // mminimize; - ignore, bogus - e.g. shading or sending to another desktop is "minimizing" too // mmaximize; - ignore, bogus - maximizing is basically just resizing motif_may_close = mclose; // motif apps like to crash when they set this hint and WM closes them anyway if( isManaged()) updateDecoration( true ); // check if noborder state has changed } void Client::readIcons( Window win, TQPixmap* icon, TQPixmap* miniicon ) { // get the icons, allow scaling if( icon != NULL ) *icon = KWin::icon( win, 32, 32, TRUE, KWin::NETWM | KWin::WMHints ); if( miniicon != NULL ) { if( icon == NULL || !icon->isNull()) *miniicon = KWin::icon( win, 16, 16, TRUE, KWin::NETWM | KWin::WMHints ); else *miniicon = TQPixmap(); } } void Client::getIcons() { // first read icons from the window itself readIcons( window(), &icon_pix, &miniicon_pix ); if( icon_pix.isNull()) { // then try window group icon_pix = group()->icon(); miniicon_pix = group()->miniIcon(); } if( icon_pix.isNull() && isTransient()) { // then mainclients ClientList mainclients = mainClients(); for( ClientList::ConstIterator it = mainclients.begin(); it != mainclients.end() && icon_pix.isNull(); ++it ) { icon_pix = (*it)->icon(); miniicon_pix = (*it)->miniIcon(); } } if( icon_pix.isNull()) { // and if nothing else, load icon from classhint or xapp icon icon_pix = KWin::icon( window(), 32, 32, TRUE, KWin::ClassHint | KWin::XApp ); miniicon_pix = KWin::icon( window(), 16, 16, TRUE, KWin::ClassHint | KWin::XApp ); } if( isManaged() && decoration != NULL ) decoration->iconChange(); } void Client::getWindowProtocols() { Atom *p; int i,n; Pdeletewindow = 0; Ptakefocus = 0; Ptakeactivity = 0; Pcontexthelp = 0; Pping = 0; if (XGetWMProtocols(tqt_xdisplay(), window(), &p, &n)) { for (i = 0; i < n; i++) if (p[i] == atoms->wm_delete_window) Pdeletewindow = 1; else if (p[i] == atoms->wm_take_focus) Ptakefocus = 1; else if (p[i] == atoms->net_wm_take_activity) Ptakeactivity = 1; else if (p[i] == atoms->net_wm_context_help) Pcontexthelp = 1; else if (p[i] == atoms->net_wm_ping) Pping = 1; if (n>0) XFree(p); } } static int nullErrorHandler(Display *, XErrorEvent *) { return 0; } /*! Returns WM_WINDOW_ROLE property for a given window. */ TQCString Client::staticWindowRole(WId w) { return getStringProperty(w, tqt_window_role).lower(); } /*! Returns SM_CLIENT_ID property for a given window. */ TQCString Client::staticSessionId(WId w) { return getStringProperty(w, tqt_sm_client_id); } /*! Returns WM_COMMAND property for a given window. */ TQCString Client::staticWmCommand(WId w) { return getStringProperty(w, XA_WM_COMMAND, ' '); } /*! Returns WM_CLIENT_LEADER property for a given window. */ Window Client::staticWmClientLeader(WId w) { Atom type; int format, status; unsigned long nitems = 0; unsigned long extra = 0; unsigned char *data = 0; Window result = w; XErrorHandler oldHandler = XSetErrorHandler(nullErrorHandler); status = XGetWindowProperty( tqt_xdisplay(), w, atoms->wm_client_leader, 0, 10000, FALSE, XA_WINDOW, &type, &format, &nitems, &extra, &data ); XSetErrorHandler(oldHandler); if (status == Success ) { if (data && nitems > 0) result = *((Window*) data); XFree(data); } return result; } void Client::getWmClientLeader() { wmClientLeaderWin = staticWmClientLeader(window()); } /*! Returns sessionId for this client, taken either from its window or from the leader window. */ TQCString Client::sessionId() { TQCString result = staticSessionId(window()); if (result.isEmpty() && wmClientLeaderWin && wmClientLeaderWin!=window()) result = staticSessionId(wmClientLeaderWin); return result; } /*! Returns command property for this client, taken either from its window or from the leader window. */ TQCString Client::wmCommand() { TQCString result = staticWmCommand(window()); if (result.isEmpty() && wmClientLeaderWin && wmClientLeaderWin!=window()) result = staticWmCommand(wmClientLeaderWin); return result; } void Client::getWmClientMachine() { client_machine = getStringProperty(window(), XA_WM_CLIENT_MACHINE); if( client_machine.isEmpty() && wmClientLeaderWin && wmClientLeaderWin!=window()) client_machine = getStringProperty(wmClientLeaderWin, XA_WM_CLIENT_MACHINE); if( client_machine.isEmpty()) client_machine = "localhost"; } /*! Returns client machine for this client, taken either from its window or from the leader window. */ TQCString Client::wmClientMachine( bool use_localhost ) const { TQCString result = client_machine; if( use_localhost ) { // special name for the local machine (localhost) if( result != "localhost" && isLocalMachine( result )) result = "localhost"; } return result; } /*! Returns client leader window for this client. Returns the client window itself if no leader window is defined. */ Window Client::wmClientLeader() const { if (wmClientLeaderWin) return wmClientLeaderWin; return window(); } bool Client::wantsTabFocus() const { return ( isNormalWindow() || isDialog()) && wantsInput() && !skip_taskbar; } bool Client::wantsInput() const { return rules()->checkAcceptFocus( input || Ptakefocus ); } bool Client::isDesktop() const { return windowType() == NET::Desktop; } bool Client::isDock() const { return windowType() == NET::Dock; } bool Client::isTopMenu() const { return windowType() == NET::TopMenu; } bool Client::isMenu() const { return windowType() == NET::Menu && !isTopMenu(); // because of backwards comp. } bool Client::isToolbar() const { return windowType() == NET::Toolbar; } bool Client::isSplash() const { return windowType() == NET::Splash; } bool Client::isUtility() const { return windowType() == NET::Utility; } bool Client::isDialog() const { return windowType() == NET::Dialog; } bool Client::isNormalWindow() const { return windowType() == NET::Normal; } bool Client::isSpecialWindow() const { return isDesktop() || isDock() || isSplash() || isTopMenu() || isToolbar(); // TODO } NET::WindowType Client::windowType( bool direct, int supported_types ) const { NET::WindowType wt = info->windowType( supported_types ); if( direct ) return wt; NET::WindowType wt2 = rules()->checkType( wt ); if( wt != wt2 ) { wt = wt2; info->setWindowType( wt ); // force hint change } // hacks here if( wt == NET::Menu ) { // ugly hack to support the times when NET::Menu meant NET::TopMenu // if it's as wide as the screen, not very high and has its upper-left // corner a bit above the screen's upper-left cornet, it's a topmenu if( x() == 0 && y() < 0 && y() > -10 && height() < 100 && abs( width() - workspace()->clientArea( FullArea, this ).width()) < 10 ) wt = NET::TopMenu; } // TODO change this to rule const char* const oo_prefix = "openoffice.org"; // TQCString has no startsWith() // oo_prefix is lowercase, because resourceClass() is forced to be lowercase if( tqstrncmp( resourceClass(), oo_prefix, strlen( oo_prefix )) == 0 && wt == NET::Dialog ) wt = NET::Normal; // see bug #66065 if( wt == NET::Unknown ) // this is more or less suggested in NETWM spec wt = isTransient() ? NET::Dialog : NET::Normal; return wt; } /*! Sets an appropriate cursor shape for the logical mouse position \a m */ void Client::setCursor( Position m ) { if( !isResizable() || isShade()) { m = PositionCenter; } switch ( m ) { case PositionTopLeft: case PositionBottomRight: setCursor( tqsizeFDiagCursor ); break; case PositionBottomLeft: case PositionTopRight: setCursor( tqsizeBDiagCursor ); break; case PositionTop: case PositionBottom: setCursor( tqsizeVerCursor ); break; case PositionLeft: case PositionRight: setCursor( tqsizeHorCursor ); break; default: if( buttonDown && isMovable()) setCursor( tqsizeAllCursor ); else setCursor( tqarrowCursor ); break; } } // TODO mit nejake checkCursor(), ktere se zavola v manage() a pri vecech, kdy by se kurzor mohl zmenit? // TRANSLATION: TODO: have a checkCursor() function, which is called both in manage() and in cases where the cursor might change void Client::setCursor( const TQCursor& c ) { if( c.handle() == cursor.handle()) return; cursor = c; if( decoration != NULL ) decoration->widget()->setCursor( cursor ); XDefineCursor( tqt_xdisplay(), frameId(), cursor.handle()); } Client::Position Client::mousePosition( const TQPoint& p ) const { if( decoration != NULL ) return decoration->mousePosition( p ); return PositionCenter; } void Client::updateAllowedActions( bool force ) { if( !isManaged() && !force ) return; unsigned long old_allowed_actions = allowed_actions; allowed_actions = 0; if( isMovable()) allowed_actions |= NET::ActionMove; if( isResizable()) allowed_actions |= NET::ActionResize; if( isMinimizable()) allowed_actions |= NET::ActionMinimize; if( isShadeable()) allowed_actions |= NET::ActionShade; // sticky state not supported if( isMaximizable()) allowed_actions |= NET::ActionMax; if( userCanSetFullScreen()) allowed_actions |= NET::ActionFullScreen; allowed_actions |= NET::ActionChangeDesktop; // always (pagers shouldn't show Docks etc.) if( isCloseable()) allowed_actions |= NET::ActionClose; if( old_allowed_actions == allowed_actions ) return; // TODO this could be delayed and compressed - it's only for pagers etc. anyway info->setAllowedActions( allowed_actions ); // TODO this should also tell the decoration, so that it can update the buttons } void Client::autoRaise() { workspace()->raiseClient( this ); cancelAutoRaise(); } void Client::cancelAutoRaise() { delete autoRaiseTimer; autoRaiseTimer = 0; } void Client::setOpacity(bool translucent, uint opacity) { if (isDesktop()) return; // xcompmgr does not like non solid desktops and the user could set it accidently by mouse scrolling // tqWarning("setting opacity for %d",tqt_xdisplay()); //rule out activated translulcency with 100% opacity if (!translucent || opacity == 0xFFFFFFFF) { opacity_ = 0xFFFFFFFF; XDeleteProperty (tqt_xdisplay(), frameId(), atoms->net_wm_window_opacity); XDeleteProperty (tqt_xdisplay(), window(), atoms->net_wm_window_opacity); // ??? frameId() is necessary for visible changes, window() is the winId() that would be set by apps - we set both to be sure the app knows what's currently displayd } else{ if(opacity == opacity_) return; opacity_ = opacity; long data = opacity; // 32bit XChangeProperty needs long XChangeProperty(tqt_xdisplay(), frameId(), atoms->net_wm_window_opacity, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &data, 1L); XChangeProperty(tqt_xdisplay(), window(), atoms->net_wm_window_opacity, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &data, 1L); } } void Client::setShadowSize(uint shadowSize) { // ignoring all individual settings - if we control a window, we control it's shadow // TODO somehow handle individual settings for docks (besides custom sizes) long data = shadowSize; XChangeProperty(tqt_xdisplay(), frameId(), atoms->net_wm_window_shadow, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &data, 1L); } void Client::updateOpacity() // extra syncscreen flag allows to avoid double syncs when active state changes (as it will usually change for two windows) { if (!(isNormalWindow() || isDialog() || isUtility() )|| custom_opacity) return; if (isActive()) { if( ruleOpacityActive() ) setOpacity(rule_opacity_active < 0xFFFFFFFF, rule_opacity_active); else setOpacity(options->translucentActiveWindows, options->activeWindowOpacity); if (isBMP()) // beep-media-player, only undecorated windows (gtk2 xmms, xmms doesn't work with compmgr at all - s.e.p. :P ) { ClientList tmpGroupMembers = group()->members(); ClientList activeGroupMembers; activeGroupMembers.append(this); tmpGroupMembers.remove(this); ClientList::Iterator it = tmpGroupMembers.begin(); while (it != tmpGroupMembers.end()) // search for next attached and not activated client and repeat if found { if ((*it) != this && (*it)->isBMP()) // potential "to activate" client found { // tqWarning("client found"); if ((*it)->touches(this)) // first test, if the new client touches the just activated one { // tqWarning("found client touches me"); if( ruleOpacityActive() ) (*it)->setOpacity(rule_opacity_active < 0xFFFFFFFF, rule_opacity_active); else (*it)->setOpacity(options->translucentActiveWindows, options->activeWindowOpacity); // tqWarning("activated, search restarted (1)"); (*it)->setShadowSize(options->activeWindowShadowSize); activeGroupMembers.append(*it); tmpGroupMembers.remove(it); it = tmpGroupMembers.begin(); // restart, search next client continue; } else { // pot. client does not touch c, so we have to search if it touches some other activated client bool found = false; for( ClientList::ConstIterator it2 = activeGroupMembers.begin(); it2 != activeGroupMembers.end(); it2++ ) { if ((*it2) != this && (*it2) != (*it) && (*it)->touches(*it2)) { // tqWarning("found client touches other active client"); if( ruleOpacityActive() ) (*it)->setOpacity(rule_opacity_active < 0xFFFFFFFF, rule_opacity_active); else (*it)->setOpacity(options->translucentActiveWindows, options->activeWindowOpacity); (*it)->setShadowSize(options->activeWindowShadowSize); activeGroupMembers.append(*it); tmpGroupMembers.remove(it); it = tmpGroupMembers.begin(); // reset potential client search found = true; // tqWarning("activated, search restarted (2)"); break; // skip this loop } } if (found) continue; } } it++; } } else if (isNormalWindow()) // activate dependend minor windows as well { for( ClientList::ConstIterator it = group()->members().begin(); it != group()->members().end(); it++ ) if ((*it)->isDialog() || (*it)->isUtility()) { if( (*it)->ruleOpacityActive() ) (*it)->setOpacity((*it)->ruleOpacityActive() < 0xFFFFFFFF, (*it)->ruleOpacityActive()); else (*it)->setOpacity(options->translucentActiveWindows, options->activeWindowOpacity); } } } else { if( ruleOpacityInactive() ) setOpacity(rule_opacity_inactive < 0xFFFFFFFF, rule_opacity_inactive); else setOpacity(options->translucentInactiveWindows && !(keepAbove() && options->keepAboveAsActive), options->inactiveWindowOpacity); // deactivate dependend minor windows as well if (isBMP()) // beep-media-player, only undecorated windows (gtk2 xmms, xmms doesn't work with compmgr at all - s.e.p. :P ) { ClientList tmpGroupMembers = group()->members(); ClientList inactiveGroupMembers; inactiveGroupMembers.append(this); tmpGroupMembers.remove(this); ClientList::Iterator it = tmpGroupMembers.begin(); while ( it != tmpGroupMembers.end() ) // search for next attached and not activated client and repeat if found { if ((*it) != this && (*it)->isBMP()) // potential "to activate" client found { // tqWarning("client found"); if ((*it)->touches(this)) // first test, if the new client touches the just activated one { // tqWarning("found client touches me"); if( (*it)->ruleOpacityInactive() ) (*it)->setOpacity((*it)->ruleOpacityInactive() < 0xFFFFFFFF, (*it)->ruleOpacityInactive()); else (*it)->setOpacity(options->translucentInactiveWindows && !((*it)->keepAbove() && options->keepAboveAsActive), options->inactiveWindowOpacity); (*it)->setShadowSize(options->inactiveWindowShadowSize); // tqWarning("deactivated, search restarted (1)"); inactiveGroupMembers.append(*it); tmpGroupMembers.remove(it); it = tmpGroupMembers.begin(); // restart, search next client continue; } else // pot. client does not touch c, so we have to search if it touches some other activated client { bool found = false; for( ClientList::ConstIterator it2 = inactiveGroupMembers.begin(); it2 != inactiveGroupMembers.end(); it2++ ) { if ((*it2) != this && (*it2) != (*it) && (*it)->touches(*it2)) { // tqWarning("found client touches other inactive client"); if( (*it)->ruleOpacityInactive() ) (*it)->setOpacity((*it)->ruleOpacityInactive() < 0xFFFFFFFF, (*it)->ruleOpacityInactive()); else (*it)->setOpacity(options->translucentInactiveWindows && !((*it)->keepAbove() && options->keepAboveAsActive), options->inactiveWindowOpacity); (*it)->setShadowSize(options->inactiveWindowShadowSize); // tqWarning("deactivated, search restarted (2)"); inactiveGroupMembers.append(*it); tmpGroupMembers.remove(it); it = tmpGroupMembers.begin(); // reset potential client search found = true; break; // skip this loop } } if (found) continue; } } it++; } } else if (isNormalWindow()) { for( ClientList::ConstIterator it = group()->members().begin(); it != group()->members().end(); it++ ) if ((*it)->isUtility()) //don't deactivate dialogs... { if( (*it)->ruleOpacityInactive() ) (*it)->setOpacity((*it)->ruleOpacityInactive() < 0xFFFFFFFF, (*it)->ruleOpacityInactive()); else (*it)->setOpacity(options->translucentInactiveWindows && !((*it)->keepAbove() && options->keepAboveAsActive), options->inactiveWindowOpacity); } } } } void Client::updateShadowSize() // extra syncscreen flag allows to avoid double syncs when active state changes (as it will usually change for two windows) { if (!(isNormalWindow() || isDialog() || isUtility() )) return; if (isActive()) setShadowSize(options->activeWindowShadowSize); else setShadowSize(options->inactiveWindowShadowSize); } uint Client::ruleOpacityInactive() { return rule_opacity_inactive;// != 0 ; } uint Client::ruleOpacityActive() { return rule_opacity_active;// != 0; } bool Client::getWindowOpacity() //query translucency settings from X, returns true if window opacity is set { unsigned char *data = 0; Atom actual; int format, result; unsigned long n, left; result = XGetWindowProperty(tqt_xdisplay(), window(), atoms->net_wm_window_opacity, 0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left, /*(unsigned char **)*/ &data); if (result == Success && data && format == 32 ) { opacity_ = *reinterpret_cast< long* >( data ); custom_opacity = true; // setOpacity(opacity_ < 0xFFFFFFFF, opacity_); XFree ((char*)data); return TRUE; } return FALSE; } void Client::setCustomOpacityFlag(bool custom) { custom_opacity = custom; } uint Client::opacity() { return opacity_; } int Client::opacityPercentage() { return int(100*((double)opacity_/0xffffffff)); } bool Client::touches(const Client* c) // checks if this client borders c, needed to test beep media player window state { if (y() == c->y() + c->height()) // this bottom to c return TRUE; if (y() + height() == c->y()) // this top to c return TRUE; if (x() == c->x() + c->width()) // this right to c return TRUE; if (x() + width() == c->x()) // this left to c return TRUE; return FALSE; } void Client::setDecoHashProperty(uint topHeight, uint rightWidth, uint bottomHeight, uint leftWidth) { long data = (topHeight < 255 ? topHeight : 255) << 24 | (rightWidth < 255 ? rightWidth : 255) << 16 | (bottomHeight < 255 ? bottomHeight : 255) << 8 | (leftWidth < 255 ? leftWidth : 255); XChangeProperty(tqt_xdisplay(), frameId(), atoms->net_wm_window_decohash, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &data, 1L); } void Client::unsetDecoHashProperty() { XDeleteProperty( tqt_xdisplay(), frameId(), atoms->net_wm_window_decohash); } #ifndef NDEBUG kdbgstream& operator<<( kdbgstream& stream, const Client* cl ) { if( cl == NULL ) return stream << "\'NULL_CLIENT\'"; return stream << "\'ID:" << cl->window() << ";WMCLASS:" << cl->resourceClass() << ":" << cl->resourceName() << ";Caption:" << cl->caption() << "\'"; } kdbgstream& operator<<( kdbgstream& stream, const ClientList& list ) { stream << "LIST:("; bool first = true; for( ClientList::ConstIterator it = list.begin(); it != list.end(); ++it ) { if( !first ) stream << ":"; first = false; stream << *it; } stream << ")"; return stream; } kdbgstream& operator<<( kdbgstream& stream, const ConstClientList& list ) { stream << "LIST:("; bool first = true; for( ConstClientList::ConstIterator it = list.begin(); it != list.end(); ++it ) { if( !first ) stream << ":"; first = false; stream << *it; } stream << ")"; return stream; } #endif TQPixmap * twin_get_menu_pix_hack() { static TQPixmap p; if ( p.isNull() ) p = SmallIcon( "bx2" ); return &p; } } // namespace #include "client.moc"