QMainWindowLayout Class Reference

#include <qmainwindowlayout_p.h>

Inheritance diagram for QMainWindowLayout:

Classes
struct	ToolBarSaveState

Public Types
enum	{ VersionMarker = 0xff }
Public Types inherited from QLayout
enum	SizeConstraint {   SetDefaultConstraint, SetNoConstraint, SetMinimumSize, SetFixedSize,   SetMaximumSize, SetMinAndMaxSize }
	The possible values are: More...

Public Functions
void	addDockWidget (Qt::DockWidgetArea area, QDockWidget *dockwidget, Qt::Orientation orientation)
void	addItem (QLayoutItem *item)
	Implemented in subclasses to add an item. More...
void	addToolBar (Qt::ToolBarArea area, QToolBar *toolbar, bool needAddChildWidget=true)
	Adds toolbar to area, continuing the current line. More...
void	addToolBarBreak (Qt::ToolBarArea area)
void	animationFinished (QWidget *widget)
void	applyState (QMainWindowLayoutState &newState, bool animate=true)
QWidget *	centralWidget () const
void	cleanUpMacToolbarItems ()
Qt::DockWidgetArea	corner (Qt::Corner corner) const
int	count () const
	Must be implemented in subclasses to return the number of items in the layout. More...
Qt::DockWidgetArea	dockWidgetArea (QDockWidget *dockwidget) const
bool	documentMode () const
bool	endSeparatorMove (const QPoint &pos)
void	fixSizeInUnifiedToolbar (QToolBar *tb) const
QWidget *	getSeparatorWidget ()
void	getStyleOptionInfo (QStyleOptionToolBar *option, QToolBar *toolBar) const
QTabBar *	getTabBar ()
QList< int >	hover (QLayoutItem *widgetItem, const QPoint &mousePos)
void	insertIntoMacToolbar (QToolBar *before, QToolBar *after)
void	insertToolBar (QToolBar *before, QToolBar *toolbar)
	Adds toolbar before before. More...
void	insertToolBarBreak (QToolBar *before)
void	invalidate ()
	Reimplemented Function More...
QLayoutItem *	itemAt (int index) const
	Must be implemented in subclasses to return the layout item at index. More...
void	keepSize (QDockWidget *w)
QSize	minimumSize () const
	Returns the minimum size of this layout. More...
void	moveToolBar (QToolBar *toolbar, int pos)
void	paintDropIndicator (QPainter *p, QWidget *widget, const QRegion &clip)
bool	plug (QLayoutItem *widgetItem)
	QMainWindowLayout (QMainWindow *mainwindow, QLayout *parentLayout)
void	raise (QDockWidget *widget)
void	removeFromMacToolbar (QToolBar *toolbar)
void	removeToolBar (QToolBar *toolbar)
void	removeToolBarBreak (QToolBar *before)
void	restore (bool keepSavedState=false)
bool	restoreDockWidget (QDockWidget *dockwidget)
bool	restoreState (QDataStream &stream)
void	revert (QLayoutItem *widgetItem)
void	saveState (QDataStream &stream) const
bool	separatorMove (const QPoint &pos)
void	setCentralWidget (QWidget *cw)
void	setCorner (Qt::Corner corner, Qt::DockWidgetArea area)
void	setDockOptions (QMainWindow::DockOptions opts)
void	setDocumentMode (bool enabled)
void	setGeometry (const QRect &r)
	Reimplemented Function More...
void	setStatusBar (QStatusBar *sb)
void	setTabPosition (Qt::DockWidgetAreas areas, QTabWidget::TabPosition tabPosition)
void	setTabShape (QTabWidget::TabShape tabShape)
void	setVerticalTabsEnabled (bool enabled)
QSize	sizeHint () const
	Implemented in subclasses to return the preferred size of this item. More...
void	splitDockWidget (QDockWidget *after, QDockWidget *dockwidget, Qt::Orientation orientation)
bool	startSeparatorMove (const QPoint &pos)
QStatusBar *	statusBar () const
void	syncUnifiedToolbarVisibility ()
void	tabifyDockWidget (QDockWidget *first, QDockWidget *second)
QTabWidget::TabPosition	tabPosition (Qt::DockWidgetArea area) const
QTabWidget::TabShape	tabShape () const
QLayoutItem *	takeAt (int index)
	Must be implemented in subclasses to remove the layout item at index from the layout, and return the item. More...
void	timerEvent (QTimerEvent *e)
	This event handler can be reimplemented in a subclass to receive timer events for the object. More...
void	toggleToolBarsVisible ()
Qt::ToolBarArea	toolBarArea (QToolBar *toolbar) const
bool	toolBarBreak (QToolBar *toolBar) const
QLayoutItem *	unplug (QWidget *widget)
void	updateGapIndicator ()
void	updateHIToolBarStatus ()
bool	usesHIToolBar (QToolBar *toolbar) const
	~QMainWindowLayout ()
Public Functions inherited from QLayout
bool	activate ()
	Redoes the layout for parentWidget() if necessary. More...
void	addWidget (QWidget *w)
	Adds widget w to this layout in a manner specific to the layout. More...
QMargins	contentsMargins () const
	Returns the margins used around the layout. More...
QRect	contentsRect () const
	Returns the layout's geometry() rectangle, but taking into account the contents margins. More...
Qt::Orientations	expandingDirections () const
	Returns whether this layout can make use of more space than sizeHint(). More...
QRect	geometry () const
	Reimplemented Function More...
void	getContentsMargins (int *left, int *top, int *right, int *bottom) const
virtual int	indexOf (QWidget *) const
	Searches for widget widget in this layout (not including child layouts). More...
bool	isEmpty () const
	Reimplemented Function More...
bool	isEnabled () const
	Returns true if the layout is enabled; otherwise returns false. More...
QLayout *	layout ()
	Reimplemented Function More...
int	margin () const
QSize	maximumSize () const
	Returns the maximum size of this layout. More...
QWidget *	menuBar () const
	Returns the menu bar set for this layout, or 0 if no menu bar is set. More...
QWidget *	parentWidget () const
	Returns the parent widget of this layout, or 0 if this layout is not installed on any widget. More...
	QLayout (QWidget *parent)
	Constructs a new top-level QLayout, with parent parent. More...
	QLayout ()
	Constructs a new child QLayout. More...
void	removeItem (QLayoutItem *)
	Removes the layout item item from the layout. More...
void	removeWidget (QWidget *w)
	Removes the widget widget from the layout. More...
bool	setAlignment (QWidget *w, Qt::Alignment alignment)
	Sets the alignment for widget w to alignment and returns true if w is found in this layout (not including child layouts); otherwise returns false. More...
bool	setAlignment (QLayout *l, Qt::Alignment alignment)
	Sets the alignment for the layout l to alignment and returns true if l is found in this layout (not including child layouts); otherwise returns false. More...
void	setContentsMargins (int left, int top, int right, int bottom)
	Sets the left, top, right, and bottom margins to use around the layout. More...
void	setContentsMargins (const QMargins &margins)
	Sets the margins to use around the layout. More...
void	setEnabled (bool)
	Enables this layout if enable is true, otherwise disables it. More...
void	setMargin (int)
void	setMenuBar (QWidget *w)
	Tells the geometry manager to place the menu bar widget at the top of parentWidget(), outside QWidget::contentsMargins(). More...
void	setSizeConstraint (SizeConstraint)
void	setSpacing (int)
SizeConstraint	sizeConstraint () const
int	spacing () const
int	totalHeightForWidth (int w) const
	Also takes contentsMargins and menu bar into account. More...
QSize	totalMaximumSize () const
	Also takes contentsMargins and menu bar into account. More...
QSize	totalMinimumSize () const
	Also takes contentsMargins and menu bar into account. More...
QSize	totalSizeHint () const
	Also takes contentsMargins and menu bar into account. More...
void	update ()
	Updates the layout for parentWidget(). More...
	~QLayout ()
	Destroys the layout, deleting all child layouts. More...
Public Functions inherited from QObject
bool	blockSignals (bool b)
	If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it). More...
const QObjectList &	children () const
	Returns a list of child objects. More...
bool	connect (const QObject *sender, const char *signal, const char *member, Qt::ConnectionType type=Qt::AutoConnection) const
bool	disconnect (const char *signal=0, const QObject *receiver=0, const char *member=0)
bool	disconnect (const QObject *receiver, const char *member=0)
void	dumpObjectInfo ()
	Dumps information about signal connections, etc. More...
void	dumpObjectTree ()
	Dumps a tree of children to the debug output. More...
QList< QByteArray >	dynamicPropertyNames () const
	Returns the names of all properties that were dynamically added to the object using setProperty(). More...
virtual bool	event (QEvent *)
	This virtual function receives events to an object and should return true if the event e was recognized and processed. More...
virtual bool	eventFilter (QObject *, QEvent *)
	Filters events if this object has been installed as an event filter for the watched object. More...
template<typename T >
T	findChild (const QString &aName=QString()) const
	Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. More...
template<typename T >
QList< T >	findChildren (const QString &aName=QString()) const
	Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. More...
template<typename T >
QList< T >	findChildren (const QRegExp &re) const
bool	inherits (const char *classname) const
	Returns true if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns false. More...
void	installEventFilter (QObject *)
	Installs an event filter filterObj on this object. More...
bool	isWidgetType () const
	Returns true if the object is a widget; otherwise returns false. More...
void	killTimer (int id)
	Kills the timer with timer identifier, id. More...
virtual const QMetaObject *	metaObject () const
	Returns a pointer to the meta-object of this object. More...
void	moveToThread (QThread *thread)
	Changes the thread affinity for this object and its children. More...
QString	objectName () const
QObject *	parent () const
	Returns a pointer to the parent object. More...
QVariant	property (const char *name) const
	Returns the value of the object's name property. More...
Q_INVOKABLE	QObject (QObject *parent=0)
	Constructs an object with parent object parent. More...
void	removeEventFilter (QObject *)
	Removes an event filter object obj from this object. More...
void	setObjectName (const QString &name)
void	setParent (QObject *)
	Makes the object a child of parent. More...
bool	setProperty (const char *name, const QVariant &value)
	Sets the value of the object's name property to value. More...
void	setUserData (uint id, QObjectUserData *data)
bool	signalsBlocked () const
	Returns true if signals are blocked; otherwise returns false. More...
int	startTimer (int interval)
	Starts a timer and returns a timer identifier, or returns zero if it could not start a timer. More...
QThread *	thread () const
	Returns the thread in which the object lives. More...
QObjectUserData *	userData (uint id) const
virtual	~QObject ()
	Destroys the object, deleting all its child objects. More...
Public Functions inherited from QLayoutItem
Qt::Alignment	alignment () const
	Returns the alignment of this item. More...
QSizePolicy::ControlTypes	controlTypes () const
	Returns the control type(s) for the layout item. More...
virtual bool	hasHeightForWidth () const
	Returns true if this layout's preferred height depends on its width; otherwise returns false. More...
virtual int	heightForWidth (int) const
	Returns the preferred height for this layout item, given the width w. More...
virtual int	minimumHeightForWidth (int) const
	Returns the minimum height this widget needs for the given width, w. More...
	QLayoutItem (Qt::Alignment alignment=0)
	Constructs a layout item with an alignment. More...
void	setAlignment (Qt::Alignment a)
	Sets the alignment of this item to alignment. More...
