kwin/geometry.cpp

/*****************************************************************
 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.
******************************************************************/

/*

 This file contains things relevant to geometry, i.e. workspace size,
 window positions and window sizes.

*/

#include "client.h"
#include "workspace.h"

#include <kapplication.h>
#include <kglobal.h>
#include <qpainter.h>

#include "placement.h"
#include "notifications.h"
#include "geometrytip.h"

extern Time qt_x_time;

namespace KWinInternal
{

//********************************************
// Workspace
//********************************************

/*!
  Returns the workspace's geometry

  \sa clientArea()
 */
QRect Workspace::geometry() const
    {
    if ( root == qt_xrootwin() )
        return QRect( QPoint(0, 0), QApplication::desktop()->size() );
    else 
        {
        // todo caching, keep track of configure notify etc.
        QRect r;
        XWindowAttributes attr;
        if (XGetWindowAttributes(qt_xdisplay(), root, &attr))
            {
            r.setRect(0, 0, attr.width, attr.height );
            }
        return r;
        }
    }

/*!
  Resizes the workspace after an XRANDR screen size change
 */
void Workspace::desktopResized()
    {
    updateClientArea();
    if (options->electricBorders() == Options::ElectricAlways)
        { // update electric borders
        destroyBorderWindows();
        createBorderWindows();
        }
    }

/*!
  Updates the current client areas according to the current clients.

  If the area changes or force is true, the new areas are propagated to the world.

  The client area is the area that is available for clients (that
  which is not taken by windows like panels, the top-of-screen menu
  etc).

  \sa clientArea()
 */

void Workspace::updateClientArea( bool force )
    {
    QRect* new_areas = new QRect[ numberOfDesktops() + 1 ];
    QRect all = QApplication::desktop()->geometry();
    for( int i = 1;
         i <= numberOfDesktops();
         ++i )
         new_areas[ i ] = all;
    for ( ClientList::ConstIterator it = clients.begin(); it != clients.end(); ++it) 
        {
        QRect r = (*it)->adjustedClientArea( all );
        if( r == all )
            continue;
        if( (*it)->isOnAllDesktops())
            for( int i = 1;
                 i <= numberOfDesktops();
                 ++i )
                new_areas[ i ] = new_areas[ i ].intersect( r );
        else
            new_areas[ (*it)->desktop() ] = new_areas[ (*it)->desktop() ].intersect( r );
        }

    bool changed = force;
    for( int i = 1;
         !changed && i <= numberOfDesktops();
         ++i )
        if( workarea[ i ] != new_areas[ i ] )
            changed = true;
    if ( changed ) 
        {
        delete[] workarea;
        workarea = new_areas;
        new_areas = NULL;
        NETRect r;
        for( int i = 1; i <= numberOfDesktops(); i++)
            {
            r.pos.x = workarea[ i ].x();
            r.pos.y = workarea[ i ].y();
            r.size.width = workarea[ i ].width();
            r.size.height = workarea[ i ].height();
            rootInfo->setWorkArea( i, r );
            }

        for( ClientList::ConstIterator it = clients.begin();
             it != clients.end();
             ++it)
            (*it)->checkWorkspacePosition();
        }    
    delete[] new_areas;
    }

void Workspace::updateClientArea()
    {
    updateClientArea( false );
    }


/*!
  returns the area available for clients. This is the desktop
  geometry minus windows on the dock.  Placement algorithms should
  refer to this rather than geometry().

  \sa geometry()
 */
QRect Workspace::clientArea(clientAreaOption opt, const QPoint& p, int desktop ) const
    {
    if( desktop == NETWinInfo::OnAllDesktops )
        desktop = currentDesktop();
    QRect rect = QApplication::desktop()->geometry();
    QDesktopWidget *desktopwidget = KApplication::desktop();

    switch (opt) 
        {
        case MaximizeArea:
            if (options->xineramaMaximizeEnabled)
                rect = desktopwidget->screenGeometry(desktopwidget->screenNumber(p));
            break;
        case PlacementArea:
            if (options->xineramaPlacementEnabled)
                rect = desktopwidget->screenGeometry(desktopwidget->screenNumber(p));
            break;
        case MovementArea:
            if (options->xineramaMovementEnabled)
                rect = desktopwidget->screenGeometry(desktopwidget->screenNumber(p));
            break;
        }

    if (workarea[ desktop ].isNull())
        return rect;

    return workarea[ desktop ].intersect(rect);
    }

QRect Workspace::clientArea(clientAreaOption opt, const QPoint& p) const
    {
    return clientArea( opt, p, currentDesktop());
    }

QRect Workspace::clientArea(const QPoint& p, int desktop) const
    {
    if( desktop == NETWinInfo::OnAllDesktops )
        desktop = currentDesktop();

    QRect rect;
    if (options->xineramaPlacementEnabled) 
        {
        int screenNum = QApplication::desktop()->screenNumber(p);
        rect = QApplication::desktop()->screenGeometry(screenNum);
        }
    else 
        {
        rect = QApplication::desktop()->geometry();
        }

    if (workarea[ desktop ].isNull())
        return rect;

    return workarea[ desktop ].intersect(rect);
    }

QRect Workspace::clientArea(const QPoint& p) const
    {
    return clientArea( p, currentDesktop());
    }

/*!
  Client \a c is moved around to position \a pos. This gives the
  workspace the opportunity to interveniate and to implement
  snap-to-windows functionality.
 */
QPoint Workspace::adjustClientPosition( Client* c, QPoint pos )
    {
   //CT 16mar98, 27May98 - magics: BorderSnapZone, WindowSnapZone
   //CT adapted for kwin on 25Nov1999
   //aleXXX 02Nov2000 added second snapping mode
    if (options->windowSnapZone || options->borderSnapZone )
        {
        bool sOWO=options->snapOnlyWhenOverlapping;
        QRect maxRect = clientArea(MovementArea, pos+c->rect().center(), c->desktop());
        int xmin = maxRect.left();
        int xmax = maxRect.right()+1;               //desk size
        int ymin = maxRect.top();
        int ymax = maxRect.bottom()+1;

        int cx(pos.x());
        int cy(pos.y());
        int cw(c->width());
        int ch(c->height());
        int rx(cx+cw);
        int ry(cy+ch);                 //these don't change

        int nx(cx), ny(cy);                         //buffers
        int deltaX(xmax);
        int deltaY(ymax);   //minimum distance to other clients

        int lx, ly, lrx, lry; //coords and size for the comparison client, l

      // border snap
        int snap = options->borderSnapZone; //snap trigger
        if (snap)
            {
            if ((sOWO?(cx<xmin):true) && (QABS(xmin-cx)<snap))
                {
                deltaX = xmin-cx;
                nx = xmin;
                }
            if ((sOWO?(rx>xmax):true) && (QABS(rx-xmax)<snap) && (QABS(xmax-rx) < deltaX))
                {
                deltaX = rx-xmax;
                nx = xmax - cw;
                }

            if ((sOWO?(cy<ymin):true) && (QABS(ymin-cy)<snap))
                {
                deltaY = ymin-cy;
                ny = ymin;
                }
            if ((sOWO?(ry>ymax):true) && (QABS(ry-ymax)<snap) && (QABS(ymax-ry) < deltaY))
                {
                deltaY =ry-ymax;
                ny = ymax - ch;
                }
            }

      // windows snap
        snap = options->windowSnapZone;
        if (snap)
            {
            QValueList<Client *>::ConstIterator l;
            for (l = clients.begin();l != clients.end();++l )
                {
                if ((*l)->isOnDesktop(currentDesktop()) &&
                   !(*l)->isMinimized()
                    && (*l) != c )
                    {
                    lx = (*l)->x();
                    ly = (*l)->y();
                    lrx = lx + (*l)->width();
                    lry = ly + (*l)->height();

                    if ( (( cy <= lry ) && ( cy  >= ly  ))  ||
                         (( ry >= ly  ) && ( ry  <= lry ))  ||
                         (( cy <= ly  ) && ( ry >= lry  )) )
                        {
                        if ((sOWO?(cx<lrx):true) && (QABS(lrx-cx)<snap) && ( QABS(lrx -cx) < deltaX) )
                            {
                            deltaX = QABS( lrx - cx );
                            nx = lrx;
                            }
                        if ((sOWO?(rx>lx):true) && (QABS(rx-lx)<snap) && ( QABS( rx - lx )<deltaX) )
                            {
                            deltaX = QABS(rx - lx);
                            nx = lx - cw;
                            }
                        }

                    if ( (( cx <= lrx ) && ( cx  >= lx  ))  ||
                         (( rx >= lx  ) && ( rx  <= lrx ))  ||
                         (( cx <= lx  ) && ( rx >= lrx  )) )
                        {
                        if ((sOWO?(cy<lry):true) && (QABS(lry-cy)<snap) && (QABS( lry -cy ) < deltaY))
                            {
                            deltaY = QABS( lry - cy );
                            ny = lry;
                            }
                  //if ( (QABS( ry-ly ) < snap) && (QABS( ry - ly ) < deltaY ))
                        if ((sOWO?(ry>ly):true) && (QABS(ry-ly)<snap) && (QABS( ry - ly ) < deltaY ))
                            {
                            deltaY = QABS( ry - ly );
                            ny = ly - ch;
                            }
                        }
                    }
                }
            }
        pos = QPoint(nx, ny);
        }
    return pos;
    }

/*!
  Marks the client as being moved around by the user.
 */
void Workspace::setClientIsMoving( Client *c )
    {
    Q_ASSERT(!c || !movingClient); // Catch attempts to move a second
    // window while still moving the first one.
    movingClient = c;
    if (movingClient)
        setFocusChangeEnabled( false );
    else
        setFocusChangeEnabled( true );
    }

/*!
  Cascades all clients on the current desktop
 */
void Workspace::cascadeDesktop()
    {
    Q_ASSERT( block_stacking_updates == 0 );
    ClientList::ConstIterator it(stackingOrder().begin());
    bool re_init_cascade_at_first_client = true;
    for (; it != stackingOrder().end(); ++it) 
        {
        if((!(*it)->isOnDesktop(currentDesktop())) ||
           ((*it)->isMinimized())                  ||
           ((*it)->isOnAllDesktops())              ||
           (!(*it)->isMovable()) )
            continue;
        initPositioning->placeCascaded(*it, re_init_cascade_at_first_client);
        //CT is an if faster than an attribution??
        if (re_init_cascade_at_first_client)
          re_init_cascade_at_first_client = false;
        }
    }

/*!
  Unclutters the current desktop by smart-placing all clients
  again.
 */
void Workspace::unclutterDesktop()
    {
    ClientList::Iterator it(clients.fromLast());
    for (; it != clients.end(); --it) 
        {
        if((!(*it)->isOnDesktop(currentDesktop())) ||
           ((*it)->isMinimized())                  ||
           ((*it)->isOnAllDesktops())              ||
           (!(*it)->isMovable()) )
            continue;
        initPositioning->placeSmart(*it);
        }
    }


//********************************************
// Client
//********************************************


/*!
  Returns \a area with the client's strut taken into account.

  Used from Workspace in updateClientArea.
 */
// TODO move to Workspace?
QRect Client::adjustedClientArea( const QRect& area ) const
    {
    QRect r = area;
    NETStrut strut = info->strut();
    if ( strut.left > 0 )
        r.setLeft( r.left() + (int) strut.left );
    if ( strut.top > 0 )
        r.setTop( r.top() + (int) strut.top );
    if ( strut.right > 0  )
        r.setRight( r.right() - (int) strut.right );
    if ( strut.bottom > 0  )
        r.setBottom( r.bottom() - (int) strut.bottom );
    return r;
    }



// updates differences to workarea edges for all directions
// area_ is workarea for this Client (optimization - given only if already known)
void Client::updateWorkareaDiffs( const QRect& area_ )
    {
    QRect area = area_;
    if( !area.isValid()) // default arg
        area = workspace()->clientArea( geometry().center(), desktop());
    QRect geom = geometry();
    workarea_diff_x = computeWorkareaDiff( geom.left(), geom.right(), area.left(), area.right());
    workarea_diff_y = computeWorkareaDiff( geom.top(), geom.bottom(), area.top(), area.bottom());
    }

// If the client was inside workarea in the x direction, and if it was close to the left/right
// edge, return the distance from the left/right edge (negative for left, positive for right)
// INT_MIN means 'not inside workarea', INT_MAX means 'not near edge'.
// In order to recognize 'at the left workarea edge' from 'at the right workarea edge'
// (i.e. negative vs positive zero), the distances are one larger in absolute value than they
// really are (i.e. 5 pixels from the left edge is -6, not -5). A bit hacky, but I'm lazy
// to rewrite it just to make it nicer. If this will ever get touched again, perhaps then.
// the y direction is done the same, just the values will be rotated: top->left, bottom->right
int Client::computeWorkareaDiff( int left, int right, int a_left, int a_right )
    {
    int left_diff = left - a_left;
    int right_diff = a_right - right;
    if( left_diff < 0 || right_diff < 0 )
        return INT_MIN;
    else // fully inside workarea in this direction direction
        {
        // max distance from edge where it's still considered to be close and is kept at that distance
        int max_diff = ( a_right - a_left ) / 10;
        if( left_diff < right_diff )
            return left_diff < max_diff ? -left_diff - 1 : INT_MAX;
        else if( left_diff > right_diff )
            return right_diff < max_diff ? right_diff + 1 : INT_MAX;
        return INT_MAX; // not close to workarea edge
        }
    }

void Client::checkWorkspacePosition()
    {
    if( maximizeMode() != MaximizeRestore )
	// TODO update geom_restore?
        changeMaximize( false, false, true ); // adjust size

    if( isFullScreen())
        {
        QRect area = workspace()->geometry();
        // TODO XINERAMA only one xinerama screen
        if( geometry() != area )
            setGeometry( area );
        return;
        }
    if( isDock())
        return;
    if( isOverride())
        return; // I wish I knew what to do here :(
    if( isTopMenu())
        {
        if( workspace()->managingTopMenus())
            { // XINERAMA
            QRect area;
        ClientList mainclients = mainClients();
        if( mainclients.count() == 1 )
            area = kapp->desktop()->screenGeometry( mainclients.first()->geometry().center());
        else
            area = kapp->desktop()->geometry(); // desktop menu ?
        area.setHeight( workspace()->topMenuHeight());
//            kdDebug() << "TOPMENU size adjust: " << area << ":" << this << endl;
        setGeometry( area );
            }
        NETStrut strut = info->strut();
        int top = workspace()->managingTopMenus() ? workspace()->topMenuHeight() : 0;
        if( strut.left != 0 || strut.right != 0 || strut.bottom != 0 || strut.top != top )
            {
            NETStrut new_strut;
            new_strut.left = 0;
            new_strut.right = 0;
            new_strut.top = top;
            new_strut.bottom = 0;
            info->setStrut( new_strut );
            workspace()->updateClientArea();
            }
        return;
        }

    if( !isShade()) // TODO
        {
        QRect area = workspace()->clientArea( geometry().center(), desktop());
        int old_diff_x = workarea_diff_x;
        int old_diff_y = workarea_diff_y;
        updateWorkareaDiffs( area );

        // this can be true only if this window was mapped before KWin
        // was started - in such case, don't adjust position to workarea,
        // because the window already had its position, and if a window
        // with a strut altering the workarea would be managed in initialization
        // after this one, this window would be moved
        if( workspace()->initializing())
            return;

        QRect new_geom = geometry();
        QRect tmp_rect_x( new_geom.left(), 0, new_geom.width(), 0 );
        QRect tmp_area_x( area.left(), 0, area.width(), 0 );
        checkDirection( workarea_diff_x, old_diff_x, tmp_rect_x, tmp_area_x );
        // the x<->y swapping
        QRect tmp_rect_y( new_geom.top(), 0, new_geom.height(), 0 );
        QRect tmp_area_y( area.top(), 0, area.height(), 0 );
        checkDirection( workarea_diff_y, old_diff_y, tmp_rect_y, tmp_area_y );
        new_geom = QRect( tmp_rect_x.left(), tmp_rect_y.left(), tmp_rect_x.width(), tmp_rect_y.width());
        QRect final_geom( new_geom.topLeft(), adjustedSize( new_geom.size()));
        if( final_geom != new_geom ) // size increments, or size restrictions
            { // adjusted size differing matters only for right and bottom edge
            if( old_diff_x != INT_MAX && old_diff_x > 0 )
                final_geom.moveRight( area.right() - ( old_diff_x - 1 ));
            if( old_diff_y != INT_MAX && old_diff_y > 0 )
                final_geom.moveBottom( area.bottom() - ( old_diff_y - 1 ));
            }
        if( final_geom != geometry() )
            setGeometry( final_geom );
        //    updateWorkareaDiffs( area ); done already by setGeometry()
        }
    }

// Try to be smart about keeping the clients visible.
// If the client was fully inside the workspace before, try to keep
// it still inside the workarea, possibly moving it or making it smaller if possible,
// and try to keep the distance from the nearest workarea edge.
// On the other hand, it it was partially moved outside of the workspace in some direction,
// don't do anything with that direction if it's still at least partially visible. If it's
// not visible anymore at all, make sure it's visible at least partially
// again (not fully, as that could(?) be potentionally annoying) by
// moving it slightly inside the workarea (those '+ 5').
// Again, this is done for the x direction, y direction will be done by x<->y swapping
void Client::checkDirection( int new_diff, int old_diff, QRect& rect, const QRect& area )
    {
    if( old_diff != INT_MIN ) // was inside workarea
        {
        if( old_diff == INT_MAX ) // was in workarea, but far from edge
            {
            if( new_diff == INT_MIN )  // is not anymore fully in workarea
                {
                rect.setLeft( area.left());
                rect.setRight( area.right());
                }
            return;
            }
        if( isResizable())
            {
            if( rect.width() > area.width())
                rect.setWidth( area.width());
            if( rect.width() >= area.width() / 2 )
                {
                if( old_diff < 0 )
                    rect.setLeft( area.left() + ( -old_diff - 1 ) );
                else // old_diff > 0
                    rect.setRight( area.right() - ( old_diff - 1 ));
                }
            }
        if( isMovable())
            {
            if( old_diff < 0 ) // was in left third, keep distance from left edge
                rect.moveLeft( area.left() + ( -old_diff - 1 ));
            else // old_diff > 0 // was in right third, keep distance from right edge
                rect.moveRight( area.right() - ( old_diff - 1 ));
            }
        // this isResizable() block is copied from above, the difference is
        // the condition with 'area.width() / 2' - for windows that are not wide,
        // moving is preffered to resizing
        if( isResizable())
            {
            if( old_diff < 0 )
                rect.setLeft( area.left() + ( -old_diff - 1 ) );
            else // old_diff > 0
                rect.setRight( area.right() - ( old_diff - 1 ));
            }
        }
    if( rect.right() < area.left() + 5 || rect.left() > area.right() - 5 )
        { // not visible (almost) at all - try to make it at least partially visible
        if( isMovable())
            {
            if( rect.left() < area.left() + 5 )
                rect.moveRight( area.left() + 5 );
            if( rect.right() > area.right() - 5 )
                rect.moveLeft( area.right() - 5 );
            }
        }
    }

/*!
  Adjust the frame size \a frame according to he window's size hints.
 */
QSize Client::adjustedSize( const QSize& frame) const
    {
    // first, get the window size for the given frame size s

    QSize wsize( frame.width() - ( border_left + border_right ),
             frame.height() - ( border_top + border_bottom ));

    return sizeForClientSize( wsize );
    }

/*!
  Calculate the appropriate frame size for the given client size \a
  wsize.

  \a wsize is adapted according to the window's size hints (minimum,
  maximum and incremental size changes).

 */
QSize Client::sizeForClientSize( const QSize& wsize, bool ignore_height) const
    {
    int w = wsize.width();
    int h = wsize.height();
    if (w<1) w = 1;
    if (h<1) h = 1;

    // basesize, minsize, maxsize, paspect and resizeinc have all values defined,
    // even if they're not set in flags - see getWmNormalHints()
    QSize min_size( xSizeHint.min_width, xSizeHint.min_height );
    QSize max_size( xSizeHint.max_width, xSizeHint.max_height );
    if( decoration != NULL )
        {
        QSize decominsize = decoration->minimumSize();
        if( decominsize.width() > min_size.width())
                min_size.setWidth( decominsize.width());
        if( decominsize.height() > min_size.height())
                min_size.setHeight( decominsize.height());
        }
    w = QMIN( max_size.width(), w );
    h = QMIN( max_size.height(), h );
    w = QMAX( min_size.width(), w );    
    h = QMAX( min_size.height(), h );

    int width_inc = xSizeHint.width_inc;
    int height_inc = xSizeHint.height_inc;
    int basew_inc = xSizeHint.min_width; // see getWmNormalHints()
    int baseh_inc = xSizeHint.min_height;
    w = int(( w - basew_inc ) / width_inc ) * width_inc + basew_inc;
    h = int(( h - baseh_inc ) / height_inc ) * height_inc + baseh_inc;

  // The algorithm for aspect ratios in based on the one used in Metacity, which says:
  /* This is partially borrowed from GTK (LGPL), which in turn 
   * partially borrowed from fvwm,
   *
   * Copyright 1993, Robert Nation
   *     You may use this code for any purpose, as long as the original
   *     copyright remains in the source code and all documentation
   *
   * which in turn borrows parts of the algorithm from uwm
   */
    float min_wh = float( xSizeHint.min_aspect.x ) / xSizeHint.min_aspect.y;
    float max_wh = float( xSizeHint.max_aspect.x ) / xSizeHint.max_aspect.y;
    int aspect_w = w - xSizeHint.base_width;
    int aspect_h = h - xSizeHint.base_height;
    if( min_wh > float( aspect_w ) / aspect_h )
        {
        int delta = int(( aspect_h - aspect_w / min_wh ) / height_inc ) * height_inc;
        if( h - delta >= min_size.height())
            h -= delta;
        else
            {
            delta = int(( aspect_h * min_wh - aspect_w ) / width_inc ) * width_inc;
            if( w + delta <= max_size.width())
                w -= delta;
            }
        }
    if( max_wh < float( aspect_w ) / aspect_h )
        {
        int delta = int(( aspect_w - aspect_h * max_wh ) / width_inc ) * width_inc;
        if( w - delta >= min_size.width())
            w -= delta;
        else
            {
            delta = int(( aspect_w / max_wh - aspect_h ) / height_inc ) * height_inc;
            if( h + delta <= max_size.height())
                h += delta;
            }
        }

    if ( ignore_height && wsize.height() == 0 )
        h = 0;
    return QSize( w + border_left + border_right, h + border_top + border_bottom );
    }

/*!
  Gets the client's normal WM hints and reconfigures itself respectively.
 */
void Client::getWmNormalHints()
    {
    long msize;
    if (XGetWMNormalHints(qt_xdisplay(), window(), &xSizeHint, &msize) == 0 )
        xSizeHint.flags = 0;
    // set defined values for basesize, minsize, maxsize, aspect and resizeinc,
    // even if they're not in flags

    // basesize is just like minsize, except for minsize is not used for aspect ratios
    // keep basesize only for aspect ratios, for size increments, keep the base
    // value in minsize - see ICCCM 4.1.2.3
    if( xSizeHint.flags & PBaseSize )
        {
        if( ! ( xSizeHint.flags & PMinSize )) // PBaseSize and PMinSize are equivalent
            {
            xSizeHint.flags |= PMinSize;
            xSizeHint.min_width = xSizeHint.base_width;
                xSizeHint.min_height = xSizeHint.base_height;
            }
        }
    else
        xSizeHint.base_width = xSizeHint.base_height = 0;
    if( ! ( xSizeHint.flags & PMinSize ))
        xSizeHint.min_width = xSizeHint.min_height = 0;
    if( ! ( xSizeHint.flags & PMaxSize ))
        xSizeHint.max_width = xSizeHint.max_height = INT_MAX;
    if( xSizeHint.flags & PResizeInc )
        {
        xSizeHint.width_inc = kMax( xSizeHint.width_inc, 1 );
        xSizeHint.height_inc = kMax( xSizeHint.height_inc, 1 );
        }
    else
        {
        xSizeHint.width_inc = 1;
        xSizeHint.height_inc = 1;
        }
    if( xSizeHint.flags & PAspect )
        { // no dividing by zero
        xSizeHint.min_aspect.y = kMax( xSizeHint.min_aspect.y, 1 );
        xSizeHint.max_aspect.y = kMax( xSizeHint.max_aspect.y, 1 );
        }
    else
        {
        xSizeHint.min_aspect.x = 1;
        xSizeHint.min_aspect.y = INT_MAX;
        xSizeHint.max_aspect.x = INT_MAX;
        xSizeHint.max_aspect.y = 1;
        }
    if( !xSizeHint.flags & PWinGravity )
        xSizeHint.win_gravity = NorthWestGravity;
    if( isManaged())
        { // update to match restrictions
        QSize new_size = adjustedSize( size());
        if( new_size != size())
            resizeWithChecks( new_size );
        }
    updateAllowedActions(); // affects isResizeable()
    }

/*!
  Auxiliary function to inform the client about the current window
  configuration.

 */
void Client::sendSyntheticConfigureNotify()
    {
    XConfigureEvent c;
    c.type = ConfigureNotify;
    c.send_event = True;
    c.event = window();
    c.window = window();
    c.x = x() + clientPos().x();
    c.y = y() + clientPos().y();
    c.width = clientSize().width();
    c.height = clientSize().height();
    c.border_width = 0;
    c.above = None;
    c.override_redirect = 0;
    XSendEvent( qt_xdisplay(), c.event, TRUE, StructureNotifyMask, (XEvent*)&c );
    }

const QPoint Client::calculateGravitation( bool invert, int gravity ) const
    {
    int dx, dy;
    dx = dy = 0;
    
    if( gravity == 0 ) // default (nonsense) value for the argument
        gravity = xSizeHint.win_gravity;

// dx, dy specify how the client window moves to make space for the frame
    switch (gravity) 
        {
        case NorthWestGravity: // move down right
        default:
            dx = border_left;
            dy = border_top;
            break;
        case NorthGravity: // move right
            dx = 0;
            dy = border_top;
            break;
        case NorthEastGravity: // move down left
            dx = -border_right;
            dy = border_top;
            break;
        case WestGravity: // move right
            dx = border_left;
            dy = 0;
            break;
        case CenterGravity:
            break; // will be handled specially
        case StaticGravity: // don't move
            dx = 0;
            dy = 0;
            break;
        case EastGravity: // move left
            dx = -border_right;
            dy = 0;
            break;
        case SouthWestGravity: // move up right
            dx = border_left ;
            dy = -border_bottom;
            break;
        case SouthGravity: // move up
            dx = 0;
            dy = -border_bottom;
            break;
        case SouthEastGravity: // move up left
            dx = -border_right;
            dy = -border_bottom;
            break;
        }
    if( gravity != CenterGravity )
        { // translate from client movement to frame movement
        dx -= border_left;
        dy -= border_top;
        }
    else
        { // center of the frame will be at the same position client center without frame would be
        dx = - ( border_left + border_right ) / 2;
        dy = - ( border_top + border_bottom ) / 2;
        }
    if( !invert )
        return QPoint( x() + dx, y() + dy );
    else
        return QPoint( x() - dx, y() - dy );
    }

void Client::configureRequest( int value_mask, int rx, int ry, int rw, int rh, int gravity )
    {
    if( gravity == 0 ) // default (nonsense) value for the argument
        gravity = xSizeHint.win_gravity;
    if( value_mask & ( CWX | CWY )) 
        {
        if ( isShade()) // SELI SHADE
            setShade( ShadeNone );

        QPoint new_pos = calculateGravitation( true, gravity ); // undo gravitation
        if ( value_mask & CWX )
            new_pos.setX( rx );
        if ( value_mask & CWY )
            new_pos.setY( ry );

#if 0 /* let's see how well things will work without trying to be clever */
        // clever workaround for applications like xv that want to set
        // the location to the current location but miscalculate the
        // frame size due to kwin being a double-reparenting window
        // manager
        if ( ox == 0 && oy == 0 &&
             nx == x() + clientPos().x() &&
             ny == y() + clientPos().y() ) 
            {
            nx = x();
            ny = y();
            }
#endif

        int nw = clientSize().width();
        int nh = clientSize().height();
        if ( value_mask & CWWidth )
            nw = rw;
        if ( value_mask & CWHeight )
            nh = rh;
        QSize ns = sizeForClientSize( QSize( nw, nh ) );
        
        // TODO what to do with maximized windows?
        if ( maximizeMode() != MaximizeFull
            || ns != size())
            {
            resetMaximize();
            ++block_geometry;
            move( new_pos );
            plainResize( ns ); // TODO must(?) resize before gravitating?
            --block_geometry;
            setGeometry( QRect( calculateGravitation( false, gravity ), size()), ForceGeometrySet );
            }
        }

    if ( value_mask & (CWWidth | CWHeight )
        && ! ( value_mask & ( CWX | CWY )) )  // pure resize
        {
        int nw = clientSize().width();
        int nh = clientSize().height();
        if ( value_mask & CWWidth )
            nw = rw;
        if ( value_mask & CWHeight )
            nh = rh;
        QSize ns = sizeForClientSize( QSize( nw, nh ) );
        
        if( ns != size())  // don't restore if some app sets its own size again
            {
            resetMaximize();
            int save_gravity = xSizeHint.win_gravity;
            xSizeHint.win_gravity = gravity;
            resizeWithChecks( ns );
            xSizeHint.win_gravity = save_gravity;
            }
        }
    // No need to send synthetic configure notify event here, either it's sent together
    // with geometry change, or there's no need to send it.
    // Handling of the real ConfigureRequest event forces sending it, as there it's necessary.
    }

void Client::resizeWithChecks( int w, int h, ForceGeometry_t force )
    {
    int newx = x();
    int newy = y();
    QRect area = workspace()->clientArea( geometry().center(), desktop());
    // don't allow growing larger than workarea
    if( w > area.width())
        w = area.width();
    if( h > area.height())
        h = area.height();
    QSize tmp = adjustedSize( QSize( w, h )); // checks size constraints, including min/max size
    w = tmp.width();
    h = tmp.height();
    switch( xSizeHint.win_gravity )
        {
        case NorthWestGravity: // top left corner doesn't move
        default:
            break;
        case NorthGravity: // middle of top border doesn't move
            newx = ( newx + width() / 2 ) - ( w / 2 );
            break;
        case NorthEastGravity: // top right corner doesn't move
            newx = newx + width() - w;
            break;
        case WestGravity: // middle of left border doesn't move
            newy = ( newy + height() / 2 ) - ( h / 2 );
            break;
        case CenterGravity: // middle point doesn't move
            newx = ( newx + width() / 2 ) - ( w / 2 );
            newy = ( newy + height() / 2 ) - ( h / 2 );
            break;
        case StaticGravity: // top left corner of _client_ window doesn't move
            // since decoration doesn't change, equal to NorthWestGravity
            break;
        case EastGravity: // // middle of right border doesn't move
            newx = newx + width() - w;
            newy = ( newy + height() / 2 ) - ( h / 2 );
            break;
        case SouthWestGravity: // bottom left corner doesn't move
            newy = newy + height() - h;
            break;
        case SouthGravity: // middle of bottom border doesn't move
            newx = ( newx + width() / 2 ) - ( w / 2 );
            newy = newy + height() - h;
            break;
        case SouthEastGravity: // bottom right corner doesn't move
            newx = newx + width() - w;
            newy = newy + height() - h;
            break;
        }
    // if it would be moved outside of workarea, keep it inside,
    // see also Client::computeWorkareaDiff()
    if( workarea_diff_x != INT_MIN ) // was inside
        {
        if( newx < area.left())
            newx = area.left();
        if( newx + w > area.right() + 1 )
            newx = area.right() + 1 - w;
        assert( newx >= area.left() && newx + w <= area.right() + 1 ); // width was checked above
        }
    if( workarea_diff_y != INT_MIN ) // was inside
        {
        if( newy < area.top())
            newy = area.top();
        if( newy + h > area.bottom() + 1 )
            newy = area.bottom() + 1 - h;
        assert( newy >= area.top() && newy + h <= area.bottom() + 1 ); // height was checked above
        }
    setGeometry( newx, newy, w, h, force );
    }
    
// _NET_MOVERESIZE_WINDOW
void Client::NETMoveResizeWindow( int flags, int x, int y, int width, int height )
    {
    int gravity = flags & 0xff;
    int value_mask = 0;
    if( flags & ( 1 << 8 ))
        value_mask |= CWX;
    if( flags & ( 1 << 9 ))
        value_mask |= CWY;
    if( flags & ( 1 << 10 ))
        value_mask |= CWWidth;
    if( flags & ( 1 << 11 ))
        value_mask |= CWHeight;
    configureRequest( value_mask, x, y, width, height, gravity );
    }
    
/*!
  Returns whether the window is resizable or has a fixed size.
 */
bool Client::isResizable() const
    {
    if ( !isMovable() || !motif_may_resize || isSplash())
        return FALSE;

    if ( ( xSizeHint.flags & PMaxSize) == 0 || (xSizeHint.flags & PMinSize ) == 0 )
        return TRUE;
    return ( xSizeHint.min_width < xSizeHint.max_width  ) ||
          ( xSizeHint.min_height < xSizeHint.max_height  );
    }

/*
  Returns whether the window is maximizable or not
 */
bool Client::isMaximizable() const
    {
    if ( maximizeMode() != MaximizeRestore )
        return TRUE;
    if( !isResizable() || isToolbar()) // SELI isToolbar() ?
        return false;
    if( xSizeHint.max_height < 32767 || xSizeHint.max_width < 32767 ) // sizes are 16bit with X
        return false;
    return true;
    }


/*!
  Reimplemented to inform the client about the new window position.
 */
void Client::setGeometry( int x, int y, int w, int h, ForceGeometry_t force )
    {
    if( force == NormalGeometrySet && frame_geometry == QRect( x, y, w, h ))
        return;
    frame_geometry = QRect( x, y, w, h );
    if( !isShade())
        client_size = QSize( w - border_left - border_right, h - border_top - border_bottom );
    else
        {
        // check that the frame is not resized to full size when it should be shaded
        if( !shade_geometry_change && h != border_top + border_bottom )
            {
            kdDebug() << "h:" << h << ":t:" << border_top << ":b:" << border_bottom << endl;
            assert( false );
            }
        client_size = QSize( w - border_left - border_right, client_size.height());
        }
    updateWorkareaDiffs();
    if( block_geometry == 0 )
        {
        XMoveResizeWindow( qt_xdisplay(), frameId(), x, y, w, h );
        resizeDecoration( QSize( w, h ));
        if( !isShade())
            {
            QSize cs = clientSize();
            XMoveResizeWindow( qt_xdisplay(), wrapperId(), clientPos().x(), clientPos().y(),
                cs.width(), cs.height());
    	    // FRAME tady poradi tak, at neni flicker
            XMoveResizeWindow( qt_xdisplay(), window(), 0, 0, cs.width(), cs.height());
            }
        if( shape())
            updateShape();
        // SELI TODO won't this be too expensive?
        updateWorkareaDiffs();
        if ( !isResize() ) 
            sendSyntheticConfigureNotify(); // TODO make this ICCCM compliant
        }
    }

void Client::plainResize( int w, int h, ForceGeometry_t force )
    { // TODO make this deffered with isResize() ? old kwin did
    if( force == NormalGeometrySet && frame_geometry.size() == QSize( w, h ))
        return;
    frame_geometry.setSize( QSize( w, h ));
    if( !isShade())
        client_size = QSize( w - border_left - border_right, h - border_top - border_bottom );
    else
        {
        // check that the frame is not resized to full size when it should be shaded
        if( !shade_geometry_change && h != border_top + border_bottom )
            {
            kdDebug() << "h:" << h << ":t:" << border_top << ":b:" << border_bottom << endl;
            assert( false );
            }
        client_size = QSize( w - border_left - border_right, client_size.height());
        }
    updateWorkareaDiffs();
    if( block_geometry == 0 )
        {
        // FRAME tady poradi tak, at neni flicker
        XResizeWindow( qt_xdisplay(), frameId(), w, h );
        resizeDecoration( QSize( w, h ));
        if( !isShade())
            {
            QSize cs = clientSize();
            XMoveResizeWindow( qt_xdisplay(), wrapperId(), clientPos().x(), clientPos().y(),
                cs.width(), cs.height());
            XMoveResizeWindow( qt_xdisplay(), window(), 0, 0, cs.width(), cs.height());
            }
        if( shape())
            updateShape();
        updateWorkareaDiffs();
        if ( !isResize() ) 
            sendSyntheticConfigureNotify(); // TODO make this ICCCM compliant
        }
// TODO to be done with synt. notify cleanup
// resize() is called from manage(), can't send synt. notify here
//    if ( !isResize() && isVisible() )
//        sendSyntheticConfigureNotify();
    }

/*!
  Reimplemented to inform the client about the new window position.
 */
void Client::move( int x, int y, ForceGeometry_t force )
    {
    if( force == NormalGeometrySet && frame_geometry.topLeft() == QPoint( x, y ))
        return;
    frame_geometry.moveTopLeft( QPoint( x, y ));
    updateWorkareaDiffs();
    if( block_geometry == 0 )
        {
        XMoveWindow( qt_xdisplay(), frameId(), x, y );
        if ( !isResize() )  // TODO isMove() ?
            sendSyntheticConfigureNotify();  // TODO make this ICCCM compliant
        }
    }


void Client::maximize( MaximizeMode m )
    {
    setMaximize( m & MaximizeVertical, m & MaximizeHorizontal );
    }

/*!
  Sets the maximization according to \a vertically and \a horizontally
 */
void Client::setMaximize( bool vertically, bool horizontally )
    {   // changeMaximize() flips the state, so change from set->flip
    changeMaximize(
        max_mode & MaximizeVertical ? !vertically : vertically,
        max_mode & MaximizeHorizontal ? !horizontally : horizontally,
        false );
    }

void Client::changeMaximize( bool vertical, bool horizontal, bool adjust )
    {
    if( !isMaximizable())
        return;

    ++block_geometry; // TODO GeometryBlocker class?

    if( isShade()) // SELI SHADE
        setShade( ShadeNone );

    MaximizeMode old_mode = max_mode;
    // 'adjust == true' means to update the size only, e.g. after changing workspace size
    if( !adjust )
        {
        if( vertical )
            max_mode = MaximizeMode( max_mode ^ MaximizeVertical );
        if( horizontal )
            max_mode = MaximizeMode( max_mode ^ MaximizeHorizontal );
        }

    // maximing one way and unmaximizing the other way shouldn't happen
    Q_ASSERT( !( vertical && horizontal )
        || (( max_mode & MaximizeVertical != 0 ) == ( max_mode & MaximizeHorizontal != 0 )));

    // save sizes for restoring, if maximalizing
    bool maximalizing = false;
    if( vertical && !(old_mode & MaximizeVertical ))
        {
        geom_restore.setTop( y());
        geom_restore.setHeight( height());
        maximalizing = true;
        }
    if( horizontal && !( old_mode & MaximizeHorizontal ))
        {
        geom_restore.setLeft( x());
        geom_restore.setWidth( width());
        maximalizing = true;
        }

    if( !adjust )
        {
        if( maximalizing )
                Notify::raise( Notify::Maximize );
        else
            Notify::raise( Notify::UnMaximize );
        }

    if( decoration != NULL ) // decorations may turn off some borders when maximized
        decoration->borders( border_left, border_right, border_top, border_bottom );

    QRect clientArea = workspace()->clientArea(geometry().center());

    switch (max_mode) 
        {

        case MaximizeVertical:
            {
            if( old_mode & MaximizeHorizontal ) // actually restoring from MaximizeFull
                {
                if( geom_restore.width() == 0 )
                    { // needs placement
                    plainResize( adjustedSize(QSize(width(), clientArea.height())));
                    workspace()->placeSmart( this );
                    }
                else
                    setGeometry( QRect(QPoint( geom_restore.x(), clientArea.top()),
                              adjustedSize(QSize( geom_restore.width(), clientArea.height()))));
                }
            else
                setGeometry( QRect(QPoint(x(), clientArea.top()),
                              adjustedSize(QSize(width(), clientArea.height()))));
            info->setState( NET::MaxVert, NET::Max );
            break;
            }

        case MaximizeHorizontal:
            {
            if( old_mode & MaximizeVertical ) // actually restoring from MaximizeFull
                {
                if( geom_restore.height() == 0 )
                    { // needs placement
                    plainResize( adjustedSize(QSize(clientArea.width(), height())));
                    workspace()->placeSmart( this );
                    }
                else
                    setGeometry( QRect( QPoint(clientArea.left(), geom_restore.y()),
                              adjustedSize(QSize(clientArea.width(), geom_restore.height()))));
                }
            else
                setGeometry( QRect( QPoint(clientArea.left(), y()),
                              adjustedSize(QSize(clientArea.width(), height()))));
            info->setState( NET::MaxHoriz, NET::Max );
            break;
            }

        case MaximizeRestore:
            {
            QRect restore = geom_restore;
            if( !geom_restore.isValid())
                {
                QSize s = QSize( clientArea.width()*2/3, clientArea.height()*2/3 );
                if( geom_restore.width() > 0 )
                    s.setWidth( geom_restore.width());
                if( geom_restore.height() > 0 )
                    s.setHeight( geom_restore.height());
                plainResize( adjustedSize( s ));
                workspace()->placeSmart( this );
                restore = geometry();
                if( geom_restore.width() > 0 )
                    restore.moveLeft( geom_restore.x());
                if( geom_restore.height() > 0 )
                    restore.moveTop( geom_restore.y());
                }
	// when only partially maximized, geom_restore may not have the other dimension remembered
            if(( old_mode & MaximizeHorizontal ) == 0 && restore.width() <= 0 )
                {
                restore.setLeft( x());
                restore.setWidth( width());
                }
            if(( old_mode & MaximizeVertical ) == 0 && restore.height() <= 0 )
                {
                restore.setTop( y());
                restore.setHeight( height());
                }
            setGeometry( restore );
            info->setState( 0, NET::Max );
            break;
            }

        case MaximizeFull: 
            {
            QSize adjSize = adjustedSize(clientArea.size());
            QRect r = QRect(clientArea.topLeft(), adjSize);
            setGeometry( r );
            info->setState( NET::Max, NET::Max );
            break;
            }
        default:
            break;
        }

    --block_geometry;
    setGeometry( geometry(), ForceGeometrySet );

    updateAllowedActions();
    if( decoration != NULL )
        decoration->maximizeChange();
    }

void Client::resetMaximize()
    {
    if( max_mode == MaximizeRestore )
        return;
    max_mode = MaximizeRestore;
    Notify::raise( Notify::UnMaximize );
    info->setState( 0, NET::Max );
    updateAllowedActions();
    if( decoration != NULL )
        decoration->maximizeChange();
    }

bool Client::isFullScreenable() const
    {
    return isFullScreen() // necessary, because for fullscreen windows isMaximizable() returns false
        || (( isNormalWindow() || isOverride()) && isMaximizable());
    }

bool Client::userCanSetFullScreen() const
    {
    return isFullScreenable() && isNormalWindow() && fullscreen_mode != FullScreenHack;
    }

void Client::setFullScreen( bool set, bool user )
    {
    if( !isFullScreen() && !set )
        return;
    if( fullscreen_mode == FullScreenHack )
        return;
    if( user && !userCanSetFullScreen())
        return;
    setShade( ShadeNone );
    bool was_fs = isFullScreen();
    if( !was_fs )
        geom_fs_restore = geometry();
    fullscreen_mode = set ? FullScreenNormal : FullScreenNone;
    if( was_fs == isFullScreen())
        return;
    StackingUpdatesBlocker blocker( workspace());
    workspace()->updateClientLayer( this ); // active fullscreens get different layer
    info->setState( isFullScreen() ? NET::FullScreen : 0, NET::FullScreen );
    updateDecoration( false, false, true ); // delayed deletion of decoration
    if( isFullScreen())
        setGeometry( workspace()->geometry());
        // XINERAMA only on one screen
    else
        {
        if( maximizeMode() != MaximizeRestore )
            changeMaximize( false, false, true ); // adjust size
        else if( !geom_fs_restore.isNull())
            setGeometry( geom_fs_restore );
        // TODO isShaded() ?
        else
            { // does this ever happen?
            setGeometry( workspace()->clientArea( Workspace::MaximizeArea, geometry().center(), desktop()));
            }
        }
    }


static QRect*       visible_bound  = 0;
static GeometryTip* geometryTip    = 0;

void Client::drawbound( const QRect& geom )
    {
    assert( visible_bound == NULL );
    visible_bound = new QRect( geom );
    doDrawbound( *visible_bound, false );
    }

void Client::clearbound()
    {
    if( visible_bound == NULL )
        return;
    doDrawbound( *visible_bound, true );
    delete visible_bound;
    visible_bound = 0;
    }

void Client::doDrawbound( const QRect& geom, bool clear )
    {
    if( decoration != NULL && decoration->drawbound( geom, clear ))
        return; // done by decoration
    QPainter p ( workspace()->desktopWidget() );
    p.setPen( QPen( Qt::white, 5 ) );
    p.setRasterOp( Qt::XorROP );
    p.drawRect( geom );
    }

void Client::positionGeometryTip()
    {
    assert( isMove() || isResize());
    // Position and Size display
    if (options->showGeometryTip())
        {
        if( !geometryTip )
            { // save under is not necessary with opaque, and seem to make things slower
            bool save_under = ( isMove() && options->moveMode != Options::Opaque )
                        || ( isResize() && options->resizeMode != Options::Opaque );
            geometryTip = new GeometryTip( &xSizeHint, save_under );
            }
        QRect wgeom( moveResizeGeom ); // position of the frame, size of the window itself
        wgeom.setWidth( wgeom.width() - ( width() - clientSize().width()));
        wgeom.setHeight( wgeom.height() - ( height() - clientSize().height()));
        if( isShade())
            wgeom.setHeight( 0 );
        geometryTip->setGeometry( wgeom );
        if( !geometryTip->isVisible())
            {
            geometryTip->show();
            geometryTip->raise();
            }
        }
    }

class EatAllPaintEvents
    : public QObject
    {
    protected:
        virtual bool eventFilter( QObject* o, QEvent* e )
            { return e->type() == QEvent::Paint && o != geometryTip; }
    };

static EatAllPaintEvents* eater = 0;

// TODO kontrolovat navratovou hodnotu
bool Client::startMoveResize()
    {
    assert( !moveResizeMode );
    if( mode == Center )
        setCursor( sizeAllCursor ); // change from arrow cursor if moving
    if( !grabInput())
        return false;
    if ( maximizeMode() != MaximizeRestore )
        resetMaximize();
    moveResizeMode = true;
    workspace()->setClientIsMoving(this);
    initialMoveResizeGeom = moveResizeGeom = geometry();
    if ( ( isMove() && options->moveMode != Options::Opaque )
      || ( isResize() && options->resizeMode != Options::Opaque ) )
        {
        XGrabServer( qt_xdisplay() );
        kapp->sendPostedEvents();
        // we have server grab -> nothing should cause paint events
        // unfortunately, that's not completely true, Qt may generate
        // paint events on some widgets due to FocusIn(?)
        // eat them, otherwise XOR painting will be broken (#58054)
        // paint events for the geometrytip need to be allowed, though
        eater = new EatAllPaintEvents;
        kapp->installEventFilter( eater );
        }
    Notify::raise( isResize() ? Notify::ResizeStart : Notify::MoveStart );
    return true;
    }

void Client::finishMoveResize( bool cancel )
    {
    leaveMoveResize();
    if( cancel )
        setGeometry( initialMoveResizeGeom );
    else    
        setGeometry( moveResizeGeom );
// FRAME    update();
    Notify::raise( isResize() ? Notify::ResizeEnd : Notify::MoveEnd );
    }

void Client::leaveMoveResize()
    {
    clearbound();
    if (geometryTip)
        {
        geometryTip->hide();
        delete geometryTip;
        geometryTip = NULL;
        }
    if ( ( isMove() && options->moveMode != Options::Opaque )
      || ( isResize() && options->resizeMode != Options::Opaque ) )
        XUngrabServer( qt_xdisplay() );
    ungrabInput();
    workspace()->setClientIsMoving(0);
    if( move_faked_activity )
        workspace()->unfakeActivity( this );
    move_faked_activity = false;
    moveResizeMode = false;
    delete eater;
    eater = 0;
    }

void Client::handleMoveResize( int x, int y, int x_root, int y_root )
    {
    if(( mode == Center && !isMovable())
        || ( mode != Center && ( isShade() || !isResizable())))
        return;

    if ( !moveResizeMode ) 
        {
        QPoint p( QPoint( x, y ) - moveOffset );
        if (p.manhattanLength() >= 6)
            startMoveResize();
        else
            return;
        }

    // ShadeHover or ShadeActive, ShadeNormal was already avoided above
    if ( mode != Center && shade_mode != ShadeNone )
        setShade( ShadeNone );

    QPoint globalPos( x_root, y_root );
    QRect desktopArea = workspace()->clientArea( globalPos );

    QPoint p = globalPos + invertedMoveOffset;

    QPoint pp = globalPos - moveOffset;

    if( !unrestrictedMoveResize )
        {
        // width/height change with opaque resizing, use the initial ones
        int init_width = initialMoveResizeGeom.width(); 
        int init_height = initialMoveResizeGeom.height();
        // how much must remain visible when moved away in that direction
        const int left_limit = 100 + border_right;
        const int right_limit = 100 + border_left;
        const int top_limit = init_height;
        const int bottom_limit = border_top;
        int left_overlap = KMAX( init_width - left_limit, 0 );
        int right_overlap = KMAX( init_width - right_limit, 0 );
        int top_overlap = KMAX( init_height - top_limit, 0 );
        int bottom_overlap = KMAX( init_height - bottom_limit, 0 );
        // 'pp' is top left corner, 'p' is bottom right corner
        if( mode == Center ) // moving
            {
            pp.setX( KMIN( desktopArea.right() + right_overlap - init_width,
                KMAX( desktopArea.left() - left_overlap, pp.x())));
            pp.setY( KMIN( desktopArea.bottom() + bottom_overlap - init_height,
                KMAX( desktopArea.top() - top_overlap, pp.y())));
            }
        else
            { // resizing
            pp.setX( KMAX( desktopArea.left() - left_overlap, pp.x()));
            pp.setY( KMAX( desktopArea.top() - top_overlap, pp.y()));
            p.setX( KMIN( desktopArea.right() + right_overlap, p.x()));
            p.setY( KMIN( desktopArea.bottom() + bottom_overlap, p.y()));
            }
        }

    QSize mpsize( geometry().right() - pp.x() + 1, geometry().bottom() - pp.y() + 1 );
    mpsize = adjustedSize( mpsize );
    QPoint mp( geometry().right() - mpsize.width() + 1,
               geometry().bottom() - mpsize.height() + 1 );

    QRect previousMoveResizeGeom = moveResizeGeom;
    switch ( mode ) 
        {
        case TopLeft2:
            moveResizeGeom =  QRect( mp, geometry().bottomRight() ) ;
            break;
        case BottomRight2:
            moveResizeGeom =  QRect( geometry().topLeft(), p ) ;
            break;
        case BottomLeft2:
            moveResizeGeom =  QRect( QPoint(mp.x(), geometry().y() ), QPoint( geometry().right(), p.y()) ) ;
            break;
        case TopRight2:
            moveResizeGeom =  QRect( QPoint(geometry().x(), mp.y() ), QPoint( p.x(), geometry().bottom()) ) ;
            break;
        case Top:
            moveResizeGeom =  QRect( QPoint( geometry().left(), mp.y() ), geometry().bottomRight() ) ;
            break;
        case Bottom:
            moveResizeGeom =  QRect( geometry().topLeft(), QPoint( geometry().right(), p.y() ) ) ;
            break;
        case Left:
            moveResizeGeom =  QRect( QPoint( mp.x(), geometry().top() ), geometry().bottomRight() ) ;
            break;
        case Right:
            moveResizeGeom =  QRect( geometry().topLeft(), QPoint( p.x(), geometry().bottom() ) ) ;
            break;
        case Center:
            moveResizeGeom.moveTopLeft( pp );
            break;
        default:
            assert( false );
            break;
        }

    const int marge = 5;

    // TODO move whole group when moving its leader or when the leader is not mapped?

    if ( isResize() && moveResizeGeom.size() != previousMoveResizeGeom.size() ) 
        {
        if (moveResizeGeom.bottom() < desktopArea.top()+marge)
            moveResizeGeom.setBottom(desktopArea.top()+marge);
        if (moveResizeGeom.top() > desktopArea.bottom()-marge)
            moveResizeGeom.setTop(desktopArea.bottom()-marge);
        if (moveResizeGeom.right() < desktopArea.left()+marge)
            moveResizeGeom.setRight(desktopArea.left()+marge);
        if (moveResizeGeom.left() > desktopArea.right()-marge)
            moveResizeGeom.setLeft(desktopArea.right()-marge);

        moveResizeGeom.setSize( adjustedSize( moveResizeGeom.size() ) );
        if  (options->resizeMode == Options::Opaque ) 
            {
            setGeometry( moveResizeGeom );
            positionGeometryTip();
            }
        else if ( options->resizeMode == Options::Transparent ) 
            {
            clearbound();  // it's necessary to move the geometry tip when there's no outline
            positionGeometryTip(); // shown, otherwise it would cause repaint problems in case
            drawbound( moveResizeGeom ); // they overlap; the paint event will come after this,
            }                               // so the geometry tip will be painted above the outline
        }
    else if ( isMove() && moveResizeGeom.topLeft() != previousMoveResizeGeom.topLeft() ) 
        {
        moveResizeGeom.moveTopLeft( workspace()->adjustClientPosition( this, moveResizeGeom.topLeft() ) );
        if (moveResizeGeom.bottom() < desktopArea.top()+marge)
            moveResizeGeom.moveBottomLeft( QPoint( moveResizeGeom.left(), desktopArea.top()+marge));
        if (moveResizeGeom.top() > desktopArea.bottom()-marge)
            moveResizeGeom.moveTopLeft( QPoint( moveResizeGeom.left(), desktopArea.bottom()-marge));
        if (moveResizeGeom.right() < desktopArea.left()+marge)
            moveResizeGeom.moveTopRight( QPoint( desktopArea.left()+marge, moveResizeGeom.top()));
        if (moveResizeGeom.left() > desktopArea.right()-marge)
            moveResizeGeom.moveTopLeft( QPoint( desktopArea.right()-marge, moveResizeGeom.top()));
        switch ( options->moveMode ) 
            {
            case Options::Opaque:
                move( moveResizeGeom.topLeft() );
                positionGeometryTip();
                break;
            case Options::Transparent:
                clearbound();
                positionGeometryTip();
                drawbound( moveResizeGeom );
                break;
            }
        }

    if ( isMove() )
      workspace()->clientMoved(globalPos, qt_x_time);
    }


} // namespace