summaryrefslogtreecommitdiffstats
path: root/twin/geometry.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'twin/geometry.cpp')
-rw-r--r--twin/geometry.cpp2649
1 files changed, 2649 insertions, 0 deletions
diff --git a/twin/geometry.cpp b/twin/geometry.cpp
new file mode 100644
index 000000000..2e0b205c7
--- /dev/null
+++ b/twin/geometry.cpp
@@ -0,0 +1,2649 @@
+/*****************************************************************
+ 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 <tqpainter.h>
+#include <twin.h>
+
+#include "placement.h"
+#include "notifications.h"
+#include "geometrytip.h"
+#include "rules.h"
+
+namespace KWinInternal
+{
+
+//********************************************
+// Workspace
+//********************************************
+
+/*!
+ Resizes the workspace after an XRANDR screen size change
+ */
+void Workspace::desktopResized()
+ {
+ //printf("Workspace::desktopResized()\n\r");
+ TQRect geom = KApplication::desktop()->geometry();
+ NETSize desktop_geometry;
+ desktop_geometry.width = geom.width();
+ desktop_geometry.height = geom.height();
+ rootInfo->setDesktopGeometry( -1, desktop_geometry );
+
+ updateClientArea( true );
+ checkElectricBorders( true );
+ }
+
+/*!
+ Resizes the workspace after kdesktop signals a desktop resize
+ */
+void Workspace::kDestopResized()
+ {
+ //printf("Workspace::kDesktopResized()\n\r");
+ TQRect geom = KApplication::desktop()->geometry();
+ NETSize desktop_geometry;
+ desktop_geometry.width = geom.width();
+ desktop_geometry.height = geom.height();
+ rootInfo->setDesktopGeometry( -1, desktop_geometry );
+
+ updateClientArea( true );
+ checkElectricBorders( true );
+ }
+
+/*!
+ 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 )
+ {
+ TQDesktopWidget *desktopwidget = KApplication::desktop();
+ int nscreens = desktopwidget -> numScreens ();
+// kdDebug () << "screens: " << nscreens << endl;
+ TQRect* new_wareas = new TQRect[ numberOfDesktops() + 1 ];
+ TQRect** new_sareas = new TQRect*[ numberOfDesktops() + 1];
+ TQRect* screens = new TQRect [ nscreens ];
+ TQRect desktopArea = desktopwidget -> geometry ();
+ for( int iS = 0;
+ iS < nscreens;
+ iS ++ )
+ {
+ screens [iS] = desktopwidget -> screenGeometry (iS);
+ }
+ for( int i = 1;
+ i <= numberOfDesktops();
+ ++i )
+ {
+ new_wareas[ i ] = desktopArea;
+ new_sareas[ i ] = new TQRect [ nscreens ];
+ for( int iS = 0;
+ iS < nscreens;
+ iS ++ )
+ new_sareas[ i ][ iS ] = screens[ iS ];
+ }
+ for ( ClientList::ConstIterator it = clients.begin(); it != clients.end(); ++it)
+ {
+ if( !(*it)->hasStrut())
+ continue;
+ TQRect r = (*it)->adjustedClientArea( desktopArea, desktopArea );
+ if( (*it)->isOnAllDesktops())
+ for( int i = 1;
+ i <= numberOfDesktops();
+ ++i )
+ {
+ new_wareas[ i ] = new_wareas[ i ].intersect( r );
+ for( int iS = 0;
+ iS < nscreens;
+ iS ++ )
+ new_sareas[ i ][ iS ] =
+ new_sareas[ i ][ iS ].intersect(
+ (*it)->adjustedClientArea( desktopArea, screens[ iS ] )
+ );
+ }
+ else
+ {
+ new_wareas[ (*it)->desktop() ] = new_wareas[ (*it)->desktop() ].intersect( r );
+ for( int iS = 0;
+ iS < nscreens;
+ iS ++ )
+ {
+// kdDebug () << "adjusting new_sarea: " << screens[ iS ] << endl;
+ new_sareas[ (*it)->desktop() ][ iS ] =
+ new_sareas[ (*it)->desktop() ][ iS ].intersect(
+ (*it)->adjustedClientArea( desktopArea, screens[ iS ] )
+ );
+ }
+ }
+ }
+#if 0
+ for( int i = 1;
+ i <= numberOfDesktops();
+ ++i )
+ {
+ for( int iS = 0;
+ iS < nscreens;
+ iS ++ )
+ kdDebug () << "new_sarea: " << new_sareas[ i ][ iS ] << endl;
+ }
+#endif
+ // TODO topmenu update for screenarea changes?
+ if( topmenu_space != NULL )
+ {
+ TQRect topmenu_area = desktopArea;
+ topmenu_area.setTop( topMenuHeight());
+ for( int i = 1;
+ i <= numberOfDesktops();
+ ++i )
+ new_wareas[ i ] = new_wareas[ i ].intersect( topmenu_area );
+ }
+
+ bool changed = force;
+
+ if (! screenarea)
+ changed = true;
+
+ for( int i = 1;
+ !changed && i <= numberOfDesktops();
+ ++i )
+ {
+ if( workarea[ i ] != new_wareas[ i ] )
+ changed = true;
+ for( int iS = 0;
+ iS < nscreens;
+ iS ++ )
+ if (new_sareas[ i ][ iS ] != screenarea [ i ][ iS ])
+ changed = true;
+ }
+
+ if ( changed )
+ {
+ delete[] workarea;
+ workarea = new_wareas;
+ new_wareas = NULL;
+ delete[] screenarea;
+ screenarea = new_sareas;
+ new_sareas = 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 );
+ }
+
+ updateTopMenuGeometry();
+ for( ClientList::ConstIterator it = clients.begin();
+ it != clients.end();
+ ++it)
+ (*it)->checkWorkspacePosition();
+ for( ClientList::ConstIterator it = desktops.begin();
+ it != desktops.end();
+ ++it)
+ (*it)->checkWorkspacePosition();
+ }
+ delete[] screens;
+ delete[] new_sareas;
+ delete[] new_wareas;
+ }
+
+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()
+ */
+TQRect Workspace::clientArea( clientAreaOption opt, int screen, int desktop ) const
+ {
+ if( desktop == NETWinInfo::OnAllDesktops || desktop == 0 )
+ desktop = currentDesktop();
+ TQDesktopWidget *desktopwidget = kapp->desktop();
+ TQRect sarea = screenarea // may be NULL during KWin initialization
+ ? screenarea[ desktop ][ screen ]
+ : desktopwidget->screenGeometry( screen );
+ TQRect warea = workarea[ desktop ].isNull()
+ ? kapp->desktop()->geometry()
+ : workarea[ desktop ];
+ switch (opt)
+ {
+ case MaximizeArea:
+ if (options->xineramaMaximizeEnabled)
+ if (desktopwidget->numScreens() < 2)
+ return warea;
+ else
+ return sarea;
+ else
+ return warea;
+ case MaximizeFullArea:
+ if (options->xineramaMaximizeEnabled)
+ if (desktopwidget->numScreens() < 2)
+ return desktopwidget->geometry();
+ else
+ return desktopwidget->screenGeometry( screen );
+ else
+ return desktopwidget->geometry();
+ case FullScreenArea:
+ if (options->xineramaFullscreenEnabled)
+ if (desktopwidget->numScreens() < 2)
+ return desktopwidget->geometry();
+ else
+ return desktopwidget->screenGeometry( screen );
+ else
+ return desktopwidget->geometry();
+ case PlacementArea:
+ if (options->xineramaPlacementEnabled)
+ if (desktopwidget->numScreens() < 2)
+ return warea;
+ else
+ return sarea;
+ else
+ return warea;
+ case MovementArea:
+ if (options->xineramaMovementEnabled)
+ if (desktopwidget->numScreens() < 2)
+ return desktopwidget->geometry();
+ else
+ return desktopwidget->screenGeometry( screen );
+ else
+ return desktopwidget->geometry();
+ case WorkArea:
+ return warea;
+ case FullArea:
+ return desktopwidget->geometry();
+ case ScreenArea:
+ if (desktopwidget->numScreens() < 2)
+ return desktopwidget->geometry();
+ else
+ return desktopwidget->screenGeometry( screen );
+ }
+ assert( false );
+ return TQRect();
+ }
+
+TQRect Workspace::clientArea( clientAreaOption opt, const TQPoint& p, int desktop ) const
+ {
+ TQDesktopWidget *desktopwidget = KApplication::desktop();
+ int screen = desktopwidget->screenNumber( p );
+ if( screen < 0 )
+ screen = desktopwidget->primaryScreen();
+ return clientArea( opt, screen, desktop );
+ }
+
+TQRect Workspace::clientArea( clientAreaOption opt, const Client* c ) const
+ {
+ return clientArea( opt, c->geometry().center(), c->desktop());
+ }
+
+
+/*!
+ 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.
+ */
+TQPoint Workspace::adjustClientPosition( Client* c, TQPoint pos )
+ {
+ //CT 16mar98, 27May98 - magics: BorderSnapZone, WindowSnapZone
+ //CT adapted for twin on 25Nov1999
+ //aleXXX 02Nov2000 added second snapping mode
+ if (options->windowSnapZone || options->borderSnapZone )
+ {
+ const bool sOWO=options->snapOnlyWhenOverlapping;
+ const TQRect maxRect = clientArea(MovementArea, pos+c->rect().center(), c->desktop());
+ const int xmin = maxRect.left();
+ const int xmax = maxRect.right()+1; //desk size
+ const int ymin = maxRect.top();
+ const int ymax = maxRect.bottom()+1;
+
+ const int cx(pos.x());
+ const int cy(pos.y());
+ const int cw(c->width());
+ const int ch(c->height());
+ const int rx(cx+cw);
+ const 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)
+ {
+ TQValueList<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 = TQPoint(nx, ny);
+ }
+ return pos;
+ }
+
+TQRect Workspace::adjustClientSize( Client* c, TQRect moveResizeGeom, int mode )
+ {
+ //adapted from adjustClientPosition on 29May2004
+ //this function is called when resizing a window and will modify
+ //the new dimensions to snap to other windows/borders if appropriate
+ if ( options->windowSnapZone || options->borderSnapZone )
+ {
+ const bool sOWO=options->snapOnlyWhenOverlapping;
+
+ const TQRect maxRect = clientArea(MovementArea, c->rect().center(), c->desktop());
+ const int xmin = maxRect.left();
+ const int xmax = maxRect.right(); //desk size
+ const int ymin = maxRect.top();
+ const int ymax = maxRect.bottom();
+
+ const int cx(moveResizeGeom.left());
+ const int cy(moveResizeGeom.top());
+ const int rx(moveResizeGeom.right());
+ const int ry(moveResizeGeom.bottom());
+
+ int newcx(cx), newcy(cy); //buffers
+ int newrx(rx), newry(ry);
+ 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)
+ {
+ deltaX = int(snap);
+ deltaY = int(snap);
+
+#define SNAP_BORDER_TOP \
+ if ((sOWO?(newcy<ymin):true) && (QABS(ymin-newcy)<deltaY)) \
+ { \
+ deltaY = QABS(ymin-newcy); \
+ newcy = ymin; \
+ }
+
+#define SNAP_BORDER_BOTTOM \
+ if ((sOWO?(newry>ymax):true) && (QABS(ymax-newry)<deltaY)) \
+ { \
+ deltaY = QABS(ymax-newcy); \
+ newry = ymax; \
+ }
+
+#define SNAP_BORDER_LEFT \
+ if ((sOWO?(newcx<xmin):true) && (QABS(xmin-newcx)<deltaX)) \
+ { \
+ deltaX = QABS(xmin-newcx); \
+ newcx = xmin; \
+ }
+
+#define SNAP_BORDER_RIGHT \
+ if ((sOWO?(newrx>xmax):true) && (QABS(xmax-newrx)<deltaX)) \
+ { \
+ deltaX = QABS(xmax-newrx); \
+ newrx = xmax; \
+ }
+ switch ( mode )
+ {
+ case PositionBottomRight:
+ SNAP_BORDER_BOTTOM
+ SNAP_BORDER_RIGHT
+ break;
+ case PositionRight:
+ SNAP_BORDER_RIGHT
+ break;
+ case PositionBottom:
+ SNAP_BORDER_BOTTOM
+ break;
+ case PositionTopLeft:
+ SNAP_BORDER_TOP
+ SNAP_BORDER_LEFT
+ break;
+ case PositionLeft:
+ SNAP_BORDER_LEFT
+ break;
+ case PositionTop:
+ SNAP_BORDER_TOP
+ break;
+ case PositionTopRight:
+ SNAP_BORDER_TOP
+ SNAP_BORDER_RIGHT
+ break;
+ case PositionBottomLeft:
+ SNAP_BORDER_BOTTOM
+ SNAP_BORDER_LEFT
+ break;
+ default:
+ assert( false );
+ break;
+ }
+
+
+ }
+
+ // windows snap
+ snap = options->windowSnapZone;
+ if (snap)
+ {
+ deltaX = int(snap);
+ deltaY = int(snap);
+ TQValueList<Client *>::ConstIterator l;
+ for (l = clients.begin();l != clients.end();++l )
+ {
+ if ((*l)->isOnDesktop(currentDesktop()) &&
+ !(*l)->isMinimized()
+ && (*l) != c )
+ {
+ lx = (*l)->x()-1;
+ ly = (*l)->y()-1;
+ lrx =(*l)->x() + (*l)->width();
+ lry =(*l)->y() + (*l)->height();
+
+#define WITHIN_HEIGHT ((( newcy <= lry ) && ( newcy >= ly )) || \
+ (( newry >= ly ) && ( newry <= lry )) || \
+ (( newcy <= ly ) && ( newry >= lry )) )
+
+#define WITHIN_WIDTH ( (( cx <= lrx ) && ( cx >= lx )) || \
+ (( rx >= lx ) && ( rx <= lrx )) || \
+ (( cx <= lx ) && ( rx >= lrx )) )
+
+#define SNAP_WINDOW_TOP if ( (sOWO?(newcy<lry):true) \
+ && WITHIN_WIDTH \
+ && (QABS( lry - newcy ) < deltaY) ) { \
+ deltaY = QABS( lry - newcy ); \
+ newcy=lry; \
+ }
+
+#define SNAP_WINDOW_BOTTOM if ( (sOWO?(newry>ly):true) \
+ && WITHIN_WIDTH \
+ && (QABS( ly - newry ) < deltaY) ) { \
+ deltaY = QABS( ly - newry ); \
+ newry=ly; \
+ }
+
+#define SNAP_WINDOW_LEFT if ( (sOWO?(newcx<lrx):true) \
+ && WITHIN_HEIGHT \
+ && (QABS( lrx - newcx ) < deltaX)) { \
+ deltaX = QABS( lrx - newcx ); \
+ newcx=lrx; \
+ }
+
+#define SNAP_WINDOW_RIGHT if ( (sOWO?(newrx>lx):true) \
+ && WITHIN_HEIGHT \
+ && (QABS( lx - newrx ) < deltaX)) \
+ { \
+ deltaX = QABS( lx - newrx ); \
+ newrx=lx; \
+ }
+
+ switch ( mode )
+ {
+ case PositionBottomRight:
+ SNAP_WINDOW_BOTTOM
+ SNAP_WINDOW_RIGHT
+ break;
+ case PositionRight:
+ SNAP_WINDOW_RIGHT
+ break;
+ case PositionBottom:
+ SNAP_WINDOW_BOTTOM
+ break;
+ case PositionTopLeft:
+ SNAP_WINDOW_TOP
+ SNAP_WINDOW_LEFT
+ break;
+ case PositionLeft:
+ SNAP_WINDOW_LEFT
+ break;
+ case PositionTop:
+ SNAP_WINDOW_TOP
+ break;
+ case PositionTopRight:
+ SNAP_WINDOW_TOP
+ SNAP_WINDOW_RIGHT
+ break;
+ case PositionBottomLeft:
+ SNAP_WINDOW_BOTTOM
+ SNAP_WINDOW_LEFT
+ break;
+ default:
+ assert( false );
+ break;
+ }
+ }
+ }
+ }
+ moveResizeGeom = TQRect(TQPoint(newcx, newcy), TQPoint(newrx, newry));
+ }
+ return moveResizeGeom;
+ }
+
+/*!
+ 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)
+ ++block_focus;
+ else
+ --block_focus;
+ }
+
+/*!
+ Cascades all clients on the current desktop
+ */
+void Workspace::cascadeDesktop()
+ {
+// TODO XINERAMA this probably is not right for xinerama
+ Q_ASSERT( block_stacking_updates == 0 );
+ ClientList::ConstIterator it(stackingOrder().begin());
+ initPositioning->reinitCascading( currentDesktop());
+ TQRect area = clientArea( PlacementArea, TQPoint( 0, 0 ), currentDesktop());
+ for (; it != stackingOrder().end(); ++it)
+ {
+ if((!(*it)->isOnDesktop(currentDesktop())) ||
+ ((*it)->isMinimized()) ||
+ ((*it)->isOnAllDesktops()) ||
+ (!(*it)->isMovable()) )
+ continue;
+ initPositioning->placeCascaded(*it, area);
+ }
+ }
+
+/*!
+ 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, TQRect());
+ }
+ }
+
+
+void Workspace::updateTopMenuGeometry( Client* c )
+ {
+ if( !managingTopMenus())
+ return;
+ if( c != NULL )
+ {
+ XEvent ev;
+ ev.xclient.display = qt_xdisplay();
+ ev.xclient.type = ClientMessage;
+ ev.xclient.window = c->window();
+ static Atom msg_type_atom = XInternAtom( qt_xdisplay(), "_KDE_TOPMENU_MINSIZE", False );
+ ev.xclient.message_type = msg_type_atom;
+ ev.xclient.format = 32;
+ ev.xclient.data.l[0] = GET_QT_X_TIME();
+ ev.xclient.data.l[1] = topmenu_space->width();
+ ev.xclient.data.l[2] = topmenu_space->height();
+ ev.xclient.data.l[3] = 0;
+ ev.xclient.data.l[4] = 0;
+ XSendEvent( qt_xdisplay(), c->window(), False, NoEventMask, &ev );
+ KWin::setStrut( c->window(), 0, 0, topmenu_height, 0 ); // so that kicker etc. know
+ c->checkWorkspacePosition();
+ return;
+ }
+ // c == NULL - update all, including topmenu_space
+ TQRect area;
+ area = clientArea( MaximizeFullArea, TQPoint( 0, 0 ), 1 ); // HACK desktop ?
+ area.setHeight( topMenuHeight());
+ topmenu_space->setGeometry( area );
+ for( ClientList::ConstIterator it = topmenus.begin();
+ it != topmenus.end();
+ ++it )
+ updateTopMenuGeometry( *it );
+ }
+
+//********************************************
+// Client
+//********************************************
+
+
+void Client::keepInArea( TQRect area, bool partial )
+ {
+ if( partial )
+ {
+ // increase the area so that can have only 100 pixels in the area
+ area.setLeft( QMIN( area.left() - width() + 100, area.left()));
+ area.setTop( QMIN( area.top() - height() + 100, area.top()));
+ area.setRight( QMAX( area.right() + width() - 100, area.right()));
+ area.setBottom( QMAX( area.bottom() + height() - 100, area.bottom()));
+ }
+ if ( geometry().right() > area.right() && width() < area.width() )
+ move( area.right() - width(), y() );
+ if ( geometry().bottom() > area.bottom() && height() < area.height() )
+ move( x(), area.bottom() - height() );
+ if( !area.contains( geometry().topLeft() ))
+ {
+ int tx = x();
+ int ty = y();
+ if ( tx < area.x() )
+ tx = area.x();
+ if ( ty < area.y() )
+ ty = area.y();
+ move( tx, ty );
+ }
+ }
+
+/*!
+ Returns \a area with the client's strut taken into account.
+
+ Used from Workspace in updateClientArea.
+ */
+// TODO move to Workspace?
+
+TQRect Client::adjustedClientArea( const TQRect &desktopArea, const TQRect& area ) const
+ {
+ TQRect r = area;
+ // topmenu area is reserved in updateClientArea()
+ if( isTopMenu())
+ return r;
+ NETExtendedStrut str = strut();
+ TQRect stareaL = TQRect(
+ 0,
+ str . left_start,
+ str . left_width,
+ str . left_end - str . left_start + 1 );
+ TQRect stareaR = TQRect (
+ desktopArea . right () - str . right_width + 1,
+ str . right_start,
+ str . right_width,
+ str . right_end - str . right_start + 1 );
+ TQRect stareaT = TQRect (
+ str . top_start,
+ 0,
+ str . top_end - str . top_start + 1,
+ str . top_width);
+ TQRect stareaB = TQRect (
+ str . bottom_start,
+ desktopArea . bottom () - str . bottom_width + 1,
+ str . bottom_end - str . bottom_start + 1,
+ str . bottom_width);
+
+ NETExtendedStrut ext = info->extendedStrut();
+ if( ext.left_width == 0 && ext.right_width == 0 && ext.top_width == 0 && ext.bottom_width == 0
+ && ( str.left_width != 0 || str.right_width != 0 || str.top_width != 0 || str.bottom_width != 0 )) {
+
+ // hack, might cause problems... this tries to guess the start/end of a
+ // non-extended strut; only works on windows that have exact same
+ // geometry as their strut (ie, if the geometry fits the width
+ // exactly, we will adjust length of strut to match the geometry as well;
+ // otherwise we use the full-edge strut)
+
+ if (stareaT.top() == geometry().top() && stareaT.bottom() == geometry().bottom()) {
+ stareaT.setLeft(geometry().left());
+ stareaT.setRight(geometry().right());
+// kdDebug () << "Trimming top-strut to geometry() to: " << stareaT << endl;
+ }
+ if (stareaB.top() == geometry().top() && stareaB.bottom() == geometry().bottom()) {
+ stareaB.setLeft(geometry().left());
+ stareaB.setRight(geometry().right());
+// kdDebug () << "Trimming bottom-strut to geometry(): " << stareaB << endl;
+ }
+ if (stareaL.left() == geometry().left() && stareaL.right() == geometry().right()) {
+ stareaL.setTop(geometry().top());
+ stareaL.setBottom(geometry().bottom());
+// kdDebug () << "Trimming left-strut to geometry(): " << stareaL << endl;
+ }
+ if (stareaR.left() == geometry().left() && stareaR.right() == geometry().right()) {
+ stareaR.setTop(geometry().top());
+ stareaR.setBottom(geometry().bottom());
+// kdDebug () << "Trimming right-strut to geometry(): " << stareaR << endl;
+ }
+ }
+
+ TQRect screenarea = workspace()->clientArea( ScreenArea, this );
+ // HACK: workarea handling is not xinerama aware, so if this strut
+ // reserves place at a xinerama edge that's inside the virtual screen,
+ // ignore the strut for workspace setting.
+ if( area == kapp->desktop()->geometry())
+ {
+ if( stareaL.left() < screenarea.left())
+ stareaL = TQRect();
+ if( stareaR.right() > screenarea.right())
+ stareaR = TQRect();
+ if( stareaT.top() < screenarea.top())
+ stareaT = TQRect();
+ if( stareaB.bottom() < screenarea.bottom())
+ stareaB = TQRect();
+ }
+ // Handle struts at xinerama edges that are inside the virtual screen.
+ // They're given in virtual screen coordinates, make them affect only
+ // their xinerama screen.
+ stareaL.setLeft( KMAX( stareaL.left(), screenarea.left()));
+ stareaR.setRight( KMIN( stareaR.right(), screenarea.right()));
+ stareaT.setTop( KMAX( stareaT.top(), screenarea.top()));
+ stareaB.setBottom( KMIN( stareaB.bottom(), screenarea.bottom()));
+
+ if (stareaL . intersects (area)) {
+// kdDebug () << "Moving left of: " << r << " to " << stareaL.right() + 1 << endl;
+ r . setLeft( stareaL . right() + 1 );
+ }
+ if (stareaR . intersects (area)) {
+// kdDebug () << "Moving right of: " << r << " to " << stareaR.left() - 1 << endl;
+ r . setRight( stareaR . left() - 1 );
+ }
+ if (stareaT . intersects (area)) {
+// kdDebug () << "Moving top of: " << r << " to " << stareaT.bottom() + 1 << endl;
+ r . setTop( stareaT . bottom() + 1 );
+ }
+ if (stareaB . intersects (area)) {
+// kdDebug () << "Moving bottom of: " << r << " to " << stareaB.top() - 1 << endl;
+ r . setBottom( stareaB . top() - 1 );
+ }
+ return r;
+ }
+
+NETExtendedStrut Client::strut() const
+ {
+ NETExtendedStrut ext = info->extendedStrut();
+ NETStrut str = info->strut();
+ if( ext.left_width == 0 && ext.right_width == 0 && ext.top_width == 0 && ext.bottom_width == 0
+ && ( str.left != 0 || str.right != 0 || str.top != 0 || str.bottom != 0 ))
+ {
+ // build extended from simple
+ if( str.left != 0 )
+ {
+ ext.left_width = str.left;
+ ext.left_start = 0;
+ ext.left_end = XDisplayHeight( qt_xdisplay(), DefaultScreen( qt_xdisplay()));
+ }
+ if( str.right != 0 )
+ {
+ ext.right_width = str.right;
+ ext.right_start = 0;
+ ext.right_end = XDisplayHeight( qt_xdisplay(), DefaultScreen( qt_xdisplay()));
+ }
+ if( str.top != 0 )
+ {
+ ext.top_width = str.top;
+ ext.top_start = 0;
+ ext.top_end = XDisplayWidth( qt_xdisplay(), DefaultScreen( qt_xdisplay()));
+ }
+ if( str.bottom != 0 )
+ {
+ ext.bottom_width = str.bottom;
+ ext.bottom_start = 0;
+ ext.bottom_end = XDisplayWidth( qt_xdisplay(), DefaultScreen( qt_xdisplay()));
+ }
+ }
+ return ext;
+ }
+
+bool Client::hasStrut() const
+ {
+ NETExtendedStrut ext = strut();
+ if( ext.left_width == 0 && ext.right_width == 0 && ext.top_width == 0 && ext.bottom_width == 0 )
+ return false;
+ return true;
+ }
+
+
+// updates differences to workarea edges for all directions
+void Client::updateWorkareaDiffs()
+ {
+ TQRect area = workspace()->clientArea( WorkArea, this );
+ TQRect 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( isDesktop())
+ {
+ TQRect area = workspace()->clientArea( FullArea, this );
+ if( geometry() != area )
+ setGeometry( area );
+ return;
+ }
+ if( isFullScreen())
+ {
+ TQRect area = workspace()->clientArea( FullScreenArea, this );
+ if( geometry() != area )
+ setGeometry( area );
+ return;
+ }
+ if( isDock())
+ return;
+ if( isTopMenu())
+ {
+ if( workspace()->managingTopMenus())
+ {
+ TQRect area;
+ ClientList mainclients = mainClients();
+ if( mainclients.count() == 1 )
+ area = workspace()->clientArea( MaximizeFullArea, mainclients.first());
+ else
+ area = workspace()->clientArea( MaximizeFullArea, TQPoint( 0, 0 ), desktop());
+ area.setHeight( workspace()->topMenuHeight());
+// kdDebug() << "TOPMENU size adjust: " << area << ":" << this << endl;
+ setGeometry( area );
+ }
+ return;
+ }
+
+ if( maximizeMode() != MaximizeRestore )
+ // TODO update geom_restore?
+ changeMaximize( false, false, true ); // adjust size
+
+ if( !isShade()) // TODO
+ {
+ int old_diff_x = workarea_diff_x;
+ int old_diff_y = workarea_diff_y;
+ updateWorkareaDiffs();
+
+ // 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;
+
+ TQRect area = workspace()->clientArea( WorkArea, this );
+ TQRect new_geom = geometry();
+ TQRect tmp_rect_x( new_geom.left(), 0, new_geom.width(), 0 );
+ TQRect 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
+ TQRect tmp_rect_y( new_geom.top(), 0, new_geom.height(), 0 );
+ TQRect tmp_area_y( area.top(), 0, area.height(), 0 );
+ checkDirection( workarea_diff_y, old_diff_y, tmp_rect_y, tmp_area_y );
+ new_geom = TQRect( tmp_rect_x.left(), tmp_rect_y.left(), tmp_rect_x.width(), tmp_rect_y.width());
+ TQRect 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(); 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, TQRect& rect, const TQRect& 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( 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 ));
+ }
+ else 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.width() > area.width() && isResizable())
+ rect.setWidth( area.width());
+ if( isMovable())
+ {
+ if( rect.left() < area.left())
+ rect.moveLeft( area.left());
+ else if( rect.right() > area.right())
+ rect.moveRight( area.right());
+ }
+ }
+ 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 );
+ }
+ }
+ if (!moveResizeMode && options->shadowEnabled(isActive()))
+ {
+ // If the user is manually resizing, let Client::leaveMoveResize()
+ // decide when to redraw the shadow
+ removeShadow();
+ drawIntersectingShadows();
+ if (options->shadowEnabled(isActive()))
+ drawDelayedShadow();
+ }
+ }
+
+/*!
+ Adjust the frame size \a frame according to he window's size hints.
+ */
+TQSize Client::adjustedSize( const TQSize& frame, Sizemode mode ) const
+ {
+ // first, get the window size for the given frame size s
+
+ TQSize wsize( frame.width() - ( border_left + border_right ),
+ frame.height() - ( border_top + border_bottom ));
+ if( wsize.isEmpty())
+ wsize = TQSize( 1, 1 );
+
+ return sizeForClientSize( wsize, mode, false );
+ }
+
+// this helper returns proper size even if the window is shaded
+// see also the comment in Client::setGeometry()
+TQSize Client::adjustedSize() const
+ {
+ return sizeForClientSize( clientSize());
+ }
+
+/*!
+ 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).
+
+ */
+TQSize Client::sizeForClientSize( const TQSize& wsize, Sizemode mode, bool noframe ) const
+ {
+ int w = wsize.width();
+ int h = wsize.height();
+ if( w < 1 || h < 1 )
+ {
+ kdWarning() << "sizeForClientSize() with empty size!" << endl;
+ kdWarning() << kdBacktrace() << endl;
+ }
+ 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()
+ TQSize min_size = minSize();
+ TQSize max_size = maxSize();
+ if( decoration != NULL )
+ {
+ TQSize decominsize = decoration->tqminimumSize();
+ TQSize border_size( border_left + border_right, border_top + border_bottom );
+ if( border_size.width() > decominsize.width()) // just in case
+ decominsize.setWidth( border_size.width());
+ if( border_size.height() > decominsize.height())
+ decominsize.setHeight( border_size.height());
+ 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 w1 = w;
+ int h1 = 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;
+// code for aspect ratios based on code from FVWM
+ /*
+ * The math looks like this:
+ *
+ * minAspectX dwidth maxAspectX
+ * ---------- <= ------- <= ----------
+ * minAspectY dheight maxAspectY
+ *
+ * If that is multiplied out, then the width and height are
+ * invalid in the following situations:
+ *
+ * minAspectX * dheight > minAspectY * dwidth
+ * maxAspectX * dheight < maxAspectY * dwidth
+ *
+ */
+ if( xSizeHint.flags & PAspect )
+ {
+ double min_aspect_w = xSizeHint.min_aspect.x; // use doubles, because the values can be MAX_INT
+ double min_aspect_h = xSizeHint.min_aspect.y; // and multiplying would go wrong otherwise
+ double max_aspect_w = xSizeHint.max_aspect.x;
+ double max_aspect_h = xSizeHint.max_aspect.y;
+ // According to ICCCM 4.1.2.3 PMinSize should be a fallback for PBaseSize for size increments,
+ // but not for aspect ratio. Since this code comes from FVWM, handles both at the same time,
+ // and I have no idea how it works, let's hope nobody relies on that.
+ w -= xSizeHint.base_width;
+ h -= xSizeHint.base_height;
+ int max_width = max_size.width() - xSizeHint.base_width;
+ int min_width = min_size.width() - xSizeHint.base_width;
+ int max_height = max_size.height() - xSizeHint.base_height;
+ int min_height = min_size.height() - xSizeHint.base_height;
+#define ASPECT_CHECK_GROW_W \
+ if( min_aspect_w * h > min_aspect_h * w ) \
+ { \
+ int delta = int( min_aspect_w * h / min_aspect_h - w ) / width_inc * width_inc; \
+ if( w + delta <= max_width ) \
+ w += delta; \
+ }
+#define ASPECT_CHECK_SHRINK_H_GROW_W \
+ if( min_aspect_w * h > min_aspect_h * w ) \
+ { \
+ int delta = int( h - w * min_aspect_h / min_aspect_w ) / height_inc * height_inc; \
+ if( h - delta >= min_height ) \
+ h -= delta; \
+ else \
+ { \
+ int delta = int( min_aspect_w * h / min_aspect_h - w ) / width_inc * width_inc; \
+ if( w + delta <= max_width ) \
+ w += delta; \
+ } \
+ }
+#define ASPECT_CHECK_GROW_H \
+ if( max_aspect_w * h < max_aspect_h * w ) \
+ { \
+ int delta = int( w * max_aspect_h / max_aspect_w - h ) / height_inc * height_inc; \
+ if( h + delta <= max_height ) \
+ h += delta; \
+ }
+#define ASPECT_CHECK_SHRINK_W_GROW_H \
+ if( max_aspect_w * h < max_aspect_h * w ) \
+ { \
+ int delta = int( w - max_aspect_w * h / max_aspect_h ) / width_inc * width_inc; \
+ if( w - delta >= min_width ) \
+ w -= delta; \
+ else \
+ { \
+ int delta = int( w * max_aspect_h / max_aspect_w - h ) / height_inc * height_inc; \
+ if( h + delta <= max_height ) \
+ h += delta; \
+ } \
+ }
+ switch( mode )
+ {
+ case SizemodeAny:
+#if 0 // make SizemodeAny equal to SizemodeFixedW - prefer keeping fixed width,
+ // so that changing aspect ratio to a different value and back keeps the same size (#87298)
+ {
+ ASPECT_CHECK_SHRINK_H_GROW_W
+ ASPECT_CHECK_SHRINK_W_GROW_H
+ ASPECT_CHECK_GROW_H
+ ASPECT_CHECK_GROW_W
+ break;
+ }
+#endif
+ case SizemodeFixedW:
+ {
+ // the checks are order so that attempts to modify height are first
+ ASPECT_CHECK_GROW_H
+ ASPECT_CHECK_SHRINK_H_GROW_W
+ ASPECT_CHECK_SHRINK_W_GROW_H
+ ASPECT_CHECK_GROW_W
+ break;
+ }
+ case SizemodeFixedH:
+ {
+ ASPECT_CHECK_GROW_W
+ ASPECT_CHECK_SHRINK_W_GROW_H
+ ASPECT_CHECK_SHRINK_H_GROW_W
+ ASPECT_CHECK_GROW_H
+ break;
+ }
+ case SizemodeMax:
+ {
+ // first checks that try to shrink
+ ASPECT_CHECK_SHRINK_H_GROW_W
+ ASPECT_CHECK_SHRINK_W_GROW_H
+ ASPECT_CHECK_GROW_W
+ ASPECT_CHECK_GROW_H
+ break;
+ }
+ }
+#undef ASPECT_CHECK_SHRINK_H_GROW_W
+#undef ASPECT_CHECK_SHRINK_W_GROW_H
+#undef ASPECT_CHECK_GROW_W
+#undef ASPECT_CHECK_GROW_H
+ w += xSizeHint.base_width;
+ h += xSizeHint.base_height;
+ }
+ if( !rules()->checkStrictGeometry( false ))
+ {
+ // disobey increments and aspect when maximized
+ if( maximizeMode() & MaximizeHorizontal )
+ w = w1;
+ if( maximizeMode() & MaximizeVertical )
+ h = h1;
+ }
+
+ if( !noframe )
+ {
+ w += border_left + border_right;
+ h += border_top + border_bottom;
+ }
+ return rules()->checkSize( TQSize( w, h ));
+ }
+
+/*!
+ 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 the fields, even if they're not in flags
+
+ if( ! ( xSizeHint.flags & PMinSize ))
+ xSizeHint.min_width = xSizeHint.min_height = 0;
+ if( xSizeHint.flags & PBaseSize )
+ {
+ // PBaseSize is a fallback for PMinSize according to ICCCM 4.1.2.3
+ // The other way around PMinSize is not a complete fallback for PBaseSize,
+ // so that's not handled here.
+ if( ! ( 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 & PMaxSize ))
+ xSizeHint.max_width = xSizeHint.max_height = INT_MAX;
+ else
+ {
+ xSizeHint.max_width = QMAX( xSizeHint.max_width, 1 );
+ xSizeHint.max_height = QMAX( xSizeHint.max_height, 1 );
+ }
+ 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
+ TQSize new_size = adjustedSize();
+ if( new_size != size() && !isFullScreen())
+ {
+ TQRect orig_geometry = geometry();
+ resizeWithChecks( new_size );
+ if( ( !isSpecialWindow() || isToolbar()) && !isFullScreen())
+ {
+ // try to keep the window in its xinerama screen if possible,
+ // if that fails at least keep it visible somewhere
+ TQRect area = workspace()->clientArea( MovementArea, this );
+ if( area.contains( orig_geometry ))
+ keepInArea( area );
+ area = workspace()->clientArea( WorkArea, this );
+ if( area.contains( orig_geometry ))
+ keepInArea( area );
+ }
+ }
+ }
+ updateAllowedActions(); // affects isResizeable()
+ }
+
+TQSize Client::minSize() const
+ {
+ return rules()->checkMinSize( TQSize( xSizeHint.min_width, xSizeHint.min_height ));
+ }
+
+TQSize Client::maxSize() const
+ {
+ return rules()->checkMaxSize( TQSize( xSizeHint.max_width, xSizeHint.max_height ));
+ }
+
+/*!
+ 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 TQPoint 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 TQPoint( x() + dx, y() + dy );
+ else
+ return TQPoint( x() - dx, y() - dy );
+ }
+
+void Client::configureRequest( int value_mask, int rx, int ry, int rw, int rh, int gravity, bool from_tool )
+ {
+ if( gravity == 0 ) // default (nonsense) value for the argument
+ gravity = xSizeHint.win_gravity;
+ if( value_mask & ( CWX | CWY ))
+ {
+ TQPoint new_pos = calculateGravitation( true, gravity ); // undo gravitation
+ if ( value_mask & CWX )
+ new_pos.setX( rx );
+ if ( value_mask & CWY )
+ new_pos.setY( ry );
+
+ // clever(?) workaround for applications like xv that want to set
+ // the location to the current location but miscalculate the
+ // frame size due to twin being a double-reparenting window
+ // manager
+ if ( new_pos.x() == x() + clientPos().x() && new_pos.y() == y() + clientPos().y()
+ && gravity == NorthWestGravity && !from_tool )
+ {
+ new_pos.setX( x());
+ new_pos.setY( y());
+ }
+
+ int nw = clientSize().width();
+ int nh = clientSize().height();
+ if ( value_mask & CWWidth )
+ nw = rw;
+ if ( value_mask & CWHeight )
+ nh = rh;
+ TQSize ns = sizeForClientSize( TQSize( nw, nh ) );
+ new_pos = rules()->checkPosition( new_pos );
+
+ // TODO what to do with maximized windows?
+ if ( maximizeMode() != MaximizeFull
+ || ns != size())
+ {
+ TQRect orig_geometry = geometry();
+ GeometryUpdatesPostponer blocker( this );
+ move( new_pos );
+ plainResize( ns );
+ setGeometry( TQRect( calculateGravitation( false, gravity ), size()));
+ updateFullScreenHack( TQRect( new_pos, TQSize( nw, nh )));
+ TQRect area = workspace()->clientArea( WorkArea, this );
+ if( !from_tool && ( !isSpecialWindow() || isToolbar()) && !isFullScreen()
+ && area.contains( orig_geometry ))
+ keepInArea( area );
+
+ // this is part of the kicker-xinerama-hack... it should be
+ // safe to remove when kicker gets proper ExtendedStrut support;
+ // see Workspace::updateClientArea() and
+ // Client::adjustedClientArea()
+ if (hasStrut ())
+ workspace() -> updateClientArea ();
+ }
+ }
+
+ 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;
+ TQSize ns = sizeForClientSize( TQSize( nw, nh ) );
+
+ if( ns != size()) // don't restore if some app sets its own size again
+ {
+ TQRect orig_geometry = geometry();
+ GeometryUpdatesPostponer blocker( this );
+ int save_gravity = xSizeHint.win_gravity;
+ xSizeHint.win_gravity = gravity;
+ resizeWithChecks( ns );
+ xSizeHint.win_gravity = save_gravity;
+ updateFullScreenHack( TQRect( calculateGravitation( true, xSizeHint.win_gravity ), TQSize( nw, nh )));
+ if( !from_tool && ( !isSpecialWindow() || isToolbar()) && !isFullScreen())
+ {
+ // try to keep the window in its xinerama screen if possible,
+ // if that fails at least keep it visible somewhere
+ TQRect area = workspace()->clientArea( MovementArea, this );
+ if( area.contains( orig_geometry ))
+ keepInArea( area );
+ area = workspace()->clientArea( WorkArea, this );
+ if( area.contains( orig_geometry ))
+ keepInArea( area );
+ }
+ }
+ }
+ // 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 )
+ {
+ if( shade_geometry_change )
+ assert( false );
+ else if( isShade())
+ {
+ if( h == border_top + border_bottom )
+ {
+ kdWarning() << "Shaded geometry passed for size:" << endl;
+ kdWarning() << kdBacktrace() << endl;
+ }
+ }
+ int newx = x();
+ int newy = y();
+ TQRect area = workspace()->clientArea( WorkArea, this );
+ // don't allow growing larger than workarea
+ if( w > area.width())
+ w = area.width();
+ if( h > area.height())
+ h = area.height();
+ TQSize tmp = adjustedSize( TQSize( 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 && w <= area.width()) // was inside and can still fit
+ {
+ 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 && h <= area.height()) // was inside and can still fit
+ {
+ 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, true );
+ }
+
+/*!
+ Returns whether the window is moveable or has a fixed
+ position.
+ */
+bool Client::isMovable() const
+ {
+ if( !motif_may_move || isFullScreen())
+ return false;
+ if( isSpecialWindow() && !isSplash() && !isToolbar()) // allow moving of splashscreens :)
+ return false;
+ if( maximizeMode() == MaximizeFull && !options->moveResizeMaximizedWindows() )
+ return false;
+ if( rules()->checkPosition( invalidPoint ) != invalidPoint ) // forced position
+ return false;
+ return true;
+ }
+
+/*!
+ Returns whether the window is resizable or has a fixed size.
+ */
+bool Client::isResizable() const
+ {
+ if( !motif_may_resize || isFullScreen())
+ return false;
+ if( isSpecialWindow() )
+ return false;
+ if( maximizeMode() == MaximizeFull && !options->moveResizeMaximizedWindows() )
+ return false;
+ if( rules()->checkSize( TQSize()).isValid()) // forced size
+ return false;
+
+ TQSize min = minSize();
+ TQSize max = maxSize();
+ return min.width() < max.width() || min.height() < max.height();
+ }
+
+/*
+ Returns whether the window is maximizable or not
+ */
+bool Client::isMaximizable() const
+ {
+ if( isModalSystemNotification())
+ return false;
+ { // isMovable() and isResizable() may be false for maximized windows
+ // with moving/resizing maximized windows disabled
+ TemporaryAssign< MaximizeMode > tmp( max_mode, MaximizeRestore );
+ if( !isMovable() || !isResizable() || isToolbar()) // SELI isToolbar() ?
+ return false;
+ }
+ if ( maximizeMode() != MaximizeRestore )
+ return TRUE;
+ TQSize max = maxSize();
+#if 0
+ if( max.width() < 32767 || max.height() < 32767 ) // sizes are 16bit with X
+ return false;
+#else
+ // apparently there are enough apps which specify some arbitrary value
+ // for their maximum size just for the fun of it
+ TQSize areasize = workspace()->clientArea( MaximizeArea, this ).size();
+ if( max.width() < areasize.width() || max.height() < areasize.height())
+ return false;
+#endif
+ 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 )
+ {
+ // this code is also duplicated in Client::plainResize()
+ // Ok, the shading geometry stuff. Generally, code doesn't care about shaded geometry,
+ // simply because there are too many places dealing with geometry. Those places
+ // ignore shaded state and use normal geometry, which they usually should get
+ // from adjustedSize(). Such geometry comes here, and if the window is shaded,
+ // the geometry is used only for client_size, since that one is not used when
+ // shading. Then the frame geometry is adjusted for the shaded geometry.
+ // This gets more complicated in the case the code does only something like
+ // setGeometry( geometry()) - geometry() will return the shaded frame geometry.
+ // Such code is wrong and should be changed to handle the case when the window is shaded,
+ // for example using Client::clientSize().
+ if( shade_geometry_change )
+ ; // nothing
+ else if( isShade())
+ {
+ if( h == border_top + border_bottom )
+ {
+ kdDebug() << "Shaded geometry passed for size:" << endl;
+ kdDebug() << kdBacktrace() << endl;
+ }
+ else
+ {
+ client_size = TQSize( w - border_left - border_right, h - border_top - border_bottom );
+ h = border_top + border_bottom;
+ }
+ }
+ else
+ {
+ client_size = TQSize( w - border_left - border_right, h - border_top - border_bottom );
+ }
+ if( force == NormalGeometrySet && frame_geometry == TQRect( x, y, w, h ))
+ return;
+ frame_geometry = TQRect( x, y, w, h );
+ updateWorkareaDiffs();
+ if( postpone_geometry_updates != 0 )
+ {
+ pending_geometry_update = true;
+ return;
+ }
+ resizeDecoration( TQSize( w, h ));
+ XMoveResizeWindow( qt_xdisplay(), frameId(), x, y, w, h );
+// resizeDecoration( TQSize( w, h ));
+ if( !isShade())
+ {
+ TQSize cs = clientSize();
+ XMoveResizeWindow( qt_xdisplay(), wrapperId(), clientPos().x(), clientPos().y(),
+ cs.width(), cs.height());
+ XMoveResizeWindow( qt_xdisplay(), window(), 0, 0, cs.width(), cs.height());
+ }
+ updateShape();
+ // SELI TODO won't this be too expensive?
+ updateWorkareaDiffs();
+ sendSyntheticConfigureNotify();
+ updateWindowRules();
+ checkMaximizeGeometry();
+ workspace()->checkActiveScreen( this );
+ }
+
+void Client::plainResize( int w, int h, ForceGeometry_t force )
+ {
+ // this code is also duplicated in Client::setGeometry(), and it's also commented there
+ if( shade_geometry_change )
+ ; // nothing
+ else if( isShade())
+ {
+ if( h == border_top + border_bottom )
+ {
+ kdDebug() << "Shaded geometry passed for size:" << endl;
+ kdDebug() << kdBacktrace() << endl;
+ }
+ else
+ {
+ client_size = TQSize( w - border_left - border_right, h - border_top - border_bottom );
+ h = border_top + border_bottom;
+ }
+ }
+ else
+ {
+ client_size = TQSize( w - border_left - border_right, h - border_top - border_bottom );
+ }
+ if( TQSize( w, h ) != rules()->checkSize( TQSize( w, h )))
+ {
+ kdDebug() << "forced size fail:" << TQSize( w,h ) << ":" << rules()->checkSize( TQSize( w, h )) << endl;
+ kdDebug() << kdBacktrace() << endl;
+ }
+ if( force == NormalGeometrySet && frame_geometry.size() == TQSize( w, h ))
+ return;
+ frame_geometry.setSize( TQSize( w, h ));
+ updateWorkareaDiffs();
+ if( postpone_geometry_updates != 0 )
+ {
+ pending_geometry_update = true;
+ return;
+ }
+ resizeDecoration( TQSize( w, h ));
+ XResizeWindow( qt_xdisplay(), frameId(), w, h );
+// resizeDecoration( TQSize( w, h ));
+ if( !isShade())
+ {
+ TQSize cs = clientSize();
+ XMoveResizeWindow( qt_xdisplay(), wrapperId(), clientPos().x(), clientPos().y(),
+ cs.width(), cs.height());
+ XMoveResizeWindow( qt_xdisplay(), window(), 0, 0, cs.width(), cs.height());
+ }
+ updateShape();
+ updateWorkareaDiffs();
+ sendSyntheticConfigureNotify();
+ updateWindowRules();
+ checkMaximizeGeometry();
+ workspace()->checkActiveScreen( this );
+ }
+
+/*!
+ 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() == TQPoint( x, y ))
+ return;
+ frame_geometry.moveTopLeft( TQPoint( x, y ));
+ updateWorkareaDiffs();
+ if( postpone_geometry_updates != 0 )
+ {
+ pending_geometry_update = true;
+ return;
+ }
+ XMoveWindow( qt_xdisplay(), frameId(), x, y );
+ sendSyntheticConfigureNotify();
+ updateWindowRules();
+ checkMaximizeGeometry();
+ workspace()->checkActiveScreen( this );
+ }
+
+
+void Client::postponeGeometryUpdates( bool postpone )
+ {
+ if( postpone )
+ {
+ if( postpone_geometry_updates == 0 )
+ pending_geometry_update = false;
+ ++postpone_geometry_updates;
+ }
+ else
+ {
+ if( --postpone_geometry_updates == 0 )
+ {
+ if( pending_geometry_update )
+ {
+ if( isShade())
+ setGeometry( TQRect( pos(), adjustedSize()), ForceGeometrySet );
+ else
+ setGeometry( geometry(), ForceGeometrySet );
+ pending_geometry_update = false;
+ }
+ }
+ }
+ }
+
+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;
+
+ 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 );
+ }
+
+ max_mode = rules()->checkMaximize( max_mode );
+ if( !adjust && max_mode == old_mode )
+ return;
+
+ GeometryUpdatesPostponer blocker( this );
+
+ // maximing one way and unmaximizing the other way shouldn't happen
+ Q_ASSERT( !( vertical && horizontal )
+ || ((( max_mode & MaximizeVertical ) != 0 ) == (( max_mode & MaximizeHorizontal ) != 0 )));
+
+ TQRect clientArea = workspace()->clientArea( MaximizeArea, this );
+
+ // save sizes for restoring, if maximalizing
+ if( !adjust && !( y() == clientArea.top() && height() == clientArea.height()))
+ {
+ geom_restore.setTop( y());
+ geom_restore.setHeight( height());
+ }
+ if( !adjust && !( x() == clientArea.left() && width() == clientArea.width()))
+ {
+ geom_restore.setLeft( x());
+ geom_restore.setWidth( width());
+ }
+
+ if( !adjust )
+ {
+ if(( vertical && !(old_mode & MaximizeVertical ))
+ || ( horizontal && !( old_mode & MaximizeHorizontal )))
+ 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 );
+
+ // restore partial maximizations
+ if ( old_mode==MaximizeFull && max_mode==MaximizeRestore )
+ {
+ if ( maximizeModeRestore()==MaximizeVertical )
+ {
+ max_mode = MaximizeVertical;
+ maxmode_restore = MaximizeRestore;
+ }
+ if ( maximizeModeRestore()==MaximizeHorizontal )
+ {
+ max_mode = MaximizeHorizontal;
+ maxmode_restore = MaximizeRestore;
+ }
+ }
+
+ switch (max_mode)
+ {
+
+ case MaximizeVertical:
+ {
+ if( old_mode & MaximizeHorizontal ) // actually restoring from MaximizeFull
+ {
+ if( geom_restore.width() == 0 )
+ { // needs placement
+ plainResize( adjustedSize(TQSize(width(), clientArea.height()), SizemodeFixedH ));
+ workspace()->placeSmart( this, clientArea );
+ }
+ else
+ setGeometry( TQRect(TQPoint( geom_restore.x(), clientArea.top()),
+ adjustedSize(TQSize( geom_restore.width(), clientArea.height()), SizemodeFixedH )), ForceGeometrySet);
+ }
+ else
+ setGeometry( TQRect(TQPoint(x(), clientArea.top()),
+ adjustedSize(TQSize(width(), clientArea.height()), SizemodeFixedH )), ForceGeometrySet);
+ 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(TQSize(clientArea.width(), height()), SizemodeFixedW ));
+ workspace()->placeSmart( this, clientArea );
+ }
+ else
+ setGeometry( TQRect( TQPoint(clientArea.left(), geom_restore.y()),
+ adjustedSize(TQSize(clientArea.width(), geom_restore.height()), SizemodeFixedW )), ForceGeometrySet);
+ }
+ else
+ setGeometry( TQRect( TQPoint(clientArea.left(), y()),
+ adjustedSize(TQSize(clientArea.width(), height()), SizemodeFixedW )), ForceGeometrySet);
+ info->setState( NET::MaxHoriz, NET::Max );
+ break;
+ }
+
+ case MaximizeRestore:
+ {
+ TQRect restore = geometry();
+ // when only partially maximized, geom_restore may not have the other dimension remembered
+ if( old_mode & MaximizeVertical )
+ {
+ restore.setTop( geom_restore.top());
+ restore.setBottom( geom_restore.bottom());
+ }
+ if( old_mode & MaximizeHorizontal )
+ {
+ restore.setLeft( geom_restore.left());
+ restore.setRight( geom_restore.right());
+ }
+ if( !restore.isValid())
+ {
+ TQSize s = TQSize( 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, clientArea );
+ restore = geometry();
+ if( geom_restore.width() > 0 )
+ restore.moveLeft( geom_restore.x());
+ if( geom_restore.height() > 0 )
+ restore.moveTop( geom_restore.y());
+ }
+ setGeometry( restore, ForceGeometrySet );
+ info->setState( 0, NET::Max );
+ break;
+ }
+
+ case MaximizeFull:
+ {
+ if( !adjust )
+ {
+ if( old_mode & MaximizeVertical )
+ maxmode_restore = MaximizeVertical;
+ if( old_mode & MaximizeHorizontal )
+ maxmode_restore = MaximizeHorizontal;
+ }
+ TQSize adjSize = adjustedSize(clientArea.size(), SizemodeMax );
+ TQRect r = TQRect(clientArea.topLeft(), adjSize);
+ setGeometry( r, ForceGeometrySet );
+ info->setState( NET::Max, NET::Max );
+ break;
+ }
+ default:
+ break;
+ }
+
+ updateAllowedActions();
+ if( decoration != NULL )
+ decoration->maximizeChange();
+ updateWindowRules();
+ }
+
+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->borders( border_left, border_right, border_top, border_bottom );
+ if( isShade())
+ setGeometry( TQRect( pos(), sizeForClientSize( clientSize())), ForceGeometrySet );
+ else
+ setGeometry( geometry(), ForceGeometrySet );
+ if( decoration != NULL )
+ decoration->maximizeChange();
+ }
+
+void Client::checkMaximizeGeometry()
+ {
+ // when adding new bail-out conditions here, checkMaximizeGeometry() needs to be called
+ // when after the condition is no longer true
+ if( isShade())
+ return;
+ if( isMove() || isResize()) // this is because of the option to disallow moving/resizing of max-ed windows
+ return;
+ // Just in case.
+ static int recursion_protection = 0;
+ if( recursion_protection > 3 )
+ {
+ kdWarning( 1212 ) << "Check maximize overflow - you loose!" << endl;
+ kdWarning( 1212 ) << kdBacktrace() << endl;
+ return;
+ }
+ ++recursion_protection;
+ TQRect max_area = workspace()->clientArea( MaximizeArea, this );
+ if( geometry() == max_area )
+ {
+ if( max_mode != MaximizeFull )
+ maximize( MaximizeFull );
+ }
+ else if( x() == max_area.left() && width() == max_area.width())
+ {
+ if( max_mode != MaximizeHorizontal )
+ maximize( MaximizeHorizontal );
+ }
+ else if( y() == max_area.top() && height() == max_area.height())
+ {
+ if( max_mode != MaximizeVertical )
+ maximize( MaximizeVertical );
+ }
+ else if( max_mode != MaximizeRestore )
+ {
+ resetMaximize(); // not maximize( MaximizeRestore ), that'd change geometry - this is called from setGeometry()
+ }
+ --recursion_protection;
+ }
+
+bool Client::isFullScreenable( bool fullscreen_hack ) const
+ {
+ if( !rules()->checkFullScreen( true ))
+ return false;
+ if( fullscreen_hack )
+ return isNormalWindow();
+ if( rules()->checkStrictGeometry( false ))
+ {
+ // the app wouldn't fit exactly fullscreen geometry due its strict geometry requirements
+ TQRect fsarea = workspace()->clientArea( FullScreenArea, this );
+ if( sizeForClientSize( fsarea.size(), SizemodeAny, true ) != fsarea.size())
+ return false;
+ }
+ // don't check size constrains - some apps request fullscreen despite requesting fixed size
+ return !isSpecialWindow(); // also better disallow only weird types to go fullscreen
+ }
+
+bool Client::userCanSetFullScreen() const
+ {
+ if( fullscreen_mode == FullScreenHack )
+ return false;
+ if( !isFullScreenable( false ))
+ return false;
+ // isMaximizable() returns false if fullscreen
+ TemporaryAssign< FullScreenMode > tmp( fullscreen_mode, FullScreenNone );
+ return isNormalWindow() && isMaximizable();
+ }
+
+void Client::setFullScreen( bool set, bool user )
+ {
+ if( !isFullScreen() && !set )
+ return;
+ if( fullscreen_mode == FullScreenHack )
+ return;
+ if( user && !userCanSetFullScreen())
+ return;
+ set = rules()->checkFullScreen( set );
+ setShade( ShadeNone );
+ bool was_fs = isFullScreen();
+ if( !was_fs )
+ geom_fs_restore = geometry();
+ fullscreen_mode = set ? FullScreenNormal : FullScreenNone;
+ if( was_fs == isFullScreen())
+ return;
+ StackingUpdatesBlocker blocker1( workspace());
+ GeometryUpdatesPostponer blocker2( this );
+ workspace()->updateClientLayer( this ); // active fullscreens get different layer
+ info->setState( isFullScreen() ? NET::FullScreen : 0, NET::FullScreen );
+ updateDecoration( false, false );
+ if( isFullScreen())
+ setGeometry( workspace()->clientArea( FullScreenArea, this ));
+ else
+ {
+ if( !geom_fs_restore.isNull())
+ setGeometry( TQRect( geom_fs_restore.topLeft(), adjustedSize( geom_fs_restore.size())));
+ // TODO isShaded() ?
+ else
+ { // does this ever happen?
+ setGeometry( workspace()->clientArea( MaximizeArea, this ));
+ }
+ }
+ updateWindowRules();
+ }
+
+int Client::checkFullScreenHack( const TQRect& geom ) const
+ {
+ // if it's noborder window, and has size of one screen or the whole desktop geometry, it's fullscreen hack
+ if( noBorder() && !isUserNoBorder() && isFullScreenable( true ))
+ {
+ if( geom.size() == workspace()->clientArea( FullArea, geom.center(), desktop()).size())
+ return 2; // full area fullscreen hack
+ if( geom.size() == workspace()->clientArea( ScreenArea, geom.center(), desktop()).size())
+ return 1; // xinerama-aware fullscreen hack
+ }
+ return 0;
+ }
+
+void Client::updateFullScreenHack( const TQRect& geom )
+ {
+ int type = checkFullScreenHack( geom );
+ if( fullscreen_mode == FullScreenNone && type != 0 )
+ {
+ fullscreen_mode = FullScreenHack;
+ updateDecoration( false, false );
+ TQRect geom;
+ if( rules()->checkStrictGeometry( false ))
+ {
+ geom = type == 2 // 1 - it's xinerama-aware fullscreen hack, 2 - it's full area
+ ? workspace()->clientArea( FullArea, geom.center(), desktop())
+ : workspace()->clientArea( ScreenArea, geom.center(), desktop());
+ }
+ else
+ geom = workspace()->clientArea( FullScreenArea, geom.center(), desktop());
+ setGeometry( geom );
+ }
+ else if( fullscreen_mode == FullScreenHack && type == 0 )
+ {
+ fullscreen_mode = FullScreenNone;
+ updateDecoration( false, false );
+ // whoever called this must setup correct geometry
+ }
+ StackingUpdatesBlocker blocker( workspace());
+ workspace()->updateClientLayer( this ); // active fullscreens get different layer
+ }
+
+static TQRect* visible_bound = 0;
+static GeometryTip* geometryTip = 0;
+
+void Client::drawbound( const TQRect& geom )
+ {
+ assert( visible_bound == NULL );
+ visible_bound = new TQRect( 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 TQRect& geom, bool clear )
+ {
+ if( decoration != NULL && decoration->drawbound( geom, clear ))
+ return; // done by decoration
+ TQPainter p ( workspace()->desktopWidget() );
+ p.setPen( TQPen( Qt::white, 5 ) );
+ p.setRasterOp( TQt::XorROP );
+ // the line is 5 pixel thick, so compensate for the extra two pixels
+ // on outside (#88657)
+ TQRect g = geom;
+ if( g.width() > 5 )
+ {
+ g.setLeft( g.left() + 2 );
+ g.setRight( g.right() - 2 );
+ }
+ if( g.height() > 5 )
+ {
+ g.setTop( g.top() + 2 );
+ g.setBottom( g.bottom() - 2 );
+ }
+ p.drawRect( g );
+ }
+
+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() && rules()->checkMoveResizeMode( options->moveMode ) != Options::Opaque )
+ || ( isResize() && rules()->checkMoveResizeMode( options->resizeMode ) != Options::Opaque );
+ geometryTip = new GeometryTip( &xSizeHint, save_under );
+ }
+ TQRect 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( TQObject* o, TQEvent* e )
+ { return e->type() == TQEvent::Paint && TQT_BASE_OBJECT(o) != TQT_BASE_OBJECT(geometryTip); }
+ };
+
+static EatAllPaintEvents* eater = 0;
+
+bool Client::startMoveResize()
+ {
+ assert( !moveResizeMode );
+ assert( TQWidget::keyboardGrabber() == NULL );
+ assert( TQWidget::mouseGrabber() == NULL );
+ if( TQApplication::activePopupWidget() != NULL )
+ return false; // popups have grab
+ bool has_grab = false;
+ // This reportedly improves smoothness of the moveresize operation,
+ // something with Enter/LeaveNotify events, looks like XFree performance problem or something *shrug*
+ // (http://lists.kde.org/?t=107302193400001&r=1&w=2)
+ XSetWindowAttributes attrs;
+ TQRect r = workspace()->clientArea( FullArea, this );
+ move_resize_grab_window = XCreateWindow( qt_xdisplay(), workspace()->rootWin(), r.x(), r.y(),
+ r.width(), r.height(), 0, CopyFromParent, InputOnly, CopyFromParent, 0, &attrs );
+ XMapRaised( qt_xdisplay(), move_resize_grab_window );
+ if( XGrabPointer( qt_xdisplay(), move_resize_grab_window, False,
+ ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | LeaveWindowMask,
+ GrabModeAsync, GrabModeAsync, move_resize_grab_window, cursor.handle(), GET_QT_X_TIME() ) == Success )
+ has_grab = true;
+ if( XGrabKeyboard( qt_xdisplay(), frameId(), False, GrabModeAsync, GrabModeAsync, GET_QT_X_TIME() ) == Success )
+ has_grab = true;
+ if( !has_grab ) // at least one grab is necessary in order to be able to finish move/resize
+ {
+ XDestroyWindow( qt_xdisplay(), move_resize_grab_window );
+ move_resize_grab_window = None;
+ return false;
+ }
+ if ( maximizeMode() != MaximizeRestore )
+ resetMaximize();
+ removeShadow();
+ moveResizeMode = true;
+ workspace()->setClientIsMoving(this);
+ initialMoveResizeGeom = moveResizeGeom = geometry();
+ checkUnrestrictedMoveResize();
+ // rule out non opaque windows from useless translucency settings, maybe resizes?
+ if ((isResize() && options->removeShadowsOnResize) || (isMove() && options->removeShadowsOnMove))
+ setShadowSize(0);
+ if (rules()->checkMoveResizeMode( options->moveMode ) == Options::Opaque){
+ savedOpacity_ = opacity_;
+ setOpacity(options->translucentMovingWindows, options->movingWindowOpacity);
+ }
+ if ( ( isMove() && rules()->checkMoveResizeMode( options->moveMode ) != Options::Opaque )
+ || ( isResize() && rules()->checkMoveResizeMode( options->resizeMode ) != Options::Opaque ) )
+ {
+ grabXServer();
+ 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;
+// not needed anymore? 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 );
+ checkMaximizeGeometry();
+// FRAME update();
+ Notify::raise( isResize() ? Notify::ResizeEnd : Notify::MoveEnd );
+ }
+
+void Client::leaveMoveResize()
+ {
+ // rule out non opaque windows from useless translucency settings, maybe resizes?
+ if (rules()->checkMoveResizeMode( options->moveMode ) == Options::Opaque)
+ setOpacity(true, savedOpacity_);
+ if ((isResize() && options->removeShadowsOnResize) || (isMove() && options->removeShadowsOnMove))
+ updateShadowSize();
+ clearbound();
+ if (geometryTip)
+ {
+ geometryTip->hide();
+ delete geometryTip;
+ geometryTip = NULL;
+ }
+ if ( ( isMove() && rules()->checkMoveResizeMode( options->moveMode ) != Options::Opaque )
+ || ( isResize() && rules()->checkMoveResizeMode( options->resizeMode ) != Options::Opaque ) )
+ ungrabXServer();
+ XUngrabKeyboard( qt_xdisplay(), GET_QT_X_TIME() );
+ XUngrabPointer( qt_xdisplay(), GET_QT_X_TIME() );
+ XDestroyWindow( qt_xdisplay(), move_resize_grab_window );
+ move_resize_grab_window = None;
+ workspace()->setClientIsMoving(0);
+ if( move_faked_activity )
+ workspace()->unfakeActivity( this );
+ move_faked_activity = false;
+ moveResizeMode = false;
+ delete eater;
+ eater = 0;
+ if (options->shadowEnabled(isActive()))
+ {
+ drawIntersectingShadows();
+ updateOpacityCache();
+ }
+ }
+
+// This function checks if it actually makes sense to perform a restricted move/resize.
+// If e.g. the titlebar is already outside of the workarea, there's no point in performing
+// a restricted move resize, because then e.g. resize would also move the window (#74555).
+// NOTE: Most of it is duplicated from handleMoveResize().
+void Client::checkUnrestrictedMoveResize()
+ {
+ if( unrestrictedMoveResize )
+ return;
+ TQRect desktopArea = workspace()->clientArea( WorkArea, moveResizeGeom.center(), desktop());
+ int left_marge, right_marge, top_marge, bottom_marge, titlebar_marge;
+ // restricted move/resize - keep at least part of the titlebar always visible
+ // how much must remain visible when moved away in that direction
+ left_marge = KMIN( 100 + border_right, moveResizeGeom.width());
+ right_marge = KMIN( 100 + border_left, moveResizeGeom.width());
+ // width/height change with opaque resizing, use the initial ones
+ titlebar_marge = initialMoveResizeGeom.height();
+ top_marge = border_bottom;
+ bottom_marge = border_top;
+ if( isResize())
+ {
+ if( moveResizeGeom.bottom() < desktopArea.top() + top_marge )
+ unrestrictedMoveResize = true;
+ if( moveResizeGeom.top() > desktopArea.bottom() - bottom_marge )
+ unrestrictedMoveResize = true;
+ if( moveResizeGeom.right() < desktopArea.left() + left_marge )
+ unrestrictedMoveResize = true;
+ if( moveResizeGeom.left() > desktopArea.right() - right_marge )
+ unrestrictedMoveResize = true;
+ if( !unrestrictedMoveResize && moveResizeGeom.top() < desktopArea.top() ) // titlebar mustn't go out
+ unrestrictedMoveResize = true;
+ }
+ if( isMove())
+ {
+ if( moveResizeGeom.bottom() < desktopArea.top() + titlebar_marge - 1 ) // titlebar mustn't go out
+ unrestrictedMoveResize = true;
+ // no need to check top_marge, titlebar_marge already handles it
+ if( moveResizeGeom.top() > desktopArea.bottom() - bottom_marge )
+ unrestrictedMoveResize = true;
+ if( moveResizeGeom.right() < desktopArea.left() + left_marge )
+ unrestrictedMoveResize = true;
+ if( moveResizeGeom.left() > desktopArea.right() - right_marge )
+ unrestrictedMoveResize = true;
+ }
+ }
+
+void Client::handleMoveResize( int x, int y, int x_root, int y_root )
+ {
+ if(( mode == PositionCenter && !isMovable())
+ || ( mode != PositionCenter && ( isShade() || !isResizable())))
+ return;
+
+ if ( !moveResizeMode )
+ {
+ TQPoint p( TQPoint( x, y ) - moveOffset );
+ if (p.manhattanLength() >= 6)
+ {
+ if( !startMoveResize())
+ {
+ buttonDown = false;
+ setCursor( mode );
+ return;
+ }
+ }
+ else
+ return;
+ }
+
+ // ShadeHover or ShadeActive, ShadeNormal was already avoided above
+ if ( mode != PositionCenter && shade_mode != ShadeNone )
+ setShade( ShadeNone );
+
+ TQPoint globalPos( x_root, y_root );
+ // these two points limit the geometry rectangle, i.e. if bottomleft resizing is done,
+ // the bottomleft corner should be at is at (topleft.x(), bottomright().y())
+ TQPoint topleft = globalPos - moveOffset;
+ TQPoint bottomright = globalPos + invertedMoveOffset;
+ TQRect previousMoveResizeGeom = moveResizeGeom;
+
+ // TODO move whole group when moving its leader or when the leader is not mapped?
+
+ // compute bounds
+ // NOTE: This is duped in checkUnrestrictedMoveResize().
+ TQRect desktopArea = workspace()->clientArea( WorkArea, globalPos, desktop());
+ int left_marge, right_marge, top_marge, bottom_marge, titlebar_marge;
+ if( unrestrictedMoveResize ) // unrestricted, just don't let it go out completely
+ left_marge = right_marge = top_marge = bottom_marge = titlebar_marge = 5;
+ else // restricted move/resize - keep at least part of the titlebar always visible
+ {
+ // how much must remain visible when moved away in that direction
+ left_marge = KMIN( 100 + border_right, moveResizeGeom.width());
+ right_marge = KMIN( 100 + border_left, moveResizeGeom.width());
+ // width/height change with opaque resizing, use the initial ones
+ titlebar_marge = initialMoveResizeGeom.height();
+ top_marge = border_bottom;
+ bottom_marge = border_top;
+ }
+
+ bool update = false;
+ if( isResize())
+ {
+ // first resize (without checking constraints), then snap, then check bounds, then check constraints
+ TQRect orig = initialMoveResizeGeom;
+ Sizemode sizemode = SizemodeAny;
+ switch ( mode )
+ {
+ case PositionTopLeft:
+ moveResizeGeom = TQRect( topleft, orig.bottomRight() ) ;
+ break;
+ case PositionBottomRight:
+ moveResizeGeom = TQRect( orig.topLeft(), bottomright ) ;
+ break;
+ case PositionBottomLeft:
+ moveResizeGeom = TQRect( TQPoint( topleft.x(), orig.y() ), TQPoint( orig.right(), bottomright.y()) ) ;
+ break;
+ case PositionTopRight:
+ moveResizeGeom = TQRect( TQPoint( orig.x(), topleft.y() ), TQPoint( bottomright.x(), orig.bottom()) ) ;
+ break;
+ case PositionTop:
+ moveResizeGeom = TQRect( TQPoint( orig.left(), topleft.y() ), orig.bottomRight() ) ;
+ sizemode = SizemodeFixedH; // try not to affect height
+ break;
+ case PositionBottom:
+ moveResizeGeom = TQRect( orig.topLeft(), TQPoint( orig.right(), bottomright.y() ) ) ;
+ sizemode = SizemodeFixedH;
+ break;
+ case PositionLeft:
+ moveResizeGeom = TQRect( TQPoint( topleft.x(), orig.top() ), orig.bottomRight() ) ;
+ sizemode = SizemodeFixedW;
+ break;
+ case PositionRight:
+ moveResizeGeom = TQRect( orig.topLeft(), TQPoint( bottomright.x(), orig.bottom() ) ) ;
+ sizemode = SizemodeFixedW;
+ break;
+ case PositionCenter:
+ default:
+ assert( false );
+ break;
+ }
+
+ // adjust new size to snap to other windows/borders
+ moveResizeGeom = workspace()->adjustClientSize( this, moveResizeGeom, mode );
+
+ // NOTE: This is duped in checkUnrestrictedMoveResize().
+ if( moveResizeGeom.bottom() < desktopArea.top() + top_marge )
+ moveResizeGeom.setBottom( desktopArea.top() + top_marge );
+ if( moveResizeGeom.top() > desktopArea.bottom() - bottom_marge )
+ moveResizeGeom.setTop( desktopArea.bottom() - bottom_marge );
+ if( moveResizeGeom.right() < desktopArea.left() + left_marge )
+ moveResizeGeom.setRight( desktopArea.left() + left_marge );
+ if( moveResizeGeom.left() > desktopArea.right() - right_marge )
+ moveResizeGeom.setLeft(desktopArea.right() - right_marge );
+ if( !unrestrictedMoveResize && moveResizeGeom.top() < desktopArea.top() ) // titlebar mustn't go out
+ moveResizeGeom.setTop( desktopArea.top());
+
+ TQSize size = adjustedSize( moveResizeGeom.size(), sizemode );
+ // the new topleft and bottomright corners (after checking size constrains), if they'll be needed
+ topleft = TQPoint( moveResizeGeom.right() - size.width() + 1, moveResizeGeom.bottom() - size.height() + 1 );
+ bottomright = TQPoint( moveResizeGeom.left() + size.width() - 1, moveResizeGeom.top() + size.height() - 1 );
+ orig = moveResizeGeom;
+ switch ( mode )
+ { // these 4 corners ones are copied from above
+ case PositionTopLeft:
+ moveResizeGeom = TQRect( topleft, orig.bottomRight() ) ;
+ break;
+ case PositionBottomRight:
+ moveResizeGeom = TQRect( orig.topLeft(), bottomright ) ;
+ break;
+ case PositionBottomLeft:
+ moveResizeGeom = TQRect( TQPoint( topleft.x(), orig.y() ), TQPoint( orig.right(), bottomright.y()) ) ;
+ break;
+ case PositionTopRight:
+ moveResizeGeom = TQRect( TQPoint( orig.x(), topleft.y() ), TQPoint( bottomright.x(), orig.bottom()) ) ;
+ break;
+ // The side ones can't be copied exactly - if aspect ratios are specified, both dimensions may change.
+ // Therefore grow to the right/bottom if needed.
+ // TODO it should probably obey gravity rather than always using right/bottom ?
+ case PositionTop:
+ moveResizeGeom = TQRect( TQPoint( orig.left(), topleft.y() ), TQPoint( bottomright.x(), orig.bottom()) ) ;
+ break;
+ case PositionBottom:
+ moveResizeGeom = TQRect( orig.topLeft(), TQPoint( bottomright.x(), bottomright.y() ) ) ;
+ break;
+ case PositionLeft:
+ moveResizeGeom = TQRect( TQPoint( topleft.x(), orig.top() ), TQPoint( orig.right(), bottomright.y()));
+ break;
+ case PositionRight:
+ moveResizeGeom = TQRect( orig.topLeft(), TQPoint( bottomright.x(), bottomright.y() ) ) ;
+ break;
+ case PositionCenter:
+ default:
+ assert( false );
+ break;
+ }
+ if( moveResizeGeom.size() != previousMoveResizeGeom.size())
+ update = true;
+ }
+ else if( isMove())
+ {
+ assert( mode == PositionCenter );
+ // first move, then snap, then check bounds
+ moveResizeGeom.moveTopLeft( topleft );
+ moveResizeGeom.moveTopLeft( workspace()->adjustClientPosition( this, moveResizeGeom.topLeft() ) );
+ // NOTE: This is duped in checkUnrestrictedMoveResize().
+ if( moveResizeGeom.bottom() < desktopArea.top() + titlebar_marge - 1 ) // titlebar mustn't go out
+ moveResizeGeom.moveBottom( desktopArea.top() + titlebar_marge - 1 );
+ // no need to check top_marge, titlebar_marge already handles it
+ if( moveResizeGeom.top() > desktopArea.bottom() - bottom_marge )
+ moveResizeGeom.moveTop( desktopArea.bottom() - bottom_marge );
+ if( moveResizeGeom.right() < desktopArea.left() + left_marge )
+ moveResizeGeom.moveRight( desktopArea.left() + left_marge );
+ if( moveResizeGeom.left() > desktopArea.right() - right_marge )
+ moveResizeGeom.moveLeft(desktopArea.right() - right_marge );
+ if( moveResizeGeom.topLeft() != previousMoveResizeGeom.topLeft())
+ update = true;
+ }
+ else
+ assert( false );
+
+ if( update )
+ {
+ if( rules()->checkMoveResizeMode
+ ( isResize() ? options->resizeMode : options->moveMode ) == Options::Opaque )
+ {
+ setGeometry( moveResizeGeom );
+ positionGeometryTip();
+ }
+ else if( rules()->checkMoveResizeMode
+ ( isResize() ? options->resizeMode : options->moveMode ) == Options::Transparent )
+ {
+ clearbound(); // it's necessary to move the geometry tip when there's no outline
+ positionGeometryTip(); // shown, otherwise it would cause tqrepaint problems in case
+ drawbound( moveResizeGeom ); // they overlap; the paint event will come after this,
+ } // so the geometry tip will be painted above the outline
+ }
+ if ( isMove() )
+ workspace()->clientMoved(globalPos, GET_QT_X_TIME());
+ }
+
+
+} // namespace
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-10 09:28:53 +0000