virtual QSpacerItem *	spacerItem ()
	If this item is a QSpacerItem, it is returned as a QSpacerItem; otherwise 0 is returned. More...
virtual QWidget *	widget ()
	If this item is a QWidget, it is returned as a QWidget; otherwise 0 is returned. More...
virtual	~QLayoutItem ()
	Destroys the QLayoutItem. More...

Public Variables
bool	_documentMode
QTabWidget::TabShape	_tabShape
bool	activateUnifiedToolbarAfterFullScreen
bool	blockVisiblityCheck
QHash< QString, QToolBar * >	cocoaItemIDToToolbarHash
QList< int >	currentGapPos
QRect	currentGapRect
QMainWindow::DockOptions	dockOptions
QRubberBand *	gapIndicator
QMainWindowLayoutState	layoutState
QSize	minSize
QList< int >	movingSeparator
QPoint	movingSeparatorOrigin
QPoint	movingSeparatorPos
QWidget *	pluggingWidget
QList< QToolBar * >	qtoolbarsInUnifiedToolbarList
QMainWindowLayoutState	savedState
int	sep
QBasicTimer	separatorMoveTimer
QLayoutItem *	statusbar
QSize	szHint
QTabWidget::TabPosition	tabPositions [4]
QList< void * >	toolbarItemsCopy
QHash< QToolBar *, ToolBarSaveState >	toolbarSaveState
QHash< void *, QToolBar * >	unifiedToolbarHash
QList< QWidget * >	unusedSeparatorWidgets
QList< QTabBar * >	unusedTabBars
QSet< QWidget * >	usedSeparatorWidgets
QSet< QTabBar * >	usedTabBars
bool	verticalTabsEnabled
QWidgetAnimator	widgetAnimator

Private Slots
void	tabChanged ()

Private Functions
void	updateTabBarShapes ()

Static Private Functions
static HIToolbarItemRef	createQToolBarInHIToolbarItem (QToolBar *toolbar, QMainWindowLayout *layout)
static HIToolbarItemRef	CreateToolbarItemForIdentifier (CFStringRef identifier, CFTypeRef data)
static void	qtMacHIToolbarRegisterQToolBarInHIToolborItemClass ()
static OSStatus	qtmacToolbarDelegate (EventHandlerCallRef, EventRef, void *)
static OSStatus	qtoolbarInHIToolbarHandler (EventHandlerCallRef inCallRef, EventRef event, void *data)

Additional Inherited Members
Public Slots inherited from QObject
void	deleteLater ()
	Schedules this object for deletion. More...
Signals inherited from QObject
void	destroyed (QObject *=0)
	This signal is emitted immediately before the object obj is destroyed, and can not be blocked. More...
Static Public Functions inherited from QLayout
static QSize	closestAcceptableSize (const QWidget *w, const QSize &s)
	Returns a size that satisfies all size constraints on widget, including heightForWidth() and that is as close as possible to size. More...
Static Public Functions inherited from QObject
static bool	connect (const QObject *sender, const char *signal, const QObject *receiver, const char *member, Qt::ConnectionType=Qt::AutoConnection)
	Creates a connection of the given type from the signal in the sender object to the method in the receiver object. More...
static bool	connect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type=Qt::AutoConnection)
static bool	disconnect (const QObject *sender, const char *signal, const QObject *receiver, const char *member)
	Disconnects signal in object sender from method in object receiver. More...
static bool	disconnect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &member)
static uint	registerUserData ()
static QString	tr (const char *sourceText, const char *comment=0, int n=-1)
static QString	trUtf8 (const char *sourceText, const char *comment=0, int n=-1)
Static Public Variables inherited from QObject
static const QMetaObject	staticMetaObject
	This variable stores the meta-object for the class. More...
Protected Functions inherited from QLayout
void	addChildLayout (QLayout *l)
	This function is called from addLayout() or insertLayout() functions in subclasses to add layout l as a sub-layout. More...
void	addChildWidget (QWidget *w)
	This function is called from addWidget() functions in subclasses to add w as a managed widget of a layout. More...
bool	adoptLayout (QLayout *layout)
QRect	alignmentRect (const QRect &) const
	Returns the rectangle that should be covered when the geometry of this layout is set to r, provided that this layout supports setAlignment(). More...
void	childEvent (QChildEvent *e)
	Reimplemented Function More...
	QLayout (QLayoutPrivate &d, QLayout *, QWidget *)
void	widgetEvent (QEvent *)
	Performs child widget layout when the parent widget is resized. More...
Protected Functions inherited from QObject
virtual void	connectNotify (const char *signal)
	This virtual function is called when something has been connected to signal in this object. More...
virtual void	customEvent (QEvent *)
	This event handler can be reimplemented in a subclass to receive custom events. More...
virtual void	disconnectNotify (const char *signal)
	This virtual function is called when something has been disconnected from signal in this object. More...
	QObject (QObjectPrivate &dd, QObject *parent=0)
int	receivers (const char *signal) const
	Returns the number of receivers connected to the signal. More...
QObject *	sender () const
	Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; otherwise it returns 0. More...
int	senderSignalIndex () const
Protected Variables inherited from QObject
QScopedPointer< QObjectData >	d_ptr
Protected Variables inherited from QLayoutItem
Qt::Alignment	align
Static Protected Variables inherited from QObject
static const QMetaObject	staticQtMetaObject
Related Functions inherited from QObject
T	qFindChildqFindChildren (const QObject *obj, const QString &name)()
QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QString &name)()
QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QRegExp &regExp)()
T *	qobject_cast (QObject *object)
	QObjectList
void *	qt_find_obj_child (QObject *parent, const char *type, const QString &name)
	Returns a pointer to the object named name that inherits type and with a given parent. More...

Detailed Description

Definition at line 159 of file qmainwindowlayout_p.h.

Enumerations

anonymous enum

anonymous enum

Enumerator
VersionMarker

Definition at line 263 of file qmainwindowlayout_p.h.

         { // sentinel values used to validate state data
        VersionMarker = 0xff
    };

Constructors and Destructors

QMainWindowLayout()

QMainWindowLayout::QMainWindowLayout	(	QMainWindow *	mainwindow,
		QLayout *	parentLayout
	)

Definition at line 1686 of file qmainwindowlayout.cpp.

    : QLayout(parentLayout ? static_cast<QWidget *>(0) : mainwindow)
    , layoutState(mainwindow)
    , savedState(mainwindow)
    , dockOptions(QMainWindow::AnimatedDocks | QMainWindow::AllowTabbedDocks)
    , statusbar(0)
#ifndef QT_NO_DOCKWIDGET
#ifndef QT_NO_TABBAR
    , _documentMode(false)
    , verticalTabsEnabled(false)
#ifndef QT_NO_TABWIDGET
    , _tabShape(QTabWidget::Rounded)
#endif
#endif
#endif // QT_NO_DOCKWIDGET
    , widgetAnimator(this)
    , pluggingWidget(0)
#ifndef QT_NO_RUBBERBAND
    , gapIndicator(new QRubberBand(QRubberBand::Rectangle, mainwindow))
#endif //QT_NO_RUBBERBAND
#ifdef Q_WS_MAC
    , activateUnifiedToolbarAfterFullScreen(false)
    , blockVisiblityCheck(false)
#endif
{
    if (parentLayout)
        setParent(parentLayout);

#ifndef QT_NO_DOCKWIDGET
#ifndef QT_NO_TABBAR
    sep = mainwindow->style()->pixelMetric(QStyle::PM_DockWidgetSeparatorExtent, 0, mainwindow);
#endif

#ifndef QT_NO_TABWIDGET
    for (int i = 0; i < QInternal::DockCount; ++i)
        tabPositions[i] = QTabWidget::South;
#endif
#endif // QT_NO_DOCKWIDGET

#ifndef QT_NO_RUBBERBAND
    // For accessibility to identify this special widget.
    gapIndicator->setObjectName(QLatin1String("qt_rubberband"));
    gapIndicator->hide();
#endif
    pluggingWidget = 0;

    setObjectName(mainwindow->objectName() + QLatin1String("_layout"));
}

~QMainWindowLayout()

QMainWindowLayout::~QMainWindowLayout

(

)

Definition at line 1735 of file qmainwindowlayout.cpp.

{
    layoutState.deleteAllLayoutItems();
    layoutState.deleteCentralWidgetItem();

#ifdef Q_WS_MAC
    cleanUpMacToolbarItems();
#endif

    delete statusbar;
}

Functions

addDockWidget()

void QMainWindowLayout::addDockWidget	(	Qt::DockWidgetArea	area,
		QDockWidget *	dockwidget,
		Qt::Orientation	orientation
	)

Definition at line 1085 of file qmainwindowlayout.cpp.

{
    addChildWidget(dockwidget);

    // If we are currently moving a separator, then we need to abort the move, since each
    // time we move the mouse layoutState is replaced by savedState modified by the move.
    if (!movingSeparator.isEmpty())
        endSeparatorMove(movingSeparatorPos);

    layoutState.dockAreaLayout.addDockWidget(toDockPos(area), dockwidget, orientation);
    emit dockwidget->dockLocationChanged(area);
    invalidate();
}

addItem()

void QMainWindowLayout::addItem ( QLayoutItem *  item )

virtual

Implemented in subclasses to add an item.

How it is added is specific to each subclass.

This function is not usually called in application code. To add a widget to a layout, use the addWidget() function; to add a child layout, use the addLayout() function provided by the relevant QLayout subclass.

Note: The ownership of item is transferred to the layout, and it's the layout's responsibility to delete it.

See also

addWidget(), QBoxLayout::addLayout(), QGridLayout::addLayout()

Implements QLayout.

Definition at line 1484 of file qmainwindowlayout.cpp.

{ qWarning("QMainWindowLayout::addItem: Please use the public QMainWindow API instead"); }

addToolBar()

void QMainWindowLayout::addToolBar	(	Qt::ToolBarArea	area,
		QToolBar *	toolbar,
		bool	needAddChildWidget = true
	)

Adds toolbar to area, continuing the current line.

Definition at line 863 of file qmainwindowlayout.cpp.

{
    validateToolBarArea(area);
#ifdef Q_WS_MAC
    if ((area == Qt::TopToolBarArea)
            && layoutState.mainWindow->unifiedTitleAndToolBarOnMac()) {
        insertIntoMacToolbar(0, toolbar);
    } else
#endif
    {
        //let's add the toolbar to the layout
        addChildWidget(toolbar);
        QLayoutItem * item = layoutState.toolBarAreaLayout.addToolBar(toDockPos(area), toolbar);
        if (savedState.isValid() && item) {
            // copy the toolbar also in the saved state
            savedState.toolBarAreaLayout.insertItem(toDockPos(area), item);
        }
        invalidate();

        //this ensures that the toolbar has the right window flags (not floating any more)
        toolbar->d_func()->updateWindowFlags(false /*floating*/);
    }
}

addToolBarBreak()

void QMainWindowLayout::addToolBarBreak

(

Qt::ToolBarArea

area

)

Definition at line 804 of file qmainwindowlayout.cpp.

{
    validateToolBarArea(area);

    layoutState.toolBarAreaLayout.addToolBarBreak(toDockPos(area));
    if (savedState.isValid())
        savedState.toolBarAreaLayout.addToolBarBreak(toDockPos(area));

    invalidate();
}

animationFinished()

void QMainWindowLayout::animationFinished

(

QWidget *

widget

)

Definition at line 1612 of file qmainwindowlayout.cpp.

