Add Qt3 development HEAD version

1 files changed, 2609 insertions, 0 deletions

diff --git a/src/widgets/qmainwindow.cpp b/src/widgets/qmainwindow.cpp
new file mode 100644
index 0000000..7ad2781
--- /dev/null
+++ b/src/widgets/qmainwindow.cpp
@@ -0,0 +1,2609 @@
+/****************************************************************************
+**
+** Implementation of QMainWindow class
+**
+** Created : 980312
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the widgets module of the Qt 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 Qt 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.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** 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 "qmainwindow.h"
+#ifndef QT_NO_MAINWINDOW
+
+#include "qtimer.h"
+#include "qlayout.h"
+#include "qobjectlist.h"
+#include "qintdict.h"
+#include "qapplication.h"
+#include "qptrlist.h"
+#include "qmap.h"
+#include "qcursor.h"
+#include "qpainter.h"
+#include "qmenubar.h"
+#include "qpopupmenu.h"
+#include "qtoolbar.h"
+#include "qstatusbar.h"
+#include "qscrollview.h"
+#include "qtooltip.h"
+#include "qdatetime.h"
+#include "qwhatsthis.h"
+#include "qbitmap.h"
+#include "qdockarea.h"
+#include "qstringlist.h"
+#include "qstyle.h"
+#ifdef Q_WS_MACX
+#  include "qt_mac.h"
+#endif
+
+class QHideDock;
+class QMainWindowLayout;
+
+class QMainWindowPrivate
+{
+public:
+    QMainWindowPrivate()
+	:  mb(0), sb(0), ttg(0), mc(0), tll(0), mwl(0), ubp( FALSE ), utl( FALSE ),
+	   justify( FALSE ), movable( TRUE ), opaque( FALSE ), dockMenu( TRUE )
+    {
+	docks.insert( Qt::DockTop, TRUE );
+	docks.insert( Qt::DockBottom, TRUE );
+	docks.insert( Qt::DockLeft, TRUE );
+	docks.insert( Qt::DockRight, TRUE );
+	docks.insert( Qt::DockMinimized, FALSE );
+	docks.insert( Qt::DockTornOff, TRUE );
+    }
+
+    ~QMainWindowPrivate()
+    {
+    }
+
+#ifndef QT_NO_MENUBAR
+    QMenuBar * mb;
+#else
+    QWidget * mb;
+#endif
+    QStatusBar * sb;
+    QToolTipGroup * ttg;
+
+    QWidget * mc;
+
+    QBoxLayout * tll;
+    QMainWindowLayout * mwl;
+
+    uint ubp :1;
+    uint utl :1;
+    uint justify :1;
+    uint movable :1;
+    uint opaque :1;
+    uint dockMenu :1;
+
+    QDockArea *topDock, *bottomDock, *leftDock, *rightDock;
+
+    QPtrList<QDockWindow> dockWindows;
+    QMap<Qt::Dock, bool> docks;
+    QStringList disabledDocks;
+    QHideDock *hideDock;
+
+    QGuardedPtr<QPopupMenu> rmbMenu, tbMenu, dwMenu;
+    QMap<QDockWindow*, bool> appropriate;
+    QMap<QPopupMenu*, QMainWindow::DockWindows> dockWindowModes;
+
+};
+
+
+/* QMainWindowLayout, respects widthForHeight layouts (like the left
+  and right docks are)
+*/
+
+class QMainWindowLayout : public QLayout
+{
+    Q_OBJECT
+
+public:
+    QMainWindowLayout( QMainWindow *mw, QLayout* parent = 0 );
+    ~QMainWindowLayout() {}
+
+    void addItem( QLayoutItem * );
+    void setLeftDock( QDockArea *l );
+    void setRightDock( QDockArea *r );
+    void setCentralWidget( QWidget *w );
+    bool hasHeightForWidth() const { return FALSE; }
+    QSize sizeHint() const;
+    QSize minimumSize() const;
+    QLayoutIterator iterator();
+    QSizePolicy::ExpandData expanding() const { return QSizePolicy::BothDirections; }
+    void invalidate() {}
+
+protected:
+    void setGeometry( const QRect &r ) {
+	QLayout::setGeometry( r );
+	layoutItems( r );
+    }
+
+private:
+    int layoutItems( const QRect&, bool testonly = FALSE );
+    int extraPixels() const;
+
+    QDockArea *left, *right;
+    QWidget *central;
+    QMainWindow *mainWindow;
+
+};
+
+QSize QMainWindowLayout::sizeHint() const
+{
+    int w = 0;
+    int h = 0;
+
+    if ( left ) {
+	w += left->sizeHint().width();
+	h = QMAX( h, left->sizeHint().height() );
+    }
+    if ( right ) {
+	w += right->sizeHint().width();
+	h = QMAX( h, right->sizeHint().height() );
+    }
+    if ( central ) {
+	w += central->sizeHint().width();
+	int diff = extraPixels();
+	h = QMAX( h, central->sizeHint().height() + diff );
+    }
+    return QSize( w, h );
+}
+
+QSize QMainWindowLayout::minimumSize() const
+{
+    int w = 0;
+    int h = 0;
+
+    if ( left ) {
+	QSize ms = left->minimumSizeHint().expandedTo( left->minimumSize() );
+	w += ms.width();
+	h = QMAX( h, ms.height() );
+    }
+    if ( right ) {
+	QSize ms = right->minimumSizeHint().expandedTo( right->minimumSize() );
+	w += ms.width();
+	h = QMAX( h, ms.height() );
+    }
+    if ( central ) {
+	QSize min = central->minimumSize().isNull() ?
+		    central->minimumSizeHint() : central->minimumSize();
+	w += min.width();
+	int diff = extraPixels();
+	h = QMAX( h, min.height() + diff );
+    }
+    return QSize( w, h );
+}
+
+QMainWindowLayout::QMainWindowLayout( QMainWindow *mw, QLayout* parent )
+    : QLayout( parent ), left( 0 ), right( 0 ), central( 0 )
+{
+    mainWindow = mw;
+}
+
+void QMainWindowLayout::setLeftDock( QDockArea *l )
+{
+    left = l;
+}
+
+void QMainWindowLayout::setRightDock( QDockArea *r )
+{
+    right = r;
+}
+
+void QMainWindowLayout::setCentralWidget( QWidget *w )
+{
+    central = w;
+}
+
+int QMainWindowLayout::layoutItems( const QRect &r, bool testonly )
+{
+    if ( !left && !central && !right )
+	return 0;
+
+    int wl = 0, wr = 0;
+    if ( left )
+	wl = ( (QDockAreaLayout*)left->QWidget::layout() )->widthForHeight( r.height() );
+    if ( right )
+	wr = ( (QDockAreaLayout*)right->QWidget::layout() )->widthForHeight( r.height() );
+    int w = r.width() - wr - wl;
+    if ( w < 0 )
+	w = 0;
+
+    int diff = extraPixels();
+    if ( !testonly ) {
+	QRect g( geometry() );
+	if ( left )
+	    left->setGeometry( QRect( g.x(), g.y() + diff, wl, r.height() - diff ) );
+	if ( right )
+	    right->setGeometry( QRect( g.x() + g.width() - wr, g.y() + diff, wr, r.height() - diff ) );
+	if ( central )
+	    central->setGeometry( g.x() + wl, g.y() + diff, w, r.height() - diff );
+    }
+
+    w = wl + wr;
+    if ( central )
+	w += central->minimumSize().width();
+    return w;
+}
+
+int QMainWindowLayout::extraPixels() const
+{
+    if ( mainWindow->d->topDock->isEmpty() &&
+	 !(mainWindow->d->leftDock->isEmpty() &&
+	   mainWindow->d->rightDock->isEmpty()) ) {
+	return 2;
+    } else {
+	return 0;
+    }
+}
+
+void QMainWindowLayout::addItem( QLayoutItem * /* item */ )
+{
+}
+
+
+QLayoutIterator QMainWindowLayout::iterator()
+{
+    return 0;
+}
+
+
+/*
+  QHideToolTip and QHideDock - minimized dock
+*/
+
+#ifndef QT_NO_TOOLTIP
+class QHideToolTip : public QToolTip
+{
+public:
+    QHideToolTip( QWidget *parent ) : QToolTip( parent ) {}
+    ~QHideToolTip() {}
+
+    virtual void maybeTip( const QPoint &pos );
+};
+#endif
+
+
+class QHideDock : public QWidget
+{
+    Q_OBJECT
+
+public:
+    QHideDock( QMainWindow *parent ) : QWidget( parent, "qt_hide_dock" ) {
+	hide();
+	setFixedHeight( style().pixelMetric( QStyle::PM_DockWindowHandleExtent,
+					     this ) + 3 );
+	pressedHandle = -1;
+	pressed = FALSE;
+	setMouseTracking( TRUE );
+	win = parent;
+#ifndef QT_NO_TOOLTIP
+	tip = new QHideToolTip( this );
+#endif
+    }
+    ~QHideDock()
+    {
+#ifndef QT_NO_TOOLTIP
+	delete tip;
+#endif
+    }
+
+protected:
+    void paintEvent( QPaintEvent *e ) {
+	if ( !children() || children()->isEmpty() )
+	    return;
+	QPainter p( this );
+	p.setClipRegion( e->rect() );
+	p.fillRect( e->rect(), colorGroup().brush( QColorGroup::Background ) );
+	int x = 0;
+	int i = -1;
+	QObjectListIt it( *children() );
+	QObject *o;
+	while ( ( o = it.current() ) ) {
+	    ++it;
+	    ++i;
+	    QDockWindow *dw = ::qt_cast<QDockWindow*>(o);
+	    if ( !dw || !dw->isVisible() )
+		continue;
+
+	    QStyle::SFlags flags = QStyle::Style_Default;
+	    if ( i == pressedHandle )
+		flags |= QStyle::Style_On;
+
+	    style().drawPrimitive( QStyle::PE_DockWindowHandle, &p,
+				   QRect( x, 0, 30, 10 ), colorGroup(),
+				   flags );
+	    x += 30;
+	}
+    }
+
+    void mousePressEvent( QMouseEvent *e ) {
+	pressed = TRUE;
+	if ( !children() || children()->isEmpty() )
+	    return;
+	mouseMoveEvent( e );
+	pressedHandle = -1;
+
+	if ( e->button() == RightButton && win->isDockMenuEnabled() ) {
+	    // ### TODO: HideDock menu
+	} else {
+	    mouseMoveEvent( e );
+	}
+    }
+
+    void mouseMoveEvent( QMouseEvent *e ) {
+	if ( !children() || children()->isEmpty() )
+	    return;
+	if ( !pressed )
+	    return;
+	int x = 0;
+	int i = -1;
+	if ( e->y() >= 0 && e->y() <= height() ) {
+	    QObjectListIt it( *children() );
+	    QObject *o;
+	    while ( ( o = it.current() ) ) {
+		++it;
+		++i;
+		QDockWindow *dw = ::qt_cast<QDockWindow*>(o);
+		if ( !dw || !dw->isVisible() )
+		    continue;
+
+		if ( e->x() >= x && e->x() <= x + 30 ) {
+		    int old = pressedHandle;
+		    pressedHandle = i;
+		    if ( pressedHandle != old )
+			repaint( TRUE );
+		    return;
+		}
+		x += 30;
+	    }
+	}
+	int old = pressedHandle;
+	pressedHandle = -1;
+	if ( old != -1 )
+	    repaint( TRUE );
+    }
+
+    void mouseReleaseEvent( QMouseEvent *e ) {
+	pressed = FALSE;
+	if ( pressedHandle == -1 )
+	    return;
+	if ( !children() || children()->isEmpty() )
+	    return;
+	if ( e->button() == LeftButton ) {
+	    if ( e->y() >= 0 && e->y() <= height() ) {
+		QObject *o = ( (QObjectList*)children() )->at( pressedHandle );
+		QDockWindow *dw = ::qt_cast<QDockWindow*>(o);
+		if ( dw ) {
+		    dw->show();
+		    dw->dock();
+		}
+	    }
+	}
+	pressedHandle = -1;
+	repaint( FALSE );
+    }
+
+    bool eventFilter( QObject *o, QEvent *e ) {
+	if ( o == this || !o->isWidgetType() )
+	    return QWidget::eventFilter( o, e );
+	if ( e->type() == QEvent::Hide ||
+	     e->type() == QEvent::Show ||
+	     e->type() == QEvent::ShowToParent )
+	    updateState();
+	return QWidget::eventFilter( o, e );
+    }
+
+    void updateState() {
+	bool visible = TRUE;
+	if ( !children() || children()->isEmpty() ) {
+	    visible = FALSE;
+	} else {
+	    QObjectListIt it( *children() );
+	    QObject *o;
+	    while ( ( o = it.current() ) ) {
+		++it;
+		QDockWindow *dw = ::qt_cast<QDockWindow*>(o);
+		if ( !dw )
+		    continue;
+		if ( dw->isHidden() ) {
+		    visible = FALSE;
+		    continue;
+		}
+		if ( !dw->isVisible() )
+		    continue;
+		visible = TRUE;
+		break;
+	    }
+	}
+
+	if ( visible )
+	    show();
+	else
+	    hide();
+	win->triggerLayout( FALSE );
+	update();
+    }
+
+    void childEvent( QChildEvent *e ) {
+	QWidget::childEvent( e );
+	if ( e->type() == QEvent::ChildInserted )
+	    e->child()->installEventFilter( this );
+	else
+	    e->child()->removeEventFilter( this );
+	updateState();
+    }
+
+private:
+    QMainWindow *win;
+    int pressedHandle;
+    bool pressed;
+#ifndef QT_NO_TOOLTIP
+    QHideToolTip *tip;
+    friend class QHideToolTip;
+#endif
+};
+
+#ifndef QT_NO_TOOLTIP
+void QHideToolTip::maybeTip( const QPoint &pos )
+{
+    if ( !parentWidget() )
+	return;
+    QHideDock *dock = (QHideDock*)parentWidget();
+
+    if ( !dock->children() || dock->children()->isEmpty() )
+	return;
+    QObjectListIt it( *dock->children() );
+    QObject *o;
+    int x = 0;
+    while ( ( o = it.current() ) ) {
+	++it;
+	QDockWindow *dw = ::qt_cast<QDockWindow*>(o);
+	if ( !dw || !dw->isVisible() )
+	    continue;
+
+	if ( pos.x() >= x && pos.x() <= x + 30 ) {
+	    QDockWindow *dw = (QDockWindow*)o;
+	    if ( !dw->caption().isEmpty() )
+		tip( QRect( x, 0, 30, dock->height() ), dw->caption() );
+	    return;
+	}
+	x += 30;
+    }
+}
+#endif
+
+/*!
+    \class QMainWindow qmainwindow.h
+    \brief The QMainWindow class provides a main application window,
+    with a menu bar, dock windows (e.g. for toolbars), and a status
+    bar.
+
+    \ingroup application
+    \mainclass
+
+    Main windows are most often used to provide menus, toolbars and a
+    status bar around a large central widget, such as a text edit,
+    drawing canvas or QWorkspace (for MDI applications). QMainWindow
+    is usually subclassed since this makes it easier to encapsulate
+    the central widget, menus and toolbars as well as the window's
+    state. Subclassing makes it possible to create the slots that are
+    called when the user clicks menu items or toolbar buttons. You can
+    also create main windows using \link designer-manual.book Qt
+    Designer\endlink. We'll briefly review adding menu items and
+    toolbar buttons then describe the facilities of QMainWindow
+    itself.
+
+    \code
+    QMainWindow *mw = new QMainWindow;
+    QTextEdit *edit = new QTextEdit( mw, "editor" );
+    edit->setFocus();
+    mw->setCaption( "Main Window" );
+    mw->setCentralWidget( edit );
+    mw->show();
+    \endcode
+
+    QMainWindows may be created in their own right as shown above.
+    The central widget is set with setCentralWidget(). Popup menus can
+    be added to the default menu bar, widgets can be added to the
+    status bar, toolbars and dock windows can be added to any of the
+    dock areas.
+
+    \quotefile application/main.cpp
+    \skipto ApplicationWindow
+    \printuntil show
+
+    In the extract above ApplicationWindow is a subclass of
+    QMainWindow that we must write for ourselves; this is the usual
+    approach to using QMainWindow. (The source for the extracts in
+    this description are taken from \l application/main.cpp, \l
+    application/application.cpp, \l action/main.cpp, and \l
+    action/application.cpp )
+
+    When subclassing we add the menu items and toolbars in the
+    subclass's constructor. If we've created a QMainWindow instance
+    directly we can add menu items and toolbars just as easily by
+    passing the QMainWindow instance as the parent instead of the \e
+    this pointer.
+
+    \quotefile application/application.cpp
+    \skipto help = new
+    \printuntil about
+
+    Here we've added a new menu with one menu item. The menu has been
+    inserted into the menu bar that QMainWindow provides by default
+    and which is accessible through the menuBar() function. The slot
+    will be called when the menu item is clicked.
+
+    \quotefile application/application.cpp
+    \skipto fileTools
+    \printuntil setLabel
+    \skipto QToolButton
+    \printuntil open file
+
+    This extract shows the creation of a toolbar with one toolbar
+    button. QMainWindow supplies four dock areas for toolbars. When a
+    toolbar is created as a child of a QMainWindow (or derived class)
+    instance it will be placed in a dock area (the \c Top dock area by
+    default). The slot will be called when the toolbar button is
+    clicked. Any dock window can be added to a dock area either using
+    addDockWindow(), or by creating a dock window with the QMainWindow
+    as the parent.
+
+    \quotefile application/application.cpp
+    \skipto editor
+    \printuntil statusBar
+
+    Having created the menus and toolbar we create an instance of the
+    large central widget, give it the focus and set it as the main
+    window's central widget. In the example we've also set the status
+    bar, accessed via the statusBar() function, to an initial message
+    which will be displayed for two seconds. Note that you can add
+    additional widgets to the status bar, for example labels, to show
+    further status information. See the QStatusBar documentation for
+    details, particularly the addWidget() function.
+
+    Often we want to synchronize a toolbar button with a menu item.
+    For example, if the user clicks a 'bold' toolbar button we want
+    the 'bold' menu item to be checked. This synchronization can be
+    achieved automatically by creating actions and adding the actions
+    to the toolbar and menu.
+
+    \quotefile action/application.cpp
+    \skipto QAction * fileOpen
+    \printline
+    \skipto fileOpenAction
+    \printuntil choose
+
+    Here we create an action with an icon which will be used in any
+    menu and toolbar that the action is added to. We've also given the
+    action a menu name, '\&Open', and a keyboard shortcut. The
+    connection that we have made will be used when the user clicks
+    either the menu item \e or the toolbar button.
+
+    \quotefile action/application.cpp
+    \skipto QPopupMenu * file
+    \printuntil menuBar
+    \skipto fileOpen
+    \printline
+
+    The extract above shows the creation of a popup menu. We add the
+    menu to the QMainWindow's menu bar and add our action.
+
+    \quotefile action/application.cpp
+    \skipto QToolBar * fileTool
+    \printuntil OpenAction
+
+    Here we create a new toolbar as a child of the QMainWindow and add
+    our action to the toolbar.
+
+    We'll now explore the functionality offered by QMainWindow.
+
+    The main window will take care of the dock areas, and the geometry
+    of the central widget, but all other aspects of the central widget
+    are left to you. QMainWindow automatically detects the creation of
+    a menu bar or status bar if you specify the QMainWindow as parent,
+    or you can use the provided menuBar() and statusBar() functions.
+    The functions menuBar() and statusBar() create a suitable widget
+    if one doesn't exist, and update the window's layout to make
+    space.
+
+    QMainWindow provides a QToolTipGroup connected to the status bar.
+    The function toolTipGroup() provides access to the default
+    QToolTipGroup. It isn't possible to set a different tool tip
+    group.
+
+    New dock windows and toolbars can be added to a QMainWindow using
+    addDockWindow(). Dock windows can be moved using moveDockWindow()
+    and removed with removeDockWindow(). QMainWindow allows default
+    dock window (toolbar) docking in all its dock areas (\c Top, \c
+    Left, \c Right, \c Bottom). You can use setDockEnabled() to
+    enable and disable docking areas for dock windows. When adding or
+    moving dock windows you can specify their 'edge' (dock area). The
+    currently available edges are: \c Top, \c Left, \c Right, \c
+    Bottom, \c Minimized (effectively a 'hidden' dock area) and \c
+    TornOff (floating). See \l Qt::Dock for an explanation of these
+    areas. Note that the *ToolBar functions are included for backward
+    compatibility; all new code should use the *DockWindow functions.
+    QToolbar is a subclass of QDockWindow so all functions that work
+    with dock windows work on toolbars in the same way.
+
+    \target dwm
+    If the user clicks the close button, then the dock window is
+    hidden. A dock window can be hidden or unhidden by the user by
+    right clicking a dock area and clicking the name of the relevant
+    dock window on the pop up dock window menu. This menu lists the
+    names of every dock window; visible dock windows have a tick
+    beside their names. The dock window menu is created automatically
+    as required by createDockWindowMenu(). Since it may not always be
+    appropriate for a dock window to appear on this menu the
+    setAppropriate() function is used to inform the main window
+    whether or not the dock window menu should include a particular
+    dock window. Double clicking a dock window handle (usually on the
+    left-hand side of the dock window) undocks (floats) the dock
+    window. Double clicking a floating dock window's titlebar will
+    dock the floating dock window. (See also
+    \l{QMainWindow::DockWindows}.)
+
+    Some functions change the appearance of a QMainWindow globally:
+    \list
+    \i QDockWindow::setHorizontalStretchable() and
+    QDockWindow::setVerticalStretchable() are used to make specific dock
+    windows or toolbars stretchable.
+    \i setUsesBigPixmaps() is used to set whether tool buttons should
+    draw small or large pixmaps (see QIconSet for more information).
+    \i setUsesTextLabel() is used to set whether tool buttons
+    should display a textual label in addition to pixmaps
+    (see QToolButton for more information).
+    \endlist
+
+    The user can drag dock windows into any enabled docking area. Dock
+    windows can also be dragged \e within a docking area, for example
+    to rearrange the order of some toolbars. Dock windows can also be
+    dragged outside any docking area (undocked or 'floated'). Being
+    able to drag dock windows can be enabled (the default) and
+    disabled using setDockWindowsMovable().
+
+    The \c Minimized edge is a hidden dock area. If this dock area is
+    enabled the user can hide (minimize) a dock window or show (restore)
+    a minimized dock window by clicking the dock window handle. If the
+    user hovers the mouse cursor over one of the handles, the caption of
+    the dock window is displayed in a tool tip (see
+    QDockWindow::caption() or QToolBar::label()), so if you enable the
+    \c Minimized dock area, it is best to specify a meaningful caption
+    or label for each dock window. To minimize a dock window
+    programmatically use moveDockWindow() with an edge of \c Minimized.
+
+    Dock windows are moved transparently by default, i.e. during the
+    drag an outline rectangle is drawn on the screen representing the
+    position of the dock window as it moves. If you want the dock
+    window to be shown normally whilst it is moved use
+    setOpaqueMoving().
+
+    The location of a dock window, i.e. its dock area and position
+    within the dock area, can be determined by calling getLocation().
+    Movable dock windows can be lined up to minimize wasted space with
+    lineUpDockWindows(). Pointers to the dock areas are available from
+    topDock(), leftDock(), rightDock() and bottomDock(). A customize
+    menu item is added to the pop up dock window menu if
+    isCustomizable() returns TRUE; it returns FALSE by default.
+    Reimplement isCustomizable() and customize() if you want to offer
+    this extra menu item, for example, to allow the user to change
+    settings relating to the main window and its toolbars and dock
+    windows.
+
+    The main window's menu bar is fixed (at the top) by default. If
+    you want a movable menu bar, create a QMenuBar as a stretchable
+    widget inside its own movable dock window and restrict this dock
+    window to only live within the \c Top or \c Bottom dock:
+
+    \code
+    QToolBar *tb = new QToolBar( this );
+    addDockWindow( tb, tr( "Menubar" ), Top, FALSE );
+    QMenuBar *mb = new QMenuBar( tb );
+    mb->setFrameStyle( QFrame::NoFrame );
+    tb->setStretchableWidget( mb );
+    setDockEnabled( tb, Left, FALSE );
+    setDockEnabled( tb, Right, FALSE );
+    \endcode
+
+    An application with multiple dock windows can choose to save the
+    current dock window layout in order to restore it later, e.g. in
+    the next session. You can do this by using the streaming operators
+    for QMainWindow.
+
+    To save the layout and positions of all the dock windows do this:
+
+    \code
+    QFile file( filename );
+    if ( file.open( IO_WriteOnly ) ) {
+	QTextStream stream( &file );
+	stream << *mainWindow;
+	file.close();
+    }
+    \endcode
+
+    To restore the dock window positions and sizes (normally when the
+    application is next started), do following:
+
+    \code
+    QFile file( filename );
+    if ( file.open( IO_ReadOnly ) ) {
+	QTextStream stream( &file );
+	stream >> *mainWindow;
+	file.close();
+    }
+    \endcode
+
+    The QSettings class can be used in conjunction with the streaming
+    operators to store the application's settings.
+
+    QMainWindow's management of dock windows and toolbars is done
+    transparently behind-the-scenes by QDockArea.
+
+    For multi-document interfaces (MDI), use a QWorkspace as the
+    central widget.
+
+    Adding dock windows, e.g. toolbars, to QMainWindow's dock areas is
+    straightforward. If the supplied dock areas are not sufficient for
+    your application we suggest that you create a QWidget subclass and
+    add your own dock areas (see \l QDockArea) to the subclass since
+    QMainWindow provides functionality specific to the standard dock
+    areas it provides.
+
+    <img src=qmainwindow-m.png> <img src=qmainwindow-w.png>
+
+    \sa QToolBar QDockWindow QStatusBar QAction QMenuBar QPopupMenu QToolTipGroup QDialog
+*/
+
+/*! \enum Qt::ToolBarDock
+    \internal
+*/
+
+/*!
+    \enum Qt::Dock
+
+    Each dock window can be in one of the following positions:
+
+    \value DockTop  above the central widget, below the menu bar.
+
+    \value DockBottom  below the central widget, above the status bar.
+
+    \value DockLeft  to the left of the central widget.
+
+    \value DockRight to the right of the central widget.
+
+    \value DockMinimized the dock window is not shown (this is
+    effectively a 'hidden' dock area); the handles of all minimized
+    dock windows are drawn in one row below the menu bar.
+
+    \value DockTornOff the dock window floats as its own top level
+    window which always stays on top of the main window.
+
+    \value DockUnmanaged not managed by a QMainWindow.
+*/
+
+/*!
+    \enum QMainWindow::DockWindows
+
+    Right-clicking a dock area will pop-up the dock window menu
+    (createDockWindowMenu() is called automatically). When called in
+    code you can specify what items should appear on the menu with
+    this enum.
+
+    \value OnlyToolBars The menu will list all the toolbars, but not
+    any other dock windows.
+
+    \value NoToolBars The menu will list dock windows but not
+    toolbars.
+
+    \value AllDockWindows The menu will list all toolbars and other
+    dock windows. (This is the default.)
+*/
+
+/*!
+    \obsolete
+    \fn void QMainWindow::addToolBar( QDockWindow *, Dock = Top, bool newLine = FALSE );
+*/
+
+/*!
+    \obsolete
+    \overload void QMainWindow::addToolBar( QDockWindow *, const QString &label, Dock = Top, bool newLine = FALSE );
+*/
+
+/*!
+    \obsolete
+    \fn void QMainWindow::moveToolBar( QDockWindow *, Dock = Top );
+*/
+
+/*!
+    \obsolete
+    \overload void QMainWindow::moveToolBar( QDockWindow *, Dock, bool nl, int index, int extraOffset = -1 );
+*/
+
+/*!
+    \obsolete
+    \fn void QMainWindow::removeToolBar( QDockWindow * );
+*/
+
+/*!
+    \obsolete
+    \fn void QMainWindow::lineUpToolBars( bool keepNewLines = FALSE );
+*/
+
+/*!
+    \obsolete
+    \fn void QMainWindow::toolBarPositionChanged( QToolBar * );
+*/
+
+/*!
+    \obsolete
+    \fn bool QMainWindow::toolBarsMovable() const
+*/
+
+/*!
+    \obsolete
+    \fn void QMainWindow::setToolBarsMovable( bool )
+*/
+
+/*!
+    Constructs an empty main window. The \a parent, \a name and widget
+    flags \a f, are passed on to the QWidget constructor.
+
+    By default, the widget flags are set to \c WType_TopLevel rather
+    than 0 as they are with QWidget. If you don't want your
+    QMainWindow to be a top level widget then you will need to set \a
+    f to 0.
+*/
+
+QMainWindow::QMainWindow( QWidget * parent, const char * name, WFlags f )
+    : QWidget( parent, name, f )
+{
+    d = new QMainWindowPrivate;
+#ifdef Q_WS_MACX
+    d->opaque = TRUE;
+#else
+    d->opaque = FALSE;
+#endif
+    installEventFilter( this );
+    d->topDock = new QDockArea( Horizontal, QDockArea::Normal, this, "qt_top_dock" );
+    d->topDock->installEventFilter( this );
+    d->bottomDock = new QDockArea( Horizontal, QDockArea::Reverse, this, "qt_bottom_dock" );
+    d->bottomDock->installEventFilter( this );
+    d->leftDock = new QDockArea( Vertical, QDockArea::Normal, this, "qt_left_dock" );
+    d->leftDock->installEventFilter( this );
+    d->rightDock = new QDockArea( Vertical, QDockArea::Reverse, this, "qt_right_dock" );
+    d->rightDock->installEventFilter( this );
+    d->hideDock = new QHideDock( this );
+}
+
+
+/*!
+    Destroys the object and frees any allocated resources.
+*/
+
+QMainWindow::~QMainWindow()
+{
+    delete layout();
+    delete d;
+}
+
+#ifndef QT_NO_MENUBAR
+/*!
+    Sets this main window to use the menu bar \a newMenuBar.
+
+    The existing menu bar (if any) is deleted along with its contents.
+
+    \sa menuBar()
+*/
+
+void QMainWindow::setMenuBar( QMenuBar * newMenuBar )
+{
+    if ( !newMenuBar )
+	return;
+    if ( d->mb )
+	delete d->mb;
+    d->mb = newMenuBar;
+    d->mb->installEventFilter( this );
+    triggerLayout();
+}
+
+
+/*!
+    Returns the menu bar for this window.
+
+    If there isn't one, then menuBar() creates an empty menu bar.
+
+    \sa statusBar()
+*/
+
+QMenuBar * QMainWindow::menuBar() const
+{
+    if ( d->mb )
+	return d->mb;
+
+    QObjectList * l
+	= ((QObject*)this)->queryList( "QMenuBar", 0, FALSE, FALSE );
+    QMenuBar * b;
+    if ( l && l->count() ) {
+	b = (QMenuBar *)l->first();
+    } else {
+	b = new QMenuBar( (QMainWindow *)this, "automatic menu bar" );
+	b->show();
+    }
+    delete l;
+    d->mb = b;
+    d->mb->installEventFilter( this );
+    ((QMainWindow *)this)->triggerLayout();
+    return b;
+}
+#endif // QT_NO_MENUBAR
+
+/*!
+    Sets this main window to use the status bar \a newStatusBar.
+
+    The existing status bar (if any) is deleted along with its
+    contents.
+
+    Note that \a newStatusBar \e must be a child of this main window,
+    and that it is not automatically displayed. If you call this
+    function after show(), you will probably also need to call
+    newStatusBar->show().
+
+    \sa setMenuBar() statusBar()
+*/
+
+void QMainWindow::setStatusBar( QStatusBar * newStatusBar )
+{
+    if ( !newStatusBar || newStatusBar == d->sb )
+	return;
+    if ( d->sb )
+	delete d->sb;
+    d->sb = newStatusBar;
+#ifndef QT_NO_TOOLTIP
+    // ### this code can cause unnecessary creation of a tool tip group
+    connect( toolTipGroup(), SIGNAL(showTip(const QString&)),
+	     d->sb, SLOT(message(const QString&)) );
+    connect( toolTipGroup(), SIGNAL(removeTip()),
+	     d->sb, SLOT(clear()) );
+#endif
+    d->sb->installEventFilter( this );
+    triggerLayout();
+}
+
+
+/*!
+    Returns this main window's status bar. If there isn't one,
+    statusBar() creates an empty status bar, and if necessary a tool
+    tip group too.
+
+    \sa  menuBar() toolTipGroup()
+*/
+
+QStatusBar * QMainWindow::statusBar() const
+{
+    if ( d->sb )
+	return d->sb;
+
+    QObjectList * l
+	= ((QObject*)this)->queryList( "QStatusBar", 0, FALSE, FALSE );
+    QStatusBar * s;
+    if ( l && l->count() ) {
+	s = (QStatusBar *)l->first();
+    } else {
+	s = new QStatusBar( (QMainWindow *)this, "automatic status bar" );
+	s->show();
+    }
+    delete l;
+    ((QMainWindow *)this)->setStatusBar( s );
+    ((QMainWindow *)this)->triggerLayout( TRUE );
+    return s;
+}
+
+
+#ifndef QT_NO_TOOLTIP
+/*!
+    Sets this main window to use the tool tip group \a
+    newToolTipGroup.
+
+    The existing tool tip group (if any) is deleted along with its
+    contents. All the tool tips connected to it lose the ability to
+    display the group texts.
+
+    \sa menuBar() toolTipGroup()
+*/
+
+void QMainWindow::setToolTipGroup( QToolTipGroup * newToolTipGroup )
+{
+    if ( !newToolTipGroup || newToolTipGroup == d->ttg )
+	return;
+    if ( d->ttg )
+	delete d->ttg;
+    d->ttg = newToolTipGroup;
+
+    connect( toolTipGroup(), SIGNAL(showTip(const QString&)),
+	     statusBar(), SLOT(message(const QString&)) );
+    connect( toolTipGroup(), SIGNAL(removeTip()),
+	     statusBar(), SLOT(clear()) );
+}
+
+
+/*!
+    Returns this main window's tool tip group. If there isn't one,
+    toolTipGroup() creates an empty tool tip group.
+
+    \sa menuBar() statusBar()
+*/
+
+QToolTipGroup * QMainWindow::toolTipGroup() const
+{
+    if ( d->ttg )
+	return d->ttg;
+
+    QToolTipGroup * t = new QToolTipGroup( (QMainWindow*)this,
+					   "automatic tool tip group" );
+    ((QMainWindowPrivate*)d)->ttg = t;
+    return t;
+}
+#endif
+
+
+/*!
+    If \a enable is TRUE then users can dock windows in the \a dock
+    area. If \a enable is FALSE users cannot dock windows in the \a
+    dock dock area.
+
+    Users can dock (drag) dock windows into any enabled dock area.
+*/
+
+void QMainWindow::setDockEnabled( Dock dock, bool enable )
+{
+    d->docks.replace( dock, enable );
+}
+
+
+/*!
+    Returns TRUE if the \a dock dock area is enabled, i.e. it can
+    accept user dragged dock windows; otherwise returns FALSE.
+
+    \sa setDockEnabled()
+*/
+
+bool QMainWindow::isDockEnabled( Dock dock ) const
+{
+    return d->docks[ dock ];
+}
+
+/*!
+    \overload
+
+    Returns TRUE if dock area \a area is enabled, i.e. it can accept
+    user dragged dock windows; otherwise returns FALSE.
+
+    \sa setDockEnabled()
+*/
+
+bool QMainWindow::isDockEnabled( QDockArea *area ) const
+{
+
+    if ( area == d->leftDock )
+	return d->docks[ DockLeft ];
+    if ( area == d->rightDock )
+	return d->docks[ DockRight ];
+    if ( area == d->topDock )
+	return d->docks[ DockTop ];
+    if ( area == d->bottomDock )
+	return d->docks[ DockBottom ];
+    return FALSE;
+}
+
+/*!
+    \overload
+
+    If \a enable is TRUE then users can dock the \a dw dock window in
+    the \a dock area. If \a enable is FALSE users cannot dock the \a
+    dw dock window in the \a dock area.
+
+    In general users can dock (drag) dock windows into any enabled
+    dock area. Using this function particular dock areas can be
+    enabled (or disabled) as docking points for particular dock
+    windows.
+*/
+
+
+void QMainWindow::setDockEnabled( QDockWindow *dw, Dock dock, bool enable )
+{
+    if ( d->dockWindows.find( dw ) == -1 ) {
+	d->dockWindows.append( dw );
+	connect( dw, SIGNAL( placeChanged(QDockWindow::Place) ),
+		 this, SLOT( slotPlaceChanged() ) );
+    }
+    QString s;
+    s.sprintf( "%p_%d", (void*)dw, (int)dock );
+    if ( enable )
+	d->disabledDocks.remove( s );
+    else if ( d->disabledDocks.find( s ) == d->disabledDocks.end() )
+	d->disabledDocks << s;
+    switch ( dock ) {
+	case DockTop:
+	    topDock()->setAcceptDockWindow( dw, enable );
+	    break;
+	case DockLeft:
+	    leftDock()->setAcceptDockWindow( dw, enable );
+	    break;
+	case DockRight:
+	    rightDock()->setAcceptDockWindow( dw, enable );
+	    break;
+	case DockBottom:
+	    bottomDock()->setAcceptDockWindow( dw, enable );
+	    break;
+	default:
+	    break;
+    }
+}
+
+/*!
+    \overload
+
+    Returns TRUE if dock area \a area is enabled for the dock window
+    \a dw; otherwise returns FALSE.
+
+    \sa setDockEnabled()
+*/
+
+bool QMainWindow::isDockEnabled( QDockWindow *dw, QDockArea *area ) const
+{
+    if ( !isDockEnabled( area ) )
+	return FALSE;
+    Dock dock;
+    if ( area == d->leftDock )
+	dock = DockLeft;
+    else if ( area == d->rightDock )
+	dock = DockRight;
+    else if ( area == d->topDock )
+	dock = DockTop;
+    else if ( area == d->bottomDock )
+	dock = DockBottom;
+    else
+	return FALSE;
+    return isDockEnabled( dw, dock );
+}
+
+/*!
+    \overload
+
+    Returns TRUE if dock area \a dock is enabled for the dock window
+    \a tb; otherwise returns FALSE.
+
+    \sa setDockEnabled()
+*/
+
+bool QMainWindow::isDockEnabled( QDockWindow *tb, Dock dock ) const
+{
+    if ( !isDockEnabled( dock ) )
+	return FALSE;
+    QString s;
+    s.sprintf( "%p_%d", (void*)tb, (int)dock );
+    return d->disabledDocks.find( s ) == d->disabledDocks.end();
+}
+
+
+
+/*!
+    Adds \a dockWindow to the \a edge dock area.
+
+    If \a newLine is FALSE (the default) then the \a dockWindow is
+    added at the end of the \a edge. For vertical edges the end is at
+    the bottom, for horizontal edges (including \c Minimized) the end
+    is at the right. If \a newLine is TRUE a new line of dock windows
+    is started with \a dockWindow as the first (left-most and
+    top-most) dock window.
+
+    If \a dockWindow is managed by another main window, it is first
+    removed from that window.
+*/
+
+void QMainWindow::addDockWindow( QDockWindow *dockWindow,
+			      Dock edge, bool newLine )
+{
+#ifdef Q_WS_MAC
+    if(isTopLevel() && edge == DockTop)
+	ChangeWindowAttributes((WindowPtr)handle(), kWindowToolbarButtonAttribute, 0);
+#endif
+    moveDockWindow( dockWindow, edge );
+    dockWindow->setNewLine( newLine );
+    if ( d->dockWindows.find( dockWindow ) == -1 ) {
+	d->dockWindows.append( dockWindow );
+	connect( dockWindow, SIGNAL( placeChanged(QDockWindow::Place) ),
+		 this, SLOT( slotPlaceChanged() ) );
+	dockWindow->installEventFilter( this );
+    }
+    dockWindow->setOpaqueMoving( d->opaque );
+}
+
+
+/*!
+    \overload
+
+    Adds \a dockWindow to the dock area with label \a label.
+
+    If \a newLine is FALSE (the default) the \a dockWindow is added at
+    the end of the \a edge. For vertical edges the end is at the
+    bottom, for horizontal edges (including \c Minimized) the end is
+    at the right. If \a newLine is TRUE a new line of dock windows is
+    started with \a dockWindow as the first (left-most and top-most)
+    dock window.
+
+    If \a dockWindow is managed by another main window, it is first
+    removed from that window.
+*/
+
+void QMainWindow::addDockWindow( QDockWindow * dockWindow, const QString &label,
+			      Dock edge, bool newLine )
+{
+    addDockWindow( dockWindow, edge, newLine );
+#ifndef QT_NO_TOOLBAR
+    QToolBar *tb = ::qt_cast<QToolBar*>(dockWindow);
+    if ( tb )
+	tb->setLabel( label );
+#endif
+}
+
+/*!
+    Moves \a dockWindow to the end of the \a edge.
+
+    For vertical edges the end is at the bottom, for horizontal edges
+    (including \c Minimized) the end is at the right.
+
+    If \a dockWindow is managed by another main window, it is first
+    removed from that window.
+*/
+
+void QMainWindow::moveDockWindow( QDockWindow * dockWindow, Dock edge )
+{
+    Orientation oo = dockWindow->orientation();
+    switch ( edge ) {
+    case DockTop:
+	if ( dockWindow->area() != d->topDock )
+	    dockWindow->removeFromDock( FALSE );
+	d->topDock->moveDockWindow( dockWindow );
+	emit dockWindowPositionChanged( dockWindow );
+	break;
+    case DockBottom:
+	if ( dockWindow->area() != d->bottomDock )
+	    dockWindow->removeFromDock( FALSE );
+	d->bottomDock->moveDockWindow( dockWindow );
+	emit dockWindowPositionChanged( dockWindow );
+	break;
+    case DockRight:
+	if ( dockWindow->area() != d->rightDock )
+	    dockWindow->removeFromDock( FALSE );
+	d->rightDock->moveDockWindow( dockWindow );
+	emit dockWindowPositionChanged( dockWindow );
+	break;
+    case DockLeft:
+	if ( dockWindow->area() != d->leftDock )
+	    dockWindow->removeFromDock( FALSE );
+	d->leftDock->moveDockWindow( dockWindow );
+	emit dockWindowPositionChanged( dockWindow );
+	break;
+    case DockTornOff:
+	dockWindow->undock();
+	break;
+    case DockMinimized:
+	dockWindow->undock( d->hideDock );
+	break;
+    case DockUnmanaged:
+	break;
+    }
+
+    if ( oo != dockWindow->orientation() )
+	dockWindow->setOrientation( dockWindow->orientation() );
+}
+
+/*!
+    \overload
+
+    Moves \a dockWindow to position \a index within the \a edge dock
+    area.
+
+    Any dock windows with positions \a index or higher have their
+    position number incremented and any of these on the same line are
+    moved right (down for vertical dock areas) to make room.
+
+    If \a nl is TRUE, a new dock window line is created below the line
+    in which the moved dock window appears and the moved dock window,
+    with any others with higher positions on the same line, is moved
+    to this new line.
+
+    The \a extraOffset is the space to put between the left side of
+    the dock area (top side for vertical dock areas) and the dock
+    window. (This is mostly used for restoring dock windows to the
+    positions the user has dragged them to.)
+
+    If \a dockWindow is managed by another main window, it is first
+    removed from that window.
+*/
+
+void QMainWindow::moveDockWindow( QDockWindow * dockWindow, Dock edge, bool nl, int index, int extraOffset )
+{
+    Orientation oo = dockWindow->orientation();
+
+    dockWindow->setNewLine( nl );
+    dockWindow->setOffset( extraOffset );
+    switch ( edge ) {
+    case DockTop:
+	if ( dockWindow->area() != d->topDock )
+	    dockWindow->removeFromDock( FALSE );
+	d->topDock->moveDockWindow( dockWindow, index );
+	break;
+    case DockBottom:
+	if ( dockWindow->area() != d->bottomDock )
+	    dockWindow->removeFromDock( FALSE );
+	d->bottomDock->moveDockWindow( dockWindow, index );
+	break;
+    case DockRight:
+	if ( dockWindow->area() != d->rightDock )
+	    dockWindow->removeFromDock( FALSE );
+	d->rightDock->moveDockWindow( dockWindow, index );
+	break;
+    case DockLeft:
+	if ( dockWindow->area() != d->leftDock )
+	    dockWindow->removeFromDock( FALSE );
+	d->leftDock->moveDockWindow( dockWindow, index );
+	break;
+    case DockTornOff:
+	dockWindow->undock();
+	break;
+    case DockMinimized:
+	dockWindow->undock( d->hideDock );
+	break;
+    case DockUnmanaged:
+	break;
+    }
+
+    if ( oo != dockWindow->orientation() )
+	dockWindow->setOrientation( dockWindow->orientation() );
+}
+
+/*!
+    Removes \a dockWindow from the main window's docking area,
+    provided \a dockWindow is non-null and managed by this main
+    window.
+*/
+
+void QMainWindow::removeDockWindow( QDockWindow * dockWindow )
+{
+#ifdef Q_WS_MAC
+    if(isTopLevel() && dockWindow->area() == topDock() && !dockWindows( DockTop ).count())
+	ChangeWindowAttributes((WindowPtr)handle(), 0, kWindowToolbarButtonAttribute);
+#endif
+
+    dockWindow->hide();
+    d->dockWindows.removeRef( dockWindow );
+    disconnect( dockWindow, SIGNAL( placeChanged(QDockWindow::Place) ),
+		this, SLOT( slotPlaceChanged() ) );
+    dockWindow->removeEventFilter( this );
+}
+
+/*!
+    Sets up the geometry management of the window. It is called
+    automatically when needed, so you shouldn't need to call it.
+*/
+
+void QMainWindow::setUpLayout()
+{
+#ifndef QT_NO_MENUBAR
+    if ( !d->mb ) {
+	// slightly evil hack here.  reconsider this
+	QObjectList * l
+	    = ((QObject*)this)->queryList( "QMenuBar", 0, FALSE, FALSE );
+	if ( l && l->count() )
+	    d->mb = menuBar();
+	delete l;
+    }
+#endif
+    if ( !d->sb ) {
+	// as above.
+	QObjectList * l
+	    = ((QObject*)this)->queryList( "QStatusBar", 0, FALSE, FALSE );
+	if ( l && l->count() )
+	    d->sb = statusBar();
+	delete l;
+    }
+
+    if (!d->tll) {
+        d->tll = new QBoxLayout( this, QBoxLayout::Down );
+        d->tll->setResizeMode( minimumSize().isNull() ? QLayout::Minimum : QLayout::FreeResize );
+    } else {
+        d->tll->setMenuBar( 0 );
+        QLayoutIterator it = d->tll->iterator();
+        QLayoutItem *item;
+        while ( (item = it.takeCurrent()) )
+	    delete item;
+    }
+
+#ifndef QT_NO_MENUBAR
+    if ( d->mb && d->mb->isVisibleTo( this ) ) {
+	d->tll->setMenuBar( d->mb );
+	if (style().styleHint(QStyle::SH_MainWindow_SpaceBelowMenuBar, this))
+	    d->tll->addSpacing( d->movable ? 1 : 2 );
+    }
+#endif
+
+    d->tll->addWidget( d->hideDock );
+    if(d->topDock->parentWidget() == this)
+	d->tll->addWidget( d->topDock );
+
+    QMainWindowLayout *mwl = new QMainWindowLayout( this, d->tll );
+    d->tll->setStretchFactor( mwl, 1 );
+
+    if(d->leftDock->parentWidget() == this)
+	mwl->setLeftDock( d->leftDock );
+    if ( centralWidget() )
+	mwl->setCentralWidget( centralWidget() );
+    if(d->rightDock->parentWidget() == this)
+	mwl->setRightDock( d->rightDock );
+    d->mwl = mwl;
+
+    if(d->bottomDock->parentWidget() == this)
+	d->tll->addWidget( d->bottomDock );
+
+    if ( d->sb && d->sb->parentWidget() == this) {
+	d->tll->addWidget( d->sb, 0 );
+	// make the sb stay on top of tool bars if there isn't enough space
+	d->sb->raise();
+    }
+}
+
+/*!  \reimp */
+void QMainWindow::show()
+{
+    if ( !d->tll )
+	setUpLayout();
+
+    // show all floating dock windows not explicitly hidden
+    if (!isVisible()) {
+	QPtrListIterator<QDockWindow> it(d->dockWindows);
+	while ( it.current() ) {
+	    QDockWindow *dw = it.current();
+	    ++it;
+	    if ( dw->isTopLevel() && !dw->isVisible() && !dw->testWState(WState_ForceHide) )
+		dw->show();
+	}
+    }
+
+    // show us last so we get focus
+    QWidget::show();
+}
+
+
+/*! \reimp
+*/
+void QMainWindow::hide()
+{
+    if ( isVisible() ) {
+	QPtrListIterator<QDockWindow> it(d->dockWindows);
+	while ( it.current() ) {
+	    QDockWindow *dw = it.current();
+	    ++it;
+	    if ( dw->isTopLevel() && dw->isVisible() ) {
+		dw->hide(); // implicit hide, so clear forcehide
+		((QMainWindow*)dw)->clearWState(WState_ForceHide);
+	    }
+	}
+    }
+
+    QWidget::hide();
+}
+
+
+/*!  \reimp */
+QSize QMainWindow::sizeHint() const
+{
+    QMainWindow* that = (QMainWindow*) this;
+    // Workaround: because d->tll get's deleted in
+    // totalSizeHint->polish->sendPostedEvents->childEvent->triggerLayout
+    // [eg. canvas example on Qt/Embedded]
+    QApplication::sendPostedEvents( that, QEvent::ChildInserted );
+    if ( !that->d->tll )
+	that->setUpLayout();
+    return that->d->tll->totalSizeHint();
+}
+
+/*!  \reimp */
+QSize QMainWindow::minimumSizeHint() const
+{
+    if ( !d->tll ) {
+	QMainWindow* that = (QMainWindow*) this;
+	that->setUpLayout();
+    }
+    return d->tll->totalMinimumSize();
+}
+
+/*!
+    Sets the central widget for this main window to \a w.
+
+    The central widget is surrounded by the left, top, right and
+    bottom dock areas. The menu bar is above the top dock area.
+
+    \sa centralWidget()
+*/
+
+void QMainWindow::setCentralWidget( QWidget * w )
+{
+    if ( d->mc )
+	d->mc->removeEventFilter( this );
+    d->mc = w;
+    if ( d->mc )
+	d->mc->installEventFilter( this );
+    triggerLayout();
+}
+
+
+/*!
+    Returns a pointer to the main window's central widget.
+
+    The central widget is surrounded by the left, top, right and
+    bottom dock areas. The menu bar is above the top dock area.
+
+    \sa setCentralWidget()
+*/
+
+QWidget * QMainWindow::centralWidget() const
+{
+    return d->mc;
+}
+
+
+/*! \reimp */
+
+void QMainWindow::paintEvent( QPaintEvent * )
+{
+    if (d->mb &&
+	style().styleHint(QStyle::SH_MainWindow_SpaceBelowMenuBar, this)) {
+	QPainter p( this );
+	int y = d->mb->height() + 1;
+	style().drawPrimitive(QStyle::PE_Separator, &p, QRect(0, y, width(), 1),
+			      colorGroup(), QStyle::Style_Sunken);
+    }
+}
+
+
+bool QMainWindow::dockMainWindow( QObject *dock )
+{
+    while ( dock ) {
+	if ( dock->parent() && dock->parent() == this )
+	    return TRUE;
+	if ( ::qt_cast<QMainWindow*>(dock->parent()) )
+	    return FALSE;
+	dock = dock->parent();
+    }
+    return FALSE;
+}
+
+/*!
+    \reimp
+*/
+
+bool QMainWindow::eventFilter( QObject* o, QEvent *e )
+{
+    if ( e->type() == QEvent::Show && o == this ) {
+	if ( !d->tll )
+	    setUpLayout();
+	d->tll->activate();
+    } else if ( e->type() == QEvent::ContextMenu && d->dockMenu &&
+	( ::qt_cast<QDockArea*>(o) && dockMainWindow( o ) || o == d->hideDock || o == d->mb ) ) {
+	if ( showDockMenu( ( (QMouseEvent*)e )->globalPos() ) ) {
+	    ( (QContextMenuEvent*)e )->accept();
+	    return TRUE;
+	}
+    }
+
+    return QWidget::eventFilter( o, e );
+}
+
+
+/*!
+    Monitors events, recieved in \a e, to ensure the layout is updated.
+*/
+void QMainWindow::childEvent( QChildEvent* e)
+{
+    if ( e->type() == QEvent::ChildRemoved ) {
+	if ( e->child() == 0 ||
+	     !e->child()->isWidgetType() ||
+	     ((QWidget*)e->child())->testWFlags( WType_TopLevel ) ) {
+	    // nothing
+	} else if ( e->child() == d->sb ) {
+	    d->sb = 0;
+	    triggerLayout();
+	} else if ( e->child() == d->mb ) {
+	    d->mb = 0;
+	    triggerLayout();
+	} else if ( e->child() == d->mc ) {
+	    d->mc = 0;
+	    d->mwl->setCentralWidget( 0 );
+	    triggerLayout();
+	} else if ( ::qt_cast<QDockWindow*>(e->child()) ) {
+	    removeDockWindow( (QDockWindow *)(e->child()) );
+	    d->appropriate.remove( (QDockWindow*)e->child() );
+	    triggerLayout();
+	}
+    } else if ( e->type() == QEvent::ChildInserted && !d->sb ) {
+	d->sb = ::qt_cast<QStatusBar*>(e->child());
+	if ( d->sb ) {
+	    if ( d->tll ) {
+		if ( !d->tll->findWidget( d->sb ) )
+		    d->tll->addWidget( d->sb );
+	    } else {
+		triggerLayout();
+	    }
+	}
+    }
+}
+
+/*!
+    \reimp
+*/
+
+bool QMainWindow::event( QEvent * e )
+{
+    if ( e->type() == QEvent::ChildRemoved && ( (QChildEvent*)e )->child() == d->mc ) {
+	d->mc->removeEventFilter( this );
+	d->mc = 0;
+	d->mwl->setCentralWidget( 0 );
+    }
+
+    return QWidget::event( e );
+}
+
+
+/*!
+    \property QMainWindow::usesBigPixmaps
+    \brief whether big pixmaps are enabled
+
+    If FALSE (the default), the tool buttons will use small pixmaps;
+    otherwise big pixmaps will be used.
+
+    Tool buttons and other widgets that wish to respond to this
+    setting are responsible for reading the correct state on startup,
+    and for connecting to the main window's widget's
+    pixmapSizeChanged() signal.
+*/
+
+bool QMainWindow::usesBigPixmaps() const
+{
+    return d->ubp;
+}
+
+void QMainWindow::setUsesBigPixmaps( bool enable )
+{
+    if ( enable == (bool)d->ubp )
+	return;
+
+    d->ubp = enable;
+    emit pixmapSizeChanged( enable );
+
+    QObjectList *l = queryList( "QLayout" );
+    if ( !l || !l->first() ) {
+	delete l;
+	return;
+    }
+    for ( QLayout *lay = (QLayout*)l->first(); lay; lay = (QLayout*)l->next() )
+	    lay->activate();
+    delete l;
+}
+
+/*!
+    \property QMainWindow::usesTextLabel
+    \brief whether text labels for toolbar buttons are enabled
+
+    If disabled (the default), the tool buttons will not use text
+    labels. If enabled, text labels will be used.
+
+    Tool buttons and other widgets that wish to respond to this
+    setting are responsible for reading the correct state on startup,
+    and for connecting to the main window's widget's
+    usesTextLabelChanged() signal.
+
+    \sa QToolButton::setUsesTextLabel()
+*/
+
+bool QMainWindow::usesTextLabel() const
+{
+    return d->utl;
+}
+
+
+void QMainWindow::setUsesTextLabel( bool enable )
+{
+    if ( enable == (bool)d->utl )
+	return;
+
+    d->utl = enable;
+    emit usesTextLabelChanged( enable );
+
+    QObjectList *l = queryList( "QLayout" );
+    if ( !l || !l->first() ) {
+	delete l;
+	return;
+    }
+    for ( QLayout *lay = (QLayout*)l->first(); lay; lay = (QLayout*)l->next() )
+	    lay->activate();
+    delete l;
+}
+
+
+/*!
+    \fn void QMainWindow::pixmapSizeChanged( bool )
+
+    This signal is emitted whenever the setUsesBigPixmaps() is called
+    with a value different to the current setting. All widgets that
+    should respond to such changes, e.g. toolbar buttons, must connect
+    to this signal.
+*/
+
+/*!
+    \fn void QMainWindow::usesTextLabelChanged( bool )
+
+    This signal is emitted whenever the setUsesTextLabel() is called
+    with a value different to the current setting. All widgets that
+    should respond to such changes, e.g. toolbar buttons, must connect
+    to this signal.
+*/
+
+/*!
+    \fn void QMainWindow::dockWindowPositionChanged( QDockWindow *dockWindow )
+
+    This signal is emitted when the \a dockWindow has changed its
+    position. A change in position occurs when a dock window is moved
+    within its dock area or moved to another dock area (including the
+    \c Minimized and \c TearOff dock areas).
+
+    \sa getLocation()
+*/
+
+void QMainWindow::setRightJustification( bool enable )
+{
+    if ( enable == (bool)d->justify )
+	return;
+    d->justify = enable;
+    triggerLayout( TRUE );
+}
+
+
+/*!
+    \obsolete
+    \property QMainWindow::rightJustification
+    \brief whether the main window right-justifies its dock windows
+
+    If disabled (the default), stretchable dock windows are expanded,
+    and non-stretchable dock windows are given the minimum space they
+    need. Since most dock windows are not stretchable, this usually
+    results in an unjustified right edge (or unjustified bottom edge
+    for a vertical dock area). If enabled, the main window will
+    right-justify its dock windows.
+
+    \sa QDockWindow::setVerticalStretchable(), QDockWindow::setHorizontalStretchable()
+*/
+
+bool QMainWindow::rightJustification() const
+{
+    return d->justify;
+}
+
+/*! \internal
+ */
+
+void QMainWindow::triggerLayout( bool deleteLayout )
+{
+    if ( deleteLayout || !d->tll )
+	setUpLayout();
+    QApplication::postEvent( this, new QEvent( QEvent::LayoutHint ) );
+}
+
+/*!
+    Enters 'What's This?' mode and returns immediately.
+
+    This is the same as QWhatsThis::enterWhatsThisMode(), but
+    implemented as a main window object's slot. This way it can easily
+    be used for popup menus, for example:
+
+    \code
+    QPopupMenu * help = new QPopupMenu( this );
+    help->insertItem( "What's &This", this , SLOT(whatsThis()), SHIFT+Key_F1);
+    \endcode
+
+    \sa QWhatsThis::enterWhatsThisMode()
+*/
+void QMainWindow::whatsThis()
+{
+#ifndef QT_NO_WHATSTHIS
+    QWhatsThis::enterWhatsThisMode();
+#endif
+}
+
+
+/*!
+    \reimp
+*/
+
+void QMainWindow::styleChange( QStyle& old )
+{
+    QWidget::styleChange( old );
+}
+
+/*!
+    Finds the location of the dock window \a dw.
+
+    If the \a dw dock window is found in the main window the function
+    returns TRUE and populates the \a dock variable with the dw's dock
+    area and the \a index with the dw's position within the dock area.
+    It also sets \a nl to TRUE if the \a dw begins a new line
+    (otherwise FALSE), and \a extraOffset with the dock window's offset.
+
+    If the \a dw dock window is not found then the function returns
+    FALSE and the state of \a dock, \a index, \a nl and \a extraOffset
+    is undefined.
+
+    If you want to save and restore dock window positions then use
+    operator>>() and operator<<().
+
+    \sa operator>>() operator<<()
+*/
+
+bool QMainWindow::getLocation( QDockWindow *dw, Dock &dock, int &index, bool &nl, int &extraOffset ) const
+{
+    dock = DockTornOff;
+    if ( d->topDock->hasDockWindow( dw, &index ) )
+	dock = DockTop;
+    else if ( d->bottomDock->hasDockWindow( dw, &index ) )
+	dock = DockBottom;
+    else if ( d->leftDock->hasDockWindow( dw, &index ) )
+	dock = DockLeft;
+    else if ( d->rightDock->hasDockWindow( dw, &index ) )
+	dock = DockRight;
+    else if ( dw->parentWidget() == d->hideDock ) {
+	index = 0;
+	dock = DockMinimized;
+    } else {
+	index = 0;
+    }
+    nl = dw->newLine();
+    extraOffset = dw->offset();
+    return TRUE;
+}
+
+#ifndef QT_NO_TOOLBAR
+/*!
+    Returns a list of all the toolbars which are in the \a dock dock
+    area, regardless of their state.
+
+    For example, the \c TornOff dock area may contain closed toolbars
+    but these are returned along with the visible toolbars.
+
+    \sa dockWindows()
+*/
+
+QPtrList<QToolBar> QMainWindow::toolBars( Dock dock ) const
+{
+    QPtrList<QDockWindow> lst = dockWindows( dock );
+    QPtrList<QToolBar> tbl;
+    for ( QDockWindow *w = lst.first(); w; w = lst.next() ) {
+	QToolBar *tb = ::qt_cast<QToolBar*>(w);
+	if ( tb )
+	    tbl.append( tb );
+    }
+    return tbl;
+}
+#endif
+
+/*!
+    Returns a list of all the dock windows which are in the \a dock
+    dock area, regardless of their state.
+
+    For example, the \c DockTornOff dock area may contain closed dock
+    windows but these are returned along with the visible dock
+    windows.
+*/
+
+QPtrList<QDockWindow> QMainWindow::dockWindows( Dock dock ) const
+{
+    QPtrList<QDockWindow> lst;
+    switch ( dock ) {
+    case DockTop:
+	return d->topDock->dockWindowList();
+    case DockBottom:
+	return d->bottomDock->dockWindowList();
+    case DockLeft:
+	return d->leftDock->dockWindowList();
+    case DockRight:
+	return d->rightDock->dockWindowList();
+    case DockTornOff: {
+	for ( QDockWindow *w = d->dockWindows.first(); w; w = d->dockWindows.next() ) {
+	    if ( !w->area() && w->place() == QDockWindow::OutsideDock )
+		lst.append( w );
+	}
+    }
+    return lst;
+    case DockMinimized: {
+	if ( d->hideDock->children() ) {
+	    QObjectListIt it( *d->hideDock->children() );
+	    QObject *o;
+	    while ( ( o = it.current() ) ) {
+		++it;
+		QDockWindow *dw = ::qt_cast<QDockWindow*>(o);
+		if ( !dw )
+		    continue;
+		lst.append( dw );
+	    }
+	}
+    }
+    return lst;
+    default:
+	break;
+    }
+    return lst;
+}
+
+/*!
+    \overload
+
+    Returns the list of dock windows which belong to this main window,
+    regardless of which dock area they are in or what their state is,
+    (e.g. irrespective of whether they are visible or not).
+*/
+
+QPtrList<QDockWindow> QMainWindow::dockWindows() const
+{
+    return d->dockWindows;
+}
+
+void QMainWindow::setDockWindowsMovable( bool enable )
+{
+    d->movable = enable;
+    QObjectList *l = queryList( "QDockWindow" );
+    if ( l ) {
+	for ( QObject *o = l->first(); o; o = l->next() )
+	    ( (QDockWindow*)o )->setMovingEnabled( enable );
+    }
+    delete l;
+}
+
+/*!
+    \property QMainWindow::dockWindowsMovable
+    \brief whether the dock windows are movable
+
+    If TRUE (the default), the user will be able to move movable dock
+    windows from one QMainWindow dock area to another, including the
+    \c TearOff area (i.e. where the dock window floats freely as a
+    window in its own right), and the \c Minimized area (where only
+    the dock window's handle is shown below the menu bar). Moveable
+    dock windows can also be moved within QMainWindow dock areas, i.e.
+    to rearrange them within a dock area.
+
+    If FALSE the user will not be able to move any dock windows.
+
+    By default dock windows are moved transparently (i.e. only an
+    outline rectangle is shown during the drag), but this setting can
+    be changed with setOpaqueMoving().
+
+    \sa setDockEnabled(), setOpaqueMoving()
+*/
+
+bool QMainWindow::dockWindowsMovable() const
+{
+    return d->movable;
+}
+
+void QMainWindow::setOpaqueMoving( bool b )
+{
+    d->opaque = b;
+    QObjectList *l = queryList( "QDockWindow" );
+    if ( l ) {
+	for ( QObject *o = l->first(); o; o = l->next() )
+	    ( (QDockWindow*)o )->setOpaqueMoving( b );
+    }
+    delete l;
+}
+
+/*!
+    \property QMainWindow::opaqueMoving
+    \brief whether dock windows are moved opaquely
+
+    If TRUE the dock windows of the main window are shown opaquely
+    (i.e. it shows the toolbar as it looks when docked) whilst it is
+    being moved. If FALSE (the default) they are shown transparently,
+    (i.e. as an outline rectangle).
+
+    \warning Opaque moving of toolbars and dockwindows is known to
+    have several problems. We recommend avoiding the use of this
+    feature for the time being. We intend fixing the problems in a
+    future release.
+*/
+
+bool QMainWindow::opaqueMoving() const
+{
+    return d->opaque;
+}
+
+/*!
+    This function will line up dock windows within the visible dock
+    areas (\c Top, \c Left, \c Right and \c Bottom) as compactly as
+    possible.
+
+    If \a keepNewLines is TRUE, all dock windows stay on their
+    original lines. If \a keepNewLines is FALSE then newlines may be
+    removed to achieve the most compact layout possible.
+
+    The method only works if dockWindowsMovable() returns TRUE.
+*/
+
+void QMainWindow::lineUpDockWindows( bool keepNewLines )
+{
+    if ( !dockWindowsMovable() )
+	return;
+    d->topDock->lineUp( keepNewLines );
+    d->leftDock->lineUp( keepNewLines );
+    d->rightDock->lineUp( keepNewLines );
+    d->bottomDock->lineUp( keepNewLines );
+}
+
+/*!
+    Returns TRUE, if the dock window menu is enabled; otherwise
+    returns FALSE.
+
+    The menu lists the (appropriate()) dock windows (which may be
+    shown or hidden), and has a "Line Up Dock Windows" menu item. It
+    will also have a "Customize" menu item if isCustomizable() returns
+    TRUE.
+
+    \sa setDockEnabled(), lineUpDockWindows() appropriate()
+    setAppropriate()
+*/
+
+bool QMainWindow::isDockMenuEnabled() const
+{
+    return d->dockMenu;
+}
+
+/*!
+    If \a b is TRUE, then right clicking on a dock window or dock area
+    will pop up the dock window menu. If \a b is FALSE, right clicking
+    a dock window or dock area will not pop up the menu.
+
+    The menu lists the (appropriate()) dock windows (which may be
+    shown or hidden), and has a "Line Up Dock Windows" item. It will
+    also have a "Customize" menu item if isCustomizable() returns
+    TRUE.
+
+    \sa lineUpDockWindows(), isDockMenuEnabled()
+*/
+
+void QMainWindow::setDockMenuEnabled( bool b )
+{
+    d->dockMenu = b;
+}
+
+/*!
+    Creates the dock window menu which contains all toolbars (if \a
+    dockWindows is \c OnlyToolBars ), all dock windows (if \a
+    dockWindows is \c NoToolBars) or all toolbars and dock windows (if
+    \a dockWindows is \c AllDockWindows - the default).
+
+    This function is called internally when necessary, e.g. when the
+    user right clicks a dock area (providing isDockMenuEnabled()
+    returns TRUE).
+\omit
+### Qt 4.0
+    You can reimplement this function if you wish to customize the
+    behaviour.
+\endomit
+
+    The menu items representing the toolbars and dock windows are
+    checkable. The visible dock windows are checked and the hidden
+    dock windows are unchecked. The user can click a menu item to
+    change its state (show or hide the dock window).
+
+    The list and the state are always kept up-to-date.
+
+    Toolbars and dock windows which are not appropriate in the current
+    context (see setAppropriate()) are not listed in the menu.
+
+    The menu also has a menu item for lining up the dock windows.
+
+    If isCustomizable() returns TRUE, a Customize menu item is added
+    to the menu, which if clicked will call customize(). The
+    isCustomizable() function we provide returns FALSE and customize()
+    does nothing, so they must be reimplemented in a subclass to be
+    useful.
+*/
+
+QPopupMenu *QMainWindow::createDockWindowMenu( DockWindows dockWindows ) const
+{
+    QObjectList *l = queryList( "QDockWindow" );
+
+    if ( !l || l->isEmpty() )
+	return 0;
+
+    delete l;
+
+    QPopupMenu *menu = new QPopupMenu( (QMainWindow*)this, "qt_customize_menu" );
+    menu->setCheckable( TRUE );
+    d->dockWindowModes.replace( menu, dockWindows );
+    connect( menu, SIGNAL( aboutToShow() ), this, SLOT( menuAboutToShow() ) );
+    return menu;
+}
+
+/*!
+    This slot is called from the aboutToShow() signal of the default
+    dock menu of the mainwindow. The default implementation
+    initializes the menu with all dock windows and toolbars in this
+    slot.
+\omit
+### Qt 4.0
+    If you want to do small adjustments to the menu, you can do it in
+    this slot; or you can reimplement createDockWindowMenu().
+\endomit
+*/
+
+void QMainWindow::menuAboutToShow()
+{
+    QPopupMenu *menu = (QPopupMenu*)sender();
+    QMap<QPopupMenu*, DockWindows>::Iterator it = d->dockWindowModes.find( menu );
+    if ( it == d->dockWindowModes.end() )
+	return;
+    menu->clear();
+
+    DockWindows dockWindows = *it;
+
+    QObjectList *l = queryList( "QDockWindow" );
+
+    bool empty = TRUE;
+    if ( l && !l->isEmpty() ) {
+
+	QObject *o = 0;
+	if ( dockWindows == AllDockWindows || dockWindows == NoToolBars ) {
+	    for ( o = l->first(); o; o = l->next() ) {
+		QDockWindow *dw = (QDockWindow*)o;
+		if ( !appropriate( dw ) || ::qt_cast<QToolBar*>(dw) || !dockMainWindow( dw ) )
+		    continue;
+		QString label = dw->caption();
+		if ( !label.isEmpty() ) {
+		    int id = menu->insertItem( label, dw, SLOT( toggleVisible() ) );
+		    menu->setItemChecked( id, dw->isVisible() );
+		    empty = FALSE;
+		}
+	    }
+	    if ( !empty )
+		menu->insertSeparator();
+	}
+
+	empty = TRUE;
+
+#ifndef QT_NO_TOOLBAR
+	if ( dockWindows == AllDockWindows || dockWindows == OnlyToolBars ) {
+	    for ( o = l->first(); o; o = l->next() ) {
+		QToolBar *tb = ::qt_cast<QToolBar*>(o);
+		if ( !tb || !appropriate(tb) || !dockMainWindow(tb) )
+		    continue;
+		QString label = tb->label();
+		if ( !label.isEmpty() ) {
+		    int id = menu->insertItem( label, tb, SLOT( toggleVisible() ) );
+		    menu->setItemChecked( id, tb->isVisible() );
+		    empty = FALSE;
+		}
+	    }
+	}
+#endif
+
+    }
+
+    delete l;
+
+    if ( !empty )
+	menu->insertSeparator();
+
+    if ( dockWindowsMovable() )
+	menu->insertItem( tr( "Line up" ), this, SLOT( doLineUp() ) );
+    if ( isCustomizable() )
+	menu->insertItem( tr( "Customize..." ), this, SLOT( customize() ) );
+}
+
+/*!
+    Shows the dock menu at the position \a globalPos. The menu lists
+    the dock windows so that they can be shown (or hidden), lined up,
+    and possibly customized. Returns TRUE if the menu is shown;
+    otherwise returns FALSE.
+
+    If you want a custom menu, reimplement this function. You can
+    create the menu from scratch or call createDockWindowMenu() and
+    modify the result.
+\omit
+### Qt 4.0
+    The default implementation uses the dock window menu which gets
+    created by createDockWindowMenu(). You can reimplement
+    createDockWindowMenu() if you want to use your own specialized
+    popup menu.
+\endomit
+*/
+
+bool QMainWindow::showDockMenu( const QPoint &globalPos )
+{
+    if ( !d->dockMenu )
+	return FALSE;
+    if ( !d->rmbMenu )
+	d->rmbMenu = createDockWindowMenu();
+    if ( !d->rmbMenu )
+	return FALSE;
+
+    d->rmbMenu->exec( globalPos );
+    return TRUE;
+}
+
+void QMainWindow::slotPlaceChanged()
+{
+    QObject* obj = (QObject*)sender();
+    QDockWindow *dw = ::qt_cast<QDockWindow*>(obj);
+    if ( dw )
+	emit dockWindowPositionChanged( dw );
+#ifndef QT_NO_TOOLBAR
+    QToolBar *tb = ::qt_cast<QToolBar*>(obj);
+    if ( tb )
+	emit toolBarPositionChanged( tb );
+#endif
+}
+
+/*!
+    \internal
+    For internal use of QDockWindow only.
+ */
+
+QDockArea *QMainWindow::dockingArea( const QPoint &p )
+{
+    int mh = d->mb ? d->mb->height() : 0;
+    int sh = d->sb ? d->sb->height() : 0;
+    if ( p.x() >= -5 && p.x() <= 100 && p.y() > mh && p.y() - height() - sh )
+	return d->leftDock;
+    if ( p.x() >= width() - 100 && p.x() <= width() + 5 && p.y() > mh && p.y() - height() - sh )
+	return d->rightDock;
+    if ( p.y() >= -5 && p.y() < mh + 100 && p.x() >= 0 && p.x() <= width() )
+	return d->topDock;
+    if ( p.y() >= height() - sh - 100 && p.y() <= height() + 5 && p.x() >= 0 && p.x() <= width() )
+	return d->bottomDock;
+    return 0;
+}
+
+/*!
+    Returns TRUE if \a dw is a dock window known to the main window;
+    otherwise returns FALSE.
+*/
+
+bool QMainWindow::hasDockWindow( QDockWindow *dw )
+{
+    return d->dockWindows.findRef( dw ) != -1;
+}
+
+/*!
+    Returns the \c Left dock area
+
+    \sa rightDock() topDock() bottomDock()
+*/
+
+QDockArea *QMainWindow::leftDock() const
+{
+    return d->leftDock;
+}
+
+/*!
+    Returns the \c Right dock area
+
+    \sa leftDock() topDock() bottomDock()
+*/
+
+QDockArea *QMainWindow::rightDock() const
+{
+    return d->rightDock;
+}
+
+/*!
+    Returns the \c Top dock area
+
+    \sa bottomDock() leftDock() rightDock()
+*/
+
+QDockArea *QMainWindow::topDock() const
+{
+    return d->topDock;
+}
+
+/*!
+    Returns a pointer the \c Bottom dock area
+
+    \sa topDock() leftDock() rightDock()
+*/
+
+QDockArea *QMainWindow::bottomDock() const
+{
+    return d->bottomDock;
+}
+
+/*!
+    This function is called when the user clicks the Customize menu
+    item on the dock window menu.
+
+    The customize menu item will only appear if isCustomizable()
+    returns TRUE (it returns FALSE by default).
+
+    The function is intended, for example, to provide the user with a
+    means of telling the application that they wish to customize the
+    main window, dock windows or dock areas.
+
+    The default implementation does nothing and the Customize menu
+    item is not shown on the right-click menu by default. If you want
+    the item to appear then reimplement isCustomizable() to return
+    TRUE, and reimplement this function to do whatever you want.
+
+    \sa isCustomizable()
+*/
+
+void QMainWindow::customize()
+{
+}
+
+/*!
+    Returns TRUE if the dock area dock window menu includes the
+    Customize menu item (which calls customize() when clicked).
+    Returns FALSE by default, i.e. the popup menu will not contain a
+    Customize menu item. You will need to reimplement this function
+    and set it to return TRUE if you wish the user to be able to see
+    the dock window menu.
+
+    \sa customize()
+*/
+
+bool QMainWindow::isCustomizable() const
+{
+    return FALSE;
+}
+
+/*!
+    Returns TRUE if it is appropriate to include a menu item for the
+    \a dw dock window in the dock window menu; otherwise returns
+    FALSE.
+
+    The user is able to change the state (show or hide) a dock window
+    that has a menu item by clicking the item.
+
+    Call setAppropriate() to indicate whether or not a particular dock
+    window should appear on the popup menu.
+
+    \sa setAppropriate()
+*/
+
+bool QMainWindow::appropriate( QDockWindow *dw ) const
+{
+    QMap<QDockWindow*, bool>::ConstIterator it = d->appropriate.find( dw );
+    if ( it == d->appropriate.end() )
+	return TRUE;
+    return *it;
+}
+
+/*!
+    Use this function to control whether or not the \a dw dock
+    window's caption should appear as a menu item on the dock window
+    menu that lists the dock windows.
+
+    If \a a is TRUE then the \a dw will appear as a menu item on the
+    dock window menu. The user is able to change the state (show or
+    hide) a dock window that has a menu item by clicking the item;
+    depending on the state of your application, this may or may not be
+    appropriate. If \a a is FALSE the \a dw will not appear on the
+    popup menu.
+
+    \sa showDockMenu() isCustomizable() customize()
+*/
+
+void QMainWindow::setAppropriate( QDockWindow *dw, bool a )
+{
+    d->appropriate.replace( dw, a );
+}
+
+#ifndef QT_NO_TEXTSTREAM
+static void saveDockArea( QTextStream &ts, QDockArea *a )
+{
+    QPtrList<QDockWindow> l = a->dockWindowList();
+    for ( QDockWindow *dw = l.first(); dw; dw = l.next() ) {
+	ts << QString( dw->caption() );
+	ts << ",";
+    }
+    ts << endl;
+    ts << *a;
+}
+
+/*!
+    \relates QMainWindow
+
+    Writes the layout (sizes and positions) of the dock windows in the
+    dock areas of the QMainWindow \a mainWindow, including \c
+    Minimized and \c TornOff dock windows, to the text stream \a ts.
+
+    This can be used, for example, in conjunction with QSettings to
+    save the user's layout when the \mainWindow receives a closeEvent.
+
+    \sa operator>>() closeEvent()
+*/
+
+QTextStream &operator<<( QTextStream &ts, const QMainWindow &mainWindow )
+{
+    QPtrList<QDockWindow> l = mainWindow.dockWindows( Qt::DockMinimized );
+    QDockWindow *dw = 0;
+    for ( dw = l.first(); dw; dw = l.next() ) {
+	ts << dw->caption();
+	ts << ",";
+    }
+    ts << endl;
+
+    l = mainWindow.dockWindows( Qt::DockTornOff );
+    for ( dw = l.first(); dw; dw = l.next() ) {
+	ts << dw->caption();
+	ts << ",";
+    }
+    ts << endl;
+    for ( dw = l.first(); dw; dw = l.next() ) {
+	ts << "[" << dw->caption() << ","
+	   << (int)dw->geometry().x() << ","
+	   << (int)dw->geometry().y() << ","
+	   << (int)dw->geometry().width() << ","
+	   << (int)dw->geometry().height() << ","
+	   << (int)dw->isVisible() << "]";
+    }
+    ts << endl;
+
+    saveDockArea( ts, mainWindow.topDock() );
+    saveDockArea( ts, mainWindow.bottomDock() );
+    saveDockArea( ts, mainWindow.rightDock() );
+    saveDockArea( ts, mainWindow.leftDock() );
+    return ts;
+}
+
+static void loadDockArea( const QStringList &names, QDockArea *a, Qt::Dock d, QPtrList<QDockWindow> &l, QMainWindow *mw, QTextStream &ts )
+{
+    for ( QStringList::ConstIterator it = names.begin(); it != names.end(); ++it ) {
+	for ( QDockWindow *dw = l.first(); dw; dw = l.next() ) {
+	    if ( dw->caption() == *it ) {
+		mw->addDockWindow( dw, d );
+		break;
+	    }
+	}
+    }
+    if ( a ) {
+	ts >> *a;
+    } else if ( d == Qt::DockTornOff ) {
+	QString s = ts.readLine();
+	enum State { Pre, Name, X, Y, Width, Height, Visible, Post };
+	int state = Pre;
+	QString name, x, y, w, h, visible;
+	QChar c;
+	for ( int i = 0; i < (int)s.length(); ++i ) {
+	    c = s[ i ];
+	    if ( state == Pre && c == '[' ) {
+		state++;
+		continue;
+	    }
+	    if ( c == ',' &&
+		 ( state == Name || state == X || state == Y || state == Width || state == Height ) ) {
+		state++;
+		continue;
+	    }
+	    if ( state == Visible && c == ']' ) {
+		for ( QDockWindow *dw = l.first(); dw; dw = l.next() ) {
+		    if ( QString( dw->caption() ) == name ) {
+			if ( !::qt_cast<QToolBar*>(dw) )
+			    dw->setGeometry( x.toInt(), y.toInt(), w.toInt(), h.toInt() );
+			else
+			    dw->setGeometry( x.toInt(), y.toInt(), dw->width(), dw->height() );
+			if ( !(bool)visible.toInt() )
+			    dw->hide();
+			else
+			    dw->show();
+			break;
+		    }
+		}
+
+		name = x = y = w = h = visible = "";
+
+		state = Pre;
+		continue;
+	    }
+	    if ( state == Name )
+		name += c;
+	    else if ( state == X )
+		x += c;
+	    else if ( state == Y )
+		y += c;
+	    else if ( state == Width )
+		w += c;
+	    else if ( state == Height )
+		h += c;
+	    else if ( state == Visible )
+		visible += c;
+	}
+    }
+}
+
+/*!
+    \relates QMainWindow
+
+    Reads the layout (sizes and positions) of the dock windows in the
+    dock areas of the QMainWindow \a mainWindow from the text stream,
+    \a ts, including \c Minimized and \c TornOff dock windows.
+    Restores the dock windows and dock areas to these sizes and
+    positions. The layout information must be in the format produced
+    by operator<<().
+
+    This can be used, for example, in conjunction with QSettings to
+    restore the user's layout.
+
+    \sa operator<<()
+*/
+
+QTextStream &operator>>( QTextStream &ts, QMainWindow &mainWindow )
+{
+    QPtrList<QDockWindow> l = mainWindow.dockWindows();
+
+    QString s = ts.readLine();
+    QStringList names = QStringList::split( ',', s );
+    loadDockArea( names, 0, Qt::DockMinimized, l, &mainWindow, ts );
+
+    s = ts.readLine();
+    names = QStringList::split( ',', s );
+    loadDockArea( names, 0, Qt::DockTornOff, l, &mainWindow, ts );
+
+    int i = 0;
+    QDockArea *areas[] = { mainWindow.topDock(), mainWindow.bottomDock(), mainWindow.rightDock(), mainWindow.leftDock() };
+    for ( int d = (int)Qt::DockTop; d != (int)Qt::DockMinimized; ++d, ++i ) {
+	s = ts.readLine();
+	names = QStringList::split( ',', s );
+	loadDockArea( names, areas[ i ], (Qt::Dock)d, l, &mainWindow, ts );
+    }
+    return ts;
+}
+#endif
+
+#include "qmainwindow.moc"
+
+#endif