Rename kwin to twin (Part 2 of 2)

1 files changed, 2845 insertions, 0 deletions

diff --git a/twin/client.cpp b/twin/client.cpp
new file mode 100644
index 000000000..fbd2d75aa
--- /dev/null
+++ b/twin/client.cpp
@@ -0,0 +1,2845 @@
+/*****************************************************************
+ 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 <kprocess.h>
+#include <unistd.h>
+#include <kstandarddirs.h>
+#include <tqwhatsthis.h>
+#include <twin.h>
+#include <kiconloader.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 qt_wm_state;
+extern Atom qt_window_role;
+extern Atom qt_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 ),
+        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_tqshape = 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( qt_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( qt_xdisplay(), client, atoms->kde_net_wm_user_creation_time);
+    XDeleteProperty( qt_xdisplay(), client, atoms->net_frame_extents );
+    XDeleteProperty( qt_xdisplay(), client, atoms->kde_net_wm_frame_strut );
+    XReparentWindow( qt_xdisplay(), client, workspace()->rootWin(), x(), y());
+    XRemoveFromSaveSet( qt_xdisplay(), client );
+    XSelectInput( qt_xdisplay(), client, NoEventMask );
+    if( on_shutdown )
+        { // map the window, so it can be found after another WM is started
+        XMapWindow( qt_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( qt_xdisplay(), client ); 
+        }
+    client = None;
+    XDestroyWindow( qt_xdisplay(), wrapper );
+    wrapper = None;
+    XDestroyWindow( qt_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; // tqinvalidate
+    XDestroyWindow( qt_xdisplay(), wrapper );
+    wrapper = None;
+    XDestroyWindow( qt_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 tqshape mask
+        decoration = workspace()->createDecoration( bridge );
+        // TODO check decoration's minimum size?
+        decoration->init();
+        decoration->widget()->installEventFilter( this );
+        XReparentWindow( qt_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 tqshape 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(qt_xdisplay(), window(), atoms->net_wm_system_modal_notification, 0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left, /*(unsigned char **)*/ &data);
+    if (result == Success && data != None && format == 32 )
+        {
+        return TRUE;
+        }
+    return FALSE;
+    }
+
+void Client::updateShape()
+    {
+    // workaround for #19644 - tqshaped windows shouldn't have decoration
+    if( tqshape() && !noBorder()) 
+        {
+        noborder = true;
+        updateDecoration( true );
+        }
+    updateOpacityCache();
+    if ( tqshape() )
+        {
+        XShapeCombineShape(qt_xdisplay(), frameId(), ShapeBounding,
+                           clientPos().x(), clientPos().y(),
+                           window(), ShapeBounding, ShapeSet);
+        setShapable(TRUE);
+        }
+    // !tqshape() 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 tqshape support
+        { // There appears to be no way to find out if a window has input
+          // tqshape set or not, so always propagate the input tqshape
+          // (it's the same like the bounding tqshape by default).
+          // Also, build the tqshape using a helper window, not directly
+          // in the frame window, because the sequence set-tqshape-to-frame,
+          // remove-tqshape-of-client, add-input-tqshape-of-client has the problem
+          // that after the second step there's a hole in the input tqshape
+          // until the real tqshape 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( qt_xdisplay(), qt_xrootwin(),
+                0, 0, 1, 1, 0, 0, 0 );
+        XResizeWindow( qt_xdisplay(), helper_window, width(), height());
+        XShapeCombineShape( qt_xdisplay(), helper_window, ShapeInput, 0, 0,
+                           frameId(), ShapeBounding, ShapeSet );
+        XShapeCombineShape( qt_xdisplay(), helper_window, ShapeInput,
+                           clientPos().x(), clientPos().y(),
+                           window(), ShapeBounding, ShapeSubtract );
+        XShapeCombineShape( qt_xdisplay(), helper_window, ShapeInput,
+                           clientPos().x(), clientPos().y(),
+                           window(), ShapeInput, ShapeUnion );
+        XShapeCombineShape( qt_xdisplay(), frameId(), ShapeInput, 0, 0,
+                           helper_window, ShapeInput, ShapeSet );
+        }
+    }
+
+void Client::setMask( const TQRegion& reg, int mode )
+    {
+    _mask = reg;
+    if( reg.isNull())
+        XShapeCombineMask( qt_xdisplay(), frameId(), ShapeBounding, 0, 0,
+            None, ShapeSet );
+    else if( mode == X::Unsorted )
+        XShapeCombineRegion( qt_xdisplay(), frameId(), ShapeBounding, 0, 0,
+            reg.handle(), ShapeSet );
+    else
+        {
+        TQMemArray< TQRect > rects = reg.tqrects();
+        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( qt_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(qt_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;
+
+    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( !isMinimized())
+        return;
+
+    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( qt_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(qt_xdisplay());
+        XSync( qt_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(qt_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( qt_xdisplay(), wrapper, ClientWinMask ); // avoid getting UnmapNotify
+        XUnmapWindow( qt_xdisplay(), wrapper );
+        XUnmapWindow( qt_xdisplay(), client );
+        XSelectInput( qt_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       tqrepaint( FALSE );
+//        bool wasStaticContents = testWFlags( WStaticContents );
+//        setWFlags( WStaticContents );
+        int step = QMAX( 4, QABS( h - s.height() ) / as )+1;
+        do 
+            {
+            h -= step;
+            XResizeWindow( qt_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(qt_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 = QMAX( 4, QABS( h - s.height() ) / as )+1;
+        do 
+            {
+            h += step;
+            XResizeWindow( qt_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           tqrepaint( 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( qt_xdisplay(), wrapperId());
+        XMapWindow( qt_xdisplay(), window());
+        XDeleteProperty (qt_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() ? 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 = tqshapeBoundingRegion;
+
+    // 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 = tqshapeBoundingRegion;
+
+    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 tqrepaint 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 *tqshapes;
+    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.
+     */
+    tqshapes = XShapeGetRectangles(qt_xdisplay(), frameId(), ShapeBounding,
+            &count, &ordering);
+    if (!tqshapes)
+        // XShape extension not supported
+        tqshapeBoundingRegion = TQRegion(x(), y(), width(), height());
+    else {
+        tqshapeBoundingRegion = TQRegion();
+        for (i = 0; i < count; i++) {
+            // Translate XShaped window into a TQRegion
+            TQRegion tqshapeRectangle(tqshapes[i].x, tqshapes[i].y, tqshapes[i].width,
+                    tqshapes[i].height);
+            tqshapeBoundingRegion += tqshapeRectangle;
+        }
+        if (isShade())
+            // Since XResize() doesn't change a window's XShape regions, ensure that
+            // tqshapeBoundingRegion is not taller than the window's shaded height,
+            // or the bottom shadow will appear to be missing
+            tqshapeBoundingRegion &= TQRegion(0, 0, width(), height());
+        tqshapeBoundingRegion.translate(x(), y());
+    }
+
+    if (!isShadowed() || hidden || isMinimized() ||
+            maximizeMode() == MaximizeFull ||
+            !options->shadowWindowType(windowType())) {
+        XFree(tqshapes);
+
+        // 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(qt_xdisplay(), shadowWidget->winId(),
+            ButtonPressMask | ButtonReleaseMask | StructureNotifyMask);
+    shadowWidget->installEventFilter(this);
+
+    if (!tqshapes) {
+        // XShape extension not supported
+        exposedRegion = getExposedRegion(tqshapeBoundingRegion, 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, tqshapeBoundingRegion,
+                    exposedRegion, thickness,
+                    options->shadowOpacity(isActive()));
+        else
+            imposeCachedShadow(shadowPixmap, exposedRegion);
+    }
+    else {
+        TQMemArray<TQRect> exposedRects;
+        TQMemArray<TQRect>::Iterator it, itEnd;
+        XRectangle *shadowShapes;
+
+        exposedRegion = getExposedRegion(tqshapeBoundingRegion, 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.tqrects();
+        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(qt_xdisplay(), shadowWidget->winId(),
+                ShapeBounding, -x() + thickness - xOffset,
+                -y() + thickness - yOffset, shadowShapes, i, ShapeSet,
+                Unsorted);
+        delete [] shadowShapes;
+
+        if (opacityCache->isNull())
+            imposeRegionShadow(shadowPixmap, tqshapeBoundingRegion,
+                    exposedRegion, thickness,
+                    options->shadowOpacity(isActive()));
+        else
+            imposeCachedShadow(shadowPixmap, exposedRegion);
+    }
+
+    XFree(tqshapes);
+
+    // 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(qt_xdisplay(), shadows, 2);
+
+    // Don't use TQWidget::show() so we don't confuse QEffects, thus causing
+    // broken focus.
+    XMapWindow(qt_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.tqrects();
+        itEnd = occludedRects.end();
+        for (it = occludedRects.begin(); it != itEnd; ++it) {
+            // Expand each of the occluded region's tqshape 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, h, 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.tqrects();
+    rootWindow = qt_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();
+    h = pixmap.height();
+
+    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 halfMaxIntersects, 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.tqrects();
+    rootWindow = qt_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;
+    halfMaxIntersects = maxIntersects / 2;
+    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( qt_xdisplay(), window(), qt_wm_state );
+        return;
+        }
+    assert( s == NormalState || s == IconicState );
+
+    unsigned long data[2];
+    data[0] = (unsigned long) s;
+    data[1] = (unsigned long) None;
+    XChangeProperty(qt_xdisplay(), window(), qt_wm_state, qt_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( qt_xdisplay(), frame );
+    if( !isShade())
+        {
+        XMapWindow( qt_xdisplay(), wrapper );
+        XMapWindow( qt_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( qt_xdisplay(), wrapper, ClientWinMask ); // avoid getting UnmapNotify
+    XUnmapWindow( qt_xdisplay(), frame );
+    XUnmapWindow( qt_xdisplay(), wrapper );
+    XUnmapWindow( qt_xdisplay(), client );
+    XSelectInput( qt_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 == qt_xrootwin())
+      mask = SubstructureRedirectMask;        /* magic! */
+    XSendEvent(qt_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(qt_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" )
+            {
+            KProcess proc;
+            proc << "xon" << machine << "kill" << pid;
+            proc.start( KProcess::DontCare );
+            }
+        else
+            ::kill( pid, SIGTERM );
+        }
+    else
+        { // SELI TODO handle the window created by handler specially (on top,urgent?)
+        process_killer = new KProcess( this );
+        *process_killer << KStandardDirs::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( KProcess* )),
+            TQT_SLOT( processKillerExited()));
+        if( !process_killer->start( KProcess::NotifyOnExit ))
+            {
+            delete process_killer;
+            process_killer = NULL;
+            return;
+            }
+        }
+    }
+
+void Client::processKillerExited()
+    {
+    kdDebug( 1212 ) << "Killer exited" << endl;
+    delete process_killer;
+    process_killer = 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( qt_xdisplay(), window(), RevertToPointerRoot, GET_QT_X_TIME() );
+        }
+    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(qt_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(qt_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, qt_window_role).lower();
+    }
+
+/*!
+  Returns SM_CLIENT_ID property for a given window.
+ */
+TQCString Client::staticSessionId(WId w)
+    {
+    return getStringProperty(w, qt_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( qt_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 tqshape 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?
+void Client::setCursor( const TQCursor& c )
+    {
+    if( c.handle() == cursor.handle())
+        return;
+    cursor = c;
+    if( decoration != NULL )
+        decoration->widget()->setCursor( cursor );
+    XDefineCursor( qt_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
+//     qWarning("setting opacity for %d",qt_xdisplay());
+    //rule out activated translulcency with 100% opacity
+    if (!translucent || opacity ==  0xFFFFFFFF)
+        {
+        opacity_ = 0xFFFFFFFF;
+        XDeleteProperty (qt_xdisplay(), frameId(), atoms->net_wm_window_opacity);
+        XDeleteProperty (qt_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(qt_xdisplay(), frameId(), atoms->net_wm_window_opacity, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &data, 1L);
+        XChangeProperty(qt_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(qt_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
+                    {
+//                     qWarning("client found");
+                    if ((*it)->touches(this)) // first test, if the new client touches the just activated one
+                        {
+//                         qWarning("found client touches me");
+                        if( ruleOpacityActive() )
+                            (*it)->setOpacity(rule_opacity_active < 0xFFFFFFFF, rule_opacity_active);
+                        else
+                            (*it)->setOpacity(options->translucentActiveWindows, options->activeWindowOpacity);
+//                         qWarning("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))
+                                {
+//                                 qWarning("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;
+//                                 qWarning("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
+                    {
+//                     qWarning("client found");
+                    if ((*it)->touches(this)) // first test, if the new client touches the just activated one
+                        {
+//                         qWarning("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);
+//                         qWarning("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))
+                                {
+//                                 qWarning("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);
+//                                 qWarning("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(qt_xdisplay(), window(), atoms->net_wm_window_opacity, 0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left, /*(unsigned char **)*/ &data);
+    if (result == Success && data != None && 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(qt_xdisplay(), frameId(), atoms->net_wm_window_decohash, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &data, 1L);
+}
+
+void Client::unsetDecoHashProperty()
+{
+   XDeleteProperty( qt_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"