Referenced by QWidgetAnimator::abort(), and QWidgetAnimator::animate().

{
    //this function is called from within the Widget Animator whenever an animation is finished
    //on a certain widget
#ifndef QT_NO_TOOLBAR
    if (QToolBar *tb = qobject_cast<QToolBar*>(widget)) {
        QToolBarLayout *tbl = qobject_cast<QToolBarLayout*>(tb->layout());
        if (tbl->animating) {
            tbl->animating = false;
            if (tbl->expanded)
                tbl->layoutActions(tb->size());
            tb->update();
        }
    }
#endif

    if (widget == pluggingWidget) {

#ifndef QT_NO_DOCKWIDGET
        if (QDockWidget *dw = qobject_cast<QDockWidget*>(widget))
            dw->d_func()->plug(currentGapRect);
#endif
#ifndef QT_NO_TOOLBAR
        if (QToolBar *tb = qobject_cast<QToolBar*>(widget))
            tb->d_func()->plug(currentGapRect);
#endif

        savedState.clear();
        currentGapPos.clear();
        pluggingWidget = 0;
        //applying the state will make sure that the currentGap is updated correctly
        //and all the geometries (especially the one from the central widget) is correct
        layoutState.apply(false);

#ifndef QT_NO_DOCKWIDGET
#ifndef QT_NO_TABBAR
        if (qobject_cast<QDockWidget*>(widget) != 0) {
            // info() might return null if the widget is destroyed while
            // animating but before the animationFinished signal is received.
            if (QDockAreaLayoutInfo *info = layoutState.dockAreaLayout.info(widget))
                info->setCurrentTab(widget);
        }
#endif
#endif
    }

    if (!widgetAnimator.animating()) {
        //all animations are finished
#ifndef QT_NO_DOCKWIDGET
        parentWidget()->update(layoutState.dockAreaLayout.separatorRegion());
#ifndef QT_NO_TABBAR
        foreach (QTabBar *tab_bar, usedTabBars)
            tab_bar->show();
#endif // QT_NO_TABBAR
#endif // QT_NO_DOCKWIDGET
    }

    updateGapIndicator();
}

applyState()

void QMainWindowLayout::applyState	(	QMainWindowLayoutState &	newState,
		bool	animate = true
	)

Definition at line 1912 of file qmainwindowlayout.cpp.

Referenced by hover(), and restoreState().

{
#ifndef QT_NO_DOCKWIDGET
#ifndef QT_NO_TABBAR
    QSet<QTabBar*> used = newState.dockAreaLayout.usedTabBars();
    QSet<QTabBar*> retired = usedTabBars - used;
    usedTabBars = used;
    foreach (QTabBar *tab_bar, retired) {
        tab_bar->hide();
        while (tab_bar->count() > 0)
            tab_bar->removeTab(0);
        unusedTabBars.append(tab_bar);
    }

    if (sep == 1) {
        QSet<QWidget*> usedSeps = newState.dockAreaLayout.usedSeparatorWidgets();
        QSet<QWidget*> retiredSeps = usedSeparatorWidgets - usedSeps;
        usedSeparatorWidgets = usedSeps;
        foreach (QWidget *sepWidget, retiredSeps) {
            unusedSeparatorWidgets.append(sepWidget);
        }
    }


#endif // QT_NO_TABBAR
#endif // QT_NO_DOCKWIDGET
    newState.apply(dockOptions & QMainWindow::AnimatedDocks && animate);
}

centralWidget()

QWidget * QMainWindowLayout::centralWidget

(

)

const

Definition at line 1775 of file qmainwindowlayout.cpp.

{
    return layoutState.centralWidget();
}

cleanUpMacToolbarItems()

void QMainWindowLayout::cleanUpMacToolbarItems

(

)

Definition at line 538 of file qmainwindowlayout_mac.mm.

Referenced by ~QMainWindowLayout().

{
#ifdef QT_MAC_USE_COCOA
    QMacCocoaAutoReleasePool pool;
#endif
    for (int i = 0; i < toolbarItemsCopy.size(); ++i) {
#ifdef QT_MAC_USE_COCOA
        NSToolbarItem *item = static_cast<NSToolbarItem *>(toolbarItemsCopy.at(i));
        [item setView:0];
#endif
        CFRelease(toolbarItemsCopy.at(i));
    }
    toolbarItemsCopy.clear();
    unifiedToolbarHash.clear();

#ifdef QT_MAC_USE_COCOA
    OSWindowRef window = qt_mac_window_for(layoutState.mainWindow);
    NSToolbar *macToolbar = [window toolbar];
    if (macToolbar) {
      [[macToolbar delegate] release];
      [macToolbar setDelegate:nil];
    }
#endif
}

corner()

Qt::DockWidgetArea QMainWindowLayout::corner

(

Qt::Corner

corner

)

const

Definition at line 1080 of file qmainwindowlayout.cpp.

{
    return layoutState.dockAreaLayout.corners[corner];
}

count()

int QMainWindowLayout::count ( ) const

virtual

Must be implemented in subclasses to return the number of items in the layout.

See also

itemAt()

Implements QLayout.

Definition at line 1400 of file qmainwindowlayout.cpp.

{
    qWarning("QMainWindowLayout::count: ?");
    return 0; //#################################################
}

createQToolBarInHIToolbarItem()

HIToolbarItemRef QMainWindowLayout::createQToolBarInHIToolbarItem ( QToolBar *  toolbar, QMainWindowLayout *  layout  )

staticprivate

Definition at line 195 of file qmainwindowlayout_mac.mm.

{
    QMainWindowLayout::qtMacHIToolbarRegisterQToolBarInHIToolborItemClass();

    EventRef event;
    HIToolbarItemRef result = 0;

    CFStringRef identifier = kQToolBarHIToolbarIdentifier;
    UInt32 options = kHIToolbarItemAllowDuplicates;

    CreateEvent(0, kEventClassHIObject, kEventHIObjectInitialize,
                GetCurrentEventTime(), 0, &event);
    SetEventParameter(event, kEventParamToolbarItemIdentifier, typeCFStringRef,
                      sizeof(CFStringRef), &identifier);
    SetEventParameter(event, kEventParamAttributes, typeUInt32, sizeof(UInt32), &options);
    SetEventParameter(event, kEventParamQToolBar, typeVoidPtr, sizeof(void *), &toolbar);
    SetEventParameter(event, kEventParamQMainWindowLayout, typeVoidPtr, sizeof(void *), &layout);

    HIObjectCreate(kQToolBarHIToolbarItemClassID, event,
                   static_cast<HIObjectRef *>(&result));

    ReleaseEvent(event);
    return result;

}

CreateToolbarItemForIdentifier()

HIToolbarItemRef QMainWindowLayout::CreateToolbarItemForIdentifier ( CFStringRef  identifier, CFTypeRef  data  )

staticprivate

Definition at line 222 of file qmainwindowlayout_mac.mm.

{
    HIToolbarItemRef item = 0;
    if (CFStringCompare(kQToolBarHIToolbarIdentifier, identifier,
                        kCFCompareBackwards) == kCFCompareEqualTo) {
        if (data && CFGetTypeID(data) == CFArrayGetTypeID()) {
            CFArrayRef array = static_cast<CFArrayRef>(data);
            QToolBar *toolbar = static_cast<QToolBar *>(const_cast<void *>(CFArrayGetValueAtIndex(array, 0)));
            QMainWindowLayout *layout = static_cast<QMainWindowLayout *>(const_cast<void *>(CFArrayGetValueAtIndex(array, 1)));
            item = createQToolBarInHIToolbarItem(toolbar, layout);
        }
    }
    return item;
}

dockWidgetArea()

Qt::DockWidgetArea QMainWindowLayout::dockWidgetArea

(

QDockWidget *

dockwidget

)

const

Definition at line 1255 of file qmainwindowlayout.cpp.

Referenced by QDockWidgetPrivate::setWindowState().

{
    QList<int> pathToWidget = layoutState.dockAreaLayout.indexOf(widget);
    if (pathToWidget.isEmpty())
        return Qt::NoDockWidgetArea;
    return toDockWidgetArea(pathToWidget.first());
}

documentMode()

bool QMainWindowLayout::documentMode

(

)

const

Definition at line 1120 of file qmainwindowlayout.cpp.

{
    return _documentMode;
}

endSeparatorMove()

bool QMainWindowLayout::endSeparatorMove

(

const QPoint &

pos

)

Definition at line 1372 of file qmainwindowlayout.cpp.

{
    if (movingSeparator.isEmpty())
        return false;
    movingSeparator.clear();
    savedState.clear();
    return true;
}

fixSizeInUnifiedToolbar()

void QMainWindowLayout::fixSizeInUnifiedToolbar

(

QToolBar *

tb

)

const

Definition at line 563 of file qmainwindowlayout_mac.mm.

Referenced by QToolBar::event(), and QToolBarLayout::setGeometry().

{
#ifdef QT_MAC_USE_COCOA
    QHash<void *, QToolBar *>::const_iterator it = unifiedToolbarHash.constBegin();
    NSToolbarItem *item = nil;
    while (it != unifiedToolbarHash.constEnd()) {
        if (tb == it.value()) {
            item = static_cast<NSToolbarItem *>(it.key());
            break;
        }
        ++it;
    }
    if (item) {
        QMacCocoaAutoReleasePool pool;
        QWidgetItem layoutItem(tb);
        QSize size = layoutItem.maximumSize();
        NSSize nssize = NSMakeSize(size.width(), size.height());
        [item setMaxSize:nssize];
        size = layoutItem.minimumSize();
        nssize.width = size.width();
        nssize.height = size.height();
        [item setMinSize:nssize];
    }
#else
    Q_UNUSED(tb);
#endif
}

getSeparatorWidget()

QWidget * QMainWindowLayout::getSeparatorWidget

(

)

Definition at line 1320 of file qmainwindowlayout.cpp.

Referenced by QDockAreaLayoutInfo::updateSeparatorWidgets(), and QDockAreaLayout::updateSeparatorWidgets().

{
    QWidget *result = 0;
    if (!unusedSeparatorWidgets.isEmpty()) {
        result = unusedSeparatorWidgets.takeLast();
    } else {
        result = new QWidget(parentWidget());
        result->setAttribute(Qt::WA_MouseNoMask, true);
        result->setAutoFillBackground(false);
        result->setObjectName(QLatin1String("qt_qmainwindow_extended_splitter"));
    }
    usedSeparatorWidgets.insert(result);
    return result;
}

getStyleOptionInfo()

void QMainWindowLayout::getStyleOptionInfo	(	QStyleOptionToolBar *	option,
		QToolBar *	toolBar
	)		const

Definition at line 941 of file qmainwindowlayout.cpp.

Referenced by QToolBar::initStyleOption().

{
    option->toolBarArea = toolBarArea(toolBar);
    layoutState.toolBarAreaLayout.getStyleOptionInfo(option, toolBar);
}

getTabBar()

QTabBar * QMainWindowLayout::getTabBar

(

)

Definition at line 1302 of file qmainwindowlayout.cpp.

Referenced by QDockAreaLayoutInfo::updateTabBar().

{
    QTabBar *result = 0;
    if (!unusedTabBars.isEmpty()) {
        result = unusedTabBars.takeLast();
    } else {
        result = new QMainWindowTabBar(parentWidget());
        result->setDrawBase(true);
        result->setElideMode(Qt::ElideRight);
        result->setDocumentMode(_documentMode);
        connect(result, SIGNAL(currentChanged(int)), this, SLOT(tabChanged()));
    }

    usedTabBars.insert(result);
    return result;
}

