Added TQt4 HEAD

1 files changed, 1183 insertions, 0 deletions

diff --git a/tqtinterface/qt4/src/widgets/tqwidgetstack.cpp b/tqtinterface/qt4/src/widgets/tqwidgetstack.cpp
new file mode 100644
index 0000000..4bf824e
--- /dev/null
+++ b/tqtinterface/qt4/src/widgets/tqwidgetstack.cpp
@@ -0,0 +1,1183 @@
+#include "tqtglobaldefines.h"
+
+#ifdef USE_QT4
+
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "tqwidgetstack.h"
+#include "tqlayout.h"
+#include "private/tqlayoutengine_p.h"
+#include "Qt/qapplication.h"
+#include "Qt/qpainter.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace Qt;
+
+class TQWidgetStackPrivate {
+public:
+    class Invisible: public TQWidget
+    {
+    public:
+	    Invisible(TQWidgetStack * parent): TQWidget(parent, "qt_invisible_widgetstack")
+	    {
+                setBackgroundMode(TQt::NoBackground);
+	    }
+	    const char * className() const
+	    {
+	        return "TQWidgetStackPrivate::Invisible";
+	    }
+    protected:
+            void paintEvent(QPaintEvent *)
+            {
+                QPainter(this).eraseRect(rect());
+            }
+    };
+
+    int nextNegativeID;
+    int nextPositiveID;
+};
+
+
+
+/*!
+    \class TQWidgetStack
+    \brief The TQWidgetStack class provides a stack of widgets of which
+    only the top widget is user-visible.
+
+    \compat
+
+    The application programmer can move any widget to the top of the
+    stack at any time using raiseWidget(), and add or remove widgets
+    using addWidget() and removeWidget(). It is not sufficient to pass
+    the widget stack as parent to a widget which should be inserted into
+    the widgetstack.
+
+    visibleWidget() is the \e get equivalent of raiseWidget(); it
+    returns a pointer to the widget that is currently at the top of
+    the stack.
+
+    TQWidgetStack also provides the ability to manipulate widgets
+    through application-specified integer IDs. You can also translate
+    from widget pointers to IDs using id() and from IDs to widget
+    pointers using widget(). These numeric IDs are unique (per
+    TQWidgetStack, not globally), but TQWidgetStack does not attach any
+    additional meaning to them.
+
+    The default widget stack is frameless, but you can use the usual
+    TQFrame functions (such as setFrameStyle()) to add a frame.
+
+    TQWidgetStack provides a signal, aboutToShow(), which is emitted
+    just before a managed widget is shown.
+
+    \sa TQTabDialog QTabWidget QTabBar TQFrame
+*/
+
+
+/*!
+  Constructs an empty widget stack.
+
+  The \a parent, \a name and \a f arguments are passed to the TQFrame
+  constructor.
+*/
+TQWidgetStack::TQWidgetStack(TQWidget * parent, const char *name, WFlags f)
+    : TQFrame(parent, name, f) //## merge constructors in 4.0
+{
+    init();
+}
+
+void TQWidgetStack::init()
+{
+   d = new TQWidgetStackPrivate();
+   d->nextNegativeID = -2;
+   d->nextPositiveID = 0;
+   dict = new TQIntDict<TQWidget>;
+   focusWidgets = 0;
+   topWidget = 0;
+   invisible = 0;
+   invisible = new TQWidgetStackPrivate::Invisible(this);
+   invisible->hide();
+}
+
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+TQWidgetStack::~TQWidgetStack()
+{
+    delete focusWidgets;
+    delete d;
+    delete dict;
+}
+
+
+/*!
+    Adds widget \a w to this stack of widgets, with ID \a id.
+
+    If you pass an id \>= 0 this ID is used. If you pass an \a id of
+    -1 (the default), the widgets will be numbered automatically. If
+    you pass -2 a unique negative integer will be generated. No widget
+    has an ID of -1. Returns the ID or -1 on failure (e.g. \a w is 0).
+
+    If you pass an id that is already used, then a unique negative
+    integer will be generated to prevent two widgets having the same
+    id.
+
+    If \a w already exists in the stack the widget will be removed first.
+
+    If \a w is not a child of this TQWidgetStack moves it using
+    reparent().
+*/
+
+int TQWidgetStack::addWidget(TQWidget * w, int id)
+{
+    if (!w || w == invisible || invisible == 0)
+        return -1;
+
+    // prevent duplicates
+    removeWidget(w);
+
+    if (id >= 0 && dict->tqfind(id))
+        id = -2;
+    if (id < -1)
+        id = d->nextNegativeID--;
+    else if (id == -1)
+        id = d->nextPositiveID++;
+    else
+        d->nextPositiveID = qMax(d->nextPositiveID, id + 1);
+        // use id >= 0 as-is
+
+    dict->insert(id, w);
+
+    // preserve existing focus
+    TQWidget * f = TQT_TQWIDGET(w->focusWidget());
+    while(f && f != w)
+        f = TQT_TQWIDGET(f->parentWidget());
+    if (f) {
+        if (!focusWidgets)
+            focusWidgets = new TQPtrDict<TQWidget>(17);
+        focusWidgets->tqreplace(w, TQT_TQWIDGET(w->focusWidget()));
+    }
+
+    w->hide();
+    if (w->parent() != this)
+        w->reparent(this, contentsRect().topLeft(), false);
+    w->setGeometry(contentsRect());
+    updateGeometry();
+    return id;
+}
+
+
+/*!
+    Removes widget \a w from this stack of widgets. Does not delete \a
+    w. If \a w is the currently visible widget, no other widget is
+    substituted.
+
+    \sa visibleWidget() raiseWidget()
+*/
+
+void TQWidgetStack::removeWidget(TQWidget * w)
+{
+    int i;
+    if (!w || (i = id(w)) == -1)
+        return ;
+
+    dict->take(i);
+    if (w == topWidget)
+        topWidget = 0;
+    if (dict->isEmpty())
+        invisible->hide(); // let background shine through again
+    updateGeometry();
+}
+
+
+/*!
+    Raises the widget with ID \a id to the top of the widget stack.
+
+    \sa visibleWidget()
+*/
+
+void TQWidgetStack::raiseWidget(int id)
+{
+    if (id == -1)
+        return;
+    TQWidget * w = dict->tqfind(id);
+    if (w)
+        raiseWidget(w);
+}
+
+static bool isChildOf(TQWidget* child, TQWidget *parent)
+{
+    if (!child)
+        return false;
+    for (int i = 0; i < parent->childrenListObject().count(); ++i) {
+        TQObject *obj = parent->childrenListObject().at(i);
+        if (!obj->isWidgetType())
+            continue;
+        TQWidget *widget = TQT_TQWIDGET((QWidget*)obj);
+        if (!widget->isWindow())
+            continue;
+        if (widget == child || isChildOf(child, widget))
+            return true;
+    }
+    return false;
+}
+
+/*!
+    \overload
+
+    Raises widget \a w to the top of the widget stack.
+*/
+
+void TQWidgetStack::raiseWidget(TQWidget *w)
+{
+    if (!w || w == invisible || w->parent() != this || w == topWidget)
+        return;
+
+    if (id(w) == -1)
+        addWidget(w);
+    if (!isVisible()) {
+        topWidget = w;
+        return;
+    }
+
+    if (w->maximumSize().width() < invisible->width()
+        || w->maximumSize().height() < invisible->height())
+        invisible->setBackgroundMode(backgroundMode());
+    else if (invisible->backgroundMode() != TQt::NoBackground)
+        invisible->setBackgroundMode(TQt::NoBackground);
+
+    if (invisible->isHidden()) {
+        invisible->setGeometry(contentsRect());
+        invisible->lower();
+        invisible->show();
+        QApplication::sendPostedEvents(invisible, QEvent::ShowWindowRequest);
+    }
+
+    // try to move focus onto the incoming widget if focus
+    // was somewhere on the outgoing widget.
+    if (topWidget) {
+        TQWidget * fw = TQT_TQWIDGET(window()->focusWidget());
+        if (topWidget->isAncestorOf(fw)) { // focus was on old page
+            // look for the best focus widget we can find
+            TQWidget *p = TQT_TQWIDGET(w->focusWidget());
+            if (!p) {
+                // second best == first child widget in the focus chain
+                TQWidget *i = fw;
+                while ((i = TQT_TQWIDGET(i->nextInFocusChain())) != fw) {
+                    if (((i->focusPolicy() & Qt::TabFocus) == Qt::TabFocus)
+                        && !i->focusProxy() && i->isVisibleTo(w) && i->isEnabled()
+                        && w->isAncestorOf(i)) {
+                        p = i;
+                        break;
+                    }
+                }
+            }
+            if (p)
+                p->setFocus();
+        } else {
+            // the focus wasn't on the old page, so we have to ensure focus doesn't go to
+            // the widget in the page that last had focus when we show the page again.
+            TQWidget *oldfw = TQT_TQWIDGET(topWidget->focusWidget());
+            if (oldfw)
+                oldfw->clearFocus();
+        }
+    }
+
+    if (isVisible()) {
+        emit aboutToShow(w);
+        int i = id(w);
+        if (i != -1)
+            emit aboutToShow(i);
+    }
+
+    topWidget = w;
+
+    for (int i = 0; i < childrenListObject().count(); ++i) {
+        TQObject * o = childrenListObject().at(i);
+        if (o->isWidgetType() && TQT_BASE_OBJECT(o) != TQT_BASE_OBJECT(w) && TQT_BASE_OBJECT(o) != TQT_BASE_OBJECT(invisible))
+            TQT_TQWIDGET((QWidget*)o)->hide();
+    }
+
+    w->setGeometry(invisible->geometry());
+    w->show();
+}
+
+/*!
+    \reimp
+*/
+
+void TQWidgetStack::frameChanged()
+{
+    TQFrame::frameChanged();
+    setChildGeometries();
+}
+
+
+/*!
+    \internal
+*/
+
+void TQWidgetStack::setFrameRect(const QRect & r)
+{
+    // ### this function used to be virtual in QFrame in Qt 3; it is no longer virtual in Qt 4
+    TQFrame::setFrameRect(r);
+    setChildGeometries();
+}
+
+
+/*!
+    Fixes up the children's geometries.
+*/
+
+void TQWidgetStack::setChildGeometries()
+{
+    invisible->setGeometry(contentsRect());
+    if (topWidget)
+        topWidget->setGeometry(invisible->geometry());
+}
+
+
+/*!
+    \reimp
+*/
+void TQWidgetStack::setVisible(bool visible)
+{
+    if (visible) {
+        //  Reimplemented in order to set the children's geometries
+        //  appropriately and to pick the first widget as d->topWidget if no
+        //  topwidget was defined
+        if (!isVisible() && !childrenListObject().isEmpty()) {
+            for (int i = 0; i < childrenListObject().count(); ++i) {
+                TQObject * o = childrenListObject().at(i);
+                if (o->isWidgetType()) {
+                    if (!topWidget && TQT_BASE_OBJECT(o) != TQT_BASE_OBJECT(invisible))
+                        topWidget = TQT_TQWIDGET((QWidget*)o);
+                    if (TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(topWidget))
+                        TQT_TQWIDGET((QWidget*)o)->show();
+                    else
+                        TQT_TQWIDGET((QWidget*)o)->hide();
+                }
+            }
+            setChildGeometries();
+        }
+    }
+    TQFrame::setVisible(visible);
+}
+
+
+/*!
+    Returns the widget with ID \a id. Returns 0 if this widget stack
+    does not manage a widget with ID \a id.
+
+    \sa id() addWidget()
+*/
+
+TQWidget * TQWidgetStack::widget(int id) const
+{
+    return id != -1 ? dict->tqfind(id) : 0;
+}
+
+
+/*!
+    Returns the ID of the \a widget. Returns -1 if \a widget is 0 or
+    is not being managed by this widget stack.
+
+    \sa widget() addWidget()
+*/
+
+int TQWidgetStack::id(TQWidget * widget) const
+{
+    if (!widget)
+        return -1;
+
+    TQIntDictIterator<TQWidget> it(*dict);
+    while (it.current() && it.current() != widget)
+        ++it;
+    return it.current() == widget ? it.currentKey() : -1;
+}
+
+
+/*!
+    Returns the currently visible widget (the one at the top of the
+    stack), or 0 if nothing is currently being shown.
+
+    \sa aboutToShow() id() raiseWidget()
+*/
+
+TQWidget * TQWidgetStack::visibleWidget() const
+{
+    return topWidget;
+}
+
+
+/*!
+    \fn void TQWidgetStack::aboutToShow(int id)
+
+    This signal is emitted just before a managed widget is shown if
+    that managed widget has an ID != -1. The \a id parameter is the numeric
+    ID of the widget.
+
+    If you call visibleWidget() in a slot connected to aboutToShow(),
+    the widget it returns is the one that is currently visible, not
+    the one that is about to be shown.
+*/
+
+
+/*!
+    \fn void TQWidgetStack::aboutToShow(QWidget *widget)
+
+    \overload
+
+    This signal is emitted just before a managed widget is shown. The
+    argument is a pointer to the \a widget.
+
+    If you call visibleWidget() in a slot connected to aboutToShow(),
+    the widget returned is the one that is currently visible, not the
+    one that is about to be shown.
+*/
+
+
+/*!
+    \reimp
+*/
+
+void TQWidgetStack::resizeEvent(TQResizeEvent * e)
+{
+    TQFrame::resizeEvent(e);
+    setChildGeometries();
+}
+
+/*!
+    \reimp
+*/
+
+TQSize TQWidgetStack::tqsizeHint() const
+{
+    constPolish();
+
+    TQSize size(0, 0);
+
+    TQIntDictIterator<TQWidget> it(*dict);
+    TQWidget *w;
+
+    while ((w = it.current()) != 0) {
+        ++it;
+        TQSize sh = w->tqsizeHint();
+        if (w->tqsizePolicy().horData() == QSizePolicy::Ignored)
+            sh.rwidth() = 0;
+        if (w->tqsizePolicy().verData() == QSizePolicy::Ignored)
+            sh.rheight() = 0;
+#ifndef QT_NO_LAYOUT
+        size = size.expandedTo(sh).expandedTo(tqSmartMinSize(w));
+#endif
+    }
+    if (size.isNull())
+        size = TQSize(128, 64);
+    size += TQSize(2*frameWidth(), 2*frameWidth());
+    return size;
+}
+
+
+/*!
+    \reimp
+*/
+TQSize TQWidgetStack::tqminimumSizeHint() const
+{
+    constPolish();
+
+    TQSize size(0, 0);
+
+    TQIntDictIterator<TQWidget> it(*dict);
+    TQWidget *w;
+
+    while ((w = it.current()) != 0) {
+        ++it;
+        TQSize sh = w->tqminimumSizeHint();
+        if (w->tqsizePolicy().horData() == QSizePolicy::Ignored)
+            sh.rwidth() = 0;
+        if (w->tqsizePolicy().verData() == QSizePolicy::Ignored)
+            sh.rheight() = 0;
+#ifndef QT_NO_LAYOUT
+        size = size.expandedTo(sh).expandedTo(w->minimumSize());
+#endif
+    }
+    if (size.isNull())
+        size = TQSize(64, 32);
+    size += TQSize(2*frameWidth(), 2*frameWidth());
+    return size;
+}
+
+/*!
+    \reimp
+*/
+void TQWidgetStack::childEvent(TQChildEvent *e)
+{
+    if (e->child()->isWidgetType() && e->removed())
+        removeWidget((TQWidget *) e->child());
+}
+
+
+/*!
+    \reimp
+*/
+bool TQWidgetStack::event(TQEvent* e)
+{
+    if (e->type() == TQEvent::LayoutRequest || e->type() == TQEvent::LayoutHint )
+        updateGeometry(); // propgate layout hints to parent
+    return TQFrame::event(e);
+}
+
+QT_END_NAMESPACE
+
+#else // USE_QT4
+
+/****************************************************************************
+**
+** Implementation of TQWidgetStack class
+**
+** Created : 980128
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the widgets 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 "tqwidgetstack.h"
+#include "tqlayout.h"
+#include "../kernel/tqlayoutengine_p.h"
+#ifndef TQT_NO_WIDGETSTACK
+
+#include "tqobjectlist.h"
+#include "tqfocusdata.h"
+#include "tqbutton.h"
+#include "tqbuttongroup.h"
+
+#include "tqapplication.h"
+
+class TQWidgetStackPrivate {
+public:
+    class Invisible: public TQWidget
+    {
+    public:
+	Invisible( TQWidgetStack * tqparent ): TQWidget( tqparent, "qt_invisible_widgetstack" )
+	{
+	    setBackgroundMode( TQt::NoBackground );
+	}
+	const char * className() const
+	{
+	    return "TQWidgetStackPrivate::Invisible";
+	}
+    };
+};
+
+
+#if (TQT_VERSION-0 >= 0x040000)
+#if defined(TQ_CC_GNU)
+#warning "Remove TQWidgetStackEventFilter"
+#endif
+#endif
+class TQWidgetStackEventFilter : public TQObject
+{
+    /* For binary compatibility, since we cannot implement virtual
+       functions and rely on them being called. This is what we should
+       have
+
+	bool TQWidgetStack::event( TQEvent* e )
+	{
+	    if ( e->type() == TQEvent::LayoutHint )
+		updateGeometry(); // propgate tqlayout hints to tqparent
+	    return TQFrame::event( e );
+	}
+    */
+public:
+
+    TQWidgetStackEventFilter( TQObject *tqparent = 0, const char * name = 0 )
+	: TQObject( tqparent, name ) {}
+    bool eventFilter( TQObject *o, TQEvent * e ) {
+	if ( e->type() == TQEvent::LayoutHint && o->isWidgetType() )
+	    ((TQWidget*)o)->updateGeometry();
+	return FALSE;
+    }
+};
+
+
+/*!
+    \class TQWidgetStack
+    \brief The TQWidgetStack class provides a stack of widgets of which
+    only the top widget is user-visible.
+
+    \ingroup organizers
+    \mainclass
+
+    The application programmer can move any widget to the top of the
+    stack at any time using raiseWidget(), and add or remove widgets
+    using addWidget() and removeWidget(). It is not sufficient to pass
+    the widget stack as tqparent to a widget which should be inserted into
+    the widgetstack.
+
+    visibleWidget() is the \e get equivalent of raiseWidget(); it
+    returns a pointer to the widget that is currently at the top of
+    the stack.
+
+    TQWidgetStack also provides the ability to manipulate widgets
+    through application-specified integer IDs. You can also translate
+    from widget pointers to IDs using id() and from IDs to widget
+    pointers using widget(). These numeric IDs are unique (per
+    TQWidgetStack, not globally), but TQWidgetStack does not attach any
+    additional meaning to them.
+
+    The default widget stack is frameless, but you can use the usual
+    TQFrame functions (such as setFrameStyle()) to add a frame.
+
+    TQWidgetStack provides a signal, aboutToShow(), which is emitted
+    just before a managed widget is shown.
+
+    \sa TQTabDialog TQTabBar TQFrame
+*/
+
+
+/*!
+    Constructs an empty widget stack.
+
+    The \a tqparent and \a name arguments are passed to the TQFrame
+    constructor.
+*/
+
+TQWidgetStack::TQWidgetStack( TQWidget * tqparent, const char *name )
+    : TQFrame( tqparent, name )
+{
+    init();
+}
+
+/*!
+  Constructs an empty widget stack.
+
+  The \a tqparent, \a name and \a f arguments are passed to the TQFrame
+  constructor.
+*/
+TQWidgetStack::TQWidgetStack( TQWidget * tqparent, const char *name, WFlags f )
+    : TQFrame( tqparent, name, f ) //## merge constructors in 4.0
+{
+    init();
+}
+
+void TQWidgetStack::init()
+{
+   d = 0;
+   TQWidgetStackEventFilter *ef = new TQWidgetStackEventFilter( TQT_TQOBJECT(this) );
+   installEventFilter( ef );
+   dict = new TQIntDict<TQWidget>;
+   tqfocusWidgets = 0;
+   topWidget = 0;
+   invisible = new TQWidgetStackPrivate::Invisible( this );
+   invisible->hide();
+}
+
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+TQWidgetStack::~TQWidgetStack()
+{
+    delete tqfocusWidgets;
+    delete d;
+    delete dict;
+}
+
+
+/*!
+    Adds widget \a w to this stack of widgets, with ID \a id.
+
+    If you pass an id \>= 0 this ID is used. If you pass an \a id of
+    -1 (the default), the widgets will be numbered automatically. If
+    you pass -2 a unique negative integer will be generated. No widget
+    has an ID of -1. Returns the ID or -1 on failure (e.g. \a w is 0).
+
+    If you pass an id that is already used, then a unique negative
+    integer will be generated to prevent two widgets having the same
+    id.
+
+    If \a w already exists in the stack the widget will be removed first.
+
+    If \a w is not a child of this TQWidgetStack moves it using
+    reparent().
+*/
+
+int TQWidgetStack::addWidget( TQWidget * w, int id )
+{
+    static int nseq_no = -2;
+    static int pseq_no = 0;
+
+    if ( !w || w == invisible )
+	return -1;
+
+    // prevent duplicates
+    removeWidget( w );
+
+    if ( id >= 0 && dict->tqfind( id ) )
+	id = -2;
+    if ( id < -1 )
+	id = nseq_no--;
+    else if ( id == -1 )
+	id = pseq_no++;
+    else
+	pseq_no = TQMAX(pseq_no, id + 1);
+	// use id >= 0 as-is
+
+    dict->insert( id, w );
+
+    // preserve existing focus
+    TQWidget * f = w->tqfocusWidget();
+    while( f && f != w )
+	f = f->parentWidget();
+    if ( f ) {
+	if ( !tqfocusWidgets )
+	    tqfocusWidgets = new TQPtrDict<TQWidget>( 17 );
+	tqfocusWidgets->tqreplace( w, w->tqfocusWidget() );
+    }
+
+    w->hide();
+    if ( w->tqparent() != TQT_TQOBJECT(this) )
+	w->reparent( this, contentsRect().topLeft(), FALSE );
+    w->setGeometry( contentsRect() );
+    updateGeometry();
+    return id;
+}
+
+
+/*!
+    Removes widget \a w from this stack of widgets. Does not delete \a
+    w. If \a w is the currently visible widget, no other widget is
+    substituted.
+
+    \sa visibleWidget() raiseWidget()
+*/
+
+void TQWidgetStack::removeWidget( TQWidget * w )
+{
+    if ( !w )
+	return;
+    int i = id( w );
+    if ( i != -1 )
+	dict->take( i );
+
+    if ( w == topWidget )
+	topWidget = 0;
+    if ( dict->isEmpty() )
+	invisible->hide(); // let background shine through again
+    updateGeometry();
+}
+
+
+/*!
+    Raises the widget with ID \a id to the top of the widget stack.
+
+    \sa visibleWidget()
+*/
+
+void TQWidgetStack::raiseWidget( int id )
+{
+    if ( id == -1 )
+	return;
+    TQWidget * w = dict->tqfind( id );
+    if ( w )
+	raiseWidget( w );
+}
+
+static bool isChildOf( TQWidget* child, TQWidget *tqparent )
+{
+    if ( !child || !tqparent->childrenListObject().isEmpty() )
+	return FALSE;
+    TQObjectListIt it(tqparent->childrenListObject());
+    TQObject *obj;
+    while ( (obj = it.current()) ) {
+	++it;
+	if ( !obj->isWidgetType() || ((TQWidget *)obj)->isTopLevel() )
+	    continue;
+	TQWidget *widget = (TQWidget *)obj;
+	if ( widget == child || isChildOf( child, widget ) )
+	    return TRUE;
+    }
+    return FALSE;
+}
+
+/*!
+    \overload
+
+    Raises widget \a w to the top of the widget stack.
+*/
+
+void TQWidgetStack::raiseWidget( TQWidget *w )
+{
+    if ( !w || w == invisible || w->tqparent() != TQT_TQOBJECT(this) || w == topWidget )
+	return;
+
+    if ( id(w) == -1 )
+	addWidget( w );
+    if ( !isVisible() ) {
+	topWidget = w;
+	return;
+    }
+
+    if (w->tqmaximumSize().width() < invisible->width()
+        || w->tqmaximumSize().height() < invisible->height())
+        invisible->setBackgroundMode(backgroundMode());
+    else if (invisible->backgroundMode() != TQt::NoBackground)
+        invisible->setBackgroundMode(TQt::NoBackground);
+
+    if ( invisible->isHidden() ) {
+	invisible->setGeometry( contentsRect() );
+	invisible->lower();
+	invisible->show();
+	TQApplication::sendPostedEvents( invisible, TQEvent::ShowWindowRequest );
+    }
+
+    // try to move focus onto the incoming widget if focus
+    // was somewhere on the outgoing widget.
+    if ( topWidget ) {
+	TQWidget * fw = tqfocusWidget();
+	TQWidget* p = fw;
+	while ( p && p != topWidget )
+	    p = p->parentWidget();
+	if ( p == topWidget ) { // focus was on old page
+	    if ( !tqfocusWidgets )
+		tqfocusWidgets = new TQPtrDict<TQWidget>( 17 );
+	    tqfocusWidgets->tqreplace( topWidget, fw );
+	    fw->clearFocus();
+	    // look for the best focus widget we can tqfind
+	    // best == what we had (which may be deleted)
+	    fw = tqfocusWidgets->take( w );
+	    if ( isChildOf( fw, w ) ) {
+		fw->setFocus();
+	    } else {
+		// second best == first child widget in the focus chain
+		TQFocusData *f = focusData();
+		TQWidget* home = f->home();
+		TQWidget *i = home;
+		do {
+		    if ( ( ( i->focusPolicy() & Qt::TabFocus ) == Qt::TabFocus )
+			 && !i->focusProxy() && i->isVisibleTo(w) && i->isEnabled() ) {
+			p = i;
+			while ( p && p != w )
+			    p = p->parentWidget();
+			if ( p == w ) {
+			    i->setFocus();
+			    break;
+			}
+		    }
+		    i = f->next();
+		} while( i != home );
+	    }
+	}
+    }
+
+    if ( isVisible() ) {
+	emit aboutToShow( w );
+	int i = id( w );
+	if ( i != -1 )
+	    emit aboutToShow( i );
+    }
+
+    topWidget = w;
+
+    TQObjectListIt it( childrenListObject() );
+    TQObject * o;
+
+    while( (o=it.current()) != 0 ) {
+	++it;
+	if ( o->isWidgetType() && o != TQT_TQOBJECT(w) && o != TQT_TQOBJECT(invisible) )
+	    ((TQWidget *)o)->hide();
+    }
+
+    w->setGeometry( invisible->tqgeometry() );
+    w->show();
+}
+
+/*!
+    \reimp
+*/
+
+void TQWidgetStack::frameChanged()
+{
+    TQFrame::frameChanged();
+    setChildGeometries();
+}
+
+
+/*!
+    \reimp
+*/
+
+void TQWidgetStack::setFrameRect( const TQRect & r )
+{
+    TQFrame::setFrameRect( r );
+    setChildGeometries();
+}
+
+
+/*!
+    Fixes up the tqchildren's geometries.
+*/
+
+void TQWidgetStack::setChildGeometries()
+{
+    invisible->setGeometry( contentsRect() );
+    if ( topWidget )
+	topWidget->setGeometry( invisible->tqgeometry() );
+}
+
+
+/*!
+    \reimp
+*/
+void TQWidgetStack::show()
+{
+    //  Reimplemented in order to set the tqchildren's geometries
+    //  appropriately and to pick the first widget as topWidget if no
+    //  topwidget was defined
+    if ( !isVisible() && !childrenListObject().isEmpty() ) {
+	TQObjectListIt it( childrenListObject() );
+	TQObject * o;
+
+	while( (o=it.current()) != 0 ) {
+	    ++it;
+	    if ( o->isWidgetType() ) {
+		if ( !topWidget && o != TQT_TQOBJECT(invisible) )
+		    topWidget = (TQWidget*)o;
+		if ( TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(topWidget) )
+		    ((TQWidget *)o)->show();
+		else
+		    ((TQWidget *)o)->hide();
+	    }
+	}
+	setChildGeometries();
+    }
+    TQFrame::show();
+}
+
+
+/*!
+    Returns the widget with ID \a id. Returns 0 if this widget stack
+    does not manage a widget with ID \a id.
+
+    \sa id() addWidget()
+*/
+
+TQWidget * TQWidgetStack::widget( int id ) const
+{
+    return id != -1 ? dict->tqfind( id ) : 0;
+}
+
+
+/*!
+    Returns the ID of the \a widget. Returns -1 if \a widget is 0 or
+    is not being managed by this widget stack.
+
+    \sa widget() addWidget()
+*/
+
+int TQWidgetStack::id( TQWidget * widget ) const
+{
+    if ( !widget )
+	return -1;
+
+    TQIntDictIterator<TQWidget> it( *dict );
+    while ( it.current() && it.current() != widget )
+	++it;
+    return it.current() == widget ? it.currentKey() : -1;
+}
+
+
+/*!
+    Returns the currently visible widget (the one at the top of the
+    stack), or 0 if nothing is currently being shown.
+
+    \sa aboutToShow() id() raiseWidget()
+*/
+
+TQWidget * TQWidgetStack::visibleWidget() const
+{
+    return topWidget;
+}
+
+
+/*!
+    \fn void TQWidgetStack::aboutToShow( int )
+
+    This signal is emitted just before a managed widget is shown if
+    that managed widget has an ID != -1. The argument is the numeric
+    ID of the widget.
+
+    If you call visibleWidget() in a slot connected to aboutToShow(),
+    the widget it returns is the one that is currently visible, not
+    the one that is about to be shown.
+*/
+
+
+/*!
+    \fn void TQWidgetStack::aboutToShow( TQWidget * )
+
+    \overload
+
+    This signal is emitted just before a managed widget is shown. The
+    argument is a pointer to the widget.
+
+    If you call visibleWidget() in a slot connected to aboutToShow(),
+    the widget returned is the one that is currently visible, not the
+    one that is about to be shown.
+*/
+
+
+/*!
+    \reimp
+*/
+
+void TQWidgetStack::resizeEvent( TQResizeEvent * e )
+{
+    TQFrame::resizeEvent( e );
+    setChildGeometries();
+}
+
+
+/*!
+    \reimp
+*/
+
+TQSize TQWidgetStack::tqsizeHint() const
+{
+    constPolish();
+
+    TQSize size( 0, 0 );
+
+    TQIntDictIterator<TQWidget> it( *dict );
+    TQWidget *w;
+
+    while ( (w = it.current()) != 0 ) {
+	++it;
+	TQSize sh = w->tqsizeHint();
+	if ( w->tqsizePolicy().horData() == TQSizePolicy::Ignored )
+	    sh.rwidth() = 0;
+	if ( w->tqsizePolicy().verData() == TQSizePolicy::Ignored )
+	    sh.rheight() = 0;
+#ifndef TQT_NO_LAYOUT
+	size = size.expandedTo( sh ).expandedTo( tqSmartMinSize(w) );
+#endif
+    }
+    if ( size.isNull() )
+	size = TQSize( 128, 64 );
+    size += TQSize( 2*frameWidth(), 2*frameWidth() );
+    return size;
+}
+
+
+/*!
+    \reimp
+*/
+TQSize TQWidgetStack::tqminimumSizeHint() const
+{
+    constPolish();
+
+    TQSize size( 0, 0 );
+
+    TQIntDictIterator<TQWidget> it( *dict );
+    TQWidget *w;
+
+    while ( (w = it.current()) != 0 ) {
+	++it;
+	TQSize sh = w->tqminimumSizeHint();
+	if ( w->tqsizePolicy().horData() == TQSizePolicy::Ignored )
+	    sh.rwidth() = 0;
+	if ( w->tqsizePolicy().verData() == TQSizePolicy::Ignored )
+	    sh.rheight() = 0;
+#ifndef TQT_NO_LAYOUT
+	size = size.expandedTo( sh ).expandedTo( w->tqminimumSize() );
+#endif
+    }
+    if ( size.isNull() )
+	size = TQSize( 64, 32 );
+    size += TQSize( 2*frameWidth(), 2*frameWidth() );
+    return size;
+}
+
+/*!
+    \reimp
+*/
+void TQWidgetStack::childEvent( TQChildEvent * e)
+{
+    if ( e->child()->isWidgetType() && e->removed() )
+	removeWidget( (TQWidget*) e->child() );
+}
+#endif
+
+#endif // USE_QT4