diff options
Diffstat (limited to 'experimental/tqtinterface/qt4/src/widgets/tqmainwindow.cpp')
| -rw-r--r-- | experimental/tqtinterface/qt4/src/widgets/tqmainwindow.cpp | 2644 |
1 files changed, 2644 insertions, 0 deletions
diff --git a/experimental/tqtinterface/qt4/src/widgets/tqmainwindow.cpp b/experimental/tqtinterface/qt4/src/widgets/tqmainwindow.cpp new file mode 100644 index 000000000..1921297c2 --- /dev/null +++ b/experimental/tqtinterface/qt4/src/widgets/tqmainwindow.cpp @@ -0,0 +1,2644 @@ +/**************************************************************************** +** +** Implementation of TQMainWindow class +** +** Created : 980312 +** +** 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 "tqmainwindow.h" +#ifndef TQT_NO_MAINWINDOW + +#include "tqtimer.h" +#include "tqlayout.h" +#include "tqobjectlist.h" +#include "tqintdict.h" +#include "tqapplication.h" +#include "tqptrlist.h" +#include "tqmap.h" +#include "tqcursor.h" +#include "tqpainter.h" +#include "tqmenubar.h" +#include "tqpopupmenu.h" +#include "tqtoolbar.h" +#include "tqstatusbar.h" +#include "tqscrollview.h" +#include "tqtooltip.h" +#include "tqdatetime.h" +#include "tqwhatsthis.h" +#include "tqbitmap.h" +#include "tqdockarea.h" +#include "tqstringlist.h" +#include "tqstyle.h" +#ifdef TQ_WS_MACX +# include "tqt_mac.h" +#endif + +class TQHideDock; +class TQMainWindowLayout; + +class TQMainWindowPrivate +{ +public: + TQMainWindowPrivate() + : 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( TQt::DockTop, TRUE ); + docks.insert( TQt::DockBottom, TRUE ); + docks.insert( TQt::DockLeft, TRUE ); + docks.insert( TQt::DockRight, TRUE ); + docks.insert( TQt::DockMinimized, FALSE ); + docks.insert( TQt::DockTornOff, TRUE ); + } + + ~TQMainWindowPrivate() + { + } + +#ifndef TQT_NO_MENUBAR + TQMenuBar * mb; +#else + TQWidget * mb; +#endif + TQStatusBar * sb; + TQToolTipGroup * ttg; + + TQWidget * mc; + + TQBoxLayout * tll; + TQMainWindowLayout * mwl; + + uint ubp :1; + uint utl :1; + uint justify :1; + uint movable :1; + uint opaque :1; + uint dockMenu :1; + + TQDockArea *topDock, *bottomDock, *leftDock, *rightDock; + + TQPtrList<TQDockWindow> dockWindows; + TQMap<TQt::Dock, bool> docks; + TQStringList disabledDocks; + TQHideDock *hideDock; + + TQGuardedPtr<TQPopupMenu> rmbMenu, tbMenu, dwMenu; + TQMap<TQDockWindow*, bool> appropriate; + TQMap<TQPopupMenu*, TQMainWindow::DockWindows> dockWindowModes; + +}; + + +/* TQMainWindowLayout, respects widthForHeight layouts (like the left + and right docks are) +*/ + +class TQMainWindowLayout : public TQLayout +{ + Q_OBJECT + TQ_OBJECT + +public: + TQMainWindowLayout( TQMainWindow *mw, TQLayout* tqparent = 0 ); + ~TQMainWindowLayout() {} + + void addItem( QLayoutItem * ); + void setLeftDock( TQDockArea *l ); + void setRightDock( TQDockArea *r ); + void setCentralWidget( TQWidget *w ); + bool hasHeightForWidth() const { return FALSE; } + TQSize tqsizeHint() const; + TQSize tqminimumSize() const; + TQLayoutIterator iterator(); + TQ_SPExpandData expandingDirections() const { return (Qt::Orientations)TQSizePolicy::BothDirections; } + void tqinvalidate() {} + +protected: + void setGeometry( const TQRect &r ) { + TQLayout::setGeometry( r ); + layoutItems( r ); + } + +private: + int layoutItems( const TQRect&, bool testonly = FALSE ); + int extraPixels() const; + + TQDockArea *left, *right; + TQWidget *central; + TQMainWindow *mainWindow; + +#ifdef USE_QT4 + + QLAYOUT_REQUIRED_METHOD_DECLARATIONS + +#endif // USE_QT4 + +}; + +/*! + \reimp +*/ +int TQMainWindowLayout::count() const { + return 0; +} + +/*! + \reimp +*/ +TQLayoutItem* TQMainWindowLayout::itemAt(int index) const { + return 0; +} + +/*! + \reimp +*/ +TQLayoutItem* TQMainWindowLayout::takeAt(int index) { + return 0; +} + +TQSize TQMainWindowLayout::tqsizeHint() const +{ + int w = 0; + int h = 0; + + if ( left ) { + w += left->tqsizeHint().width(); + h = TQMAX( h, left->tqsizeHint().height() ); + } + if ( right ) { + w += right->tqsizeHint().width(); + h = TQMAX( h, right->tqsizeHint().height() ); + } + if ( central ) { + w += central->tqsizeHint().width(); + int diff = extraPixels(); + h = TQMAX( h, central->tqsizeHint().height() + diff ); + } + + return TQSize( w, h ); +} + +TQSize TQMainWindowLayout::tqminimumSize() const +{ + int w = 0; + int h = 0; + + if ( left ) { + TQSize ms = left->tqminimumSizeHint().expandedTo( left->tqminimumSize() ); + w += ms.width(); + h = TQMAX( h, ms.height() ); + } + if ( right ) { + TQSize ms = right->tqminimumSizeHint().expandedTo( right->tqminimumSize() ); + w += ms.width(); + h = TQMAX( h, ms.height() ); + } + if ( central ) { + TQSize min = central->tqminimumSize().isNull() ? + central->tqminimumSizeHint() : central->tqminimumSize(); + w += min.width(); + int diff = extraPixels(); + h = TQMAX( h, min.height() + diff ); + } + return TQSize( w, h ); +} + +TQMainWindowLayout::TQMainWindowLayout( TQMainWindow *mw, TQLayout* tqparent ) + : TQLayout( tqparent ), left( 0 ), right( 0 ), central( 0 ) +{ + mainWindow = mw; +} + +void TQMainWindowLayout::setLeftDock( TQDockArea *l ) +{ + left = l; +} + +void TQMainWindowLayout::setRightDock( TQDockArea *r ) +{ + right = r; +} + +void TQMainWindowLayout::setCentralWidget( TQWidget *w ) +{ + central = w; +} + +int TQMainWindowLayout::layoutItems( const TQRect &r, bool testonly ) +{ + if ( !left && !central && !right ) + return 0; + + int wl = 0, wr = 0; + if ( left ) + wl = ( (TQDockAreaLayout*)left->TQWidget::tqlayout() )->widthForHeight( r.height() ); + if ( right ) + wr = ( (TQDockAreaLayout*)right->TQWidget::tqlayout() )->widthForHeight( r.height() ); + int w = r.width() - wr - wl; + if ( w < 0 ) + w = 0; + + int diff = extraPixels(); + if ( !testonly ) { + TQRect g( tqgeometry() ); + if ( left ) + left->setGeometry( TQRect( g.x(), g.y() + diff, wl, r.height() - diff ) ); + if ( right ) + right->setGeometry( TQRect( 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->tqminimumSize().width(); + return w; +} + +int TQMainWindowLayout::extraPixels() const +{ + if ( mainWindow->d->topDock->isEmpty() && + !(mainWindow->d->leftDock->isEmpty() && + mainWindow->d->rightDock->isEmpty()) ) { + return 2; + } else { + return 0; + } +} + +void TQMainWindowLayout::addItem( QLayoutItem * /* item */ ) +{ +} + + +TQLayoutIterator TQMainWindowLayout::iterator() +{ + return 0; +} + + +/* + TQHideToolTip and TQHideDock - minimized dock +*/ + +#ifndef TQT_NO_TOOLTIP +class TQHideToolTip : public TQToolTip +{ +public: + TQHideToolTip( TQWidget *tqparent ) : TQToolTip( tqparent ) {} + ~TQHideToolTip() {} + + virtual void maybeTip( const TQPoint &pos ); +}; +#endif + + +class TQHideDock : public TQWidget +{ + Q_OBJECT + TQ_OBJECT + +public: + TQHideDock( TQMainWindow *tqparent ) : TQWidget( tqparent, "qt_hide_dock" ) { + hide(); + setFixedHeight( tqstyle().tqpixelMetric( TQStyle::PM_DockWindowHandleExtent, + this ) + 3 ); + pressedHandle = -1; + pressed = FALSE; + setMouseTracking( TRUE ); + win = tqparent; +#ifndef TQT_NO_TOOLTIP + tip = new TQHideToolTip( this ); +#endif + } + ~TQHideDock() + { +#ifndef TQT_NO_TOOLTIP + delete tip; +#endif + } + +protected: + void paintEvent( TQPaintEvent *e ) { + + if ( childrenListObject().isEmpty() ) + return; + + TQPainter p( this ); + p.setClipRegion( e->rect() ); + p.fillRect( e->rect(), tqcolorGroup().brush( TQColorGroup::Background ) ); + int x = 0; + int i = -1; + TQObjectListIt it( childrenListObject() ); + TQObject *o; + while ( ( o = it.current() ) ) { + ++it; + ++i; + TQDockWindow *dw = ::tqqt_cast<TQDockWindow*>(o); + if ( !dw || !dw->isVisible() ) + continue; + + TQStyle::SFlags flags = TQStyle::Style_Default; + if ( i == pressedHandle ) + flags |= TQStyle::Style_On; + + tqstyle().tqdrawPrimitive( TQStyle::PE_DockWindowHandle, &p, + TQRect( x, 0, 30, 10 ), tqcolorGroup(), + flags ); + x += 30; + } + } + + void mousePressEvent( TQMouseEvent *e ) { + pressed = TRUE; + if ( childrenListObject().isEmpty() ) + return; + mouseMoveEvent( e ); + pressedHandle = -1; + + if ( e->button() == Qt::RightButton && win->isDockMenuEnabled() ) { + // ### TODO: HideDock menu + } else { + mouseMoveEvent( e ); + } + } + + void mouseMoveEvent( TQMouseEvent *e ) { + if ( childrenListObject().isEmpty() ) + return; + if ( !pressed ) + return; + int x = 0; + int i = -1; + if ( e->y() >= 0 && e->y() <= height() ) { + TQObjectListIt it( childrenListObject() ); + TQObject *o; + while ( ( o = it.current() ) ) { + ++it; + ++i; + TQDockWindow *dw = ::tqqt_cast<TQDockWindow*>(o); + if ( !dw || !dw->isVisible() ) + continue; + + if ( e->x() >= x && e->x() <= x + 30 ) { + int old = pressedHandle; + pressedHandle = i; + if ( pressedHandle != old ) + tqrepaint( TRUE ); + return; + } + x += 30; + } + } + int old = pressedHandle; + pressedHandle = -1; + if ( old != -1 ) + tqrepaint( TRUE ); + } + + void mouseReleaseEvent( TQMouseEvent *e ) { + pressed = FALSE; + if ( pressedHandle == -1 ) + return; + if ( childrenListObject().isEmpty() ) + return; + if ( e->button() == Qt::LeftButton ) { + if ( e->y() >= 0 && e->y() <= height() ) { + TQObject *o = childrenListObject().at( pressedHandle ); + TQDockWindow *dw = ::tqqt_cast<TQDockWindow*>(o); + if ( dw ) { + dw->show(); + dw->dock(); + } + } + } + pressedHandle = -1; + tqrepaint( FALSE ); + } + + bool eventFilter( TQObject *o, TQEvent *e ) { + if ( TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(this) || !o->isWidgetType() ) + return TQWidget::eventFilter( o, e ); + if ( e->type() == TQEvent::Hide || + e->type() == TQEvent::Show || + e->type() == TQEvent::ShowToParent ) + updateState(); + return TQWidget::eventFilter( o, e ); + } + +protected slots: + void updateState() { + bool visible = TRUE; + if ( childrenListObject().isEmpty() ) { + visible = FALSE; + } else { + TQObjectListIt it( childrenListObject() ); + TQObject *o; + while ( ( o = it.current() ) ) { + ++it; + TQDockWindow *dw = ::tqqt_cast<TQDockWindow*>(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(); + } + +protected: + void childEvent( TQChildEvent *e ) { + TQWidget::childEvent( e ); + if ( e->type() == TQEvent::ChildInserted ) + e->child()->installEventFilter( this ); + else + e->child()->removeEventFilter( this ); + TQTimer::singleShot( 50, this, SLOT(updateState()) ); // Prevent crash due to show() calling childEvent() in an infinite recursion loop under certain conditions + } + +private: + TQMainWindow *win; + int pressedHandle; + bool pressed; +#ifndef TQT_NO_TOOLTIP + TQHideToolTip *tip; + friend class TQHideToolTip; +#endif +}; + +#ifndef TQT_NO_TOOLTIP +void TQHideToolTip::maybeTip( const TQPoint &pos ) +{ + if ( !parentWidget() ) + return; + TQHideDock *dock = (TQHideDock*)parentWidget(); + + if ( dock->childrenListObject().isEmpty() ) + return; + TQObjectListIt it( dock->childrenListObject() ); + TQObject *o; + int x = 0; + while ( ( o = it.current() ) ) { + ++it; + TQDockWindow *dw = ::tqqt_cast<TQDockWindow*>(o); + if ( !dw || !dw->isVisible() ) + continue; + + if ( pos.x() >= x && pos.x() <= x + 30 ) { + TQDockWindow *dw = (TQDockWindow*)o; + if ( !dw->caption().isEmpty() ) + tip( TQRect( x, 0, 30, dock->height() ), dw->caption() ); + return; + } + x += 30; + } +} +#endif + +/*! + \class TQMainWindow tqmainwindow.h + \brief The TQMainWindow 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 TQWorkspace (for MDI applications). TQMainWindow + 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 Q_SLOTS that are + called when the user clicks menu items or toolbar buttons. You can + also create main windows using \link designer-manual.book TQt + Designer\endlink. We'll briefly review adding menu items and + toolbar buttons then describe the facilities of TQMainWindow + itself. + + \code + TQMainWindow *mw = new TQMainWindow; + TQTextEdit *edit = new TQTextEdit( mw, "editor" ); + edit->setFocus(); + mw->setCaption( "Main Window" ); + mw->setCentralWidget( edit ); + mw->show(); + \endcode + + TQMainWindows 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 + TQMainWindow that we must write for ourselves; this is the usual + approach to using TQMainWindow. (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 TQMainWindow instance + directly we can add menu items and toolbars just as easily by + passing the TQMainWindow instance as the tqparent 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 TQMainWindow 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 TQToolButton + \printuntil open file + + This extract shows the creation of a toolbar with one toolbar + button. TQMainWindow supplies four dock areas for toolbars. When a + toolbar is created as a child of a TQMainWindow (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 TQMainWindow + as the tqparent. + + \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 TQStatusBar 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 TQAction * 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 TQPopupMenu * file + \printuntil menuBar + \skipto fileOpen + \printline + + The extract above shows the creation of a popup menu. We add the + menu to the TQMainWindow's menu bar and add our action. + + \quotefile action/application.cpp + \skipto TQToolBar * fileTool + \printuntil OpenAction + + Here we create a new toolbar as a child of the TQMainWindow and add + our action to the toolbar. + + We'll now explore the functionality offered by TQMainWindow. + + The main window will take care of the dock areas, and the tqgeometry + of the central widget, but all other aspects of the central widget + are left to you. TQMainWindow automatically detects the creation of + a menu bar or status bar if you specify the TQMainWindow as tqparent, + 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 tqlayout to make + space. + + TQMainWindow provides a TQToolTipGroup connected to the status bar. + The function toolTipGroup() provides access to the default + TQToolTipGroup. It isn't possible to set a different tool tip + group. + + New dock windows and toolbars can be added to a TQMainWindow using + addDockWindow(). Dock windows can be moved using moveDockWindow() + and removed with removeDockWindow(). TQMainWindow 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 TQt::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. + TQToolbar is a subclass of TQDockWindow 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{TQMainWindow::DockWindows}.) + + Some functions change the appearance of a TQMainWindow globally: + \list + \i TQDockWindow::setHorizontalStretchable() and + TQDockWindow::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 TQIconSet for more information). + \i setUsesTextLabel() is used to set whether tool buttons + should display a textual label in addition to pixmaps + (see TQToolButton 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 + TQDockWindow::caption() or TQToolBar::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 TQMenuBar 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 + TQToolBar *tb = new TQToolBar( this ); + addDockWindow( tb, tr( "Menubar" ), Top, FALSE ); + TQMenuBar *mb = new TQMenuBar( tb ); + mb->setFrameStyle( TQFrame::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 tqlayout in order to restore it later, e.g. in + the next session. You can do this by using the streaming operators + for TQMainWindow. + + To save the tqlayout and positions of all the dock windows do this: + + \code + TQFile file( filename ); + if ( file.open( IO_WriteOnly ) ) { + TQTextStream 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 + TQFile file( filename ); + if ( file.open( IO_ReadOnly ) ) { + TQTextStream stream( &file ); + stream >> *mainWindow; + file.close(); + } + \endcode + + The TQSettings class can be used in conjunction with the streaming + operators to store the application's settings. + + TQMainWindow's management of dock windows and toolbars is done + transparently behind-the-scenes by TQDockArea. + + For multi-document interfaces (MDI), use a TQWorkspace as the + central widget. + + Adding dock windows, e.g. toolbars, to TQMainWindow's dock areas is + straightforward. If the supplied dock areas are not sufficient for + your application we suggest that you create a TQWidget subclass and + add your own dock areas (see \l TQDockArea) to the subclass since + TQMainWindow provides functionality specific to the standard dock + areas it provides. + + <img src=qmainwindow-m.png> <img src=qmainwindow-w.png> + + \sa TQToolBar TQDockWindow TQStatusBar TQAction TQMenuBar TQPopupMenu TQToolTipGroup TQDialog +*/ + +/*! \enum TQt::ToolBarDock + \internal +*/ + +/*! + \enum TQt::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 TQMainWindow. +*/ + +/*! + \enum TQMainWindow::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 TQMainWindow::addToolBar( TQDockWindow *, Dock = Top, bool newLine = FALSE ); +*/ + +/*! + \obsolete + \overload void TQMainWindow::addToolBar( TQDockWindow *, const TQString &label, Dock = Top, bool newLine = FALSE ); +*/ + +/*! + \obsolete + \fn void TQMainWindow::moveToolBar( TQDockWindow *, Dock = Top ); +*/ + +/*! + \obsolete + \overload void TQMainWindow::moveToolBar( TQDockWindow *, Dock, bool nl, int index, int extraOffset = -1 ); +*/ + +/*! + \obsolete + \fn void TQMainWindow::removeToolBar( TQDockWindow * ); +*/ + +/*! + \obsolete + \fn void TQMainWindow::lineUpToolBars( bool keepNewLines = FALSE ); +*/ + +/*! + \obsolete + \fn void TQMainWindow::toolBarPositionChanged( TQToolBar * ); +*/ + +/*! + \obsolete + \fn bool TQMainWindow::toolBarsMovable() const +*/ + +/*! + \obsolete + \fn void TQMainWindow::setToolBarsMovable( bool ) +*/ + +/*! + Constructs an empty main window. The \a tqparent, \a name and widget + flags \a f, are passed on to the TQWidget constructor. + + By default, the widget flags are set to \c WType_TopLevel rather + than 0 as they are with TQWidget. If you don't want your + TQMainWindow to be a top level widget then you will need to set \a + f to 0. +*/ + +TQMainWindow::TQMainWindow( TQWidget * tqparent, const char * name, WFlags f ) + : TQWidget( tqparent, name, f ) +{ + d = new TQMainWindowPrivate; +#ifdef TQ_WS_MACX + d->opaque = TRUE; +#else + d->opaque = FALSE; +#endif + installEventFilter( this ); + d->topDock = new TQDockArea( Qt::Horizontal, TQDockArea::Normal, this, "qt_top_dock" ); + d->topDock->installEventFilter( this ); + d->bottomDock = new TQDockArea( Qt::Horizontal, TQDockArea::Reverse, this, "qt_bottom_dock" ); + d->bottomDock->installEventFilter( this ); + d->leftDock = new TQDockArea( Qt::Vertical, TQDockArea::Normal, this, "qt_left_dock" ); + d->leftDock->installEventFilter( this ); + d->rightDock = new TQDockArea( Qt::Vertical, TQDockArea::Reverse, this, "qt_right_dock" ); + d->rightDock->installEventFilter( this ); + d->hideDock = new TQHideDock( this ); +} + + +/*! + Destroys the object and frees any allocated resources. +*/ + +TQMainWindow::~TQMainWindow() +{ + delete tqlayout(); + delete d; +} + +#ifndef TQT_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 TQMainWindow::setMenuBar( TQMenuBar * 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() +*/ + +TQMenuBar * TQMainWindow::menuBar() const +{ + if ( d->mb ) + return d->mb; + + TQObjectList * l + = ((TQObject*)this)->queryList( "TQMenuBar", 0, FALSE, FALSE ); + TQMenuBar * b; + if ( l && l->count() ) { + b = (TQMenuBar *)l->first(); + } else { + b = new TQMenuBar( (TQMainWindow *)this, "automatic menu bar" ); + b->show(); + } + delete l; + d->mb = b; + d->mb->installEventFilter( const_cast<TQT_BASE_OBJECT_NAME*>(static_cast<const TQT_BASE_OBJECT_NAME*>(this)) ); + ((TQMainWindow *)this)->triggerLayout(); + return b; +} +#endif // TQT_NO_MENUBAR + +/*! + Sets this main window to use the status bar \a newtqStatusBar. + + The existing status bar (if any) is deleted along with its + contents. + + Note that \a newtqStatusBar \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 + newtqStatusBar->show(). + + \sa setMenuBar() statusBar() +*/ + +void TQMainWindow::setqStatusBar( TQStatusBar * newtqStatusBar ) +{ + if ( !newtqStatusBar || newtqStatusBar == d->sb ) + return; + if ( d->sb ) + delete d->sb; + d->sb = newtqStatusBar; +#ifndef TQT_NO_TOOLTIP + // ### this code can cause unnecessary creation of a tool tip group + connect( toolTipGroup(), TQT_SIGNAL(showTip(const TQString&)), + d->sb, TQT_SLOT(message(const TQString&)) ); + connect( toolTipGroup(), TQT_SIGNAL(removeTip()), + d->sb, TQT_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() +*/ + +TQStatusBar * TQMainWindow::statusBar() const +{ + if ( d->sb ) + return d->sb; + + TQObjectList * l + = ((TQObject*)this)->queryList( "TQStatusBar", 0, FALSE, FALSE ); + TQStatusBar * s; + if ( l && l->count() ) { + s = (TQStatusBar *)l->first(); + } else { + s = new TQStatusBar( (TQMainWindow *)this, "automatic status bar" ); + s->show(); + } + delete l; + ((TQMainWindow *)this)->setqStatusBar( s ); + ((TQMainWindow *)this)->triggerLayout( TRUE ); + return s; +} + + +#ifndef TQT_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 TQMainWindow::setToolTipGroup( TQToolTipGroup * newToolTipGroup ) +{ + if ( !newToolTipGroup || newToolTipGroup == d->ttg ) + return; + if ( d->ttg ) + delete d->ttg; + d->ttg = newToolTipGroup; + + connect( toolTipGroup(), TQT_SIGNAL(showTip(const TQString&)), + statusBar(), TQT_SLOT(message(const TQString&)) ); + connect( toolTipGroup(), TQT_SIGNAL(removeTip()), + statusBar(), TQT_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() +*/ + +TQToolTipGroup * TQMainWindow::toolTipGroup() const +{ + if ( d->ttg ) + return d->ttg; + + TQToolTipGroup * t = new TQToolTipGroup( TQT_TQOBJECT((TQMainWindow*)this), + "automatic tool tip group" ); + ((TQMainWindowPrivate*)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 TQMainWindow::setDockEnabled( TQt::Dock dock, bool enable ) +{ + d->docks.tqreplace( 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 TQMainWindow::isDockEnabled( TQt::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 TQMainWindow::isDockEnabled( TQDockArea *area ) const +{ + + if ( area == d->leftDock ) + return d->docks[ TQt::DockLeft ]; + if ( area == d->rightDock ) + return d->docks[ TQt::DockRight ]; + if ( area == d->topDock ) + return d->docks[ TQt::DockTop ]; + if ( area == d->bottomDock ) + return d->docks[ TQt::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 TQMainWindow::setDockEnabled( TQDockWindow *dw, TQt::Dock dock, bool enable ) +{ + if ( d->dockWindows.tqfind( dw ) == -1 ) { + d->dockWindows.append( dw ); + connect( dw, TQT_SIGNAL( placeChanged(TQDockWindow::Place) ), + this, TQT_SLOT( slotPlaceChanged() ) ); + } + TQString s; + s.sprintf( "%p_%d", (void*)dw, (int)dock ); + if ( enable ) + d->disabledDocks.remove( s ); + else if ( d->disabledDocks.tqfind( s ) == d->disabledDocks.end() ) + d->disabledDocks << s; + switch ( dock ) { + case TQt::DockTop: + topDock()->setAcceptDockWindow( dw, enable ); + break; + case TQt::DockLeft: + leftDock()->setAcceptDockWindow( dw, enable ); + break; + case TQt::DockRight: + rightDock()->setAcceptDockWindow( dw, enable ); + break; + case TQt::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 TQMainWindow::isDockEnabled( TQDockWindow *dw, TQDockArea *area ) const +{ + if ( !isDockEnabled( area ) ) + return FALSE; + TQt::Dock dock; + if ( area == d->leftDock ) + dock = TQt::DockLeft; + else if ( area == d->rightDock ) + dock = TQt::DockRight; + else if ( area == d->topDock ) + dock = TQt::DockTop; + else if ( area == d->bottomDock ) + dock = TQt::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 TQMainWindow::isDockEnabled( TQDockWindow *tb, TQt::Dock dock ) const +{ + if ( !isDockEnabled( dock ) ) + return FALSE; + TQString s; + s.sprintf( "%p_%d", (void*)tb, (int)dock ); + return d->disabledDocks.tqfind( 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 TQMainWindow::addDockWindow( TQDockWindow *dockWindow, + TQt::Dock edge, bool newLine ) +{ +#ifdef TQ_WS_MAC + if(isTopLevel() && edge == DockTop) + ChangeWindowAttributes((WindowPtr)handle(), kWindowToolbarButtonAttribute, 0); +#endif + moveDockWindow( dockWindow, edge ); + dockWindow->setNewLine( newLine ); + if ( d->dockWindows.tqfind( dockWindow ) == -1 ) { + d->dockWindows.append( dockWindow ); + connect( dockWindow, TQT_SIGNAL( placeChanged(TQDockWindow::Place) ), + this, TQT_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 TQMainWindow::addDockWindow( TQDockWindow * dockWindow, const TQString &label, + TQt::Dock edge, bool newLine ) +{ + addDockWindow( dockWindow, edge, newLine ); +#ifndef TQT_NO_TOOLBAR + TQToolBar *tb = ::tqqt_cast<TQToolBar*>(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 TQMainWindow::moveDockWindow( TQDockWindow * dockWindow, TQt::Dock edge ) +{ + Qt::Orientation oo = dockWindow->orientation(); + switch ( edge ) { + case TQt::DockTop: + if ( dockWindow->area() != d->topDock ) + dockWindow->removeFromDock( FALSE ); + d->topDock->moveDockWindow( dockWindow ); + emit dockWindowPositionChanged( dockWindow ); + break; + case TQt::DockBottom: + if ( dockWindow->area() != d->bottomDock ) + dockWindow->removeFromDock( FALSE ); + d->bottomDock->moveDockWindow( dockWindow ); + emit dockWindowPositionChanged( dockWindow ); + break; + case TQt::DockRight: + if ( dockWindow->area() != d->rightDock ) + dockWindow->removeFromDock( FALSE ); + d->rightDock->moveDockWindow( dockWindow ); + emit dockWindowPositionChanged( dockWindow ); + break; + case TQt::DockLeft: + if ( dockWindow->area() != d->leftDock ) + dockWindow->removeFromDock( FALSE ); + d->leftDock->moveDockWindow( dockWindow ); + emit dockWindowPositionChanged( dockWindow ); + break; + case TQt::DockTornOff: + dockWindow->undock(); + break; + case TQt::DockMinimized: + dockWindow->undock( d->hideDock ); + break; + case TQt::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 TQMainWindow::moveDockWindow( TQDockWindow * dockWindow, TQt::Dock edge, bool nl, int index, int extraOffset ) +{ + Qt::Orientation oo = dockWindow->orientation(); + + dockWindow->setNewLine( nl ); + dockWindow->setOffset( extraOffset ); + switch ( edge ) { + case TQt::DockTop: + if ( dockWindow->area() != d->topDock ) + dockWindow->removeFromDock( FALSE ); + d->topDock->moveDockWindow( dockWindow, index ); + break; + case TQt::DockBottom: + if ( dockWindow->area() != d->bottomDock ) + dockWindow->removeFromDock( FALSE ); + d->bottomDock->moveDockWindow( dockWindow, index ); + break; + case TQt::DockRight: + if ( dockWindow->area() != d->rightDock ) + dockWindow->removeFromDock( FALSE ); + d->rightDock->moveDockWindow( dockWindow, index ); + break; + case TQt::DockLeft: + if ( dockWindow->area() != d->leftDock ) + dockWindow->removeFromDock( FALSE ); + d->leftDock->moveDockWindow( dockWindow, index ); + break; + case TQt::DockTornOff: + dockWindow->undock(); + break; + case TQt::DockMinimized: + dockWindow->undock( d->hideDock ); + break; + case TQt::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 TQMainWindow::removeDockWindow( TQDockWindow * dockWindow ) +{ +#ifdef TQ_WS_MAC + if(isTopLevel() && dockWindow->area() == topDock() && !dockWindows( DockTop ).count()) + ChangeWindowAttributes((WindowPtr)handle(), 0, kWindowToolbarButtonAttribute); +#endif + + dockWindow->hide(); + d->dockWindows.removeRef( dockWindow ); + disconnect( dockWindow, TQT_SIGNAL( placeChanged(TQDockWindow::Place) ), + this, TQT_SLOT( slotPlaceChanged() ) ); + dockWindow->removeEventFilter( this ); +} + +/*! + Sets up the tqgeometry management of the window. It is called + automatically when needed, so you shouldn't need to call it. +*/ + +void TQMainWindow::setUpLayout() +{ +#ifndef TQT_NO_MENUBAR + if ( !d->mb ) { + // slightly evil hack here. reconsider this + TQObjectList * l + = ((TQObject*)this)->queryList( "TQMenuBar", 0, FALSE, FALSE ); + if ( l && l->count() ) + d->mb = menuBar(); + delete l; + } +#endif + if ( !d->sb ) { + // as above. + TQObjectList * l + = ((TQObject*)this)->queryList( "TQStatusBar", 0, FALSE, FALSE ); + if ( l && l->count() ) + d->sb = statusBar(); + delete l; + } + + if (!d->tll) { + d->tll = new TQBoxLayout( this, TQBoxLayout::Down ); + d->tll->setResizeMode( tqminimumSize().isNull() ? TQLayout::Minimum : TQLayout::FreeResize ); + } else { + d->tll->setMenuBar( 0 ); + TQLayoutIterator it = d->tll->iterator(); + TQLayoutItem *item; + while ( (item = it.takeCurrent()) ) + delete item; + } + +#ifndef TQT_NO_MENUBAR + if ( d->mb && d->mb->isVisibleTo( this ) ) { + d->tll->setMenuBar( d->mb ); + if (tqstyle().tqstyleHint(TQStyle::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 ); + + TQMainWindowLayout *mwl = new TQMainWindowLayout( 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 TQMainWindow::show() +{ + if ( !d->tll ) + setUpLayout(); + + // show all floating dock windows not explicitly hidden + if (!isVisible()) { + TQPtrListIterator<TQDockWindow> it(d->dockWindows); + while ( it.current() ) { + TQDockWindow *dw = it.current(); + ++it; + if ( dw->isTopLevel() && !dw->isVisible() && !dw->testWState(TQt::WState_ForceHide) ) + dw->show(); + } + } + + // show us last so we get focus + TQWidget::show(); +} + + +/*! \reimp +*/ +void TQMainWindow::hide() +{ + if ( isVisible() ) { + TQPtrListIterator<TQDockWindow> it(d->dockWindows); + while ( it.current() ) { + TQDockWindow *dw = it.current(); + ++it; + if ( dw->isTopLevel() && dw->isVisible() ) { + dw->hide(); // implicit hide, so clear forcehide + ((TQMainWindow*)dw)->clearWState(TQt::WState_ForceHide); + } + } + } + + TQWidget::hide(); +} + + +/*! \reimp */ +TQSize TQMainWindow::tqsizeHint() const +{ + TQMainWindow* that = (TQMainWindow*) this; + // Workaround: because d->tll get's deleted in + // totalSizeHint->polish->sendPostedEvents->childEvent->triggerLayout + // [eg. canvas example on TQt/Embedded] + TQApplication::sendPostedEvents( that, TQEvent::ChildInserted ); + if ( !that->d->tll ) + that->setUpLayout(); + return that->d->tll->totalSizeHint(); +} + +/*! \reimp */ +TQSize TQMainWindow::tqminimumSizeHint() const +{ + if ( !d->tll ) { + TQMainWindow* that = (TQMainWindow*) 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 TQMainWindow::setCentralWidget( TQWidget * 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() +*/ + +TQWidget * TQMainWindow::centralWidget() const +{ + return d->mc; +} + + +/*! \reimp */ + +void TQMainWindow::paintEvent( TQPaintEvent * ) +{ + if (d->mb && + tqstyle().tqstyleHint(TQStyle::SH_MainWindow_SpaceBelowMenuBar, this)) { + + TQPainter p( this ); + int y = d->mb->height() + 1; + tqstyle().tqdrawPrimitive(TQStyle::PE_Separator, &p, TQRect(0, y, width(), 1), + tqcolorGroup(), TQStyle::Style_Sunken); + } +} + + +bool TQMainWindow::dockMainWindow( TQObject *dock ) +{ + while ( dock ) { + if ( dock->tqparent() && TQT_BASE_OBJECT(dock->tqparent()) == TQT_BASE_OBJECT(this) ) + return TRUE; + if ( ::tqqt_cast<TQMainWindow*>(dock->tqparent()) ) + return FALSE; + dock = dock->tqparent(); + } + return FALSE; +} + +/*! + \reimp +*/ + +bool TQMainWindow::eventFilter( TQObject* o, TQEvent *e ) +{ + if ( e->type() == TQEvent::Show && TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(this) ) { + if ( !d->tll ) + setUpLayout(); + d->tll->activate(); + } else if ( e->type() == TQEvent::ContextMenu && d->dockMenu && + ( ::tqqt_cast<TQDockArea*>(o) && dockMainWindow( o ) || TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(d->hideDock) || TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(d->mb) ) ) { + if ( showDockMenu( ( (TQMouseEvent*)e )->globalPos() ) ) { + ( (TQContextMenuEvent*)e )->accept(); + return TRUE; + } + } + + return TQWidget::eventFilter( o, e ); +} + + +/*! + Monitors events, recieved in \a e, to ensure the tqlayout is updated. +*/ +void TQMainWindow::childEvent( TQChildEvent* e) +{ + if ( e->type() == TQEvent::ChildRemoved ) { + if ( e->child() == 0 || + !e->child()->isWidgetType() || + ((TQWidget*)e->child())->testWFlags( TQt::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 ( ::tqqt_cast<TQDockWindow*>(e->child()) ) { + removeDockWindow( (TQDockWindow *)(e->child()) ); + d->appropriate.remove( (TQDockWindow*)e->child() ); + triggerLayout(); + } + } else if ( e->type() == TQEvent::ChildInserted && !d->sb ) { + d->sb = ::tqqt_cast<TQStatusBar*>(e->child()); + if ( d->sb ) { + if ( d->tll ) { + if ( !d->tll->tqfindWidget( d->sb ) ) + d->tll->addWidget( d->sb ); + } else { + triggerLayout(); + } + } + } +} + +/*! + \reimp +*/ + +bool TQMainWindow::event( TQEvent * e ) +{ + if ( e->type() == TQEvent::ChildRemoved && ( (TQChildEvent*)e )->child() == d->mc ) { + d->mc->removeEventFilter( this ); + d->mc = 0; + d->mwl->setCentralWidget( 0 ); + } + + return TQWidget::event( e ); +} + + +/*! + \property TQMainWindow::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 TQMainWindow::usesBigPixmaps() const +{ + return d->ubp; +} + +void TQMainWindow::setUsesBigPixmaps( bool enable ) +{ + if ( enable == (bool)d->ubp ) + return; + + d->ubp = enable; + emit pixmapSizeChanged( enable ); + + TQObjectList *l = queryList( "TQLayout" ); + if ( !l || !l->first() ) { + delete l; + return; + } + for ( TQLayout *lay = (TQLayout*)l->first(); lay; lay = (TQLayout*)l->next() ) + lay->activate(); + delete l; +} + +/*! + \property TQMainWindow::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 TQToolButton::setUsesTextLabel() +*/ + +bool TQMainWindow::usesTextLabel() const +{ + return d->utl; +} + + +void TQMainWindow::setUsesTextLabel( bool enable ) +{ + if ( enable == (bool)d->utl ) + return; + + d->utl = enable; + emit usesTextLabelChanged( enable ); + + TQObjectList *l = queryList( "TQLayout" ); + if ( !l || !l->first() ) { + delete l; + return; + } + for ( TQLayout *lay = (TQLayout*)l->first(); lay; lay = (TQLayout*)l->next() ) + lay->activate(); + delete l; +} + + +/*! + \fn void TQMainWindow::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 TQMainWindow::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 TQMainWindow::dockWindowPositionChanged( TQDockWindow *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 TQMainWindow::setRightJustification( bool enable ) +{ + if ( enable == (bool)d->justify ) + return; + d->justify = enable; + triggerLayout( TRUE ); +} + + +/*! + \obsolete + \property TQMainWindow::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 TQDockWindow::setVerticalStretchable(), TQDockWindow::setHorizontalStretchable() +*/ + +bool TQMainWindow::rightJustification() const +{ + return d->justify; +} + +/*! \internal + */ + +void TQMainWindow::triggerLayout( bool deleteLayout ) +{ + if ( deleteLayout || !d->tll ) + setUpLayout(); + TQApplication::postEvent( this, new TQEvent( TQEvent::LayoutHint ) ); +} + +/*! + Enters 'What's This?' mode and returns immediately. + + This is the same as TQWhatsThis::enterWhatsThisMode(), but + implemented as a main window object's slot. This way it can easily + be used for popup menus, for example: + + \code + TQPopupMenu * help = new TQPopupMenu( this ); + help->insertItem( "What's &This", this , TQT_SLOT(whatsThis()), SHIFT+Key_F1); + \endcode + + \sa TQWhatsThis::enterWhatsThisMode() +*/ +void TQMainWindow::whatsThis() +{ +#ifndef TQT_NO_WHATSTHIS + TQWhatsThis::enterWhatsThisMode(); +#endif +} + + +/*! + \reimp +*/ + +void TQMainWindow::styleChange( TQStyle& old ) +{ + TQWidget::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 TQMainWindow::getLocation( TQDockWindow *dw, TQt::Dock &dock, int &index, bool &nl, int &extraOffset ) const +{ + dock = TQt::DockTornOff; + if ( d->topDock->hasDockWindow( dw, &index ) ) + dock = TQt::DockTop; + else if ( d->bottomDock->hasDockWindow( dw, &index ) ) + dock = TQt::DockBottom; + else if ( d->leftDock->hasDockWindow( dw, &index ) ) + dock = TQt::DockLeft; + else if ( d->rightDock->hasDockWindow( dw, &index ) ) + dock = TQt::DockRight; + else if ( dw->parentWidget() == d->hideDock ) { + index = 0; + dock = TQt::DockMinimized; + } else { + index = 0; + } + nl = dw->newLine(); + extraOffset = dw->offset(); + return TRUE; +} + +#ifndef TQT_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() +*/ + +TQPtrList<TQToolBar> TQMainWindow::toolBars( TQt::Dock dock ) const +{ + TQPtrList<TQDockWindow> lst = dockWindows( dock ); + TQPtrList<TQToolBar> tbl; + for ( TQDockWindow *w = lst.first(); w; w = lst.next() ) { + TQToolBar *tb = ::tqqt_cast<TQToolBar*>(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. +*/ + +TQPtrList<TQDockWindow> TQMainWindow::dockWindows( TQt::Dock dock ) const +{ + TQPtrList<TQDockWindow> lst; + switch ( dock ) { + case TQt::DockTop: + return d->topDock->dockWindowList(); + case TQt::DockBottom: + return d->bottomDock->dockWindowList(); + case TQt::DockLeft: + return d->leftDock->dockWindowList(); + case TQt::DockRight: + return d->rightDock->dockWindowList(); + case TQt::DockTornOff: { + for ( TQDockWindow *w = d->dockWindows.first(); w; w = d->dockWindows.next() ) { + if ( !w->area() && w->place() == TQDockWindow::OutsideDock ) + lst.append( w ); + } + } + return lst; + case TQt::DockMinimized: { + if ( !d->hideDock->childrenListObject().isEmpty() ) { + TQObjectListIt it( d->hideDock->childrenListObject() ); + TQObject *o; + while ( ( o = it.current() ) ) { + ++it; + TQDockWindow *dw = ::tqqt_cast<TQDockWindow*>(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). +*/ + +TQPtrList<TQDockWindow> TQMainWindow::dockWindows() const +{ + return d->dockWindows; +} + +void TQMainWindow::setDockWindowsMovable( bool enable ) +{ + d->movable = enable; + TQObjectList *l = queryList( "TQDockWindow" ); + if ( l ) { + for ( TQObject *o = l->first(); o; o = l->next() ) + ( (TQDockWindow*)o )->setMovingEnabled( enable ); + } + delete l; +} + +/*! + \property TQMainWindow::dockWindowsMovable + \brief whether the dock windows are movable + + If TRUE (the default), the user will be able to move movable dock + windows from one TQMainWindow 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 TQMainWindow 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 TQMainWindow::dockWindowsMovable() const +{ + return d->movable; +} + +void TQMainWindow::setOpaqueMoving( bool b ) +{ + d->opaque = b; + TQObjectList *l = queryList( "TQDockWindow" ); + if ( l ) { + for ( TQObject *o = l->first(); o; o = l->next() ) + ( (TQDockWindow*)o )->setOpaqueMoving( b ); + } + delete l; +} + +/*! + \property TQMainWindow::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 TQMainWindow::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 tqlayout possible. + + The method only works if dockWindowsMovable() returns TRUE. +*/ + +void TQMainWindow::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 TQMainWindow::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 TQMainWindow::setDockMenuEnabled( bool b ) +{ + d->dockMenu = b; +} + +/*! + Creates the dock window menu which tqcontains 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 +### TQt 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. +*/ + +TQPopupMenu *TQMainWindow::createDockWindowMenu( DockWindows dockWindows ) const +{ + TQObjectList *l = queryList( "TQDockWindow" ); + + if ( !l || l->isEmpty() ) + return 0; + + delete l; + + TQPopupMenu *menu = new TQPopupMenu( (TQMainWindow*)this, "qt_customize_menu" ); + menu->setCheckable( TRUE ); + d->dockWindowModes.tqreplace( menu, dockWindows ); + connect( menu, TQT_SIGNAL( aboutToShow() ), this, TQT_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 +### TQt 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 TQMainWindow::menuAboutToShow() +{ + TQPopupMenu *menu = (TQPopupMenu*)sender(); + TQMap<TQPopupMenu*, DockWindows>::Iterator it = d->dockWindowModes.tqfind( menu ); + if ( it == d->dockWindowModes.end() ) + return; + menu->clear(); + + DockWindows dockWindows = *it; + + TQObjectList *l = queryList( "TQDockWindow" ); + + bool empty = TRUE; + if ( l && !l->isEmpty() ) { + + TQObject *o = 0; + if ( dockWindows == AllDockWindows || dockWindows == NoToolBars ) { + for ( o = l->first(); o; o = l->next() ) { + TQDockWindow *dw = (TQDockWindow*)o; + if ( !appropriate( dw ) || ::tqqt_cast<TQToolBar*>(dw) || !dockMainWindow( TQT_TQOBJECT(dw) ) ) + continue; + TQString label = dw->caption(); + if ( !label.isEmpty() ) { + int id = menu->insertItem( label, TQT_TQOBJECT(dw), TQT_SLOT( toggleVisible() ) ); + menu->setItemChecked( id, dw->isVisible() ); + empty = FALSE; + } + } + if ( !empty ) + menu->insertSeparator(); + } + + empty = TRUE; + +#ifndef TQT_NO_TOOLBAR + if ( dockWindows == AllDockWindows || dockWindows == OnlyToolBars ) { + for ( o = l->first(); o; o = l->next() ) { + TQToolBar *tb = ::tqqt_cast<TQToolBar*>(o); + if ( !tb || !appropriate(tb) || !dockMainWindow(TQT_TQOBJECT(tb)) ) + continue; + TQString label = tb->label(); + if ( !label.isEmpty() ) { + int id = menu->insertItem( label, TQT_TQOBJECT(tb), TQT_SLOT( toggleVisible() ) ); + menu->setItemChecked( id, tb->isVisible() ); + empty = FALSE; + } + } + } +#endif + + } + + delete l; + + if ( !empty ) + menu->insertSeparator(); + + if ( dockWindowsMovable() ) + menu->insertItem( tr( "Line up" ), TQT_TQOBJECT(this), TQT_SLOT( doLineUp() ) ); + if ( isCustomizable() ) + menu->insertItem( tr( "Customize..." ), TQT_TQOBJECT(this), TQT_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 +### TQt 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 TQMainWindow::showDockMenu( const TQPoint &globalPos ) +{ + if ( !d->dockMenu ) + return FALSE; + if ( !d->rmbMenu ) + d->rmbMenu = createDockWindowMenu(); + if ( !d->rmbMenu ) + return FALSE; + + d->rmbMenu->exec( globalPos ); + return TRUE; +} + +void TQMainWindow::slotPlaceChanged() +{ + TQObject* obj = (TQObject*)sender(); + TQDockWindow *dw = ::tqqt_cast<TQDockWindow*>(obj); + if ( dw ) + emit dockWindowPositionChanged( dw ); +#ifndef TQT_NO_TOOLBAR + TQToolBar *tb = ::tqqt_cast<TQToolBar*>(obj); + if ( tb ) + emit toolBarPositionChanged( tb ); +#endif +} + +/*! + \internal + For internal use of TQDockWindow only. + */ + +TQDockArea *TQMainWindow::dockingArea( const TQPoint &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 TQMainWindow::hasDockWindow( TQDockWindow *dw ) +{ + return d->dockWindows.tqfindRef( dw ) != -1; +} + +/*! + Returns the \c Left dock area + + \sa rightDock() topDock() bottomDock() +*/ + +TQDockArea *TQMainWindow::leftDock() const +{ + return d->leftDock; +} + +/*! + Returns the \c Right dock area + + \sa leftDock() topDock() bottomDock() +*/ + +TQDockArea *TQMainWindow::rightDock() const +{ + return d->rightDock; +} + +/*! + Returns the \c Top dock area + + \sa bottomDock() leftDock() rightDock() +*/ + +TQDockArea *TQMainWindow::topDock() const +{ + return d->topDock; +} + +/*! + Returns a pointer the \c Bottom dock area + + \sa topDock() leftDock() rightDock() +*/ + +TQDockArea *TQMainWindow::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 TQMainWindow::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 TQMainWindow::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 TQMainWindow::appropriate( TQDockWindow *dw ) const +{ + TQMap<TQDockWindow*, bool>::ConstIterator it = d->appropriate.tqfind( 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 TQMainWindow::setAppropriate( TQDockWindow *dw, bool a ) +{ + d->appropriate.tqreplace( dw, a ); +} + +#ifndef TQT_NO_TEXTSTREAM +static void saveDockArea( TQTextStream &ts, TQDockArea *a ) +{ + TQPtrList<TQDockWindow> l = a->dockWindowList(); + for ( TQDockWindow *dw = l.first(); dw; dw = l.next() ) { + ts << TQString( dw->caption() ); + ts << ","; + } + ts << endl; + ts << *a; +} + +/*! + \relates TQMainWindow + + Writes the tqlayout (sizes and positions) of the dock windows in the + dock areas of the TQMainWindow \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 TQSettings to + save the user's tqlayout when the \mainWindow receives a closeEvent. + + \sa operator>>() closeEvent() +*/ + +TQTextStream &operator<<( TQTextStream &ts, const TQMainWindow &mainWindow ) +{ + TQPtrList<TQDockWindow> l = mainWindow.dockWindows( TQt::DockMinimized ); + TQDockWindow *dw = 0; + for ( dw = l.first(); dw; dw = l.next() ) { + ts << dw->caption(); + ts << ","; + } + ts << endl; + + l = mainWindow.dockWindows( TQt::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->tqgeometry().x() << "," + << (int)dw->tqgeometry().y() << "," + << (int)dw->tqgeometry().width() << "," + << (int)dw->tqgeometry().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 TQStringList &names, TQDockArea *a, TQt::Dock d, TQPtrList<TQDockWindow> &l, TQMainWindow *mw, TQTextStream &ts ) +{ + for ( TQStringList::ConstIterator it = names.begin(); it != names.end(); ++it ) { + for ( TQDockWindow *dw = l.first(); dw; dw = l.next() ) { + if ( dw->caption() == *it ) { + mw->addDockWindow( dw, d ); + break; + } + } + } + if ( a ) { + ts >> *a; + } else if ( d == TQt::DockTornOff ) { + TQString s = ts.readLine(); + enum State { Pre, Name, X, Y, Width, Height, Visible, Post }; + int state = Pre; + TQString name, x, y, w, h, visible; + TQChar 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 ( TQDockWindow *dw = l.first(); dw; dw = l.next() ) { + if ( TQString( dw->caption() ) == name ) { + if ( !::tqqt_cast<TQToolBar*>(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 TQMainWindow + + Reads the tqlayout (sizes and positions) of the dock windows in the + dock areas of the TQMainWindow \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 tqlayout information must be in the format produced + by operator<<(). + + This can be used, for example, in conjunction with TQSettings to + restore the user's tqlayout. + + \sa operator<<() +*/ + +TQTextStream &operator>>( TQTextStream &ts, TQMainWindow &mainWindow ) +{ + TQPtrList<TQDockWindow> l = mainWindow.dockWindows(); + + TQString s = ts.readLine(); + TQStringList names = TQStringList::split( ',', s ); + loadDockArea( names, 0, TQt::DockMinimized, l, &mainWindow, ts ); + + s = ts.readLine(); + names = TQStringList::split( ',', s ); + loadDockArea( names, 0, TQt::DockTornOff, l, &mainWindow, ts ); + + int i = 0; + TQDockArea *areas[] = { mainWindow.topDock(), mainWindow.bottomDock(), mainWindow.rightDock(), mainWindow.leftDock() }; + for ( int d = (int)TQt::DockTop; d != (int)TQt::DockMinimized; ++d, ++i ) { + s = ts.readLine(); + names = TQStringList::split( ',', s ); + loadDockArea( names, areas[ i ], (TQt::Dock)d, l, &mainWindow, ts ); + } + return ts; +} +#endif + +#include "tqmainwindow.tqmoc" + +#endif |