hover()

QList< int > QMainWindowLayout::hover	(	QLayoutItem *	widgetItem,
		const QPoint &	mousePos
	)

Definition at line 1840 of file qmainwindowlayout.cpp.

Referenced by QToolBarPrivate::mouseMoveEvent(), QDockWidgetPrivate::moveEvent(), and QDockWidgetPrivate::nonClientAreaMouseEvent().

{
    if (!parentWidget()->isVisible() || parentWidget()->isMinimized()
        || pluggingWidget != 0 || widgetItem == 0)
        return QList<int>();

    QWidget *widget = widgetItem->widget();
    QPoint pos = parentWidget()->mapFromGlobal(mousePos);

    if (!savedState.isValid())
        savedState = layoutState;

    QList<int> path = savedState.gapIndex(widget, pos);

    if (!path.isEmpty()) {
        bool allowed = false;

#ifndef QT_NO_DOCKWIDGET
        if (QDockWidget *dw = qobject_cast<QDockWidget*>(widget))
            allowed = dw->isAreaAllowed(toDockWidgetArea(path.at(1)));
#endif
#ifndef QT_NO_TOOLBAR
        if (QToolBar *tb = qobject_cast<QToolBar*>(widget))
            allowed = tb->isAreaAllowed(toToolBarArea(path.at(1)));
#endif

        if (!allowed)
            path.clear();
    }

    if (path == currentGapPos)
        return currentGapPos; // the gap is already there

    currentGapPos = path;
    if (path.isEmpty()) {
        fixToolBarOrientation(widgetItem, 2); // 2 = top dock, ie. horizontal
        restore(true);
        return QList<int>();
    }

    fixToolBarOrientation(widgetItem, currentGapPos.at(1));

    QMainWindowLayoutState newState = savedState;

    if (!newState.insertGap(path, widgetItem)) {
        restore(true); // not enough space
        return QList<int>();
    }

    QSize min = newState.minimumSize();
    QSize size = newState.rect.size();

    if (min.width() > size.width() || min.height() > size.height()) {
        restore(true);
        return QList<int>();
    }

    newState.fitLayout();

    currentGapRect = newState.gapRect(currentGapPos);

#ifndef QT_NO_DOCKWIDGET
    parentWidget()->update(layoutState.dockAreaLayout.separatorRegion());
#endif
    layoutState = newState;
    applyState(layoutState);

    updateGapIndicator();

    return path;
}

insertIntoMacToolbar()

void QMainWindowLayout::insertIntoMacToolbar	(	QToolBar *	before,
		QToolBar *	after
	)

Definition at line 389 of file qmainwindowlayout_mac.mm.

{
    // This layering could go on to one more level, but I decided to stop here.
    // The HIToolbar and NSToolbar APIs are fairly similar as you will see.
    if (toolbar == 0)
        return;

#if defined(QT_MAC_USE_COCOA)
    // toolbar will now become native (if not already) since we need
    // an nsview for it inside the corresponding NSToolbarItem.
    // Setting isInUnifiedToolbar will (among other things) stop alien
    // siblings from becoming native when this happends since the toolbar
    // will not overlap with other children of the QMainWindow. NB: Switching
    // unified toolbar off after this stage is not supported, as this means
    // that either the menubar must be alien again, or the sibling must
    // be backed by an nsview to protect from overlapping issues:
    toolbar->d_func()->isInUnifiedToolbar = true;
#endif

    QToolBarLayout *toolbarLayout = static_cast<QToolBarLayout *>(toolbar->layout());
    toolbarSaveState.insert(toolbar, ToolBarSaveState(toolbar->isMovable(), toolbar->maximumSize()));

    if (toolbarLayout->hasExpandFlag() == false)
        toolbar->setMaximumSize(toolbar->sizeHint());

    toolbar->setMovable(false);
    toolbarLayout->setUsePopupMenu(true);
    // Make the toolbar a child of the mainwindow to avoid creating a window.
    toolbar->setParent(layoutState.mainWindow);

    toolbar->winId();  // Now create the OSViewRef.
    layoutState.mainWindow->createWinId();

    OSWindowRef window = qt_mac_window_for(layoutState.mainWindow);
    int beforeIndex = qtoolbarsInUnifiedToolbarList.indexOf(before);
    if (beforeIndex == -1)
        beforeIndex = qtoolbarsInUnifiedToolbarList.size();

    int toolbarIndex = qtoolbarsInUnifiedToolbarList.indexOf(toolbar);

#ifndef QT_MAC_USE_COCOA
    HIToolbarRef macToolbar = NULL;
    if ((GetWindowToolbar(window, &macToolbar) == noErr) && !macToolbar) {
        HIToolbarCreate(kQMainWindowMacToolbarID,
                        kHIToolbarItemAllowDuplicates, &macToolbar);
        InstallEventHandler(HIObjectGetEventTarget(static_cast<HIToolbarRef>(macToolbar)),
                            QMainWindowLayout::qtmacToolbarDelegate, GetEventTypeCount(kToolbarEvents),
                            kToolbarEvents, this, 0);
        HIToolbarSetDisplaySize(macToolbar, kHIToolbarDisplaySizeNormal);
        HIToolbarSetDisplayMode(macToolbar, kHIToolbarDisplayModeIconOnly);
        macWindowToolbarSet(window, macToolbar);
        if (layoutState.mainWindow->isVisible())
            macWindowToolbarShow(layoutState.mainWindow, true);
        CFRelease(macToolbar);
    }
#else
    QMacCocoaAutoReleasePool pool;
    NSToolbar *macToolbar = [window toolbar];
    if (macToolbar == nil) {
        macToolbar = [[NSToolbar alloc] initWithIdentifier:qt_mac_QStringToNSString(QUuid::createUuid().toString())];
        [macToolbar setDisplayMode:NSToolbarDisplayModeIconOnly];
        [macToolbar setSizeMode:NSToolbarSizeModeRegular];
        [macToolbar setDelegate:[[QT_MANGLE_NAMESPACE(QCocoaToolBarDelegate) alloc] initWithMainWindowLayout:this]];
        [window setToolbar:macToolbar];
        [macToolbar release];
    }
#endif
    if (toolbarIndex != -1) {
        qtoolbarsInUnifiedToolbarList.removeAt(toolbarIndex);
#ifndef QT_MAC_USE_COCOA
        HIToolbarRemoveItemAtIndex(macToolbar, toolbarIndex);
#else
        [macToolbar removeItemAtIndex:toolbarIndex];
#endif
    }
    qtoolbarsInUnifiedToolbarList.insert(beforeIndex, toolbar);

    // Adding to the unified toolbar surface for the raster engine.
    if (layoutState.mainWindow->windowSurface()) {
        QPoint offset(0, 0);
        for (int i = 0; i < beforeIndex; ++i) {
            offset.setX(offset.x() + qtoolbarsInUnifiedToolbarList.at(i)->size().width());
        }
#ifdef QT_MAC_USE_COCOA
        unifiedSurface->insertToolbar(toolbar, offset);
#endif // QT_MAC_USE_COCOA
    }

#ifndef QT_MAC_USE_COCOA
    QCFType<HIToolbarItemRef> outItem;
    const QObject *stupidArray[] = { toolbar, this };
    QCFType<CFArrayRef> array = CFArrayCreate(0, reinterpret_cast<const void **>(&stupidArray),
                                              2, 0);
    HIToolbarCreateItemWithIdentifier(macToolbar, kQToolBarHIToolbarIdentifier,
                                      array, &outItem);
    HIToolbarInsertItemAtIndex(macToolbar, outItem, beforeIndex);
#else
    NSString *toolbarID = kQToolBarNSToolbarIdentifier;
    toolbarID = [toolbarID stringByAppendingFormat:@"%p", toolbar];
    cocoaItemIDToToolbarHash.insert(qt_mac_NSStringToQString(toolbarID), toolbar);
    [macToolbar insertItemWithItemIdentifier:toolbarID atIndex:beforeIndex];
#endif
}

insertToolBar()

void QMainWindowLayout::insertToolBar	(	QToolBar *	before,
		QToolBar *	toolbar
	)

Adds toolbar before before.

Definition at line 892 of file qmainwindowlayout.cpp.

{
#ifdef Q_WS_MAC
    if (usesHIToolBar(before)) {
        insertIntoMacToolbar(before, toolbar);
    } else
#endif // Q_WS_MAC
    {
        addChildWidget(toolbar);
        QLayoutItem * item = layoutState.toolBarAreaLayout.insertToolBar(before, toolbar);
        if (savedState.isValid() && item) {
            // copy the toolbar also in the saved state
            savedState.toolBarAreaLayout.insertItem(before, item);
        }
        if (!currentGapPos.isEmpty() && currentGapPos.first() == 0) {
            currentGapPos = layoutState.toolBarAreaLayout.currentGapIndex();
            if (!currentGapPos.isEmpty()) {
                currentGapPos.prepend(0);
                currentGapRect = layoutState.itemRect(currentGapPos);
            }
        }
        invalidate();
    }
}

insertToolBarBreak()

void QMainWindowLayout::insertToolBarBreak

(

QToolBar *

before

)

Definition at line 815 of file qmainwindowlayout.cpp.

{
    layoutState.toolBarAreaLayout.insertToolBarBreak(before);
    if (savedState.isValid())
        savedState.toolBarAreaLayout.insertToolBarBreak(before);
    invalidate();
}

invalidate()

void QMainWindowLayout::invalidate ( )

virtual

Reimplemented Function

Reimplemented from QLayout.

Definition at line 1517 of file qmainwindowlayout.cpp.

Referenced by setCentralWidget(), setDockOptions(), and setStatusBar().

{
    QLayout::invalidate();
    minSize = szHint = QSize();
}

itemAt()

QLayoutItem * QMainWindowLayout::itemAt ( int  index ) const

virtual

Must be implemented in subclasses to return the layout item at index.

If there is no such item, the function must return 0. Items are numbered consecutively from 0. If an item is deleted, other items will be renumbered.

This function can be used to iterate over a layout. The following code will draw a rectangle for each layout item in the layout structure of the widget.

static void paintLayout(QPainter *painter, QLayoutItem *item)
{
    QLayout *layout = item->layout();
    if (layout) {
        for (int i = 0; i < layout->count(); ++i)
            paintLayout(painter, layout->itemAt(i));
    }
    painter->drawRect(item->geometry());
}

void MyWidget::paintEvent(QPaintEvent *)
{
    QPainter painter(this);
    if (layout())
        paintLayout(&painter, layout());
}

See also

count(), takeAt()

Implements QLayout.

Definition at line 1406 of file qmainwindowlayout.cpp.

{
    int x = 0;

    if (QLayoutItem *ret = layoutState.itemAt(index, &x))
        return ret;

    if (statusbar && x++ == index)
        return statusbar;

    return 0;
}

keepSize()

void QMainWindowLayout::keepSize

(

QDockWidget *

w

)

Definition at line 1263 of file qmainwindowlayout.cpp.

{
    layoutState.dockAreaLayout.keepSize(w);
}

minimumSize()

QSize QMainWindowLayout::minimumSize ( ) const

virtual

Returns the minimum size of this layout.

This is the smallest size that the layout can have while still respecting the specifications.

