diff options
Diffstat (limited to 'twin/placement.cpp')
| -rw-r--r-- | twin/placement.cpp | 817 |
1 files changed, 817 insertions, 0 deletions
diff --git a/twin/placement.cpp b/twin/placement.cpp new file mode 100644 index 000000000..84be2e0b8 --- /dev/null +++ b/twin/placement.cpp @@ -0,0 +1,817 @@ +/***************************************************************** + KWin - the KDE window manager + This file is part of the KDE project. + +Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org> +Copyright (C) 1997 to 2002 Cristian Tibirna <tibirna@kde.org> +Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org> + +You can Freely distribute this program under the GNU General Public +License. See the file "COPYING" for the exact licensing terms. +******************************************************************/ + +#include "placement.h" + +#include <tqrect.h> +#include <assert.h> + +#ifndef KCMRULES +#include "workspace.h" +#include "client.h" +#include "options.h" +#include "rules.h" +#endif + +namespace KWinInternal +{ + +#ifndef KCMRULES + +Placement::Placement(Workspace* w) + { + m_WorkspacePtr = w; + + reinitCascading( 0 ); + } + +/*! + Places the client \a c according to the workspace's layout policy + */ +void Placement::place(Client* c, TQRect& area ) + { + Policy policy = c->rules()->checkPlacement( Default ); + if( policy != Default ) + { + place( c, area, policy ); + return; + } + + if( c->isUtility()) + placeUtility(c, area, options->placement ); + else if( c->isDialog()) + placeDialog(c, area, options->placement ); + else if( c->isSplash()) + placeOnMainWindow( c, area ); // on mainwindow, if any, otherwise centered + else + place(c, area, options->placement); + } + +void Placement::place(Client* c, TQRect& area, Policy policy, Policy nextPlacement ) + { + if( policy == Unknown ) + policy = Default; + if( policy == Default ) + policy = options->placement; + if( policy == NoPlacement ) + return; + else if (policy == Random) + placeAtRandom(c, area, nextPlacement); + else if (policy == Cascade) + placeCascaded(c, area, nextPlacement); + else if (policy == Centered) + placeCentered(c, area, nextPlacement); + else if (policy == ZeroCornered) + placeZeroCornered(c, area, nextPlacement); + else if (policy == UnderMouse) + placeUnderMouse(c, area, nextPlacement); + else if (policy == OnMainWindow) + placeOnMainWindow(c, area, nextPlacement); + else if( policy == Maximizing ) + placeMaximizing(c, area, nextPlacement); + else + placeSmart(c, area, nextPlacement); + } + +/*! + Place the client \a c according to a simply "random" placement algorithm. + */ +void Placement::placeAtRandom(Client* c, const TQRect& area, Policy /*next*/ ) + { + const int step = 24; + static int px = step; + static int py = 2 * step; + int tx,ty; + + const TQRect maxRect = checkArea( c, area ); + + if (px < maxRect.x()) + px = maxRect.x(); + if (py < maxRect.y()) + py = maxRect.y(); + + px += step; + py += 2*step; + + if (px > maxRect.width()/2) + px = maxRect.x() + step; + if (py > maxRect.height()/2) + py = maxRect.y() + step; + tx = px; + ty = py; + if (tx + c->width() > maxRect.right()) + { + tx = maxRect.right() - c->width(); + if (tx < 0) + tx = 0; + px = maxRect.x(); + } + if (ty + c->height() > maxRect.bottom()) + { + ty = maxRect.bottom() - c->height(); + if (ty < 0) + ty = 0; + py = maxRect.y(); + } + c->move(tx, ty); + } + +/*! + Place the client \a c according to a really smart placement algorithm :-) +*/ +void Placement::placeSmart(Client* c, const TQRect& area, Policy /*next*/ ) + { + /* + * SmartPlacement by Cristian Tibirna (tibirna@kde.org) + * adapted for kwm (16-19jan98) and for twin (16Nov1999) using (with + * permission) ideas from fvwm, authored by + * Anthony Martin (amartin@engr.csulb.edu). + * Xinerama supported added by Balaji Ramani (balaji@yablibli.com) + * with ideas from xfce. + */ + + const int none = 0, h_wrong = -1, w_wrong = -2; // overlap types + long int overlap, min_overlap = 0; + int x_optimal, y_optimal; + int possible; + int desktop = c->desktop() == 0 || c->isOnAllDesktops() ? m_WorkspacePtr->currentDesktop() : c->desktop(); + + int cxl, cxr, cyt, cyb; //temp coords + int xl, xr, yt, yb; //temp coords + int basket; //temp holder + + // get the maximum allowed windows space + const TQRect maxRect = checkArea( c, area ); + int x = maxRect.left(), y = maxRect.top(); + x_optimal = x; y_optimal = y; + + //client gabarit + int ch = c->height() - 1; + int cw = c->width() - 1; + + bool first_pass = true; //CT lame flag. Don't like it. What else would do? + + //loop over possible positions + do + { + //test if enough room in x and y directions + if (y + ch > maxRect.bottom() && ch < maxRect.height()) + overlap = h_wrong; // this throws the algorithm to an exit + else if(x + cw > maxRect.right()) + overlap = w_wrong; + else + { + overlap = none; //initialize + + cxl = x; cxr = x + cw; + cyt = y; cyb = y + ch; + ClientList::ConstIterator l; + for(l = m_WorkspacePtr->stackingOrder().begin(); l != m_WorkspacePtr->stackingOrder().end() ; ++l) + { + if((*l)->isOnDesktop(desktop) && + (*l)->isShown( false ) && (*l) != c) + { + + xl = (*l)->x(); yt = (*l)->y(); + xr = xl + (*l)->width(); yb = yt + (*l)->height(); + + //if windows overlap, calc the overall overlapping + if((cxl < xr) && (cxr > xl) && + (cyt < yb) && (cyb > yt)) + { + xl = QMAX(cxl, xl); xr = QMIN(cxr, xr); + yt = QMAX(cyt, yt); yb = QMIN(cyb, yb); + if((*l)->keepAbove()) + overlap += 16 * (xr - xl) * (yb - yt); + else if((*l)->keepBelow() && !(*l)->isDock()) // ignore KeepBelow windows + overlap += 0; // for placement (see Client::belongsToLayer() for Dock) + else + overlap += (xr - xl) * (yb - yt); + } + } + } + } + + //CT first time we get no overlap we stop. + if (overlap == none) + { + x_optimal = x; + y_optimal = y; + break; + } + + if (first_pass) + { + first_pass = false; + min_overlap = overlap; + } + //CT save the best position and the minimum overlap up to now + else if (overlap >= none && overlap < min_overlap) + { + min_overlap = overlap; + x_optimal = x; + y_optimal = y; + } + + // really need to loop? test if there's any overlap + if (overlap > none) + { + + possible = maxRect.right(); + if (possible - cw > x) possible -= cw; + + // compare to the position of each client on the same desk + ClientList::ConstIterator l; + for(l = m_WorkspacePtr->stackingOrder().begin(); l != m_WorkspacePtr->stackingOrder().end() ; ++l) + { + + if ((*l)->isOnDesktop(desktop) && + (*l)->isShown( false ) && (*l) != c) + { + + xl = (*l)->x(); yt = (*l)->y(); + xr = xl + (*l)->width(); yb = yt + (*l)->height(); + + // if not enough room above or under the current tested client + // determine the first non-overlapped x position + if((y < yb) && (yt < ch + y)) + { + + if((xr > x) && (possible > xr)) possible = xr; + + basket = xl - cw; + if((basket > x) && (possible > basket)) possible = basket; + } + } + } + x = possible; + } + + // ... else ==> not enough x dimension (overlap was wrong on horizontal) + else if (overlap == w_wrong) + { + x = maxRect.left(); + possible = maxRect.bottom(); + + if (possible - ch > y) possible -= ch; + + //test the position of each window on the desk + ClientList::ConstIterator l; + for(l = m_WorkspacePtr->stackingOrder().begin(); l != m_WorkspacePtr->stackingOrder().end() ; ++l) + { + if((*l)->isOnDesktop(desktop) && + (*l) != c && c->isShown( false )) + { + + xl = (*l)->x(); yt = (*l)->y(); + xr = xl + (*l)->width(); yb = yt + (*l)->height(); + + // if not enough room to the left or right of the current tested client + // determine the first non-overlapped y position + if((yb > y) && (possible > yb)) possible = yb; + + basket = yt - ch; + if((basket > y) && (possible > basket)) possible = basket; + } + } + y = possible; + } + } + while((overlap != none) && (overlap != h_wrong) && (y < maxRect.bottom())); + + if(ch>= maxRect.height()) + y_optimal=maxRect.top(); + + // place the window + c->move(x_optimal, y_optimal); + + } + +void Placement::reinitCascading( int desktop ) + { // desktop == 0 - reinit all + if( desktop == 0 ) + { + cci.clear(); + for( int i = 0; i < m_WorkspacePtr->numberOfDesktops(); i++) + { + DesktopCascadingInfo inf; + inf.pos = TQPoint(-1,-1); + inf.col = 0; + inf.row = 0; + cci.append(inf); + } + } + else + { + cci[desktop - 1].pos = TQPoint(-1, -1); + cci[desktop - 1].col = cci[desktop - 1].row = 0; + } + } + +/*! + Place windows in a cascading order, remembering positions for each desktop +*/ +void Placement::placeCascaded (Client* c, TQRect& area, Policy nextPlacement) + { + /* cascadePlacement by Cristian Tibirna (tibirna@kde.org) (30Jan98) + */ + // work coords + int xp, yp; + + //CT how do I get from the 'Client' class the size that NW squarish "handle" + const int delta_x = 24; + const int delta_y = 24; + + const int dn = c->desktop() == 0 || c->isOnAllDesktops() ? (m_WorkspacePtr->currentDesktop() - 1) : (c->desktop() - 1); + + // get the maximum allowed windows space and desk's origin + TQRect maxRect = checkArea( c, area ); + + // initialize often used vars: width and height of c; we gain speed + const int ch = c->height(); + const int cw = c->width(); + const int X = maxRect.left(); + const int Y = maxRect.top(); + const int H = maxRect.height(); + const int W = maxRect.width(); + + if( nextPlacement == Unknown ) + nextPlacement = Smart; + + //initialize if needed + if (cci[dn].pos.x() < 0 || cci[dn].pos.x() < X || cci[dn].pos.y() < Y ) + { + cci[dn].pos = TQPoint(X, Y); + cci[dn].col = cci[dn].row = 0; + } + + + xp = cci[dn].pos.x(); + yp = cci[dn].pos.y(); + + //here to touch in case people vote for resize on placement + if ((yp + ch) > H) yp = Y; + + if ((xp + cw) > W) + if (!yp) + { + place(c,area,nextPlacement); + return; + } + else xp = X; + + //if this isn't the first window + if (cci[dn].pos.x() != X && cci[dn].pos.y() != Y) + { + /* The following statements cause an internal compiler error with + * egcs-2.91.66 on SuSE Linux 6.3. The equivalent forms compile fine. + * 22-Dec-1999 CS + * + * if (xp != X && yp == Y) xp = delta_x * (++(cci[dn].col)); + * if (yp != Y && xp == X) yp = delta_y * (++(cci[dn].row)); + */ + if (xp != X && yp == Y) + { + ++(cci[dn].col); + xp = delta_x * cci[dn].col; + } + if (yp != Y && xp == X) + { + ++(cci[dn].row); + yp = delta_y * cci[dn].row; + } + + // last resort: if still doesn't fit, smart place it + if (((xp + cw) > W - X) || ((yp + ch) > H - Y)) + { + place(c,area,nextPlacement); + return; + } + } + + // place the window + c->move(TQPoint(xp, yp)); + + // new position + cci[dn].pos = TQPoint(xp + delta_x, yp + delta_y); + } + +/*! + Place windows centered, on top of all others +*/ +void Placement::placeCentered (Client* c, const TQRect& area, Policy /*next*/ ) + { + + // get the maximum allowed windows space and desk's origin + const TQRect maxRect = checkArea( c, area ); + + const int xp = maxRect.left() + (maxRect.width() - c->width()) / 2; + const int yp = maxRect.top() + (maxRect.height() - c->height()) / 2; + + // place the window + c->move(TQPoint(xp, yp)); + } + +/*! + Place windows in the (0,0) corner, on top of all others +*/ +void Placement::placeZeroCornered(Client* c, const TQRect& area, Policy /*next*/ ) + { + // get the maximum allowed windows space and desk's origin + const TQRect maxRect = checkArea( c, area ); + + // place the window + c->move(TQPoint(maxRect.left(), maxRect.top())); + } + +void Placement::placeUtility(Client* c, TQRect& area, Policy /*next*/ ) + { +// TODO twin should try to place utility windows next to their mainwindow, +// preferably at the right edge, and going down if there are more of them +// if there's not enough place outside the mainwindow, it should prefer +// top-right corner + // use the default placement for now + place( c, area, Default ); + } + + +void Placement::placeDialog(Client* c, TQRect& area, Policy nextPlacement ) + { + placeOnMainWindow( c, area, nextPlacement ); + } + +void Placement::placeUnderMouse(Client* c, TQRect& area, Policy /*next*/ ) + { + area = checkArea( c, area ); + TQRect geom = c->geometry(); + geom.moveCenter( TQCursor::pos()); + c->move( geom.topLeft()); + c->keepInArea( area ); // make sure it's kept inside workarea + } + +void Placement::placeOnMainWindow(Client* c, TQRect& area, Policy nextPlacement ) + { + if( nextPlacement == Unknown ) + nextPlacement = Centered; + if( nextPlacement == Maximizing ) // maximize if needed + placeMaximizing( c, area, NoPlacement ); + area = checkArea( c, area ); + ClientList mainwindows = c->mainClients(); + Client* place_on = NULL; + Client* place_on2 = NULL; + int mains_count = 0; + for( ClientList::ConstIterator it = mainwindows.begin(); + it != mainwindows.end(); + ++it ) + { + if( mainwindows.count() > 1 && (*it)->isSpecialWindow()) + continue; // don't consider toolbars etc when placing + ++mains_count; + place_on2 = *it; + if( (*it)->isOnCurrentDesktop()) + { + if( place_on == NULL ) + place_on = *it; + else + { // two or more on current desktop -> center + // That's the default at least. However, with maximizing placement + // policy as the default, the dialog should be either maximized or + // made as large as its maximum size and then placed centered. + // So the nextPlacement argument allows chaining. In this case, nextPlacement + // is Maximizing and it will call placeCentered(). + place( c, area, Centered ); + return; + } + } + } + if( place_on == NULL ) + { // 'mains_count' is used because it doesn't include ignored mainwindows + if( mains_count != 1 ) + { + place( c, area, Centered ); + return; + } + place_on = place_on2; // use the only window filtered together with 'mains_count' + } + if( place_on->isDesktop()) + { + place( c, area, Centered ); + return; + } + TQRect geom = c->geometry(); + geom.moveCenter( place_on->geometry().center()); + c->move( geom.topLeft()); + // get area again, because the mainwindow may be on different xinerama screen + area = checkArea( c, TQRect()); + c->keepInArea( area ); // make sure it's kept inside workarea + } + +void Placement::placeMaximizing(Client* c, TQRect& area, Policy nextPlacement ) + { + if( nextPlacement == Unknown ) + nextPlacement = Smart; + if( c->isMaximizable() && c->maxSize().width() >= area.width() && c->maxSize().height() >= area.height()) + { + if( m_WorkspacePtr->clientArea( MaximizeArea, c ) == area ) + c->maximize( Client::MaximizeFull ); + else // if the geometry doesn't match default maximize area (xinerama case?), + { // it's probably better to use the given area + c->setGeometry( area ); + } + } + else + { + c->resizeWithChecks( c->maxSize().boundedTo( area.size())); + place( c, area, nextPlacement ); + } + } + +TQRect Placement::checkArea( const Client* c, const TQRect& area ) + { + if( area.isNull()) + return m_WorkspacePtr->clientArea( PlacementArea, c->geometry().center(), c->desktop()); + return area; + } + +#endif + + +Placement::Policy Placement::policyFromString( const TQString& policy, bool no_special ) + { + if( policy == "NoPlacement" ) + return NoPlacement; + else if( policy == "Default" && !no_special ) + return Default; + else if( policy == "Random" ) + return Random; + else if( policy == "Cascade" ) + return Cascade; + else if( policy == "Centered" ) + return Centered; + else if( policy == "ZeroCornered" ) + return ZeroCornered; + else if( policy == "UnderMouse" && !no_special) + return UnderMouse; + else if( policy == "OnMainWindow" && !no_special) + return OnMainWindow; + else if( policy == "Maximizing" ) + return Maximizing; + else + return Smart; + } + +const char* Placement::policyToString( Policy policy ) + { + const char* const policies[] = + { "NoPlacement", "Default", "XXX should never see", "Random", "Smart", "Cascade", "Centered", + "ZeroCornered", "UnderMouse", "OnMainWindow", "Maximizing" }; + assert( policy < int( sizeof( policies ) / sizeof( policies[ 0 ] ))); + return policies[ policy ]; + } + + +#ifndef KCMRULES + +// ******************** +// Workspace +// ******************** + +/*! + Moves active window left until in bumps into another window or workarea edge. + */ +void Workspace::slotWindowPackLeft() + { + if( active_client && active_client->isMovable()) + active_client->move( packPositionLeft( active_client, active_client->geometry().left(), true ), + active_client->y()); + } + +void Workspace::slotWindowPackRight() + { + if( active_client && active_client->isMovable()) + active_client->move( + packPositionRight( active_client, active_client->geometry().right(), true ) + - active_client->width() + 1, active_client->y()); + } + +void Workspace::slotWindowPackUp() + { + if( active_client && active_client->isMovable()) + active_client->move( active_client->x(), + packPositionUp( active_client, active_client->geometry().top(), true )); + } + +void Workspace::slotWindowPackDown() + { + if( active_client && active_client->isMovable()) + active_client->move( active_client->x(), + packPositionDown( active_client, active_client->geometry().bottom(), true ) - active_client->height() + 1 ); + } + +void Workspace::slotWindowGrowHorizontal() + { + if( active_client ) + active_client->growHorizontal(); + } + +void Client::growHorizontal() + { + if( !isResizable() || isShade()) + return; + TQRect geom = geometry(); + geom.setRight( workspace()->packPositionRight( this, geom.right(), true )); + TQSize adjsize = adjustedSize( geom.size(), SizemodeFixedW ); + if( geometry().size() == adjsize && geom.size() != adjsize && xSizeHint.width_inc > 1 ) // take care of size increments + { + int newright = workspace()->packPositionRight( this, geom.right() + xSizeHint.width_inc - 1, true ); + // check that it hasn't grown outside of the area, due to size increments + // TODO this may be wrong? + if( workspace()->clientArea( MovementArea, + TQPoint(( x() + newright ) / 2, geometry().center().y()), desktop()).right() >= newright ) + geom.setRight( newright ); + } + geom.setSize( adjustedSize( geom.size(), SizemodeFixedW )); + setGeometry( geom ); + } + +void Workspace::slotWindowShrinkHorizontal() + { + if( active_client ) + active_client->shrinkHorizontal(); + } + +void Client::shrinkHorizontal() + { + if( !isResizable() || isShade()) + return; + TQRect geom = geometry(); + geom.setRight( workspace()->packPositionLeft( this, geom.right(), false )); + if( geom.width() <= 1 ) + return; + geom.setSize( adjustedSize( geom.size(), SizemodeFixedW )); + if( geom.width() > 20 ) + setGeometry( geom ); + } + +void Workspace::slotWindowGrowVertical() + { + if( active_client ) + active_client->growVertical(); + } + +void Client::growVertical() + { + if( !isResizable() || isShade()) + return; + TQRect geom = geometry(); + geom.setBottom( workspace()->packPositionDown( this, geom.bottom(), true )); + TQSize adjsize = adjustedSize( geom.size(), SizemodeFixedH ); + if( geometry().size() == adjsize && geom.size() != adjsize && xSizeHint.height_inc > 1 ) // take care of size increments + { + int newbottom = workspace()->packPositionDown( this, geom.bottom() + xSizeHint.height_inc - 1, true ); + // check that it hasn't grown outside of the area, due to size increments + if( workspace()->clientArea( MovementArea, + TQPoint( geometry().center().x(), ( y() + newbottom ) / 2 ), desktop()).bottom() >= newbottom ) + geom.setBottom( newbottom ); + } + geom.setSize( adjustedSize( geom.size(), SizemodeFixedH )); + setGeometry( geom ); + } + + +void Workspace::slotWindowShrinkVertical() + { + if( active_client ) + active_client->shrinkVertical(); + } + +void Client::shrinkVertical() + { + if( !isResizable() || isShade()) + return; + TQRect geom = geometry(); + geom.setBottom( workspace()->packPositionUp( this, geom.bottom(), false )); + if( geom.height() <= 1 ) + return; + geom.setSize( adjustedSize( geom.size(), SizemodeFixedH )); + if( geom.height() > 20 ) + setGeometry( geom ); + } + +int Workspace::packPositionLeft( const Client* cl, int oldx, bool left_edge ) const + { + int newx = clientArea( MovementArea, cl ).left(); + if( oldx <= newx ) // try another Xinerama screen + newx = clientArea( MovementArea, + TQPoint( cl->geometry().left() - 1, cl->geometry().center().y()), cl->desktop()).left(); + if( oldx <= newx ) + return oldx; + for( ClientList::ConstIterator it = clients.begin(); + it != clients.end(); + ++it) + { + if( !(*it)->isShown( false ) || !(*it)->isOnDesktop( active_client->desktop())) + continue; + int x = left_edge ? (*it)->geometry().right() + 1 : (*it)->geometry().left() - 1; + if( x > newx && x < oldx + && !( cl->geometry().top() > (*it)->geometry().bottom() // they overlap in Y direction + || cl->geometry().bottom() < (*it)->geometry().top())) + newx = x; + } + return newx; + } + +int Workspace::packPositionRight( const Client* cl, int oldx, bool right_edge ) const + { + int newx = clientArea( MovementArea, cl ).right(); + if( oldx >= newx ) // try another Xinerama screen + newx = clientArea( MovementArea, + TQPoint( cl->geometry().right() + 1, cl->geometry().center().y()), cl->desktop()).right(); + if( oldx >= newx ) + return oldx; + for( ClientList::ConstIterator it = clients.begin(); + it != clients.end(); + ++it) + { + if( !(*it)->isShown( false ) || !(*it)->isOnDesktop( cl->desktop())) + continue; + int x = right_edge ? (*it)->geometry().left() - 1 : (*it)->geometry().right() + 1; + if( x < newx && x > oldx + && !( cl->geometry().top() > (*it)->geometry().bottom() + || cl->geometry().bottom() < (*it)->geometry().top())) + newx = x; + } + return newx; + } + +int Workspace::packPositionUp( const Client* cl, int oldy, bool top_edge ) const + { + int newy = clientArea( MovementArea, cl ).top(); + if( oldy <= newy ) // try another Xinerama screen + newy = clientArea( MovementArea, + TQPoint( cl->geometry().center().x(), cl->geometry().top() - 1 ), cl->desktop()).top(); + if( oldy <= newy ) + return oldy; + for( ClientList::ConstIterator it = clients.begin(); + it != clients.end(); + ++it) + { + if( !(*it)->isShown( false ) || !(*it)->isOnDesktop( cl->desktop())) + continue; + int y = top_edge ? (*it)->geometry().bottom() + 1 : (*it)->geometry().top() - 1; + if( y > newy && y < oldy + && !( cl->geometry().left() > (*it)->geometry().right() // they overlap in X direction + || cl->geometry().right() < (*it)->geometry().left())) + newy = y; + } + return newy; + } + +int Workspace::packPositionDown( const Client* cl, int oldy, bool bottom_edge ) const + { + int newy = clientArea( MovementArea, cl ).bottom(); + if( oldy >= newy ) // try another Xinerama screen + newy = clientArea( MovementArea, + TQPoint( cl->geometry().center().x(), cl->geometry().bottom() + 1 ), cl->desktop()).bottom(); + if( oldy >= newy ) + return oldy; + for( ClientList::ConstIterator it = clients.begin(); + it != clients.end(); + ++it) + { + if( !(*it)->isShown( false ) || !(*it)->isOnDesktop( cl->desktop())) + continue; + int y = bottom_edge ? (*it)->geometry().top() - 1 : (*it)->geometry().bottom() + 1; + if( y < newy && y > oldy + && !( cl->geometry().left() > (*it)->geometry().right() + || cl->geometry().right() < (*it)->geometry().left())) + newy = y; + } + return newy; + } + +/*! + Asks the internal positioning object to place a client +*/ +void Workspace::place(Client* c, TQRect& area) + { + initPositioning->place( c, area ); + } + +void Workspace::placeSmart(Client* c, const TQRect& area) + { + initPositioning->placeSmart( c, area ); + } + +#endif + +} // namespace |