/****************************************************************************
**
** Implementation of the TQWorkspace class
**
** Created : 931107
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of the workspace module of the TQt GUI Toolkit.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
** Software Foundation and appearing in the files LICENSE.GPL2
** and LICENSE.GPL3 included in the packaging of this file.
** Alternatively you may (at your option) use any later version
** of the GNU General Public License if such license has been
** publicly approved by Trolltech ASA (or its successors, if any)
** and the KDE Free TQt Foundation.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** This file may be used under the terms of the Q Public License as
** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
** included in the packaging of this file. Licensees holding valid TQt
** Commercial licenses may use this file in accordance with the TQt
** Commercial License Agreement provided with the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/
#include "ntqworkspace.h"
#ifndef QT_NO_WORKSPACE
#include "ntqapplication.h"
#include "../widgets/qtitlebar_p.h"
#include "ntqobjectlist.h"
#include "ntqlayout.h"
#include "ntqtoolbutton.h"
#include "ntqlabel.h"
#include "ntqvbox.h"
#include "ntqaccel.h"
#include "ntqcursor.h"
#include "ntqpopupmenu.h"
#include "ntqmenubar.h"
#include "ntqguardedptr.h"
#include "ntqiconset.h"
#include "../widgets/qwidgetresizehandler_p.h"
#include "ntqfocusdata.h"
#include "ntqdatetime.h"
#include "ntqtooltip.h"
#include "ntqwmatrix.h"
#include "ntqimage.h"
#include "ntqscrollbar.h"
#include "ntqstyle.h"
#include "ntqbitmap.h"
// magic non-mdi things
#include "ntqtimer.h"
#include "ntqdockarea.h"
#include "ntqstatusbar.h"
#include "ntqmainwindow.h"
#include "ntqdockwindow.h"
#include "ntqtoolbar.h"
#define BUTTON_WIDTH 16
#define BUTTON_HEIGHT 14
/*!
\class TQWorkspace ntqworkspace.h
\brief The TQWorkspace widget provides a workspace window that can
contain decorated windows, e.g. for MDI.
\module workspace
\ingroup application
\ingroup organizers
\mainclass
MDI (multiple document interface) applications typically have one
main window with a menu bar and toolbar, and a central widget that
is a TQWorkspace. The workspace itself contains zero, one or more
document windows, each of which is a widget.
The workspace itself is an ordinary TQt widget. It has a standard
constructor that takes a parent widget and an object name. The
parent window is usually a TQMainWindow, but it need not be.
Document windows (i.e. MDI windows) are also ordinary TQt widgets
which have the workspace as their parent widget. When you call
show(), hide(), showMaximized(), setCaption(), etc. on a document
window, it is shown, hidden, etc. with a frame, caption, icon and
icon text, just as you'd expect. You can provide widget flags
which will be used for the layout of the decoration or the
behaviour of the widget itself.
To change or retrieve the geometry of MDI windows you must operate
on the MDI widget's parentWidget(). (The parentWidget() provides
access to the decorated window in which the MDI window's widget is
shown.)
A document window becomes active when it gets the keyboard focus.
You can also activate a window in code using setFocus(). The user
can activate a window by moving focus in the usual ways, for
example by clicking a window or by pressing Tab. The workspace
emits a signal windowActivated() when it detects the activation
change, and the function activeWindow() always returns a pointer
to the active document window.
The convenience function windowList() returns a list of all
document windows. This is useful to create a popup menu
"Windows" on the fly, for example.
TQWorkspace provides two built-in layout strategies for child
windows: cascade() and tile(). Both are slots so you can easily
connect menu entries to them.
If you want your users to be able to work with document windows
larger than the actual workspace, set the scrollBarsEnabled
property to TRUE.
If the top-level window contains a menu bar and a document window
is maximised, TQWorkspace moves the document window's minimize,
restore and close buttons from the document window's frame to the
workspace window's menu bar. It then inserts a window operations
menu at the far left of the menu bar.
*/
static bool inCaptionChange = FALSE;
class TQWorkspaceChild : public TQFrame
{
TQ_OBJECT
friend class TQWorkspace;
friend class TQTitleBar;
public:
TQWorkspaceChild( TQWidget* window,
TQWorkspace* parent=0, const char* name=0 );
~TQWorkspaceChild();
void setActive( bool );
bool isActive() const;
void adjustToFullscreen();
void setStatusBar(TQStatusBar *);
TQWidget* windowWidget() const;
TQWidget* iconWidget() const;
void doResize();
void doMove();
TQSize sizeHint() const;
TQSize minimumSizeHint() const;
TQSize baseSize() const;
signals:
void showOperationMenu();
void popupOperationMenu( const TQPoint& );
public slots:
void activate();
void showMinimized();
void showMaximized();
void showNormal();
void showShaded();
void setCaption( const TQString& );
void internalRaise();
void titleBarDoubleClicked();
void move( int x, int y );
protected:
bool event(TQEvent * );
void enterEvent( TQEvent * );
void leaveEvent( TQEvent * );
void childEvent( TQChildEvent* );
void resizeEvent( TQResizeEvent * );
void moveEvent( TQMoveEvent * );
bool eventFilter( TQObject *, TQEvent * );
bool focusNextPrevChild( bool );
void drawFrame( TQPainter * );
void styleChange( TQStyle & );
private:
TQWidget* childWidget;
TQGuardedPtr lastfocusw;
TQWidgetResizeHandler *widgetResizeHandler;
TQTitleBar* titlebar;
TQGuardedPtr statusbar;
TQGuardedPtr iconw;
TQSize windowSize;
TQSize shadeRestore;
TQSize shadeRestoreMin;
bool act :1;
bool shademode :1;
bool snappedRight :1;
bool snappedDown :1;
#if defined(TQ_DISABLE_COPY) // Disabled copy constructor and operator=
TQWorkspaceChild( const TQWorkspaceChild & );
TQWorkspaceChild &operator=( const TQWorkspaceChild & );
#endif
};
class TQMainWindow;
class TQWorkspacePrivate {
public:
TQWorkspaceChild* active;
TQPtrList windows;
TQPtrList focus;
TQPtrList icons;
TQWorkspaceChild* maxWindow;
TQRect maxRestore;
TQGuardedPtr maxcontrols;
TQGuardedPtr maxmenubar;
int px;
int py;
TQWidget *becomeActive;
TQGuardedPtr maxtools;
TQPopupMenu* popup;
TQPopupMenu* toolPopup;
int menuId;
int controlId;
TQString topCaption;
TQScrollBar *vbar, *hbar;
TQWidget *corner;
int yoffset, xoffset;
// toplevel mdi fu
TQWorkspace::WindowMode wmode;
TQGuardedPtr mainwindow;
TQPtrList dockwindows, newdocks;
};
static bool isChildOf( TQWidget * child, TQWidget * parent )
{
if ( !parent || !child )
return FALSE;
TQWidget * w = child;
while( w && w != parent )
w = w->parentWidget();
return w != 0;
}
/*!
Constructs a workspace with a \a parent and a \a name.
*/
TQWorkspace::TQWorkspace( TQWidget *parent, const char *name )
: TQWidget( parent, name )
{
init();
}
#ifdef QT_WORKSPACE_WINDOWMODE
/*!
Constructs a workspace with a \a parent and a \a name. This
constructor will also set the WindowMode to \a mode.
\sa windowMode()
*/
TQWorkspace::TQWorkspace( TQWorkspace::WindowMode mode, TQWidget *parent, const char *name )
: TQWidget( parent, name )
{
init();
d->wmode = mode;
}
#endif
/*!
\internal
*/
void
TQWorkspace::init()
{
d = new TQWorkspacePrivate;
d->maxcontrols = 0;
d->active = 0;
d->maxWindow = 0;
d->maxtools = 0;
d->px = 0;
d->py = 0;
d->becomeActive = 0;
#if defined( QT_WORKSPACE_WINDOWMODE ) && defined( Q_WS_MAC )
d->wmode = AutoDetect;
#else
d->wmode = MDI;
#endif
d->mainwindow = 0;
#if defined(Q_WS_WIN)
d->popup = new TQPopupMenu( this, "qt_internal_mdi_popup" );
d->toolPopup = new TQPopupMenu( this, "qt_internal_mdi_popup" );
#else
d->popup = new TQPopupMenu( parentWidget(), "qt_internal_mdi_popup" );
d->toolPopup = new TQPopupMenu( parentWidget(), "qt_internal_mdi_popup" );
#endif
d->menuId = -1;
d->controlId = -1;
connect( d->popup, SIGNAL( aboutToShow() ), this, SLOT(operationMenuAboutToShow() ));
connect( d->popup, SIGNAL( activated(int) ), this, SLOT( operationMenuActivated(int) ) );
d->popup->insertItem(TQIconSet(style().stylePixmap(TQStyle::SP_TitleBarNormalButton)), tr("&Restore"), 1);
d->popup->insertItem(tr("&Move"), 2);
d->popup->insertItem(tr("&Size"), 3);
d->popup->insertItem(TQIconSet(style().stylePixmap(TQStyle::SP_TitleBarMinButton)), tr("Mi&nimize"), 4);
d->popup->insertItem(TQIconSet(style().stylePixmap(TQStyle::SP_TitleBarMaxButton)), tr("Ma&ximize"), 5);
d->popup->insertSeparator();
d->popup->insertItem(TQIconSet(style().stylePixmap(TQStyle::SP_TitleBarCloseButton)),
tr("&Close")
#ifndef QT_NO_ACCEL
+"\t"+TQAccel::keyToString(CTRL+Key_F4)
#endif
, this, SLOT( closeActiveWindow() ) );
connect( d->toolPopup, SIGNAL( aboutToShow() ), this, SLOT(toolMenuAboutToShow() ));
connect( d->toolPopup, SIGNAL( activated(int) ), this, SLOT( operationMenuActivated(int) ) );
d->toolPopup->insertItem(tr("&Move"), 2);
d->toolPopup->insertItem(tr("&Size"), 3);
d->toolPopup->insertItem(tr("Stay on &Top"), 7);
d->toolPopup->setItemChecked( 7, TRUE );
d->toolPopup->setCheckable( TRUE );
d->toolPopup->insertSeparator();
d->toolPopup->insertItem(TQIconSet(style().stylePixmap(TQStyle::SP_TitleBarShadeButton)), tr("Sh&ade"), 6);
d->toolPopup->insertItem(TQIconSet(style().stylePixmap(TQStyle::SP_TitleBarCloseButton)),
tr("&Close")
#ifndef QT_NO_ACCEL
+"\t"+TQAccel::keyToString( CTRL+Key_F4)
#endif
, this, SLOT( closeActiveWindow() ) );
#ifndef QT_NO_ACCEL
TQAccel* a = new TQAccel( this );
a->connectItem( a->insertItem( ALT + Key_Minus),
this, SLOT( showOperationMenu() ) );
a->connectItem( a->insertItem( CTRL + Key_F6),
this, SLOT( activateNextWindow() ) );
a->connectItem( a->insertItem( CTRL + Key_Tab),
this, SLOT( activateNextWindow() ) );
a->connectItem( a->insertItem( Key_Forward ),
this, SLOT( activateNextWindow() ) );
a->connectItem( a->insertItem( CTRL + SHIFT + Key_F6),
this, SLOT( activatePreviousWindow() ) );
a->connectItem( a->insertItem( CTRL + SHIFT + Key_Tab),
this, SLOT( activatePreviousWindow() ) );
a->connectItem( a->insertItem( Key_Back ),
this, SLOT( activatePreviousWindow() ) );
a->connectItem( a->insertItem( CTRL + Key_F4 ),
this, SLOT( closeActiveWindow() ) );
#endif
setBackgroundMode( PaletteDark );
setSizePolicy( TQSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Expanding ) );
#ifndef QT_NO_WIDGET_TOPEXTRA
d->topCaption = topLevelWidget()->caption();
#endif
d->hbar = d->vbar = 0;
d->corner = 0;
d->xoffset = d->yoffset = 0;
updateWorkspace();
topLevelWidget()->installEventFilter( this );
}
/*! Destroys the workspace and frees any allocated resources. */
TQWorkspace::~TQWorkspace()
{
delete d;
d = 0;
}
/*!\reimp */
TQSize TQWorkspace::sizeHint() const
{
TQSize s( TQApplication::desktop()->size() );
return TQSize( s.width()*2/3, s.height()*2/3);
}
/*! \reimp */
void TQWorkspace::setPaletteBackgroundColor( const TQColor & c )
{
setEraseColor( c );
}
/*! \reimp */
void TQWorkspace::setPaletteBackgroundPixmap( const TQPixmap & pm )
{
setErasePixmap( pm );
}
/*! \reimp */
void TQWorkspace::childEvent( TQChildEvent * e)
{
if (e->inserted() && e->child()->isWidgetType()) {
TQWidget* w = (TQWidget*) e->child();
if ( !w || !w->testWFlags( WStyle_Title | WStyle_NormalBorder | WStyle_DialogBorder) || w->testWFlags(WType_Dialog)
|| d->icons.contains( w ) || w == d->vbar || w == d->hbar || w == d->corner )
return; // nothing to do
bool wasMaximized = w->isMaximized();
bool wasMinimized = w->isMinimized();
bool hasBeenHidden = w->isHidden();
bool hasSize = w->testWState( WState_Resized );
int x = w->x();
int y = w->y();
bool hasPos = x != 0 || y != 0;
TQSize s = w->size().expandedTo( w->minimumSizeHint() );
if ( !hasSize && w->sizeHint().isValid() )
w->adjustSize();
TQWorkspaceChild* child = new TQWorkspaceChild( w, this, "qt_workspacechild" );
child->installEventFilter( this );
connect( child, SIGNAL( popupOperationMenu(const TQPoint&) ),
this, SLOT( popupOperationMenu(const TQPoint&) ) );
connect( child, SIGNAL( showOperationMenu() ),
this, SLOT( showOperationMenu() ) );
d->windows.append( child );
if ( child->isVisibleTo( this ) )
d->focus.append( child );
child->internalRaise();
if ( !hasPos )
place( child );
if ( hasSize )
child->resize( s + child->baseSize() );
else
child->adjustSize();
if ( hasPos )
child->move( x, y );
if ( hasBeenHidden )
w->hide();
else if ( !isVisible() ) // that's a case were we don't receive a showEvent in time. Tricky.
child->show();
if ( wasMaximized )
w->showMaximized();
else if ( wasMinimized )
w->showMinimized();
else if (!hasBeenHidden)
activateWindow( w );
updateWorkspace();
} else if (e->removed() ) {
if ( d->windows.contains( (TQWorkspaceChild*)e->child() ) ) {
d->windows.removeRef( (TQWorkspaceChild*)e->child() );
d->focus.removeRef( (TQWorkspaceChild*)e->child() );
if (d->maxWindow == e->child())
d->maxWindow = 0;
updateWorkspace();
}
}
}
/*! \reimp
*/
#ifndef QT_NO_WHEELEVENT
void TQWorkspace::wheelEvent( TQWheelEvent *e )
{
if ( !scrollBarsEnabled() )
return;
if ( d->vbar && d->vbar->isVisible() && !( e->state() & AltButton ) )
TQApplication::sendEvent( d->vbar, e );
else if ( d->hbar && d->hbar->isVisible() )
TQApplication::sendEvent( d->hbar, e );
}
#endif
void TQWorkspace::activateWindow( TQWidget* w, bool change_focus )
{
if ( !w ) {
d->active = 0;
emit windowActivated( 0 );
return;
}
if ( d->wmode == MDI && !isVisibleTo( 0 ) ) {
d->becomeActive = w;
return;
}
if ( d->active && d->active->windowWidget() == w ) {
if ( !isChildOf( focusWidget(), w ) ) // child window does not have focus
d->active->setActive( TRUE );
return;
}
d->active = 0;
// First deactivate all other workspace clients
TQPtrListIterator it( d->windows );
while ( it.current () ) {
TQWorkspaceChild* c = it.current();
++it;
if(windowMode() == TQWorkspace::TopLevel && c->isTopLevel() &&
c->windowWidget() == w && !c->isActive())
c->setActiveWindow();
if (c->windowWidget() == w)
d->active = c;
else
c->setActive( FALSE );
}
if (!d->active)
return;
// Then activate the new one, so the focus is stored correctly
d->active->setActive( TRUE );
if (!d->active)
return;
if ( d->maxWindow && d->maxWindow != d->active && d->active->windowWidget() &&
d->active->windowWidget()->testWFlags( WStyle_MinMax ) &&
!d->active->windowWidget()->testWFlags( WStyle_Tool ) ) {
d->active->showMaximized();
if ( d->maxtools ) {
#ifndef QT_NO_WIDGET_TOPEXTRA
if ( w->icon() ) {
TQPixmap pm(*w->icon());
int iconSize = d->maxtools->size().height();
if(pm.width() > iconSize || pm.height() > iconSize) {
TQImage im;
im = pm;
pm = im.smoothScale( TQMIN(iconSize, pm.width()), TQMIN(iconSize, pm.height()) );
}
d->maxtools->setPixmap( pm );
} else
#endif
{
TQPixmap pm(14,14);
pm.fill( color1 );
pm.setMask(pm.createHeuristicMask());
d->maxtools->setPixmap( pm );
}
}
} else { // done implicitly in maximizeWindow otherwise
d->active->internalRaise();
}
if ( change_focus ) {
if ( d->focus.find( d->active ) >=0 ) {
d->focus.removeRef( d->active );
d->focus.append( d->active );
}
}
updateWorkspace();
emit windowActivated( w );
}
/*!
Returns the active window, or 0 if no window is active.
*/
TQWidget* TQWorkspace::activeWindow() const
{
return d->active?d->active->windowWidget():0;
}
void TQWorkspace::place( TQWidget* w)
{
TQPtrList widgets;
for(TQPtrListIterator it( d->windows ); it.current(); ++it)
if ((*it) != w)
widgets.append((*it));
if(d->wmode == TopLevel) {
for(TQPtrListIterator it( d->dockwindows ); it.current(); ++it)
if ((*it) != w)
widgets.append((*it));
}
int overlap, minOverlap = 0;
int possible;
TQRect r1(0, 0, 0, 0);
TQRect r2(0, 0, 0, 0);
TQRect maxRect = rect();
if(d->wmode == TopLevel) {
const TQDesktopWidget *dw = tqApp->desktop();
maxRect = dw->availableGeometry(dw->screenNumber(topLevelWidget()));
}
int x = maxRect.left(), y = maxRect.top();
TQPoint wpos(maxRect.left(), maxRect.top());
bool firstPass = TRUE;
do {
if ( y + w->height() > maxRect.bottom() ) {
overlap = -1;
} else if( x + w->width() > maxRect.right() ) {
overlap = -2;
} else {
overlap = 0;
r1.setRect(x, y, w->width(), w->height());
TQWidget *l;
TQPtrListIterator it( widgets );
while ( it.current () ) {
l = it.current();
++it;
if ( d->maxWindow == l )
r2 = d->maxRestore;
else
r2.setRect(l->x(), l->y(), l->width(), l->height());
if (r2.intersects(r1)) {
r2.setCoords(TQMAX(r1.left(), r2.left()),
TQMAX(r1.top(), r2.top()),
TQMIN(r1.right(), r2.right()),
TQMIN(r1.bottom(), r2.bottom())
);
overlap += (r2.right() - r2.left()) *
(r2.bottom() - r2.top());
}
}
}
if (overlap == 0) {
wpos = TQPoint(x, y);
break;
}
if (firstPass) {
firstPass = FALSE;
minOverlap = overlap;
} else if ( overlap >= 0 && overlap < minOverlap) {
minOverlap = overlap;
wpos = TQPoint(x, y);
}
if ( overlap > 0 ) {
possible = maxRect.right();
if ( possible - w->width() > x) possible -= w->width();
TQWidget *l;
TQPtrListIterator it( widgets );
while ( it.current () ) {
l = it.current();
++it;
if ( d->maxWindow == l )
r2 = d->maxRestore;
else
r2.setRect(l->x(), l->y(), l->width(), l->height());
if( ( y < r2.bottom() ) && ( r2.top() < w->height() + y ) ) {
if( r2.right() > x )
possible = possible < r2.right() ?
possible : r2.right();
if( r2.left() - w->width() > x )
possible = possible < r2.left() - w->width() ?
possible : r2.left() - w->width();
}
}
x = possible;
} else if ( overlap == -2 ) {
x = maxRect.left();
possible = maxRect.bottom();
if ( possible - w->height() > y ) possible -= w->height();
TQWidget *l;
TQPtrListIterator it( widgets );
while ( it.current () ) {
l = it.current();
++it;
if ( d->maxWindow == l )
r2 = d->maxRestore;
else
r2.setRect(l->x(), l->y(), l->width(), l->height());
if( r2.bottom() > y)
possible = possible < r2.bottom() ?
possible : r2.bottom();
if( r2.top() - w->height() > y )
possible = possible < r2.top() - w->height() ?
possible : r2.top() - w->height();
}
y = possible;
}
}
while( overlap != 0 && overlap != -1 );
#if 0
if(windowMode() == TQWorkspace::TopLevel && wpos.y()) {
TQPoint fr = w->topLevelWidget()->frameGeometry().topLeft(),
r = w->topLevelWidget()->geometry().topLeft();
wpos += TQPoint(r.x() - fr.x(), r.y() - fr.y());
}
#endif
w->move(wpos);
updateWorkspace();
}
void TQWorkspace::insertIcon( TQWidget* w )
{
if ( !w || d->icons.contains( w ) )
return;
d->icons.append( w );
if (w->parentWidget() != this )
w->reparent( this, 0, TQPoint(0,0), FALSE);
TQRect cr = updateWorkspace();
int x = 0;
int y = cr.height() - w->height();
TQPtrListIterator it( d->icons );
while ( it.current () ) {
TQWidget* i = it.current();
++it;
if ( x > 0 && x + i->width() > cr.width() ){
x = 0;
y -= i->height();
}
if ( i != w &&
i->geometry().intersects( TQRect( x, y, w->width(), w->height() ) ) )
x += i->width();
}
w->move( x, y );
if ( isVisibleTo( parentWidget() ) ) {
w->show();
w->lower();
}
updateWorkspace();
}
void TQWorkspace::removeIcon( TQWidget* w)
{
if ( !d->icons.contains( w ) )
return;
d->icons.remove( w );
w->hide();
}
/*! \reimp */
void TQWorkspace::resizeEvent( TQResizeEvent * )
{
if ( d->maxWindow ) {
d->maxWindow->adjustToFullscreen();
if (d->maxWindow->windowWidget())
((TQWorkspace*)d->maxWindow->windowWidget())->setWState( WState_Maximized );
}
TQRect cr = updateWorkspace();
TQPtrListIterator it( d->windows );
while ( it.current () ) {
TQWorkspaceChild* c = it.current();
++it;
if ( c->windowWidget() && !c->windowWidget()->testWFlags( WStyle_Tool ) )
continue;
int x = c->x();
int y = c->y();
if ( c->snappedDown )
y = cr.height() - c->height();
if ( c->snappedRight )
x = cr.width() - c->width();
if ( x != c->x() || y != c->y() )
c->move( x, y );
}
}
void TQWorkspace::handleUndock(TQDockWindow *w)
{
const TQDesktopWidget *dw = tqApp->desktop();
TQRect maxRect = dw->availableGeometry(dw->screenNumber(d->mainwindow));
TQPoint wpos(maxRect.left(), maxRect.top());
int possible = 0;
if(!::tqt_cast(w)) {
struct place_score { int o, x, y; } score = {0, 0, 0};
int left = 1, x = wpos.x(), y = wpos.y();
TQPtrListIterator it( d->dockwindows );
while(1) {
if(y + w->height() > maxRect.bottom()) {
if(left) {
x = maxRect.right() - w->width();
y = maxRect.top();
left = 0;
} else {
break;
}
}
TQDockWindow *l, *nearest = NULL, *furthest;
for ( it.toFirst(); it.current(); ++it ) {
l = it.current();
if ( l != w && y == l->y() ) {
if(!nearest) {
nearest = l;
} else if(l->x() == x) {
nearest = l;
break;
} else if(left && (l->x() - x) < (nearest->x() - x)) {
nearest = l;
} else if(!left && (x - l->x()) < (x - nearest->x())) {
nearest = l;
}
}
}
TQRect r2(x, y, w->width(), w->height());
if(!nearest || !nearest->geometry().intersects(r2)) {
wpos = TQPoint(x, y); //best possible outcome
possible = 2;
break;
}
TQDockWindow *o = NULL;
int overlap = 0;
for( it.toFirst(); it.current(); ++it ) {
l = it.current();
if ( l != w && l->geometry().intersects(TQRect(TQPoint(x, y), w->size()))) {
overlap++;
o = l;
}
}
if(o && overlap == 1 && w->isVisible() && !o->isVisible()) {
wpos = TQPoint(x, y);
possible = 2;
while(d->dockwindows.remove(o));
d->newdocks.append(o);
if(d->newdocks.count() == 1)
TQTimer::singleShot(0, this, SLOT(dockWindowsShow()));
break;
}
for ( furthest = nearest, it.toFirst(); it.current(); ++it ) {
l = it.current();
if ( l != w && l->y() == nearest->y() &&
((left && (l->x() == nearest->x() + nearest->width())) ||
(!left && (l->x() + l->width() == nearest->x()) )))
furthest = l;
}
if(left)
x = furthest->x() + furthest->width();
else
x = furthest->x() - w->width();
TQPoint sc_pt(x, y);
place_score sc;
if(left)
sc.x = (x + w->width()) * 2;
else
sc.x = ((maxRect.width() - x) * 2) + 1;
sc.y = sc_pt.y();
for( sc.o = 0, it.toFirst(); it.current(); ++it ) {
l = it.current();
if ( l != w && l->geometry().intersects(TQRect(sc_pt, w->size())))
sc.o++;
}
if(maxRect.contains(TQRect(sc_pt, w->size())) &&
(!possible || (sc.o < score.o) ||
((score.o || sc.o == score.o) && score.x < sc.x))) {
wpos = sc_pt;
score = sc;
possible = 1;
}
y += nearest->height();
if(left)
x = maxRect.x();
else
x = maxRect.right() - w->width();
}
if(!possible || (possible == 1 && score.o)) { //fallback to less knowledgeable function
place(w);
wpos = w->pos();
}
}
bool ishidden = w->isHidden();
TQSize olds(w->size());
if(w->place() == TQDockWindow::InDock)
w->undock();
w->move(wpos);
w->resize(olds);
if(!ishidden)
w->show();
else
w->hide();
}
void TQWorkspace::dockWindowsShow()
{
TQPtrList lst = d->newdocks;
d->newdocks.clear();
for(TQPtrListIterator dw_it(lst); (*dw_it); ++dw_it) {
if(d->dockwindows.find((*dw_it)) != -1)
continue;
handleUndock((*dw_it));
d->dockwindows.append((*dw_it));
}
}
/*! \reimp */
void TQWorkspace::showEvent( TQShowEvent *e )
{
/* This is all magic, be carefull when playing with this code - this tries to allow people to
use TQWorkspace as a high level abstraction for window management, but removes enforcement that
TQWorkspace be used as an MDI. */
if(d->wmode == AutoDetect) {
d->wmode = MDI;
TQWidget *o = topLevelWidget();
if(::tqt_cast(o)) {
d->wmode = TopLevel;
const TQObjectList *c = o->children();
for(TQObjectListIt it(*c); it; ++it) {
if((*it)->isWidgetType() && !((TQWidget *)(*it))->isTopLevel() &&
!::tqt_cast(*it) && !::tqt_cast(*it) &&
!::tqt_cast(*it) && !(*it)->inherits("TQHideDock") &&
!::tqt_cast(*it) && !::tqt_cast(*it) &&
!::tqt_cast(*it) && !::tqt_cast(*it)) {
d->wmode = MDI;
break;
}
}
}
}
if(d->wmode == TopLevel) {
TQWidget *o = topLevelWidget();
d->mainwindow = ::tqt_cast(o);
const TQObjectList children = *o->children();
for(TQObjectListIt it(children); it; ++it) {
if(!(*it)->isWidgetType())
continue;
TQWidget *w = (TQWidget *)(*it);
if(w->isTopLevel())
continue;
if(::tqt_cast(w)) {
const TQObjectList *dock_c = w->children();
if(dock_c) {
TQPtrList tb_list;
for(TQObjectListIt dock_it(*dock_c); dock_it; ++dock_it) {
if(!(*dock_it)->isWidgetType())
continue;
if(::tqt_cast(*dock_it)) {
tb_list.append((TQToolBar *)(*dock_it));
} else if (::tqt_cast(*dock_it)) {
TQDockWindow *dw = (TQDockWindow*)(*dock_it);
dw->move(dw->mapToGlobal(TQPoint(0, 0)));
d->newdocks.append(dw);
} else {
tqDebug("not sure what to do with %s %s", (*dock_it)->className(),
(*dock_it)->name());
}
}
if(tb_list.count() == 1) {
TQToolBar *tb = tb_list.first();
tb->move(0, 0);
d->newdocks.prepend(tb);
} else if(tb_list.count()) {
TQDockWindow *dw = new TQDockWindow(TQDockWindow::OutsideDock,
w->parentWidget(),
TQString("TQMagicDock_") + w->name());
dw->installEventFilter(this);
dw->setResizeEnabled(TRUE);
dw->setCloseMode( TQDockWindow::Always );
dw->setResizeEnabled(FALSE);
#ifndef QT_NO_WIDGET_TOPEXTRA
dw->setCaption(o->caption());
#endif
TQSize os(w->size());
if(w->layout() && w->layout()->hasHeightForWidth()) {
w->layout()->invalidate();
os.setHeight(w->layout()->heightForWidth(os.width()));
}
if(!w->isHidden())
dw->show();
w->reparent(dw, TQPoint(0, 0));
dw->setWidget(w);
dw->setSizePolicy(TQSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Minimum));
dw->setGeometry(0, 0, os.width(), os.height() + dw->sizeHint().height());
d->newdocks.prepend(dw);
((TQDockArea*)w)->setAcceptDockWindow(dw, FALSE);
w->show();
}
}
w->installEventFilter(this);
} else if(::tqt_cast(w)) {
if(activeWindow()) {
TQWorkspaceChild *c;
if ( ( c = findChild(activeWindow()) ) )
c->setStatusBar((TQStatusBar*)w);
}
} else if(::tqt_cast(w)) {
w->reparent(this, w->testWFlags(~(0)) | WType_TopLevel, w->pos());
}
}
dockWindowsShow(); //now place and undock windows discovered
TQWidget *w = new TQWidget(NULL, "TQDoesNotExist",
WType_Dialog | WStyle_Customize | WStyle_NoBorder);
// if(tqApp->mainWidget() == o)
// TQObject::connect(tqApp, SIGNAL(lastWindowClosed()), tqApp, SLOT(quit()));
TQDesktopWidget *dw = TQApplication::desktop();
w->setGeometry(dw->availableGeometry(dw->screenNumber(o)));
o->reparent(w, TQPoint(0, 0), TRUE);
{
TQMenuBar *mb = 0;
if(::tqt_cast(o))
mb = ((TQMainWindow *)o)->menuBar();
if(!mb)
mb = (TQMenuBar*)o->child(NULL, "TQMenuBar");
if(mb)
mb->reparent(w, TQPoint(0, 0));
}
reparent(w, TQPoint(0,0));
setGeometry(0, 0, w->width(), w->height());
#if 0
/* Hide really isn't acceptable because I need to make the rest of TQt
think it is visible, so instead I set it to an empty mask. I'm not
sure what problems this is going to create, hopefully everything will
be happy (or not even notice since this is mostly intended for TQt/Mac) */
// w->setMask(TQRegion());
// w->show();
#else
w->hide();
#endif
}
//done with that nastiness, on with your regularly schedueled programming..
if ( d->maxWindow && !style().styleHint(TQStyle::SH_Workspace_FillSpaceOnMaximize, this))
showMaximizeControls();
TQWidget::showEvent( e );
if ( d->becomeActive ) {
activateWindow( d->becomeActive );
d->becomeActive = 0;
} else if ( d->windows.count() > 0 && !d->active ) {
activateWindow( d->windows.first()->windowWidget() );
}
// force a frame repaint - this is a workaround for what seems to be a bug
// introduced when changing the TQWidget::show() implementation. Might be
// a windows bug as well though.
for (TQPtrListIterator it( d->windows ); it.current(); ++it ) {
TQWorkspaceChild* c = it.current();
TQApplication::postEvent(c, new TQPaintEvent(c->rect(), TRUE));
}
updateWorkspace();
}
/*! \reimp */
void TQWorkspace::hideEvent( TQHideEvent * )
{
if ( !isVisibleTo(0) && !style().styleHint(TQStyle::SH_Workspace_FillSpaceOnMaximize, this))
hideMaximizeControls();
}
void TQWorkspace::minimizeWindow( TQWidget* w)
{
TQWorkspaceChild* c = findChild( w );
if ( !w || ( ( w && (!w->testWFlags( WStyle_Minimize ) ) ) || w->testWFlags( WStyle_Tool) ) )
return;
if ( c ) {
TQWorkspace *fake = (TQWorkspace*)w;
setUpdatesEnabled( FALSE );
bool wasMax = FALSE;
if ( c == d->maxWindow ) {
wasMax = TRUE;
d->maxWindow = 0;
inCaptionChange = TRUE;
#ifndef QT_NO_WIDGET_TOPEXTRA
if ( !!d->topCaption )
topLevelWidget()->setCaption( d->topCaption );
#endif
inCaptionChange = FALSE;
if ( !style().styleHint(TQStyle::SH_Workspace_FillSpaceOnMaximize, this) )
hideMaximizeControls();
for (TQPtrListIterator it( d->windows ); it.current(); ++it ) {
TQWorkspaceChild* c = it.current();
if ( c->titlebar )
c->titlebar->setMovable( TRUE );
c->widgetResizeHandler->setActive( TRUE );
}
}
insertIcon( c->iconWidget() );
c->hide();
if ( wasMax )
c->setGeometry( d->maxRestore );
d->focus.append( c );
activateWindow(w);
setUpdatesEnabled( TRUE );
updateWorkspace();
fake->clearWState( WState_Maximized );
fake->setWState( WState_Minimized );
c->clearWState( WState_Maximized );
c->setWState( WState_Minimized );
}
}
void TQWorkspace::normalizeWindow( TQWidget* w)
{
TQWorkspaceChild* c = findChild( w );
if ( !w )
return;
if ( c ) {
TQWorkspace *fake = (TQWorkspace*)w;
fake->clearWState( WState_Minimized | WState_Maximized );
if ( !style().styleHint(TQStyle::SH_Workspace_FillSpaceOnMaximize, this) && d->maxWindow ) {
hideMaximizeControls();
} else {
if ( w->minimumSize() != w->maximumSize() )
c->widgetResizeHandler->setActive( TRUE );
if ( c->titlebar )
c->titlebar->setMovable(TRUE);
}
fake->clearWState( WState_Minimized | WState_Maximized );
c->clearWState( WState_Minimized | WState_Maximized );
if ( c == d->maxWindow ) {
c->setGeometry( d->maxRestore );
d->maxWindow = 0;
#ifndef QT_NO_WIDGET_TOPEXTRA
inCaptionChange = TRUE;
if ( !!d->topCaption )
topLevelWidget()->setCaption( d->topCaption );
inCaptionChange = FALSE;
#endif
} else {
if ( c->iconw )
removeIcon( c->iconw->parentWidget() );
c->show();
}
if ( !style().styleHint(TQStyle::SH_Workspace_FillSpaceOnMaximize, this))
hideMaximizeControls();
for (TQPtrListIterator it( d->windows ); it.current(); ++it ) {
TQWorkspaceChild* c = it.current();
if ( c->titlebar )
c->titlebar->setMovable( TRUE );
if ( c->childWidget && c->childWidget->minimumSize() != c->childWidget->maximumSize() )
c->widgetResizeHandler->setActive( TRUE );
}
activateWindow( w, TRUE );
updateWorkspace();
}
}
void TQWorkspace::maximizeWindow( TQWidget* w)
{
TQWorkspaceChild* c = findChild( w );
if ( !w || ( ( w && (!w->testWFlags( WStyle_Maximize ) ) ) || w->testWFlags( WStyle_Tool) ) )
return;
if ( c ) {
setUpdatesEnabled( FALSE );
if (c->iconw && d->icons.contains( c->iconw->parentWidget() ) )
normalizeWindow( w );
TQWorkspace *fake = (TQWorkspace*)w;
TQRect r( c->geometry() );
c->adjustToFullscreen();
c->show();
c->internalRaise();
tqApp->sendPostedEvents( c, TQEvent::Resize );
tqApp->sendPostedEvents( c, TQEvent::Move );
tqApp->sendPostedEvents( c, TQEvent::ShowWindowRequest );
if ( d->maxWindow != c ) {
if ( d->maxWindow )
d->maxWindow->setGeometry( d->maxRestore );
d->maxWindow = c;
d->maxRestore = r;
}
activateWindow( w );
if(!style().styleHint(TQStyle::SH_Workspace_FillSpaceOnMaximize, this)) {
showMaximizeControls();
} else {
c->widgetResizeHandler->setActive( FALSE );
if ( c->titlebar )
c->titlebar->setMovable( FALSE );
}
#ifndef QT_NO_WIDGET_TOPEXTRA
inCaptionChange = TRUE;
if ( !!d->topCaption )
topLevelWidget()->setCaption( tr("%1 - [%2]")
.arg(d->topCaption).arg(c->caption()) );
inCaptionChange = FALSE;
#endif
setUpdatesEnabled( TRUE );
updateWorkspace();
fake->clearWState( WState_Minimized );
fake->setWState( WState_Maximized );
c->clearWState( WState_Minimized );
c->setWState( WState_Maximized );
}
}
void TQWorkspace::showWindow( TQWidget* w)
{
if ( d->maxWindow && w->testWFlags( WStyle_Maximize ) && !w->testWFlags( WStyle_Tool) )
maximizeWindow(w);
else if (w->isMinimized() && !w->testWFlags(WStyle_Tool))
minimizeWindow(w);
else if ( !w->testWFlags( WStyle_Tool ) )
normalizeWindow(w);
else
w->parentWidget()->show();
if ( d->maxWindow )
d->maxWindow->internalRaise();
updateWorkspace();
}
TQWorkspaceChild* TQWorkspace::findChild( TQWidget* w)
{
TQPtrListIterator it( d->windows );
while ( it.current () ) {
TQWorkspaceChild* c = it.current();
++it;
if (c->windowWidget() == w)
return c;
}
return 0;
}
/*!
\obsolete
\overload
*/
TQWidgetList TQWorkspace::windowList() const
{
return windowList( CreationOrder );
}
/*!
Returns a list of all windows. If \a order is CreationOrder
(the default) the windows are listed in the order in which they
had been inserted into the workspace. If \a order is StackingOrder
the windows are listed in their stacking order, with the topmost window
being the last window in the list.
TQWidgetList is the same as TQPtrList.
\sa TQPtrList
*/
TQWidgetList TQWorkspace::windowList( WindowOrder order ) const
{
TQWidgetList windows;
if ( order == StackingOrder ) {
const TQObjectList *cl = children();
if ( cl ) {
TQObjectListIt it( *cl );
while (it.current()) {
TQObject *o = it.current();
++it;
TQWorkspaceChild *c = ::tqt_cast(o);
if (c && c->windowWidget())
windows.append(c->windowWidget());
}
}
} else {
TQPtrListIterator it( d->windows );
while (it.current()) {
TQWorkspaceChild* c = it.current();
++it;
if ( c->windowWidget() )
windows.append( c->windowWidget() );
}
}
return windows;
}
/*!\reimp*/
bool TQWorkspace::eventFilter( TQObject *o, TQEvent * e)
{
if(d->wmode == TopLevel && d->mainwindow && o->parent() == d->mainwindow) {
if((e->type() == TQEvent::ChildInserted || e->type() == TQEvent::Reparent) &&
::tqt_cast(o) && !((TQWidget*)o)->isVisible()) {
TQChildEvent *ce = (TQChildEvent*)e;
if(!::tqt_cast(ce->child())) {
tqDebug("No idea what to do..");
return FALSE;
}
TQDockWindow *w = (TQDockWindow*)ce->child();
if(d->newdocks.find(w) == -1 && d->dockwindows.find(w) == -1) {
if(::tqt_cast(w))
d->newdocks.prepend(w);
else
d->newdocks.append(w);
if(d->newdocks.count() == 1)
TQTimer::singleShot(0, this, SLOT(dockWindowsShow()));
}
} else if(e->type() == TQEvent::Hide && !e->spontaneous() && !tqstrncmp(o->name(), "TQMagicDock_", 11)) {
// d->mainwindow->close();
}
return TQWidget::eventFilter(o, e);
}
static TQTime* t = 0;
static TQWorkspace* tc = 0;
#ifndef QT_NO_MENUBAR
if ( o == d->maxtools && d->menuId != -1 ) {
switch ( e->type() ) {
case TQEvent::MouseButtonPress:
{
TQMenuBar* b = (TQMenuBar*)o->parent();
if ( !t )
t = new TQTime;
if ( tc != this || t->elapsed() > TQApplication::doubleClickInterval() ) {
if ( TQApplication::reverseLayout() ) {
TQPoint p = b->mapToGlobal( TQPoint( b->x() + b->width(), b->y() + b->height() ) );
p.rx() -= d->popup->sizeHint().width();
popupOperationMenu( p );
} else {
popupOperationMenu( b->mapToGlobal( TQPoint( b->x(), b->y() + b->height() ) ) );
}
t->start();
tc = this;
} else {
tc = 0;
closeActiveWindow();
}
return TRUE;
}
default:
break;
}
return TQWidget::eventFilter( o, e );
}
#endif
switch ( e->type() ) {
case TQEvent::Hide:
case TQEvent::HideToParent:
if ( !o->isA( "TQWorkspaceChild" ) || !isVisible() || e->spontaneous() )
break;
if ( d->active == o ) {
int a = d->focus.find( d->active );
for ( ;; ) {
if ( --a < 0 )
a = d->focus.count()-1;
TQWorkspaceChild* c = d->focus.at( a );
if ( !c || c == o ) {
if ( c && c->iconw && d->icons.contains( c->iconw->parentWidget() ) )
break;
activateWindow( 0 );
break;
}
if ( c->isShown() ) {
activateWindow( c->windowWidget(), FALSE );
break;
}
}
}
d->focus.removeRef( (TQWorkspaceChild*)o );
if ( d->maxWindow == o && d->maxWindow->isHidden() ) {
d->maxWindow->setGeometry( d->maxRestore );
d->maxWindow = 0;
if ( d->active )
maximizeWindow( d->active );
if ( !d->maxWindow ) {
if ( style().styleHint(TQStyle::SH_Workspace_FillSpaceOnMaximize, this)) {
TQWorkspaceChild *wc = (TQWorkspaceChild *)o;
wc->widgetResizeHandler->setActive( TRUE );
if ( wc->titlebar )
wc->titlebar->setMovable( TRUE );
} else {
hideMaximizeControls();
}
#ifndef QT_NO_WIDGET_TOPEXTRA
inCaptionChange = TRUE;
if ( !!d->topCaption )
topLevelWidget()->setCaption( d->topCaption );
inCaptionChange = FALSE;
#endif
}
}
updateWorkspace();
break;
case TQEvent::Show:
if ( o->isA("TQWorkspaceChild") && !d->focus.containsRef( (TQWorkspaceChild*)o ) )
d->focus.append( (TQWorkspaceChild*)o );
updateWorkspace();
break;
case TQEvent::CaptionChange:
if ( inCaptionChange )
break;
#ifndef QT_NO_WIDGET_TOPEXTRA
inCaptionChange = TRUE;
if ( o == topLevelWidget() ) {
TQWidget *tlw = (TQWidget*)o;
if ( !d->maxWindow
|| tlw->caption() != tr("%1 - [%2]").arg(d->topCaption).arg(d->maxWindow->caption()) )
d->topCaption = tlw->caption();
}
if ( d->maxWindow && !!d->topCaption )
topLevelWidget()->setCaption( tr("%1 - [%2]")
.arg(d->topCaption).arg(d->maxWindow->caption()));
inCaptionChange = FALSE;
#endif
break;
case TQEvent::Close:
if ( o == topLevelWidget() )
{
TQPtrListIterator it( d->windows );
while ( it.current () ) {
TQWorkspaceChild* c = it.current();
++it;
if ( c->shademode )
c->showShaded();
}
} else if ( ::tqt_cast(o) ) {
d->popup->hide();
}
updateWorkspace();
break;
default:
break;
}
return TQWidget::eventFilter( o, e);
}
void TQWorkspace::showMaximizeControls()
{
#ifndef QT_NO_MENUBAR
Q_ASSERT(d->maxWindow);
TQMenuBar* b = 0;
// Do a breadth-first search first on every parent,
TQWidget* w = parentWidget();
TQObjectList * l = 0;
while ( !l && w ) {
l = w->queryList( "TQMenuBar", 0, FALSE, FALSE );
w = w->parentWidget();
if ( l && !l->count() ) {
delete l;
l = 0;
}
}
// and query recursively if nothing is found.
if ( !l || !l->count() ) {
if ( l )
delete l;
l = topLevelWidget()->queryList( "TQMenuBar", 0, 0, TRUE );
}
if ( l && l->count() )
b = (TQMenuBar *)l->first();
delete l;
if ( !b )
return;
if ( !d->maxcontrols ) {
d->maxmenubar = b;
d->maxcontrols = new TQFrame( topLevelWidget(), "qt_maxcontrols" );
TQHBoxLayout* l = new TQHBoxLayout( d->maxcontrols,
d->maxcontrols->frameWidth(), 0 );
if ( d->maxWindow->windowWidget() &&
d->maxWindow->windowWidget()->testWFlags(WStyle_Minimize) ) {
TQToolButton* iconB = new TQToolButton( d->maxcontrols, "iconify" );
#ifndef QT_NO_TOOLTIP
TQToolTip::add( iconB, tr( "Minimize" ) );
#endif
l->addWidget( iconB );
iconB->setFocusPolicy( NoFocus );
iconB->setIconSet(style().stylePixmap(TQStyle::SP_TitleBarMinButton));
iconB->setFixedSize(BUTTON_WIDTH, BUTTON_HEIGHT);
connect( iconB, SIGNAL( clicked() ),
this, SLOT( minimizeActiveWindow() ) );
}
TQToolButton* restoreB = new TQToolButton( d->maxcontrols, "restore" );
#ifndef QT_NO_TOOLTIP
TQToolTip::add( restoreB, tr( "Restore Down" ) );
#endif
l->addWidget( restoreB );
restoreB->setFocusPolicy( NoFocus );
restoreB->setIconSet( style().stylePixmap(TQStyle::SP_TitleBarNormalButton));
restoreB->setFixedSize(BUTTON_WIDTH, BUTTON_HEIGHT);
connect( restoreB, SIGNAL( clicked() ),
this, SLOT( normalizeActiveWindow() ) );
l->addSpacing( 2 );
TQToolButton* closeB = new TQToolButton( d->maxcontrols, "close" );
#ifndef QT_NO_TOOLTIP
TQToolTip::add( closeB, tr( "Close" ) );
#endif
l->addWidget( closeB );
closeB->setFocusPolicy( NoFocus );
closeB->setIconSet( style().stylePixmap(TQStyle::SP_TitleBarCloseButton) );
closeB->setFixedSize(BUTTON_WIDTH, BUTTON_HEIGHT);
connect( closeB, SIGNAL( clicked() ),
this, SLOT( closeActiveWindow() ) );
d->maxcontrols->setFixedSize( d->maxcontrols->minimumSizeHint() );
}
if ( d->controlId == -1 || b->indexOf( d->controlId ) == -1 ) {
TQFrame* dmaxcontrols = d->maxcontrols;
d->controlId = b->insertItem( dmaxcontrols, -1, b->count() );
}
if ( !d->active && d->becomeActive ) {
d->active = (TQWorkspaceChild*)d->becomeActive->parentWidget();
d->active->setActive( TRUE );
d->becomeActive = 0;
emit windowActivated( d->active->windowWidget() );
}
if ( d->active && ( d->menuId == -1 || b->indexOf( d->menuId ) == -1 ) ) {
if ( !d->maxtools ) {
d->maxtools = new TQLabel( topLevelWidget(), "qt_maxtools" );
d->maxtools->installEventFilter( this );
}
#ifndef QT_NO_WIDGET_TOPEXTRA
if ( d->active->windowWidget() && d->active->windowWidget()->icon() ) {
TQPixmap pm(*d->active->windowWidget()->icon());
int iconSize = d->maxcontrols->size().height();
if(pm.width() > iconSize || pm.height() > iconSize) {
TQImage im;
im = pm;
pm = im.smoothScale( TQMIN(iconSize, pm.width()), TQMIN(iconSize, pm.height()) );
}
d->maxtools->setPixmap( pm );
} else
#endif
{
TQPixmap pm(14,14);
pm.fill( color1 );
pm.setMask(pm.createHeuristicMask());
d->maxtools->setPixmap( pm );
}
d->menuId = b->insertItem( d->maxtools, -1, 0 );
}
#endif
}
void TQWorkspace::hideMaximizeControls()
{
#ifndef QT_NO_MENUBAR
if ( d->maxmenubar ) {
int mi = d->menuId;
if ( mi != -1 ) {
if ( d->maxmenubar->indexOf( mi ) != -1 )
d->maxmenubar->removeItem( mi );
d->maxtools = 0;
}
int ci = d->controlId;
if ( ci != -1 && d->maxmenubar->indexOf( ci ) != -1 )
d->maxmenubar->removeItem( ci );
}
d->maxcontrols = 0;
d->menuId = -1;
d->controlId = -1;
#endif
}
/*!
Closes the child window that is currently active.
\sa closeAllWindows()
*/
void TQWorkspace::closeActiveWindow()
{
setUpdatesEnabled( FALSE );
if ( d->maxWindow && d->maxWindow->windowWidget() )
d->maxWindow->windowWidget()->close();
else if ( d->active && d->active->windowWidget() )
d->active->windowWidget()->close();
setUpdatesEnabled( TRUE );
updateWorkspace();
}
/*!
Closes all child windows.
The windows are closed in random order. The operation stops if a
window does not accept the close event.
\sa closeActiveWindow()
*/
void TQWorkspace::closeAllWindows()
{
bool did_close = TRUE;
TQPtrListIterator it( d->windows );
TQWorkspaceChild *c = 0;
while ( ( c = it.current() ) && did_close ) {
++it;
if ( c->windowWidget() )
did_close = c->windowWidget()->close();
}
}
void TQWorkspace::normalizeActiveWindow()
{
if ( d->maxWindow )
d->maxWindow->showNormal();
else if ( d->active )
d->active->showNormal();
}
void TQWorkspace::minimizeActiveWindow()
{
if ( d->maxWindow )
d->maxWindow->showMinimized();
else if ( d->active )
d->active->showMinimized();
}
void TQWorkspace::showOperationMenu()
{
if ( !d->active || !d->active->windowWidget() )
return;
Q_ASSERT( d->active->windowWidget()->testWFlags( WStyle_SysMenu ) );
TQPoint p;
TQPopupMenu *popup = d->active->windowWidget()->testWFlags( WStyle_Tool ) ? d->toolPopup : d->popup;
if ( TQApplication::reverseLayout() ) {
p = TQPoint( d->active->windowWidget()->mapToGlobal( TQPoint(d->active->windowWidget()->width(),0) ) );
p.rx() -= popup->sizeHint().width();
} else {
p = TQPoint( d->active->windowWidget()->mapToGlobal( TQPoint(0,0) ) );
}
if ( !d->active->isVisible() ) {
p = d->active->iconWidget()->mapToGlobal( TQPoint(0,0) );
p.ry() -= popup->sizeHint().height();
}
popupOperationMenu( p );
}
void TQWorkspace::popupOperationMenu( const TQPoint& p)
{
if ( !d->active || !d->active->windowWidget() || !d->active->windowWidget()->testWFlags( WStyle_SysMenu ) )
return;
if ( d->active->windowWidget()->testWFlags( WStyle_Tool ))
d->toolPopup->popup( p );
else
d->popup->popup( p );
}
void TQWorkspace::operationMenuAboutToShow()
{
for ( int i = 1; i < 6; i++ ) {
bool enable = d->active != 0;
d->popup->setItemEnabled( i, enable );
}
if ( !d->active || !d->active->windowWidget() )
return;
TQWidget *windowWidget = d->active->windowWidget();
bool canResize = windowWidget->maximumSize() != windowWidget->minimumSize();
d->popup->setItemEnabled( 3, canResize );
d->popup->setItemEnabled( 4, windowWidget->testWFlags( WStyle_Minimize ) );
d->popup->setItemEnabled( 5, windowWidget->testWFlags( WStyle_Maximize ) && canResize );
if ( d->active == d->maxWindow ) {
d->popup->setItemEnabled( 2, FALSE );
d->popup->setItemEnabled( 3, FALSE );
d->popup->setItemEnabled( 5, FALSE );
} else if ( d->active->isVisible() ){
d->popup->setItemEnabled( 1, FALSE );
} else {
d->popup->setItemEnabled( 2, FALSE );
d->popup->setItemEnabled( 3, FALSE );
d->popup->setItemEnabled( 4, FALSE );
}
}
void TQWorkspace::toolMenuAboutToShow()
{
if ( !d->active || !d->active->windowWidget() )
return;
TQWidget *windowWidget = d->active->windowWidget();
bool canResize = windowWidget->maximumSize() != windowWidget->minimumSize();
d->toolPopup->setItemEnabled( 3, !d->active->shademode && canResize );
if ( d->active->shademode )
d->toolPopup->changeItem( 6,
TQIconSet(style().stylePixmap(TQStyle::SP_TitleBarUnshadeButton)), tr("&Unshade") );
else
d->toolPopup->changeItem( 6, TQIconSet(style().stylePixmap(TQStyle::SP_TitleBarShadeButton)), tr("Sh&ade") );
d->toolPopup->setItemEnabled( 6, d->active->windowWidget()->testWFlags( WStyle_MinMax ) );
d->toolPopup->setItemChecked( 7, d->active->windowWidget()->testWFlags( WStyle_StaysOnTop ) );
}
void TQWorkspace::operationMenuActivated( int a )
{
if ( !d->active )
return;
switch ( a ) {
case 1:
d->active->showNormal();
break;
case 2:
d->active->doMove();
break;
case 3:
if ( d->active->shademode )
d->active->showShaded();
d->active->doResize();
break;
case 4:
d->active->showMinimized();
break;
case 5:
d->active->showMaximized();
break;
case 6:
d->active->showShaded();
break;
case 7:
{
TQWorkspace* w = (TQWorkspace*)d->active->windowWidget();
if ( !w )
break;
if ( w->testWFlags( WStyle_StaysOnTop ) ) {
w->clearWFlags( WStyle_StaysOnTop );
} else {
w->setWFlags( WStyle_StaysOnTop );
w->parentWidget()->raise();
}
}
break;
default:
break;
}
}
/*!
Activates the next window in the child window chain.
\sa activatePrevWindow()
*/
void TQWorkspace::activateNextWindow()
{
if ( d->focus.isEmpty() )
return;
if ( !d->active ) {
if ( d->focus.first() )
activateWindow( d->focus.first()->windowWidget(), FALSE );
return;
}
int a = d->focus.find( d->active ) + 1;
a = a % d->focus.count();
if ( d->focus.at( a ) )
activateWindow( d->focus.at( a )->windowWidget(), FALSE );
else
activateWindow(0);
}
void TQWorkspace::activatePreviousWindow()
{
activatePrevWindow();
}
/*!
Activates the previous window in the child window chain.
\sa activateNextWindow()
*/
void TQWorkspace::activatePrevWindow()
{
if ( d->focus.isEmpty() )
return;
if ( !d->active ) {
if ( d->focus.last() )
activateWindow( d->focus.first()->windowWidget(), FALSE );
else
activateWindow( 0 );
return;
}
int a = d->focus.find( d->active ) - 1;
if ( a < 0 )
a = d->focus.count()-1;
if ( d->focus.at( a ) )
activateWindow( d->focus.at( a )->windowWidget(), FALSE );
else
activateWindow( 0 );
}
/*!
\fn void TQWorkspace::windowActivated( TQWidget* w )
This signal is emitted when the window widget \a w becomes active.
Note that \a w can be null, and that more than one signal may be
emitted for a single activation event.
\sa activeWindow(), windowList()
*/
/*!
Arranges all the child windows in a cascade pattern.
\sa tile()
*/
void TQWorkspace::cascade()
{
blockSignals(TRUE);
if ( d->maxWindow )
d->maxWindow->showNormal();
if ( d->vbar ) {
d->vbar->blockSignals( TRUE );
d->vbar->setValue( 0 );
d->vbar->blockSignals( FALSE );
d->hbar->blockSignals( TRUE );
d->hbar->setValue( 0 );
d->hbar->blockSignals( FALSE );
scrollBarChanged();
}
const int xoffset = 13;
const int yoffset = 20;
// make a list of all relevant mdi clients
TQPtrList widgets;
TQWorkspaceChild* wc = 0;
for ( wc = d->focus.first(); wc; wc = d->focus.next() )
if ( wc->windowWidget()->isVisibleTo( this ) && !wc->windowWidget()->testWFlags( WStyle_Tool ) && !wc->iconw )
widgets.append( wc );
int x = 0;
int y = 0;
setUpdatesEnabled( FALSE );
TQPtrListIterator it( widgets );
while ( it.current () ) {
TQWorkspaceChild *child = it.current();
++it;
child->setUpdatesEnabled( FALSE );
TQSize prefSize = child->windowWidget()->sizeHint().expandedTo( child->windowWidget()->minimumSizeHint() );
if ( !prefSize.isValid() )
prefSize = child->windowWidget()->size();
prefSize = prefSize.expandedTo( child->windowWidget()->minimumSize() ).boundedTo( child->windowWidget()->maximumSize() );
if (prefSize.isValid())
prefSize += TQSize( child->baseSize().width(), child->baseSize().height() );
int w = prefSize.width();
int h = prefSize.height();
child->showNormal();
tqApp->sendPostedEvents( 0, TQEvent::ShowNormal );
if ( y + h > height() )
y = 0;
if ( x + w > width() )
x = 0;
child->setGeometry( x, y, w, h );
x += xoffset;
y += yoffset;
child->internalRaise();
child->setUpdatesEnabled( TRUE );
}
setUpdatesEnabled( TRUE );
updateWorkspace();
blockSignals(FALSE);
}
/*!
Arranges all child windows in a tile pattern.
\sa cascade()
*/
void TQWorkspace::tile()
{
blockSignals(TRUE);
TQWidget *oldActive = d->active ? d->active->windowWidget() : 0;
if ( d->maxWindow )
d->maxWindow->showNormal();
if ( d->vbar ) {
d->vbar->blockSignals( TRUE );
d->vbar->setValue( 0 );
d->vbar->blockSignals( FALSE );
d->hbar->blockSignals( TRUE );
d->hbar->setValue( 0 );
d->hbar->blockSignals( FALSE );
scrollBarChanged();
}
int rows = 1;
int cols = 1;
int n = 0;
TQWorkspaceChild* c;
TQPtrListIterator it( d->windows );
while ( it.current () ) {
c = it.current();
++it;
if ( !c->windowWidget()->isHidden() &&
!c->windowWidget()->testWFlags( WStyle_StaysOnTop ) &&
!c->windowWidget()->testWFlags( WStyle_Tool ) &&
!c->iconw )
n++;
}
while ( rows * cols < n ) {
if ( cols <= rows )
cols++;
else
rows++;
}
int add = cols * rows - n;
bool* used = new bool[ cols*rows ];
for ( int i = 0; i < rows*cols; i++ )
used[i] = FALSE;
int row = 0;
int col = 0;
int w = width() / cols;
int h = height() / rows;
it.toFirst();
while ( it.current () ) {
c = it.current();
++it;
if ( c->iconw || c->windowWidget()->isHidden() || c->windowWidget()->testWFlags( WStyle_Tool ) )
continue;
if (!row && !col) {
w -= c->baseSize().width();
h -= c->baseSize().height();
}
if ( c->windowWidget()->testWFlags( WStyle_StaysOnTop ) ) {
TQPoint p = c->pos();
if ( p.x()+c->width() < 0 )
p.setX( 0 );
if ( p.x() > width() )
p.setX( width() - c->width() );
if ( p.y() + 10 < 0 )
p.setY( 0 );
if ( p.y() > height() )
p.setY( height() - c->height() );
if ( p != c->pos() )
c->TQFrame::move( p );
} else {
c->showNormal();
tqApp->sendPostedEvents( 0, TQEvent::ShowNormal );
used[row*cols+col] = TRUE;
TQSize sz(w, h);
TQSize bsize(c->baseSize());
sz = sz.expandedTo(c->windowWidget()->minimumSize()).boundedTo(c->windowWidget()->maximumSize());
sz += bsize;
if ( add ) {
if (sz.height() == h + bsize.height()) // no relevant constrains
sz.rheight() *= 2;
c->setGeometry(col*w + col*bsize.width(), row*h + row*bsize.height(), sz.width(), sz.height());
used[(row+1)*cols+col] = TRUE;
add--;
} else {
c->setGeometry(col*w + col*bsize.width(), row*h + row*bsize.height(), sz.width(), sz.height());
}
while( row < rows && col < cols && used[row*cols+col] ) {
col++;
if ( col == cols ) {
col = 0;
row++;
}
}
}
}
delete [] used;
activateWindow( oldActive );
updateWorkspace();
blockSignals(FALSE);
}
TQWorkspaceChild::TQWorkspaceChild( TQWidget* window, TQWorkspace *parent,
const char *name )
: TQFrame( parent, name,
(parent->windowMode() == TQWorkspace::TopLevel ? (WStyle_MinMax | WStyle_SysMenu | WType_TopLevel) :
WStyle_NoBorder ) | WStyle_Customize | WDestructiveClose | WNoMousePropagation | WSubWindow )
{
statusbar = 0;
setMouseTracking( TRUE );
act = FALSE;
iconw = 0;
lastfocusw = 0;
shademode = FALSE;
titlebar = 0;
snappedRight = FALSE;
snappedDown = FALSE;
if (window) {
switch (window->focusPolicy()) {
case TQWidget::NoFocus:
window->setFocusPolicy(TQWidget::ClickFocus);
break;
case TQWidget::TabFocus:
window->setFocusPolicy(TQWidget::StrongFocus);
break;
default:
break;
}
}
if ( window && window->testWFlags( WStyle_Title ) && parent->windowMode() != TQWorkspace::TopLevel ) {
titlebar = new TQTitleBar( window, this, "qt_ws_titlebar" );
connect( titlebar, SIGNAL( doActivate() ),
this, SLOT( activate() ) );
connect( titlebar, SIGNAL( doClose() ),
window, SLOT( close() ) );
connect( titlebar, SIGNAL( doMinimize() ),
this, SLOT( showMinimized() ) );
connect( titlebar, SIGNAL( doNormal() ),
this, SLOT( showNormal() ) );
connect( titlebar, SIGNAL( doMaximize() ),
this, SLOT( showMaximized() ) );
connect( titlebar, SIGNAL( popupOperationMenu(const TQPoint&) ),
this, SIGNAL( popupOperationMenu(const TQPoint&) ) );
connect( titlebar, SIGNAL( showOperationMenu() ),
this, SIGNAL( showOperationMenu() ) );
connect( titlebar, SIGNAL( doShade() ),
this, SLOT( showShaded() ) );
connect( titlebar, SIGNAL( doubleClicked() ),
this, SLOT( titleBarDoubleClicked() ) );
}
setFrameStyle( TQFrame::StyledPanel | TQFrame::Raised );
setLineWidth( style().pixelMetric(TQStyle::PM_MDIFrameWidth, this) );
setMinimumSize( 128, 0 );
childWidget = window;
if (!childWidget)
return;
#ifndef QT_NO_WIDGET_TOPEXTRA
setCaption( childWidget->caption() );
#endif
TQPoint p;
TQSize s;
TQSize cs;
bool hasBeenResized = childWidget->testWState( WState_Resized );
if ( !hasBeenResized )
cs = childWidget->sizeHint().expandedTo( childWidget->minimumSizeHint() );
else
cs = childWidget->size();
int th = titlebar ? titlebar->sizeHint().height() : 0;
if ( titlebar ) {
#ifndef QT_NO_WIDGET_TOPEXTRA
int iconSize = th;
if( childWidget->icon() ) {
TQPixmap pm(*childWidget->icon());
if(pm.width() > iconSize || pm.height() > iconSize) {
TQImage im;
im = pm;
pm = im.smoothScale( TQMIN(iconSize, pm.width()), TQMIN(iconSize, pm.height()) );
}
titlebar->setIcon( pm );
}
#endif
if ( !style().styleHint( TQStyle::SH_TitleBar_NoBorder, titlebar ) )
th += frameWidth();
else
th -= contentsRect().y();
p = TQPoint( contentsRect().x(),
th + contentsRect().y() );
s = TQSize( cs.width() + 2*frameWidth(),
cs.height() + 2*frameWidth() + th );
} else {
p = TQPoint( contentsRect().x(), contentsRect().y() );
s = TQSize( cs.width() + 2*frameWidth(),
cs.height() + 2*frameWidth() );
}
childWidget->reparent( this, p);
resize( s );
childWidget->installEventFilter( this );
widgetResizeHandler = new TQWidgetResizeHandler( this, window );
widgetResizeHandler->setSizeProtection( !parent->scrollBarsEnabled() );
connect( widgetResizeHandler, SIGNAL( activate() ),
this, SLOT( activate() ) );
if ( !style().styleHint( TQStyle::SH_TitleBar_NoBorder, titlebar ) )
widgetResizeHandler->setExtraHeight( th + contentsRect().y() - 2*frameWidth() );
else
widgetResizeHandler->setExtraHeight( th + contentsRect().y() - frameWidth() );
if(parent->windowMode() == TQWorkspace::TopLevel && isTopLevel()) {
move(0, 0);
widgetResizeHandler->setActive( FALSE );
}
if ( childWidget->minimumSize() == childWidget->maximumSize() )
widgetResizeHandler->setActive( TQWidgetResizeHandler::Resize, FALSE );
setBaseSize( baseSize() );
}
TQWorkspaceChild::~TQWorkspaceChild()
{
if ( iconw )
delete iconw->parentWidget();
TQWorkspace *workspace = ::tqt_cast(parentWidget());
if ( workspace ) {
workspace->d->focus.removeRef(this);
if ( workspace->d->active == this ) {
workspace->activatePrevWindow();
if (workspace->d->active == this) {
workspace->activateWindow(0);
}
}
if ( workspace->d->maxWindow == this ) {
workspace->hideMaximizeControls();
workspace->d->maxWindow = 0;
}
}
}
bool TQWorkspaceChild::event( TQEvent *e )
{
if(((TQWorkspace*)parentWidget())->windowMode() == TQWorkspace::TopLevel) {
switch(e->type()) {
case TQEvent::Close:
if(windowWidget()) {
if(!windowWidget()->close()) {
if(((TQWorkspace*) parentWidget() )->d->active == this)
((TQWorkspace*) parentWidget() )->activatePrevWindow();
return TRUE;
}
}
break;
#if 0
case TQEvent::WindowDeactivate:
if(statusbar) {
TQSize newsize(width(), height() - statusbar->height());
if(statusbar->parentWidget() == this)
statusbar->hide();
statusbar = 0;
resize(newsize);
}
break;
#endif
case TQEvent::WindowActivate:
if(((TQWorkspace*)parentWidget())->activeWindow() == windowWidget())
activate();
if(statusbar)
statusbar->show();
else if(((TQWorkspace*) parentWidget() )->d->mainwindow)
setStatusBar(((TQWorkspace*) parentWidget() )->d->mainwindow->statusBar());
break;
default:
break;
}
}
return TQWidget::event(e);
}
void TQWorkspaceChild::setStatusBar( TQStatusBar *sb )
{
if(((TQWorkspace*) parentWidget() )->windowMode() == TQWorkspace::TopLevel) {
TQSize newsize;
if(sb) {
sb->show();
if(sb != statusbar) {
sb->reparent(this, TQPoint(0, height()), TRUE);
newsize = TQSize(width(), height() + sb->height());
}
}
statusbar = sb;
if(!newsize.isNull())
resize(newsize);
}
}
void TQWorkspaceChild::moveEvent( TQMoveEvent *e )
{
if(((TQWorkspace*) parentWidget() )->windowMode() == TQWorkspace::TopLevel && !e->spontaneous()) {
TQPoint p = parentWidget()->topLevelWidget()->pos();
if(x() < p.x() || y() < p.y())
move(TQMAX(x(), p.x()), TQMAX(y(), p.y()));
}
((TQWorkspace*) parentWidget() )->updateWorkspace();
}
void TQWorkspaceChild::resizeEvent( TQResizeEvent * )
{
TQRect r = contentsRect();
TQRect cr;
if ( titlebar ) {
int th = titlebar->sizeHint().height();
TQRect tbrect( 0, 0, width(), th );
if ( !style().styleHint( TQStyle::SH_TitleBar_NoBorder ) )
tbrect = TQRect( r.x(), r.y(), r.width(), th );
titlebar->setGeometry( tbrect );
if ( style().styleHint( TQStyle::SH_TitleBar_NoBorder, titlebar ) )
th -= frameWidth();
cr = TQRect( r.x(), r.y() + th + (shademode ? (frameWidth() * 3) : 0),
r.width(), r.height() - th );
} else {
cr = r;
}
if(statusbar && statusbar->isVisible()) {
int sh = statusbar->height();
statusbar->setGeometry(r.x(), r.bottom() - sh, r.width(), sh);
cr.setBottom(cr.bottom() - sh);
}
if (!childWidget)
return;
windowSize = cr.size();
childWidget->setGeometry( cr );
((TQWorkspace*) parentWidget() )->updateWorkspace();
}
TQSize TQWorkspaceChild::baseSize() const
{
int th = titlebar ? titlebar->sizeHint().height() : 0;
if ( style().styleHint( TQStyle::SH_TitleBar_NoBorder, titlebar ) )
th -= frameWidth();
return TQSize( 2*frameWidth(), 2*frameWidth() + th );
}
TQSize TQWorkspaceChild::sizeHint() const
{
if ( !childWidget )
return TQFrame::sizeHint() + baseSize();
TQSize prefSize = windowWidget()->sizeHint().expandedTo( windowWidget()->minimumSizeHint() );
prefSize = prefSize.expandedTo( windowWidget()->minimumSize() ).boundedTo( windowWidget()->maximumSize() );
prefSize += baseSize();
return prefSize;
}
TQSize TQWorkspaceChild::minimumSizeHint() const
{
if ( !childWidget )
return TQFrame::minimumSizeHint() + baseSize();
TQSize s = childWidget->minimumSize();
if ( s.isEmpty() )
s = childWidget->minimumSizeHint();
return s + baseSize();
}
void TQWorkspaceChild::activate()
{
((TQWorkspace*)parentWidget())->activateWindow( windowWidget() );
}
bool TQWorkspaceChild::eventFilter( TQObject * o, TQEvent * e)
{
if ( !isActive() && ( e->type() == TQEvent::MouseButtonPress ||
e->type() == TQEvent::FocusIn ) ) {
if ( iconw ) {
((TQWorkspace*)parentWidget())->normalizeWindow( windowWidget() );
if ( iconw ) {
((TQWorkspace*)parentWidget())->removeIcon( iconw->parentWidget() );
delete iconw->parentWidget();
iconw = 0;
}
}
activate();
}
// for all widgets except the window, that's the only thing we
// process, and if we have no childWidget we skip totally
if ( o != childWidget || childWidget == 0 )
return FALSE;
switch ( e->type() ) {
case TQEvent::Show:
if ( ((TQWorkspace*)parentWidget())->d->focus.find( this ) < 0 )
((TQWorkspace*)parentWidget())->d->focus.append( this );
if ( isVisibleTo( parentWidget() ) )
break;
if (( (TQShowEvent*)e)->spontaneous() )
break;
// fall through
case TQEvent::ShowToParent:
if ( windowWidget() && windowWidget()->testWFlags( WStyle_StaysOnTop ) ) {
internalRaise();
show();
}
((TQWorkspace*)parentWidget())->showWindow( windowWidget() );
break;
case TQEvent::ShowMaximized:
if ( windowWidget()->maximumSize().isValid() &&
( windowWidget()->maximumWidth() < parentWidget()->width() ||
windowWidget()->maximumHeight() < parentWidget()->height() ) ) {
windowWidget()->resize( windowWidget()->maximumSize() );
((TQWorkspace*)windowWidget())->clearWState(WState_Maximized);
if (titlebar)
titlebar->repaint(FALSE);
break;
}
if ( windowWidget()->testWFlags( WStyle_Maximize ) && !windowWidget()->testWFlags( WStyle_Tool ) )
((TQWorkspace*)parentWidget())->maximizeWindow( windowWidget() );
else
((TQWorkspace*)parentWidget())->normalizeWindow( windowWidget() );
break;
case TQEvent::ShowMinimized:
((TQWorkspace*)parentWidget())->minimizeWindow( windowWidget() );
break;
case TQEvent::ShowNormal:
((TQWorkspace*)parentWidget())->normalizeWindow( windowWidget() );
if (iconw) {
((TQWorkspace*)parentWidget())->removeIcon( iconw->parentWidget() );
delete iconw->parentWidget();
}
break;
case TQEvent::Hide:
case TQEvent::HideToParent:
if ( !childWidget->isVisibleTo( this ) ) {
TQWidget * w = iconw;
if ( w && ( w = w->parentWidget() ) ) {
((TQWorkspace*)parentWidget())->removeIcon( w );
delete w;
}
hide();
}
break;
case TQEvent::CaptionChange:
#ifndef QT_NO_WIDGET_TOPEXTRA
setCaption( childWidget->caption() );
if ( iconw )
iconw->setCaption( childWidget->caption() );
#endif
break;
case TQEvent::IconChange:
{
TQWorkspace* ws = (TQWorkspace*)parentWidget();
if ( !titlebar )
break;
TQPixmap pm;
int iconSize = titlebar->size().height();
#ifndef QT_NO_WIDGET_TOPEXTRA
if ( childWidget->icon() ) {
pm = *childWidget->icon();
if(pm.width() > iconSize || pm.height() > iconSize) {
TQImage im;
im = pm;
pm = im.smoothScale( TQMIN(iconSize, pm.width()), TQMIN(iconSize, pm.height()) );
}
} else
#endif
{
pm.resize( iconSize, iconSize );
pm.fill( color1 );
pm.setMask(pm.createHeuristicMask());
}
titlebar->setIcon( pm );
if ( iconw )
iconw->setIcon( pm );
if ( ws->d->maxWindow != this )
break;
if ( ws->d->maxtools )
ws->d->maxtools->setPixmap( pm );
}
break;
case TQEvent::Resize:
{
TQResizeEvent* re = (TQResizeEvent*)e;
if ( re->size() != windowSize && !shademode )
resize( re->size() + baseSize() );
}
break;
case TQEvent::WindowDeactivate:
if ( titlebar )
titlebar->setActive( FALSE );
repaint( FALSE );
break;
case TQEvent::WindowActivate:
if ( titlebar )
titlebar->setActive( act );
repaint( FALSE );
break;
default:
break;
}
return TQFrame::eventFilter(o, e);
}
bool TQWorkspaceChild::focusNextPrevChild( bool next )
{
TQFocusData *f = focusData();
TQWidget *startingPoint = f->home();
TQWidget *candidate = 0;
TQWidget *w = next ? f->next() : f->prev();
while( !candidate && w != startingPoint ) {
if ( w != startingPoint &&
(w->focusPolicy() & TabFocus) == TabFocus
&& w->isEnabled() &&!w->focusProxy() && w->isVisible() )
candidate = w;
w = next ? f->next() : f->prev();
}
if ( candidate ) {
TQObjectList *ol = queryList();
bool ischild = ol->findRef( candidate ) != -1;
delete ol;
if ( !ischild ) {
startingPoint = f->home();
TQWidget *nw = next ? f->prev() : f->next();
TQObjectList *ol2 = queryList();
TQWidget *lastValid = 0;
candidate = startingPoint;
while ( nw != startingPoint ) {
if ( ( candidate->focusPolicy() & TabFocus ) == TabFocus
&& candidate->isEnabled() &&!candidate->focusProxy() && candidate->isVisible() )
lastValid = candidate;
if ( ol2->findRef( nw ) == -1 ) {
candidate = lastValid;
break;
}
candidate = nw;
nw = next ? f->prev() : f->next();
}
delete ol2;
}
}
if ( !candidate )
return FALSE;
candidate->setFocus();
return TRUE;
}
void TQWorkspaceChild::childEvent( TQChildEvent* e)
{
if ( e->type() == TQEvent::ChildRemoved && e->child() == childWidget ) {
childWidget = 0;
if ( iconw ) {
((TQWorkspace*)parentWidget())->removeIcon( iconw->parentWidget() );
delete iconw->parentWidget();
}
close();
}
}
void TQWorkspaceChild::doResize()
{
widgetResizeHandler->doResize();
}
void TQWorkspaceChild::doMove()
{
widgetResizeHandler->doMove();
}
void TQWorkspaceChild::enterEvent( TQEvent * )
{
}
void TQWorkspaceChild::leaveEvent( TQEvent * )
{
#ifndef QT_NO_CURSOR
if ( !widgetResizeHandler->isButtonDown() )
setCursor( arrowCursor );
#endif
}
void TQWorkspaceChild::drawFrame( TQPainter *p )
{
TQStyle::SFlags flags = TQStyle::Style_Default;
TQStyleOption opt(lineWidth(),midLineWidth());
if ( titlebar && titlebar->isActive() )
flags |= TQStyle::Style_Active;
style().drawPrimitive( TQStyle::PE_WindowFrame, p, rect(), colorGroup(), flags, opt );
}
void TQWorkspaceChild::styleChange( TQStyle & )
{
resizeEvent( 0 );
if ( iconw ) {
TQVBox *vbox = (TQVBox*)iconw->parentWidget()->tqt_cast( "TQVBox" );
Q_ASSERT(vbox);
if ( !style().styleHint( TQStyle::SH_TitleBar_NoBorder ) ) {
vbox->setFrameStyle( TQFrame::WinPanel | TQFrame::Raised );
vbox->resize( 196+2*vbox->frameWidth(), 20 + 2*vbox->frameWidth() );
} else {
vbox->resize( 196, 20 );
}
}
}
void TQWorkspaceChild::setActive( bool b )
{
if ( !childWidget )
return;
bool hasFocus = isChildOf( focusWidget(), childWidget );
if ( act == b && hasFocus )
return;
act = b;
if ( titlebar )
titlebar->setActive( act );
if ( iconw )
iconw->setActive( act );
repaint( FALSE );
TQObjectList* ol = childWidget->queryList( "TQWidget" );
if ( act ) {
TQObject *o;
for ( o = ol->first(); o; o = ol->next() )
o->removeEventFilter( this );
if ( !hasFocus ) {
if ( lastfocusw && ol->contains( lastfocusw ) &&
lastfocusw->focusPolicy() != NoFocus ) {
// this is a bug if lastfocusw has been deleted, a new
// widget has been created, and the new one is a child
// of the same window as the old one. but even though
// it's a bug the behaviour is reasonable
lastfocusw->setFocus();
} else if ( childWidget->focusPolicy() != NoFocus ) {
childWidget->setFocus();
} else {
// find something, anything, that accepts focus, and use that.
o = ol->first();
while( o && ((TQWidget*)o)->focusPolicy() == NoFocus )
o = ol->next();
if ( o )
((TQWidget*)o)->setFocus();
}
}
} else {
if ( isChildOf( focusWidget(), childWidget ) )
lastfocusw = focusWidget();
TQObject * o;
for ( o = ol->first(); o; o = ol->next() ) {
o->removeEventFilter( this );
o->installEventFilter( this );
}
}
delete ol;
}
bool TQWorkspaceChild::isActive() const
{
return act;
}
TQWidget* TQWorkspaceChild::windowWidget() const
{
return childWidget;
}
TQWidget* TQWorkspaceChild::iconWidget() const
{
if ( !iconw ) {
TQWorkspaceChild* that = (TQWorkspaceChild*) this;
// ### why do we even need the vbox? -Brad
TQVBox* vbox = new TQVBox(that, "qt_vbox", WType_TopLevel );
TQTitleBar *tb = new TQTitleBar( windowWidget(), vbox, "_workspacechild_icon_");
int th = style().pixelMetric( TQStyle::PM_TitleBarHeight, tb );
int iconSize = style().pixelMetric( TQStyle::PM_MDIMinimizedWidth, this );
if ( !style().styleHint( TQStyle::SH_TitleBar_NoBorder ) ) {
vbox->setFrameStyle( TQFrame::WinPanel | TQFrame::Raised );
vbox->resize( iconSize+2*vbox->frameWidth(), th+2*vbox->frameWidth() );
} else {
vbox->resize( iconSize, th );
}
that->iconw = tb;
iconw->setActive( isActive() );
connect( iconw, SIGNAL( doActivate() ),
this, SLOT( activate() ) );
connect( iconw, SIGNAL( doClose() ),
windowWidget(), SLOT( close() ) );
connect( iconw, SIGNAL( doNormal() ),
this, SLOT( showNormal() ) );
connect( iconw, SIGNAL( doMaximize() ),
this, SLOT( showMaximized() ) );
connect( iconw, SIGNAL( popupOperationMenu(const TQPoint&) ),
this, SIGNAL( popupOperationMenu(const TQPoint&) ) );
connect( iconw, SIGNAL( showOperationMenu() ),
this, SIGNAL( showOperationMenu() ) );
connect( iconw, SIGNAL( doubleClicked() ),
this, SLOT( titleBarDoubleClicked() ) );
}
#ifndef QT_NO_WIDGET_TOPEXTRA
if ( windowWidget() ) {
iconw->setCaption( windowWidget()->caption() );
if ( windowWidget()->icon() ) {
int iconSize = iconw->sizeHint().height();
TQPixmap pm(*childWidget->icon());
if(pm.width() > iconSize || pm.height() > iconSize) {
TQImage im;
im = pm;
pm = im.smoothScale( TQMIN(iconSize, pm.width()), TQMIN(iconSize, pm.height()) );
}
iconw->setIcon( pm );
}
}
#endif
return iconw->parentWidget();
}
void TQWorkspaceChild::showMinimized()
{
windowWidget()->setWindowState(WindowMinimized | windowWidget()->windowState());
}
void TQWorkspaceChild::showMaximized()
{
windowWidget()->setWindowState(WindowMaximized | (windowWidget()->windowState() & ~WindowMinimized));
}
void TQWorkspaceChild::showNormal()
{
windowWidget()->setWindowState(windowWidget()->windowState() & ~(WindowMinimized|WindowMaximized));
}
void TQWorkspaceChild::showShaded()
{
if ( !titlebar)
return;
Q_ASSERT( windowWidget()->testWFlags( WStyle_MinMax ) && windowWidget()->testWFlags( WStyle_Tool ) );
((TQWorkspace*)parentWidget())->activateWindow( windowWidget() );
if ( shademode ) {
TQWorkspaceChild* fake = (TQWorkspaceChild*)windowWidget();
fake->clearWState( WState_Minimized );
clearWState( WState_Minimized );
shademode = FALSE;
resize( shadeRestore );
setMinimumSize( shadeRestoreMin );
style().polish(this);
} else {
shadeRestore = size();
shadeRestoreMin = minimumSize();
setMinimumHeight(0);
shademode = TRUE;
TQWorkspaceChild* fake = (TQWorkspaceChild*)windowWidget();
fake->setWState( WState_Minimized );
setWState( WState_Minimized );
if ( style().styleHint( TQStyle::SH_TitleBar_NoBorder ) )
resize( width(), titlebar->height() );
else
resize( width(), titlebar->height() + 2*lineWidth() + 1 );
style().polish(this);
}
titlebar->update();
}
void TQWorkspaceChild::titleBarDoubleClicked()
{
if ( !windowWidget() )
return;
if ( windowWidget()->testWFlags( WStyle_MinMax ) ) {
if ( windowWidget()->testWFlags( WStyle_Tool ) )
showShaded();
else if ( iconw )
showNormal();
else if ( windowWidget()->testWFlags( WStyle_Maximize ) )
showMaximized();
}
}
void TQWorkspaceChild::adjustToFullscreen()
{
if ( !childWidget )
return;
tqApp->sendPostedEvents( this, TQEvent::Resize );
tqApp->sendPostedEvents( childWidget, TQEvent::Resize );
tqApp->sendPostedEvents( childWidget, TQEvent::Move );
if( style().styleHint(TQStyle::SH_Workspace_FillSpaceOnMaximize, this) ) {
setGeometry( 0, 0, parentWidget()->width(), parentWidget()->height());
} else {
int w = parentWidget()->width() + width() - childWidget->width();
int h = parentWidget()->height() + height() - childWidget->height();
w = TQMAX( w, childWidget->minimumWidth() );
h = TQMAX( h, childWidget->minimumHeight() );
setGeometry( -childWidget->x(), -childWidget->y(), w, h );
}
setWState( WState_Maximized );
((TQWorkspaceChild*)childWidget)->setWState( WState_Maximized );
}
void TQWorkspaceChild::setCaption( const TQString& cap )
{
if ( titlebar )
titlebar->setCaption( cap );
#ifndef QT_NO_WIDGET_TOPEXTRA
TQWidget::setCaption( cap );
#endif
}
void TQWorkspaceChild::internalRaise()
{
setUpdatesEnabled( FALSE );
if ( iconw )
iconw->parentWidget()->raise();
raise();
if ( !windowWidget() || windowWidget()->testWFlags( WStyle_StaysOnTop ) ) {
setUpdatesEnabled( TRUE );
return;
}
TQPtrListIterator it( ((TQWorkspace*)parent())->d->windows );
while ( it.current () ) {
TQWorkspaceChild* c = it.current();
++it;
if ( c->windowWidget() &&
!c->windowWidget()->isHidden() &&
c->windowWidget()->testWFlags( WStyle_StaysOnTop ) )
c->raise();
}
setUpdatesEnabled( TRUE );
}
void TQWorkspaceChild::move( int x, int y )
{
int nx = x;
int ny = y;
if ( windowWidget() && windowWidget()->testWFlags( WStyle_Tool ) ) {
int dx = 10;
int dy = 10;
if ( TQABS( x ) < dx )
nx = 0;
if ( TQABS( y ) < dy )
ny = 0;
if ( TQABS( x + width() - parentWidget()->width() ) < dx ) {
nx = parentWidget()->width() - width();
snappedRight = TRUE;
} else
snappedRight = FALSE;
if ( TQABS( y + height() - parentWidget()->height() ) < dy ) {
ny = parentWidget()->height() - height();
snappedDown = TRUE;
} else
snappedDown = FALSE;
}
TQFrame::move( nx, ny );
}
bool TQWorkspace::scrollBarsEnabled() const
{
return d->vbar != 0;
}
/*!
\property TQWorkspace::scrollBarsEnabled
\brief whether the workspace provides scrollbars
If this property is set to TRUE, it is possible to resize child
windows over the right or the bottom edge out of the visible area
of the workspace. The workspace shows scrollbars to make it
possible for the user to access those windows. If this property is
set to FALSE (the default), resizing windows out of the visible
area of the workspace is not permitted.
*/
void TQWorkspace::setScrollBarsEnabled( bool enable )
{
if ( (d->vbar != 0) == enable )
return;
d->xoffset = d->yoffset = 0;
if ( enable ) {
d->vbar = new TQScrollBar( Vertical, this, "vertical scrollbar" );
connect( d->vbar, SIGNAL( valueChanged(int) ), this, SLOT( scrollBarChanged() ) );
d->hbar = new TQScrollBar( Horizontal, this, "horizontal scrollbar" );
connect( d->hbar, SIGNAL( valueChanged(int) ), this, SLOT( scrollBarChanged() ) );
d->corner = new TQWidget( this, "qt_corner" );
updateWorkspace();
} else {
delete d->vbar;
delete d->hbar;
delete d->corner;
d->vbar = d->hbar = 0;
d->corner = 0;
}
TQPtrListIterator it( d->windows );
while ( it.current () ) {
TQWorkspaceChild *child = it.current();
++it;
child->widgetResizeHandler->setSizeProtection( !enable );
}
}
TQRect TQWorkspace::updateWorkspace()
{
if ( !isUpdatesEnabled() )
return rect();
TQRect cr( rect() );
if ( scrollBarsEnabled() && !d->maxWindow ) {
d->corner->raise();
d->vbar->raise();
d->hbar->raise();
if ( d->maxWindow )
d->maxWindow->internalRaise();
TQRect r( 0, 0, 0, 0 );
TQPtrListIterator it( d->windows );
while ( it.current () ) {
TQWorkspaceChild *child = it.current();
++it;
if ( !child->isHidden() )
r = r.unite( child->geometry() );
}
d->vbar->blockSignals( TRUE );
d->hbar->blockSignals( TRUE );
int hsbExt = d->hbar->sizeHint().height();
int vsbExt = d->vbar->sizeHint().width();
bool showv = d->yoffset || d->yoffset + r.bottom() - height() + 1 > 0 || d->yoffset + r.top() < 0;
bool showh = d->xoffset || d->xoffset + r.right() - width() + 1 > 0 || d->xoffset + r.left() < 0;
if ( showh && !showv)
showv = d->yoffset + r.bottom() - height() + hsbExt + 1 > 0;
if ( showv && !showh )
showh = d->xoffset + r.right() - width() + vsbExt + 1 > 0;
if ( !showh )
hsbExt = 0;
if ( !showv )
vsbExt = 0;
if ( showv ) {
d->vbar->setSteps( TQMAX( height() / 12, 30 ), height() - hsbExt );
d->vbar->setRange( TQMIN( 0, d->yoffset + TQMIN( 0, r.top() ) ), TQMAX( 0, d->yoffset + TQMAX( 0, r.bottom() - height() + hsbExt + 1) ) );
d->vbar->setGeometry( width() - vsbExt, 0, vsbExt, height() - hsbExt );
d->vbar->setValue( d->yoffset );
d->vbar->show();
} else {
d->vbar->hide();
}
if ( showh ) {
d->hbar->setSteps( TQMAX( width() / 12, 30 ), width() - vsbExt );
d->hbar->setRange( TQMIN( 0, d->xoffset + TQMIN( 0, r.left() ) ), TQMAX( 0, d->xoffset + TQMAX( 0, r.right() - width() + vsbExt + 1) ) );
d->hbar->setGeometry( 0, height() - hsbExt, width() - vsbExt, hsbExt );
d->hbar->setValue( d->xoffset );
d->hbar->show();
} else {
d->hbar->hide();
}
if ( showh && showv ) {
d->corner->setGeometry( width() - vsbExt, height() - hsbExt, vsbExt, hsbExt );
d->corner->show();
} else {
d->corner->hide();
}
d->vbar->blockSignals( FALSE );
d->hbar->blockSignals( FALSE );
cr.setRect( 0, 0, width() - vsbExt, height() - hsbExt );
}
TQPtrListIterator ii( d->icons );
while ( ii.current() ) {
TQWorkspaceChild* w = (TQWorkspaceChild*)ii.current();
++ii;
int x = w->x();
int y = w->y();
bool m = FALSE;
if ( x+w->width() > cr.width() ) {
m = TRUE;
x = cr.width() - w->width();
}
if ( y+w->height() > cr.height() ) {
y = cr.height() - w->height();
m = TRUE;
}
if ( m )
w->move( x, y );
}
return cr;
}
void TQWorkspace::scrollBarChanged()
{
int ver = d->yoffset - d->vbar->value();
int hor = d->xoffset - d->hbar->value();
d->yoffset = d->vbar->value();
d->xoffset = d->hbar->value();
TQPtrListIterator it( d->windows );
while ( it.current () ) {
TQWorkspaceChild *child = it.current();
++it;
// we do not use move() due to the reimplementation in TQWorkspaceChild
child->setGeometry( child->x() + hor, child->y() + ver, child->width(), child->height() );
}
updateWorkspace();
}
/*!
\enum TQWorkspace::WindowOrder
Specifies the order in which windows are returned from windowList().
\value CreationOrder The windows are returned in the order of their creation
\value StackingOrder The windows are returned in the order of their stacking
*/
#ifdef QT_WORKSPACE_WINDOWMODE
/*!
\enum TQWorkspace::WindowMode
Determines the Windowing Model TQWorkspace will use for sub-windows.
\value TopLevel Subwindows are treated as toplevel windows
\value MDI Subwindows are organized in an MDI interface
\value AutoDetect TQWorkspace will detect whether TopLevel or MDI
is appropriate
*/
/*!
The windowing model influences how the subwindows are actually
created. For most platforms the default behavior of a workspace is
to operate in MDI mode, with TQt/Mac the default mode is
AutoDetect.
*/
#else
/*! \internal */
#endif
TQWorkspace::WindowMode TQWorkspace::windowMode() const
{
return d->wmode;
}
#ifndef QT_NO_STYLE
/*!\reimp */
void TQWorkspace::styleChange( TQStyle &olds )
{
int fs = style().styleHint(TQStyle::SH_Workspace_FillSpaceOnMaximize, this);
if ( isVisibleTo(0) && d->maxWindow &&
fs != olds.styleHint(TQStyle::SH_Workspace_FillSpaceOnMaximize, this)) {
if( fs )
hideMaximizeControls();
else
showMaximizeControls();
}
TQWidget::styleChange(olds);
}
#endif
#include "qworkspace.moc"
#endif // QT_NO_WORKSPACE