The returned value doesn't include the space required by QWidget::setContentsMargins() or menuBar().

The default implementation allows unlimited resizing.

Reimplemented from QLayout.

Definition at line 1498 of file qmainwindowlayout.cpp.

{
    if (!minSize.isValid()) {
        minSize = layoutState.minimumSize();
        const QSize sbMin = statusbar ? statusbar->minimumSize() : QSize(0, 0);
        minSize = QSize(qMax(sbMin.width(), minSize.width()),
                        sbMin.height() + minSize.height());
#ifdef Q_WS_MAC
        const QSize storedSize = minSize;
        int minWidth = 0;
        foreach (QToolBar *toolbar, qtoolbarsInUnifiedToolbarList) {
            minWidth += toolbar->sizeHint().width() + 20;
        }
        minSize = QSize(qMax(minWidth, storedSize.width()), storedSize.height());
#endif
    }
    return minSize;
}

moveToolBar()

void QMainWindowLayout::moveToolBar	(	QToolBar *	toolbar,
		int	pos
	)

Definition at line 831 of file qmainwindowlayout.cpp.

Referenced by QToolBarPrivate::mouseMoveEvent().

{
    layoutState.toolBarAreaLayout.moveToolBar(toolbar, pos);
    if (savedState.isValid())
        savedState.toolBarAreaLayout.moveToolBar(toolbar, pos);
    invalidate();
}

paintDropIndicator()

void QMainWindowLayout::paintDropIndicator	(	QPainter *	p,
		QWidget *	widget,
		const QRegion &	clip
	)

plug()

bool QMainWindowLayout::plug

(

QLayoutItem *

widgetItem

)

Definition at line 1575 of file qmainwindowlayout.cpp.

Referenced by QDockWidgetPrivate::endDrag(), and QToolBarPrivate::endDrag().

{
    if (!parentWidget()->isVisible() || parentWidget()->isMinimized() || currentGapPos.isEmpty())
        return false;

    fixToolBarOrientation(widgetItem, currentGapPos.at(1));

    QWidget *widget = widgetItem->widget();

    QList<int> previousPath = layoutState.indexOf(widget);

    const QLayoutItem *it = layoutState.plug(currentGapPos);
    if (!it)
        return false;
    Q_ASSERT(it == widgetItem);
    if (!previousPath.isEmpty())
        layoutState.remove(previousPath);

    pluggingWidget = widget;
    QRect globalRect = currentGapRect;
    globalRect.moveTopLeft(parentWidget()->mapToGlobal(globalRect.topLeft()));
#ifndef QT_NO_DOCKWIDGET
    if (qobject_cast<QDockWidget*>(widget) != 0) {
        QDockWidgetLayout *layout = qobject_cast<QDockWidgetLayout*>(widget->layout());
        if (layout->nativeWindowDeco()) {
            globalRect.adjust(0, layout->titleHeight(), 0, 0);
        } else {
            int fw = widget->style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, widget);
            globalRect.adjust(-fw, -fw, fw, fw);
        }
    }
#endif
    widgetAnimator.animate(widget, globalRect, dockOptions & QMainWindow::AnimatedDocks);

    return true;
}

qtMacHIToolbarRegisterQToolBarInHIToolborItemClass()

void QMainWindowLayout::qtMacHIToolbarRegisterQToolBarInHIToolborItemClass ( )

staticprivate

Definition at line 178 of file qmainwindowlayout_mac.mm.

Referenced by createQToolBarInHIToolbarItem().

{
    static bool registered = false;

    if (!registered) {
        HIObjectRegisterSubclass( kQToolBarHIToolbarItemClassID,
                                 kHIToolbarItemClassID, 0, QMainWindowLayout::qtoolbarInHIToolbarHandler,
                                 GetEventTypeCount(qtoolbarEvents), qtoolbarEvents, 0, 0 );
        registered = true;
    }
}

qtmacToolbarDelegate()

OSStatus QMainWindowLayout::qtmacToolbarDelegate ( EventHandlerCallRef  , EventRef  event, void *  data  )

staticprivate

Definition at line 246 of file qmainwindowlayout_mac.mm.

Referenced by insertIntoMacToolbar().

{
    QMainWindowLayout *mainWindowLayout = static_cast<QMainWindowLayout *>(data);
    OSStatus            result = eventNotHandledErr;
    CFMutableArrayRef   array;
    CFStringRef         identifier;
    switch (GetEventKind(event)) {
        case kEventToolbarGetDefaultIdentifiers:
        case kEventToolbarGetAllowedIdentifiers:
            GetEventParameter(event, kEventParamMutableArray, typeCFMutableArrayRef, 0,
                              sizeof(CFMutableArrayRef), 0, &array);
            GetToolbarAllowedItems(array);
            result = noErr;
            break;
        case kEventToolbarCreateItemWithIdentifier: {
            HIToolbarItemRef item;
            CFTypeRef data = 0;
            OSStatus err = GetEventParameter(event, kEventParamToolbarItemIdentifier, typeCFStringRef,
                                             0, sizeof(CFStringRef), 0, &identifier);
            err = GetEventParameter(event, kEventParamToolbarItemConfigData, typeCFTypeRef,
                                    0, sizeof(CFTypeRef), 0, &data);
            item = CreateToolbarItemForIdentifier(identifier, data);
            if (item) {
                result = SetEventParameter(event, kEventParamToolbarItem, typeHIToolbarItemRef,
                                           sizeof(HIToolbarItemRef), &item );
            }
            break;
        }
        case kEventToolbarItemAdded: {
            // Double check that our "view" of the toolbar is similar.
            HIToolbarItemRef item;
            CFIndex index;
            if (GetEventParameter(event, kEventParamToolbarItem, typeHIToolbarItemRef,
                                  0, sizeof(HIToolbarItemRef), 0, &item) == noErr
                && GetEventParameter(event, kEventParamIndex, typeCFIndex, 0,
                                     sizeof(CFIndex), 0, &index) == noErr) {
                CFRetain(item); // We will watch this until it's removed from the list (or bust).
                mainWindowLayout->toolbarItemsCopy.insert(index, item);
                QToolBar *toolbar = mainWindowLayout->unifiedToolbarHash.value(item);
                if (toolbar) {
                    int toolbarIndex = mainWindowLayout->qtoolbarsInUnifiedToolbarList.indexOf(toolbar);
                    if (index != toolbarIndex) {
                        // Dang, we must be out of sync, rebuild it from the "toolbarItemsCopy"
                        mainWindowLayout->qtoolbarsInUnifiedToolbarList.clear();
                        for (int i = 0; i < mainWindowLayout->toolbarItemsCopy.size(); ++i) {
                            // This will either append the correct toolbar or an
                            // null toolbar. This is fine because this list
                            // is really only kept to make sure that things are but in the right order.
                            mainWindowLayout->qtoolbarsInUnifiedToolbarList.append(
                                                                                   mainWindowLayout->unifiedToolbarHash.value(mainWindowLayout->
                                                                                                                              toolbarItemsCopy.at(i)));
                        }
                    }
                }
            }
            break;
        }
        case kEventToolbarItemRemoved: {
            HIToolbarItemRef item;
            if (GetEventParameter(event, kEventParamToolbarItem, typeHIToolbarItemRef,
                                  0, sizeof(HIToolbarItemRef), 0, &item) == noErr) {
                mainWindowLayout->unifiedToolbarHash.remove(item);
                for (int i = 0; i < mainWindowLayout->toolbarItemsCopy.size(); ++i) {
                    if (mainWindowLayout->toolbarItemsCopy.at(i) == item) {
                        // I know about it, so release it.
                        mainWindowLayout->toolbarItemsCopy.removeAt(i);
                        mainWindowLayout->qtoolbarsInUnifiedToolbarList.removeAt(i);
                        CFRelease(item);
                        break;
                    }
                }
            }
            break;
        }
    }
    return result;
}

qtoolbarInHIToolbarHandler()

OSStatus QMainWindowLayout::qtoolbarInHIToolbarHandler ( EventHandlerCallRef  inCallRef, EventRef  event, void *  data  )

staticprivate

Definition at line 113 of file qmainwindowlayout_mac.mm.

Referenced by qtMacHIToolbarRegisterQToolBarInHIToolborItemClass().

{
    OSStatus result = eventNotHandledErr;
    QToolBarInHIToolbarInfo *object = static_cast<QToolBarInHIToolbarInfo *>(data);

    switch (GetEventClass(event)) {
        case kEventClassHIObject:
            switch (GetEventKind(event)) {
                case kEventHIObjectConstruct:
                {
                    HIObjectRef toolbarItem;
                    GetEventParameter(event, kEventParamHIObjectInstance, typeHIObjectRef,
                                      0, sizeof( HIObjectRef ), 0, &toolbarItem);

                    QToolBarInHIToolbarInfo *item = new QToolBarInHIToolbarInfo(toolbarItem);
                    SetEventParameter(event, kEventParamHIObjectInstance, typeVoidPtr,
                                      sizeof(void *), &item);
                    result = noErr;
                }
                    break;
                case kEventHIObjectInitialize:
                    result = CallNextEventHandler(inCallRef, event);
                    if (result == noErr) {
                        QToolBar *toolbar = 0;
                        QMainWindowLayout *layout = 0;
                        GetEventParameter(event, kEventParamQToolBar, typeVoidPtr,
                                          0, sizeof(void *), 0, &toolbar);
                        GetEventParameter(event, kEventParamQMainWindowLayout, typeVoidPtr,
                                          0, sizeof(void *), 0, &layout);
                        object->mainWindowLayout = layout;
                        object->mainWindowLayout->unifiedToolbarHash.insert(object->toolbarItem, toolbar);
                        HIToolbarItemChangeAttributes(object->toolbarItem,
                                                      kHIToolbarItemLabelDisabled, 0);
                    }
                    break;

                case kEventHIObjectDestruct:
                    delete object;
                    result = noErr;
                    break;
            }
            break;

        case kEventClassToolbarItem:
            switch (GetEventKind(event))
        {
            case kEventToolbarItemCreateCustomView:
            {
                QToolBar *toolbar
                = object->mainWindowLayout->unifiedToolbarHash.value(object->toolbarItem);
                if (toolbar) {
                    HIViewRef hiview = HIViewRef(toolbar->winId());
                    SetEventParameter(event, kEventParamControlRef, typeControlRef,
                                      sizeof(HIViewRef), &hiview);
                    result = noErr;
                }
            }
                break;
        }
            break;
    }
    return result;
}

raise()

void QMainWindowLayout::raise

(

QDockWidget *

widget

)

Definition at line 1381 of file qmainwindowlayout.cpp.

{
    QDockAreaLayoutInfo *info = layoutState.dockAreaLayout.info(widget);
    if (info == 0)
        return;
#ifndef QT_NO_TABBAR
    if (!info->tabbed)
        return;
    info->setCurrentTab(widget);
#endif
}

removeFromMacToolbar()

void QMainWindowLayout::removeFromMacToolbar

(

QToolBar *

toolbar

)

Definition at line 506 of file qmainwindowlayout_mac.mm.

{
    QHash<void *, QToolBar *>::iterator it = unifiedToolbarHash.begin();
    while (it != unifiedToolbarHash.end()) {
        if (it.value() == toolbar) {
            // Rescue our HIView and set it on the mainWindow again.
            bool saveVisible = !toolbar->isHidden();
            toolbar->setParent(0);
            toolbar->setParent(parentWidget());
            toolbar->setVisible(saveVisible);
            ToolBarSaveState saveState = toolbarSaveState.value(toolbar);
            static_cast<QToolBarLayout *>(toolbar->layout())->setUsePopupMenu(false);
            toolbar->setMovable(saveState.movable);
            toolbar->setMaximumSize(saveState.maximumSize);
            toolbarSaveState.remove(toolbar);
#ifndef QT_MAC_USE_COCOA
            HIToolbarItemRef item = static_cast<HIToolbarItemRef>(it.key());
            HIToolbarRemoveItemAtIndex(HIToolbarItemGetToolbar(item),
                                       toolbarItemsCopy.indexOf(item));
#else
            NSToolbarItem *item = static_cast<NSToolbarItem *>(it.key());
            [[qt_mac_window_for(layoutState.mainWindow->window()) toolbar]
                removeItemAtIndex:toolbarItemsCopy.indexOf(item)];
             unifiedToolbarHash.remove(item);
             qtoolbarsInUnifiedToolbarList.removeAll(toolbar);
#endif
            break;
        }
        ++it;
    }
}

removeToolBar()

void QMainWindowLayout::removeToolBar

(

QToolBar *

toolbar

)

Definition at line 841 of file qmainwindowlayout.cpp.

{
    if (toolbar) {
        QObject::disconnect(parentWidget(), SIGNAL(iconSizeChanged(QSize)),
                   toolbar, SLOT(_q_updateIconSize(QSize)));
        QObject::disconnect(parentWidget(), SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)),
                   toolbar, SLOT(_q_updateToolButtonStyle(Qt::ToolButtonStyle)));

#ifdef Q_WS_MAC
        if (usesHIToolBar(toolbar)) {
            removeFromMacToolbar(toolbar);
        } else
#endif // Q_WS_MAC
        {
            removeWidget(toolbar);
        }
    }
}

removeToolBarBreak()

void QMainWindowLayout::removeToolBarBreak

(

QToolBar *

before

)

Definition at line 823 of file qmainwindowlayout.cpp.

{
    layoutState.toolBarAreaLayout.removeToolBarBreak(before);
    if (savedState.isValid())
        savedState.toolBarAreaLayout.removeToolBarBreak(before);
    invalidate();
}

restore()

void QMainWindowLayout::restore

(

bool

keepSavedState = false

)

Definition at line 1672 of file qmainwindowlayout.cpp.

Referenced by QDockWidgetPrivate::endDrag(), QToolBarPrivate::endDrag(), hover(), and QDockWidgetPrivate::startDrag().

{
    if (!savedState.isValid())
        return;

    layoutState = savedState;
    applyState(layoutState);
    if (!keepSavedState)
        savedState.clear();
    currentGapPos.clear();
    pluggingWidget = 0;
    updateGapIndicator();
}

restoreDockWidget()

bool QMainWindowLayout::restoreDockWidget

(

QDockWidget *

dockwidget

)

Definition at line 1109 of file qmainwindowlayout.cpp.

{
    addChildWidget(dockwidget);
    if (!layoutState.dockAreaLayout.restoreDockWidget(dockwidget))
        return false;
    emit dockwidget->dockLocationChanged(dockWidgetArea(dockwidget));
    invalidate();
    return true;
}

restoreState()

bool QMainWindowLayout::restoreState

(

QDataStream &

stream

)

Definition at line 1946 of file qmainwindowlayout.cpp.

{
    savedState = layoutState;
    layoutState.clear();
    layoutState.rect = savedState.rect;

    if (!layoutState.restoreState(stream, savedState)) {
        layoutState.deleteAllLayoutItems();
        layoutState = savedState;
        if (parentWidget()->isVisible())
            applyState(layoutState, false); // hides tabBars allocated by newState
        return false;
    }

    if (parentWidget()->isVisible()) {
        layoutState.fitLayout();
        applyState(layoutState, false);
    }

    savedState.deleteAllLayoutItems();
    savedState.clear();

#ifndef QT_NO_DOCKWIDGET
    if (parentWidget()->isVisible()) {
#ifndef QT_NO_TABBAR
        foreach (QTabBar *tab_bar, usedTabBars)
            tab_bar->show();

#endif
    }
#endif // QT_NO_DOCKWIDGET

    return true;
}

revert()

void QMainWindowLayout::revert

(

QLayoutItem *

widgetItem

)

Definition at line 1559 of file qmainwindowlayout.cpp.

Referenced by QDockWidgetPrivate::endDrag(), and QToolBarPrivate::endDrag().

{
    if (!savedState.isValid())
        return;

    QWidget *widget = widgetItem->widget();
    layoutState = savedState;
    currentGapPos = layoutState.indexOf(widget);
    fixToolBarOrientation(widgetItem, currentGapPos.at(1));
    layoutState.unplug(currentGapPos);
    layoutState.fitLayout();
    currentGapRect = layoutState.itemRect(currentGapPos);

    plug(widgetItem);
}

saveState()

void QMainWindowLayout::saveState

(

QDataStream &

stream

)

const

Definition at line 1941 of file qmainwindowlayout.cpp.

{
    layoutState.saveState(stream);
}

separatorMove()

bool QMainWindowLayout::separatorMove

(

const QPoint &

pos

)

Definition at line 1363 of file qmainwindowlayout.cpp.

{
    if (movingSeparator.isEmpty())
        return false;
    movingSeparatorPos = pos;
    separatorMoveTimer.start(0, this);
    return true;
}

setCentralWidget()

void QMainWindowLayout::setCentralWidget

(

QWidget *

cw

)

Definition at line 1780 of file qmainwindowlayout.cpp.

{
    if (widget != 0)
        addChildWidget(widget);
    layoutState.setCentralWidget(widget);
    if (savedState.isValid()) {
#ifndef QT_NO_DOCKWIDGET
        savedState.dockAreaLayout.centralWidgetItem = layoutState.dockAreaLayout.centralWidgetItem;
        savedState.dockAreaLayout.fallbackToSizeHints = true;
#else
        savedState.centralWidgetItem = layoutState.centralWidgetItem;
#endif
    }
    invalidate();
}

setCorner()

void QMainWindowLayout::setCorner	(	Qt::Corner	corner,
		Qt::DockWidgetArea	area
	)

Definition at line 1070 of file qmainwindowlayout.cpp.

{
    if (layoutState.dockAreaLayout.corners[corner] == area)
        return;
    layoutState.dockAreaLayout.corners[corner] = area;
    if (savedState.isValid())
        savedState.dockAreaLayout.corners[corner] = area;
    invalidate();
}

setDockOptions()

void QMainWindowLayout::setDockOptions

(

QMainWindow::DockOptions

opts

)

Definition at line 1747 of file qmainwindowlayout.cpp.

{
    if (opts == dockOptions)
        return;

    dockOptions = opts;

#ifndef QT_NO_DOCKWIDGET
    setVerticalTabsEnabled(opts & QMainWindow::VerticalTabs);
#endif

    invalidate();
}

setDocumentMode()

void QMainWindowLayout::setDocumentMode

(

bool

enabled

)

Definition at line 1125 of file qmainwindowlayout.cpp.

{
    if (_documentMode == enabled)
        return;

    _documentMode = enabled;

    // Update the document mode for all tab bars
    foreach (QTabBar *bar, usedTabBars)
        bar->setDocumentMode(_documentMode);
    foreach (QTabBar *bar, unusedTabBars)
        bar->setDocumentMode(_documentMode);
}

setGeometry()

void QMainWindowLayout::setGeometry ( const QRect &  r )

virtual

Reimplemented Function

Reimplemented from QLayout.

Definition at line 1460 of file qmainwindowlayout.cpp.

{
    if (savedState.isValid())
        return;

    QRect r = _r;

    QLayout::setGeometry(r);

    if (statusbar) {
        QRect sbr(QPoint(0, 0),
                  QSize(r.width(), statusbar->heightForWidth(r.width()))
                  .expandedTo(statusbar->minimumSize()));
        sbr.moveBottom(r.bottom());
        QRect vr = QStyle::visualRect(parentWidget()->layoutDirection(), _r, sbr);
        statusbar->setGeometry(vr);
        r.setBottom(sbr.top() - 1);
    }

    layoutState.rect = r;
    layoutState.fitLayout();
    applyState(layoutState, false);
}

setStatusBar()

void QMainWindowLayout::setStatusBar

(

QStatusBar *

sb

)

Definition at line 1765 of file qmainwindowlayout.cpp.

{
    if (sb)
        addChildWidget(sb);
    delete statusbar;
    statusbar = sb ? new QWidgetItemV2(sb) : 0;
    invalidate();
}

setTabPosition()

void QMainWindowLayout::setTabPosition	(	Qt::DockWidgetAreas	areas,
		QTabWidget::TabPosition	tabPosition
	)

Definition at line 1175 of file qmainwindowlayout.cpp.

{
    const Qt::DockWidgetArea dockWidgetAreas[] = {
        Qt::TopDockWidgetArea,
        Qt::LeftDockWidgetArea,
        Qt::BottomDockWidgetArea,
        Qt::RightDockWidgetArea
    };
    const QInternal::DockPosition dockPositions[] = {
        QInternal::TopDock,
        QInternal::LeftDock,
        QInternal::BottomDock,
        QInternal::RightDock
    };

    for (int i = 0; i < QInternal::DockCount; ++i)
        if (areas & dockWidgetAreas[i])
            tabPositions[dockPositions[i]] = tabPosition;

    updateTabBarShapes();
}

setTabShape()

void QMainWindowLayout::setTabShape

(

QTabWidget::TabShape

tabShape

)

Definition at line 1160 of file qmainwindowlayout.cpp.

{
    if (_tabShape == tabShape)
        return;

    _tabShape = tabShape;

    updateTabBarShapes();
}

setVerticalTabsEnabled()

void QMainWindowLayout::setVerticalTabsEnabled

(

bool

enabled

)

Definition at line 1140 of file qmainwindowlayout.cpp.

Referenced by setDockOptions().

{
#ifdef QT_NO_TABBAR
    Q_UNUSED(enabled);
#else
    if (verticalTabsEnabled == enabled)
        return;

    verticalTabsEnabled = enabled;

    updateTabBarShapes();
#endif // QT_NO_TABBAR
}

sizeHint()

QSize QMainWindowLayout::sizeHint ( ) const

virtual

Implemented in subclasses to return the preferred size of this item.

Implements QLayoutItem.

Definition at line 1487 of file qmainwindowlayout.cpp.

{
    if (!szHint.isValid()) {
        szHint = layoutState.sizeHint();
        const QSize sbHint = statusbar ? statusbar->sizeHint() : QSize(0, 0);
        szHint = QSize(qMax(sbHint.width(), szHint.width()),
                        sbHint.height() + szHint.height());
    }
    return szHint;
}

splitDockWidget()

void QMainWindowLayout::splitDockWidget	(	QDockWidget *	after,
		QDockWidget *	dockwidget,
		Qt::Orientation	orientation
	)

Definition at line 1245 of file qmainwindowlayout.cpp.

{
    addChildWidget(dockwidget);
    layoutState.dockAreaLayout.splitDockWidget(after, dockwidget, orientation);
    emit dockwidget->dockLocationChanged(dockWidgetArea(after));
    invalidate();
}

startSeparatorMove()

bool QMainWindowLayout::startSeparatorMove

(

const QPoint &

pos

)

Definition at line 1350 of file qmainwindowlayout.cpp.

{
    movingSeparator = layoutState.dockAreaLayout.findSeparator(pos);

    if (movingSeparator.isEmpty())
        return false;

    savedState = layoutState;
    movingSeparatorPos = movingSeparatorOrigin = pos;

    return true;
}

statusBar()

QStatusBar * QMainWindowLayout::statusBar

(

)

const

Definition at line 1762 of file qmainwindowlayout.cpp.

{ return statusbar ? qobject_cast<QStatusBar *>(statusbar->widget()) : 0; }

syncUnifiedToolbarVisibility()

void QMainWindowLayout::syncUnifiedToolbarVisibility

(

)

Definition at line 591 of file qmainwindowlayout_mac.mm.

Referenced by QToolBar::event().

{
    if (blockVisiblityCheck)
        return;

    Q_ASSERT(layoutState.mainWindow->unifiedTitleAndToolBarOnMac());
    bool show = false;
    const int ToolBarCount = qtoolbarsInUnifiedToolbarList.count();
    for (int i = 0; i < ToolBarCount; ++i) {
        if (qtoolbarsInUnifiedToolbarList.at(i)->isVisible()) {
            show = true;
            break;
        }
    }
    macWindowToolbarShow(layoutState.mainWindow, show);
}

tabChanged

void QMainWindowLayout::tabChanged ( )

privateslot

Definition at line 1335 of file qmainwindowlayout.cpp.

{
    QTabBar *tb = qobject_cast<QTabBar*>(sender());
    if (tb == 0)
        return;
    QDockAreaLayoutInfo *info = layoutState.dockAreaLayout.info(tb);
    if (info == 0)
        return;
    info->apply(false);

    if (QWidget *w = centralWidget())
        w->raise();
}

tabifyDockWidget()

void QMainWindowLayout::tabifyDockWidget	(	QDockWidget *	first,
		QDockWidget *	second
	)

Definition at line 1101 of file qmainwindowlayout.cpp.

{
    addChildWidget(second);
    layoutState.dockAreaLayout.tabifyDockWidget(first, second);
    emit second->dockLocationChanged(dockWidgetArea(first));
    invalidate();
}

tabPosition()

QTabWidget::TabPosition QMainWindowLayout::tabPosition

(

Qt::DockWidgetArea

area

)

const

Definition at line 1170 of file qmainwindowlayout.cpp.

{
    return tabPositions[toDockPos(area)];
}

tabShape()

QTabWidget::TabShape QMainWindowLayout::tabShape

(

)

const

Definition at line 1155 of file qmainwindowlayout.cpp.

{
    return _tabShape;
}

takeAt()

QLayoutItem * QMainWindowLayout::takeAt ( int  index )

virtual

Must be implemented in subclasses to remove the layout item at index from the layout, and return the item.

If there is no such item, the function must do nothing and return 0. Items are numbered consecutively from 0. If an item is removed, other items will be renumbered.

The following code fragment shows a safe way to remove all items from a layout:

QLayoutItem *child;
while ((child = layout->takeAt(0)) != 0) {
    ...
    delete child;
}

See also

itemAt(), count()

Implements QLayout.

Definition at line 1419 of file qmainwindowlayout.cpp.

{
    int x = 0;

    if (QLayoutItem *ret = layoutState.takeAt(index, &x)) {
        // the widget might in fact have been destroyed by now
        if (QWidget *w = ret->widget()) {
            widgetAnimator.abort(w);
            if (w == pluggingWidget)
                pluggingWidget = 0;
        }

        if (savedState.isValid() ) {
            //we need to remove the item also from the saved state to prevent crash
            savedState.remove(ret);
            //Also, the item may be contained several times as a gap item.
            layoutState.remove(ret);
        }

#ifndef QT_NO_TOOLBAR
        if (!currentGapPos.isEmpty() && currentGapPos.first() == 0) {
            currentGapPos = layoutState.toolBarAreaLayout.currentGapIndex();
            if (!currentGapPos.isEmpty()) {
                currentGapPos.prepend(0);
                currentGapRect = layoutState.itemRect(currentGapPos);
            }
        }
#endif

        return ret;
    }

    if (statusbar && x++ == index) {
        QLayoutItem *ret = statusbar;
        statusbar = 0;
        return ret;
    }

    return 0;
}

timerEvent()

void QMainWindowLayout::timerEvent ( QTimerEvent *  event )

virtual

This event handler can be reimplemented in a subclass to receive timer events for the object.

QTimer provides a higher-level interface to the timer functionality, and also more general information about timers. The timer event is passed in the event parameter.

See also

startTimer(), killTimer(), event()

Reimplemented from QObject.

Definition at line 1997 of file qmainwindowlayout.cpp.

{
#ifndef QT_NO_DOCKWIDGET
    if (e->timerId() == separatorMoveTimer.timerId()) {
        //let's move the separators
        separatorMoveTimer.stop();
        if (movingSeparator.isEmpty())
            return;
        if (movingSeparatorOrigin == movingSeparatorPos)
            return;

        //when moving the separator, we need to update the previous position
        parentWidget()->update(layoutState.dockAreaLayout.separatorRegion());

        layoutState = savedState;
        layoutState.dockAreaLayout.separatorMove(movingSeparator, movingSeparatorOrigin,
                                                    movingSeparatorPos);
        movingSeparatorPos = movingSeparatorOrigin;
    }
#endif
    QLayout::timerEvent(e);
}

toggleToolBarsVisible()

void QMainWindowLayout::toggleToolBarsVisible

(

)

Definition at line 947 of file qmainwindowlayout.cpp.

{
    bool updateNonUnifiedParts = true;
#ifdef Q_WS_MAC
    if (layoutState.mainWindow->unifiedTitleAndToolBarOnMac()) {
        // If we hit this case, someone has pressed the "toolbar button" which will
        // toggle the unified toolbar visibility, because that's what the user wants.
        // We might be in a situation where someone has hidden all the toolbars
        // beforehand (maybe in construction), but now they've hit this button and
        // and are expecting the items to show. What do we do?
        // 1) Check the visibility of all the toolbars, if one is visible, do nothing, this
        //    preserves what people would expect (these toolbars were visible when I clicked last time).
        // 2) If NONE are visible, then show them all. Again, this preserves the user expectation
        //    of, "I want to see the toolbars." The user may get more toolbars than expected, but this
        //    is better seeing nothing.
        // Don't worry about any of this if we are going invisible. This does mean we may get
        // into issues when switching into and out of fullscreen mode, but this is probably minor.
        // If we ever need to do hiding, that would have to be taken care of after the unified toolbar
        // has finished hiding.
        // People can of course handle the QEvent::ToolBarChange event themselves and do
        // WHATEVER they want if they don't like what we are doing (though the unified toolbar
        // will fire regardless).

        // Check if we REALLY need to update the geometry below. If we only have items in the
        // unified toolbar, all the docks will be empty, so there's very little point
        // in doing the geometry as Apple will do it (we also avoid flicker in Cocoa as well).
        // FWIW, layoutState.toolBarAreaLayout.visible and the state of the unified toolbar
        // visibility can get out of sync. I really don't think it's a big issue. It is kept
        // to a minimum because we only change the visibility if we absolutely must.
        // update the "non unified parts."
        updateNonUnifiedParts = !layoutState.toolBarAreaLayout.isEmpty();

        // We get this function before the unified toolbar does its thing.
        // So, the value will be opposite of what we expect.
        bool goingVisible = !macWindowToolbarIsVisible(qt_mac_window_for(layoutState.mainWindow));
        if (goingVisible) {
            const int ToolBarCount = qtoolbarsInUnifiedToolbarList.size();
            bool needAllVisible = true;
            for (int i = 0; i < ToolBarCount; ++i) {
                if (!qtoolbarsInUnifiedToolbarList.at(i)->isHidden()) {
                    needAllVisible = false;
                    break;
                }
            }
            if (needAllVisible) {
                QBoolBlocker blocker(blockVisiblityCheck);  // Disable the visibilty check because
                                                            // the toggle has already happened.
                for (int i = 0; i < ToolBarCount; ++i)
                    qtoolbarsInUnifiedToolbarList.at(i)->setVisible(true);
            }
        }
        if (!updateNonUnifiedParts)
            layoutState.toolBarAreaLayout.visible = goingVisible;
    }
#endif
    if (updateNonUnifiedParts) {
        layoutState.toolBarAreaLayout.visible = !layoutState.toolBarAreaLayout.visible;
        if (!layoutState.mainWindow->isMaximized()) {
            QPoint topLeft = parentWidget()->geometry().topLeft();
            QRect r = parentWidget()->geometry();
            r = layoutState.toolBarAreaLayout.rectHint(r);
            r.moveTo(topLeft);
            parentWidget()->setGeometry(r);
        } else {
            update();
        }
    }
}

toolBarArea()

Qt::ToolBarArea QMainWindowLayout::toolBarArea

(

QToolBar *

toolbar

)

const

Definition at line 917 of file qmainwindowlayout.cpp.

Referenced by QRasterWindowSurface::setGeometry(), and usesHIToolBar().

{
    QInternal::DockPosition pos = layoutState.toolBarAreaLayout.findToolBar(toolbar);
    switch (pos) {
        case QInternal::LeftDock:   return Qt::LeftToolBarArea;
        case QInternal::RightDock:  return Qt::RightToolBarArea;
        case QInternal::TopDock:    return Qt::TopToolBarArea;
        case QInternal::BottomDock: return Qt::BottomToolBarArea;
        default: break;
    }
#ifdef Q_WS_MAC
    if (pos == QInternal::DockCount) {
        if (qtoolbarsInUnifiedToolbarList.contains(toolbar))
            return Qt::TopToolBarArea;
    }
#endif
    return Qt::NoToolBarArea;
}

toolBarBreak()

bool QMainWindowLayout::toolBarBreak

(

QToolBar *

toolBar

)

const

Definition at line 936 of file qmainwindowlayout.cpp.

{
    return layoutState.toolBarAreaLayout.toolBarBreak(toolBar);
}

unplug()

QLayoutItem * QMainWindowLayout::unplug

(

QWidget *

widget

)

Definition at line 1796 of file qmainwindowlayout.cpp.

Referenced by QDockWidgetPrivate::startDrag(), and QToolBarPrivate::startDrag().

{
    QList<int> path = layoutState.indexOf(widget);
    if (path.isEmpty())
        return 0;

    QLayoutItem *item = layoutState.item(path);
    if (widget->isWindow())
        return item;

    QRect r = layoutState.itemRect(path);
    savedState = layoutState;

#ifndef QT_NO_DOCKWIDGET
    if (QDockWidget *dw = qobject_cast<QDockWidget*>(widget)) {
        dw->d_func()->unplug(r);
    }
#endif
#ifndef QT_NO_TOOLBAR
    if (QToolBar *tb = qobject_cast<QToolBar*>(widget)) {
        tb->d_func()->unplug(r);
    }
#endif


    layoutState.unplug(path ,&savedState);
    savedState.fitLayout();
    currentGapPos = path;
    currentGapRect = r;
    updateGapIndicator();

    fixToolBarOrientation(item, currentGapPos.at(1));

    return item;
}

updateGapIndicator()

void QMainWindowLayout::updateGapIndicator

(

)

Definition at line 1832 of file qmainwindowlayout.cpp.

Referenced by hover(), and unplug().

{
#ifndef QT_NO_RUBBERBAND
    gapIndicator->setVisible(!widgetAnimator.animating() && !currentGapPos.isEmpty());
    gapIndicator->setGeometry(currentGapRect);
#endif
}

updateHIToolBarStatus()

void QMainWindowLayout::updateHIToolBarStatus

(

)

Definition at line 329 of file qmainwindowlayout_mac.mm.

Referenced by QWidgetPrivate::setModal_sys().

{
    bool useMacToolbar = layoutState.mainWindow->unifiedTitleAndToolBarOnMac();
#ifndef QT_MAC_USE_COCOA
    if (useMacToolbar) {
        ChangeWindowAttributes(qt_mac_window_for(layoutState.mainWindow),
                               kWindowUnifiedTitleAndToolbarAttribute, 0);
    } else {
        ChangeWindowAttributes(qt_mac_window_for(layoutState.mainWindow),
                               0, kWindowUnifiedTitleAndToolbarAttribute);
    }
#endif

    layoutState.mainWindow->setUpdatesEnabled(false);  // reduces a little bit of flicker, not all though
#if defined(QT_MAC_USE_COCOA)
    QMacCocoaAutoReleasePool pool;
    NSView *cView = [qt_mac_window_for(layoutState.mainWindow) contentView];
    if (useMacToolbar) {
        [cView setPostsFrameChangedNotifications:YES];
        [[NSNotificationCenter defaultCenter] addObserver: [QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate]
                                                 selector: @selector(syncContentViewFrame:)
                                                     name: NSViewFrameDidChangeNotification
                                                   object: cView];
    }
#endif
    if (!useMacToolbar) {
        macWindowToolbarShow(layoutState.mainWindow, false);
        // Move everything out of the HIToolbar into the main toolbar.
        while (!qtoolbarsInUnifiedToolbarList.isEmpty()) {
            // Should shrink the list by one every time.
            QToolBar *toolbar = qtoolbarsInUnifiedToolbarList.first();
#if defined(QT_MAC_USE_COCOA)
            unifiedSurface->removeToolbar(toolbar);
#endif
            layoutState.mainWindow->addToolBar(Qt::TopToolBarArea, toolbar);
        }
        macWindowToolbarSet(qt_mac_window_for(layoutState.mainWindow), 0);
    } else {
        QList<QToolBar *> toolbars = layoutState.mainWindow->findChildren<QToolBar *>();
        for (int i = 0; i < toolbars.size(); ++i) {
            QToolBar *toolbar = toolbars.at(i);
            if (toolBarArea(toolbar) == Qt::TopToolBarArea) {
                // Do this here, because we are in an in-between state.
                removeWidget(toolbar);
                layoutState.mainWindow->addToolBar(Qt::TopToolBarArea, toolbar);
            }
        }
        syncUnifiedToolbarVisibility();
    }
#if defined(QT_MAC_USE_COCOA)
    if (!useMacToolbar) {
        [cView setPostsFrameChangedNotifications:NO];
        [[NSNotificationCenter defaultCenter] removeObserver: [QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate]
                                                        name: NSViewFrameDidChangeNotification
                                                      object: cView];
    }
#endif
    layoutState.mainWindow->setUpdatesEnabled(true);
}

updateTabBarShapes()

void QMainWindowLayout::updateTabBarShapes ( )

private

Definition at line 1213 of file qmainwindowlayout.cpp.

{
#ifndef QT_NO_TABWIDGET
    const QTabWidget::TabPosition vertical[] = {
        QTabWidget::West,
        QTabWidget::East,
        QTabWidget::North,
        QTabWidget::South
    };
#else
    const QTabBar::Shape vertical[] = {
        QTabBar::RoundedWest,
        QTabBar::RoundedEast,
        QTabBar::RoundedNorth,
        QTabBar::RoundedSouth
    };
#endif

    QDockAreaLayout &layout = layoutState.dockAreaLayout;

    for (int i = 0; i < QInternal::DockCount; ++i) {
#ifndef QT_NO_TABWIDGET
        QTabWidget::TabPosition pos = verticalTabsEnabled ? vertical[i] : tabPositions[i];
        QTabBar::Shape shape = tabBarShapeFrom(_tabShape, pos);
#else
        QTabBar::Shape shape = verticalTabsEnabled ? vertical[i] : QTabBar::RoundedSouth;
#endif
        layout.docks[i].setTabBarShape(shape);
    }
}

usesHIToolBar()

bool QMainWindowLayout::usesHIToolBar

(

QToolBar *

toolbar

)

const

Definition at line 1985 of file qmainwindowlayout.cpp.

{
#ifndef Q_WS_MAC
    Q_UNUSED(toolbar);
    return false;
#else
    return qtoolbarsInUnifiedToolbarList.contains(toolbar)
           || ((toolBarArea(toolbar) == Qt::TopToolBarArea)
                && layoutState.mainWindow->unifiedTitleAndToolBarOnMac());
#endif
}

Properties

_documentMode

bool QMainWindowLayout::_documentMode

Definition at line 224 of file qmainwindowlayout_p.h.

_tabShape

QTabWidget::TabShape QMainWindowLayout::_tabShape

Definition at line 240 of file qmainwindowlayout_p.h.

activateUnifiedToolbarAfterFullScreen

bool QMainWindowLayout::activateUnifiedToolbarAfterFullScreen

Definition at line 341 of file qmainwindowlayout_p.h.

Referenced by QWidget::showFullScreen(), QWidget::showMaximized(), and QWidget::showNormal().

blockVisiblityCheck

bool QMainWindowLayout::blockVisiblityCheck

Definition at line 343 of file qmainwindowlayout_p.h.

cocoaItemIDToToolbarHash

QHash<QString, QToolBar *> QMainWindowLayout::cocoaItemIDToToolbarHash

Definition at line 336 of file qmainwindowlayout_p.h.

currentGapPos

QList<int> QMainWindowLayout::currentGapPos

Definition at line 286 of file qmainwindowlayout_p.h.

Referenced by hover(), unplug(), and updateGapIndicator().

currentGapRect

QRect QMainWindowLayout::currentGapRect

Definition at line 287 of file qmainwindowlayout_p.h.

Referenced by hover(), unplug(), and updateGapIndicator().

dockOptions

QMainWindow::DockOptions QMainWindowLayout::dockOptions

Definition at line 169 of file qmainwindowlayout_p.h.

Referenced by applyState(), and setDockOptions().

gapIndicator

QRubberBand* QMainWindowLayout::gapIndicator

Definition at line 290 of file qmainwindowlayout_p.h.

Referenced by QMainWindowLayout(), and updateGapIndicator().

layoutState

QMainWindowLayoutState QMainWindowLayout::layoutState

Definition at line 164 of file qmainwindowlayout_p.h.

Referenced by centralWidget(), hover(), restoreState(), saveState(), setCentralWidget(), QToolBarLayout::setExpanded(), timerEvent(), unplug(), usesHIToolBar(), ~QMainWindowLayout(), and QToolBar::~QToolBar().

minSize

QSize QMainWindowLayout::minSize

mutable

Definition at line 280 of file qmainwindowlayout_p.h.

movingSeparator

QList<int> QMainWindowLayout::movingSeparator

Definition at line 251 of file qmainwindowlayout_p.h.

Referenced by timerEvent().

movingSeparatorOrigin

QPoint QMainWindowLayout::movingSeparatorOrigin

Definition at line 252 of file qmainwindowlayout_p.h.

Referenced by timerEvent().

movingSeparatorPos

QPoint QMainWindowLayout::movingSeparatorPos

Definition at line 252 of file qmainwindowlayout_p.h.

Referenced by timerEvent().

pluggingWidget

QWidget* QMainWindowLayout::pluggingWidget

Definition at line 288 of file qmainwindowlayout_p.h.

Referenced by hover(), QDockWidgetPrivate::initDrag(), QToolBarPrivate::initDrag(), QDockWidgetPrivate::isAnimating(), QToolBarPrivate::mouseMoveEvent(), and QMainWindowLayout().

qtoolbarsInUnifiedToolbarList

QList<QToolBar *> QMainWindowLayout::qtoolbarsInUnifiedToolbarList

Definition at line 332 of file qmainwindowlayout_p.h.

Referenced by qtmacToolbarDelegate(), QRasterWindowSurface::setGeometry(), and usesHIToolBar().

savedState

QMainWindowLayoutState QMainWindowLayout::savedState

Definition at line 164 of file qmainwindowlayout_p.h.

Referenced by hover(), restoreState(), setCentralWidget(), timerEvent(), and unplug().

sep

int QMainWindowLayout::sep

Definition at line 236 of file qmainwindowlayout_p.h.

Referenced by applyState(), and QMainWindowLayout().

separatorMoveTimer

QBasicTimer QMainWindowLayout::separatorMoveTimer

Definition at line 253 of file qmainwindowlayout_p.h.

Referenced by timerEvent().

statusbar

QLayoutItem* QMainWindowLayout::statusbar

Definition at line 177 of file qmainwindowlayout_p.h.

Referenced by setStatusBar(), statusBar(), and ~QMainWindowLayout().

szHint

QSize QMainWindowLayout::szHint

mutable

Definition at line 279 of file qmainwindowlayout_p.h.

tabPositions

QTabWidget::TabPosition QMainWindowLayout::tabPositions[4]

Definition at line 239 of file qmainwindowlayout_p.h.

Referenced by QMainWindowLayout().

toolbarItemsCopy

QList<void *> QMainWindowLayout::toolbarItemsCopy

Definition at line 333 of file qmainwindowlayout_p.h.

Referenced by qtmacToolbarDelegate().

toolbarSaveState

QHash<QToolBar *, ToolBarSaveState> QMainWindowLayout::toolbarSaveState

Definition at line 335 of file qmainwindowlayout_p.h.

unifiedToolbarHash

QHash<void *, QToolBar *> QMainWindowLayout::unifiedToolbarHash

Definition at line 334 of file qmainwindowlayout_p.h.

Referenced by qtmacToolbarDelegate().

unusedSeparatorWidgets

QList<QWidget*> QMainWindowLayout::unusedSeparatorWidgets

Definition at line 235 of file qmainwindowlayout_p.h.

Referenced by applyState().

unusedTabBars

QList<QTabBar*> QMainWindowLayout::unusedTabBars

Definition at line 230 of file qmainwindowlayout_p.h.

Referenced by applyState().

usedSeparatorWidgets

QSet<QWidget*> QMainWindowLayout::usedSeparatorWidgets

Definition at line 234 of file qmainwindowlayout_p.h.

Referenced by applyState().

usedTabBars

QSet<QTabBar*> QMainWindowLayout::usedTabBars

Definition at line 229 of file qmainwindowlayout_p.h.

Referenced by applyState(), and restoreState().

verticalTabsEnabled

bool QMainWindowLayout::verticalTabsEnabled

Definition at line 231 of file qmainwindowlayout_p.h.

widgetAnimator

QWidgetAnimator QMainWindowLayout::widgetAnimator

Definition at line 285 of file qmainwindowlayout_p.h.

Referenced by QMainWindowLayoutState::apply(), QDockAreaLayoutInfo::apply(), QToolBarAreaLayout::apply(), QDockAreaLayout::apply(), and updateGapIndicator().

---

The documentation for this class was generated from the following files:

• /src/gui/widgets/qmainwindowlayout_p.h
• /src/gui/widgets/qmainwindowlayout.cpp
• /src/gui/widgets/qmainwindowlayout_mac.mm