#include <qdockarealayout_p.h>

Public Types
enum	{ SequenceMarker = 0xfc, TabMarker = 0xfa, WidgetMarker = 0xfb }

enum	TabMode { NoTabs, AllowTabs, ForceTabs }

Public Functions
void	apply (bool animate)

int	changeSize (int index, int size, bool below)

void	clear ()

quintptr	currentTabId () const

void	deleteAllLayoutItems ()

bool	expansive (Qt::Orientation o) const

QList< int >	findSeparator (const QPoint &pos) const

void	fitItems ()

QList< int >	gapIndex (const QPoint &pos, bool nestingEnabled, TabMode tabMode) const

bool	hasFixedSize () const

QList< int >	indexOf (QWidget *widget) const

QList< int >	indexOfPlaceHolder (const QString &objectName) const

QDockAreaLayoutInfo *	info (const QList< int > &path)

QDockAreaLayoutInfo *	info (QWidget *widget)

bool	insertGap (const QList< int > &path, QLayoutItem *dockWidgetItem)

bool	isEmpty () const

QDockAreaLayoutItem &	item (const QList< int > &path)

QLayoutItem *	itemAt (int *x, int index) const

QRect	itemRect (int index) const

QRect	itemRect (const QList< int > &path) const

QMainWindowLayout *	mainWindowLayout () const

QSize	maximumSize () const

QSize	minimumSize () const

int	next (int idx) const

void	paintSeparators (QPainter p, QWidget widget, const QRegion &clip, const QPoint &mouse) const

QLayoutItem *	plug (const QList< int > &path)

int	prev (int idx) const

	QDockAreaLayoutInfo ()

	QDockAreaLayoutInfo (const int _sep, QInternal::DockPosition _dockPos, Qt::Orientation _o, int tbhape, QMainWindow window)

void	remove (const QList< int > &path)

bool	restoreState (QDataStream &stream, QList< QDockWidget *> &widgets, bool testing)

void	saveState (QDataStream &stream) const

int	separatorMove (int index, int delta)

QRect	separatorRect (int index) const

QRect	separatorRect (const QList< int > &path) const

QRegion	separatorRegion () const

void	setCurrentTab (QWidget *widget)

void	setCurrentTabId (quintptr id)

void	setTabBarShape (int shape)

QSize	size () const

QSize	sizeHint () const

void	split (int index, Qt::Orientation orientation, QLayoutItem *dockWidgetItem)

void	tab (int index, QLayoutItem *dockWidgetItem)

QSize	tabBarMinimumSize () const

QSize	tabBarSizeHint () const

QRect	tabContentRect () const

QLayoutItem *	takeAt (int *x, int index)

void	unnest (int index)

QLayoutItem *	unplug (const QList< int > &path)

void	updateSeparatorWidgets () const

bool	updateTabBar () const

QSet< QWidget * >	usedSeparatorWidgets () const

QSet< QTabBar * >	usedTabBars () const

Public Variables
QInternal::DockPosition	dockPos

QList< QDockAreaLayoutItem >	item_list

QMainWindow *	mainWindow

Qt::Orientation	o

QRect	rect

const int *	sep

QVector< QWidget * >	separatorWidgets

QTabBar *	tabBar

int	tabBarShape

bool	tabbed

Detailed Description

Definition at line 127 of file qdockarealayout_p.h.

Enumerations

◆ anonymous enum

anonymous enum

Enumerator
SequenceMarker
TabMarker
WidgetMarker

Definition at line 153 of file qdockarealayout_p.h.

          { // sentinel values used to validate state data
         SequenceMarker = 0xfc,
         TabMarker = 0xfa,
         WidgetMarker = 0xfb
     };

◆ TabMode

enum QDockAreaLayoutInfo::TabMode

Enumerator
NoTabs
AllowTabs
ForceTabs

Definition at line 142 of file qdockarealayout_p.h.

142 { NoTabs, AllowTabs, ForceTabs };

QDockAreaLayoutInfo::AllowTabs

Definition: qdockarealayout_p.h:142

QDockAreaLayoutInfo::NoTabs

Definition: qdockarealayout_p.h:142

QDockAreaLayoutInfo::ForceTabs

Definition: qdockarealayout_p.h:142

Constructors and Destructors

◆ QDockAreaLayoutInfo() [1/2]

QDockAreaLayoutInfo::QDockAreaLayoutInfo ( )

Definition at line 228 of file qdockarealayout.cpp.

Referenced by restoreState(), split(), and tab().

     : sep(&zero), dockPos(QInternal::LeftDock), o(Qt::Horizontal), mainWindow(0)
 #ifndef QT_NO_TABBAR
     , tabbed(false), tabBar(0), tabBarShape(QTabBar::RoundedSouth)
 #endif
 {
 }

◆ QDockAreaLayoutInfo() [2/2]

QDockAreaLayoutInfo::QDockAreaLayoutInfo	(	const int *	_sep,
		QInternal::DockPosition	_dockPos,
		Qt::Orientation	_o,
		int	tbhape,
		QMainWindow *	window
	)

Definition at line 236 of file qdockarealayout.cpp.

     : sep(_sep), dockPos(_dockPos), o(_o), mainWindow(window)
 #ifndef QT_NO_TABBAR
     , tabbed(false), tabBar(0), tabBarShape(static_cast<QTabBar::Shape>(tbshape))
 #endif
 {
 #ifdef QT_NO_TABBAR
     Q_UNUSED(tbshape);
 #endif
 }

Functions

◆ apply()

void QDockAreaLayoutInfo::apply ( bool animate )

Definition at line 1497 of file qdockarealayout.cpp.

Referenced by apply(), QDockAreaLayout::separatorMove(), and QMainWindowLayout::tabChanged().

 {
     QWidgetAnimator &widgetAnimator = mainWindowLayout()->widgetAnimator;
 
 #ifndef QT_NO_TABBAR
     if (tabbed) {
         QRect tab_rect;
         QSize tbh = tabBarSizeHint();
 
         if (!tbh.isNull()) {
             switch (tabBarShape) {
                 case QTabBar::RoundedNorth:
                 case QTabBar::TriangularNorth:
                     tab_rect = QRect(rect.left(), rect.top(), rect.width(), tbh.height());
                     break;
                 case QTabBar::RoundedSouth:
                 case QTabBar::TriangularSouth:
                     tab_rect = QRect(rect.left(), rect.bottom() - tbh.height() + 1,
                                         rect.width(), tbh.height());
                     break;
                 case QTabBar::RoundedEast:
                 case QTabBar::TriangularEast:
                     tab_rect = QRect(rect.right() - tbh.width() + 1, rect.top(),
                                         tbh.width(), rect.height());
                     break;
                 case QTabBar::RoundedWest:
                 case QTabBar::TriangularWest:
                     tab_rect = QRect(rect.left(), rect.top(),
                                         tbh.width(), rect.height());
                     break;
                 default:
                     break;
             }
         }
 
         widgetAnimator.animate(tabBar, tab_rect, animate);
     }
 #endif // QT_NO_TABBAR
 
     for (int i = 0; i < item_list.size(); ++i) {
         QDockAreaLayoutItem &item = item_list[i];
 
         if (item.flags & QDockAreaLayoutItem::GapItem)
             continue;
 
         if (item.subinfo != 0) {
             item.subinfo->apply(animate);
             continue;
         }
 
         if (item.skip())
             continue;
 
         Q_ASSERT(item.widgetItem);
         QRect r = itemRect(i);
         QWidget *w = item.widgetItem->widget();
 
         QRect geo = w->geometry();
         widgetAnimator.animate(w, r, animate);
         if (!w->isHidden() && w->window()->isVisible()) {
             QDockWidget *dw = qobject_cast<QDockWidget*>(w);
             if (!r.isValid() && geo.right() >= 0 && geo.bottom() >= 0) {
                 dw->lower();
                 emit dw->visibilityChanged(false);
             } else if (r.isValid()
                         && (geo.right() < 0 || geo.bottom() < 0)) {
                 emit dw->visibilityChanged(true);
             }
         }
     }
 #ifndef QT_NO_TABBAR
     if (*sep == 1)
         updateSeparatorWidgets();
 #endif //QT_NO_TABBAR
 }

◆ changeSize()

int QDockAreaLayoutInfo::changeSize	(	int	index,
		int	size,
		bool	below
	)

◆ clear()

void QDockAreaLayoutInfo::clear ( )

Definition at line 254 of file qdockarealayout.cpp.

 {
     item_list.clear();
     rect = QRect();
 #ifndef QT_NO_TABBAR
     tabbed = false;
     tabBar = 0;
 #endif
 }

◆ currentTabId()

quintptr QDockAreaLayoutInfo::currentTabId ( ) const

Definition at line 1103 of file qdockarealayout.cpp.

Referenced by itemRect(), and saveState().

 {
     if (!tabbed || tabBar == 0)
         return 0;
 
     int index = tabBar->currentIndex();
     if (index == -1)
         return 0;
 
     return qvariant_cast<quintptr>(tabBar->tabData(index));
 }

◆ deleteAllLayoutItems()

void QDockAreaLayoutInfo::deleteAllLayoutItems ( )

Definition at line 1768 of file qdockarealayout.cpp.

Referenced by deleteAllLayoutItems().

 {
     for (int i = 0; i < item_list.count(); ++i) {
         QDockAreaLayoutItem &item= item_list[i];
         if (item.subinfo) {
             item.subinfo->deleteAllLayoutItems();
         } else {
             delete item.widgetItem;
             item.widgetItem = 0;
         }
     }
 }

◆ expansive()

bool QDockAreaLayoutInfo::expansive ( Qt::Orientation o ) const

Definition at line 467 of file qdockarealayout.cpp.

Referenced by QDockAreaLayoutItem::expansive().

 {
     for (int i = 0; i < item_list.size(); ++i) {
         if (item_list.at(i).expansive(o))
             return true;
     }
     return false;
 }

◆ findSeparator()

QList< int > QDockAreaLayoutInfo::findSeparator ( const QPoint & pos ) const

Definition at line 1390 of file qdockarealayout.cpp.

Referenced by findSeparator(), and QDockAreaLayout::findSeparator().

 {
 #ifndef QT_NO_TABBAR
     if (tabbed)
         return QList<int>();
 #endif
 
     int pos = pick(o, _pos);
 
     for (int i = 0; i < item_list.size(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         if (item.skip() || (item.flags & QDockAreaLayoutItem::GapItem))
             continue;
 
         if (item.pos + item.size > pos) {
             if (item.subinfo != 0) {
                 QList<int> result = item.subinfo->findSeparator(_pos);
                 if (!result.isEmpty()) {
                     result.prepend(i);
                     return result;
                 } else {
                     return QList<int>();
                 }
             }
         }
 
         int next = this->next(i);
         if (next == -1 || (item_list.at(next).flags & QDockAreaLayoutItem::GapItem))
             continue;
 
         QRect sepRect = separatorRect(i);
         if (!sepRect.isNull() && *sep == 1)
             sepRect.adjust(-2, -2, 2, 2);
         //we also make sure we don't find a separator that's not there
         if (sepRect.contains(_pos) && !item.hasFixedSize(o)) {
             return QList<int>() << i;
         }
 
     }
 
     return QList<int>();
 }

◆ fitItems()

void QDockAreaLayoutInfo::fitItems ( )

Definition at line 536 of file qdockarealayout.cpp.

Referenced by fitItems(), separatorMove(), and QDockAreaLayout::setGrid().

 {
 #ifndef QT_NO_TABBAR
     if (tabbed) {
         return;
     }
 #endif
 
     QVector<QLayoutStruct> layout_struct_list(item_list.size()*2);
     int j = 0;
 
     int size = pick(o, rect.size());
     int min_size = realMinSize(*this);
     int max_size = realMaxSize(*this);
     int last_index = -1;
 
     const QDockAreaLayoutItem *previous = 0;
     for (int i = 0; i < item_list.size(); ++i) {
         QDockAreaLayoutItem &item = item_list[i];
         if (item.skip())
             continue;
 
         bool gap = item.flags & QDockAreaLayoutItem::GapItem;
         if (previous && !gap) {
             if (!(previous->flags & QDockAreaLayoutItem::GapItem)) {
                 QLayoutStruct &ls = layout_struct_list[j++];
                 ls.init();
                 ls.minimumSize = ls.maximumSize = ls.sizeHint = previous->hasFixedSize(o) ? 0 : *sep;
                 ls.empty = false;
             }
         }
 
         if (item.flags & QDockAreaLayoutItem::KeepSize) {
             // Check if the item can keep its size, without violating size constraints
             // of other items.
 
             if (size < min_size) {
                 // There is too little space to keep this widget's size
                 item.flags &= ~QDockAreaLayoutItem::KeepSize;
                 min_size -= item.size;
                 min_size += pick(o, item.minimumSize());
                 min_size = qMax(0, min_size);
             } else if (size > max_size) {
                 // There is too much space to keep this widget's size
                 item.flags &= ~QDockAreaLayoutItem::KeepSize;
                 max_size -= item.size;
                 max_size += pick(o, item.maximumSize());
                 max_size = qMin<int>(QWIDGETSIZE_MAX, max_size);
             }
         }
 
         last_index = j;
         QLayoutStruct &ls = layout_struct_list[j++];
         ls.init();
         ls.empty = false;
         if (item.flags & QDockAreaLayoutItem::KeepSize) {
             ls.minimumSize = ls.maximumSize = ls.sizeHint = item.size;
             ls.expansive = false;
             ls.stretch = 0;
         } else {
             ls.maximumSize = pick(o, item.maximumSize());
             ls.expansive = item.expansive(o);
             ls.minimumSize = pick(o, item.minimumSize());
             ls.sizeHint = item.size == -1 ? pick(o, item.sizeHint()) : item.size;
             ls.stretch = ls.expansive ? ls.sizeHint : 0;
         }
 
         item.flags &= ~QDockAreaLayoutItem::KeepSize;
         previous = &item;
     }
     layout_struct_list.resize(j);
 
     // If there is more space than the widgets can take (due to maximum size constraints),
     // we detect it here and stretch the last widget to take up the rest of the space.
     if (size > max_size && last_index != -1) {
         layout_struct_list[last_index].maximumSize = QWIDGETSIZE_MAX;
         layout_struct_list[last_index].expansive = true;
     }
 
     qGeomCalc(layout_struct_list, 0, j, pick(o, rect.topLeft()), size, 0);
 
     j = 0;
     bool prev_gap = false;
     bool first = true;
     for (int i = 0; i < item_list.size(); ++i) {
         QDockAreaLayoutItem &item = item_list[i];
         if (item.skip())
             continue;
 
         bool gap = item.flags & QDockAreaLayoutItem::GapItem;
         if (!first && !gap && !prev_gap)
             ++j;
 
         const QLayoutStruct &ls = layout_struct_list.at(j++);
         item.size = ls.size;
         item.pos = ls.pos;
 
         if (item.subinfo != 0) {
             item.subinfo->rect = itemRect(i);
             item.subinfo->fitItems();
         }
 
         prev_gap = gap;
         first = false;
     }
 }

◆ gapIndex()

QList< int > QDockAreaLayoutInfo::gapIndex	(	const QPoint &	pos,
		bool	nestingEnabled,
		TabMode	tabMode
	)		const

Definition at line 745 of file qdockarealayout.cpp.

Referenced by gapIndex(), and QDockAreaLayout::gapIndex().

 {
     QList<int> result;
     QRect item_rect;
     int item_index = 0;
 
 #ifndef QT_NO_TABBAR
     if (tabbed) {
         item_rect = tabContentRect();
     } else
 #endif
     {
         int pos = pick(o, _pos);
 
         int last = -1;
         for (int i = 0; i < item_list.size(); ++i) {
             const QDockAreaLayoutItem &item = item_list.at(i);
             if (item.skip())
                 continue;
 
             last = i;
 
             if (item.pos + item.size < pos)
                 continue;
 
             if (item.subinfo != 0
 #ifndef QT_NO_TABBAR
                 && !item.subinfo->tabbed
 #endif
                 ) {
                 result = item.subinfo->gapIndex(_pos, nestingEnabled,
                                                     tabMode);
                 result.prepend(i);
                 return result;
             }
 
             item_rect = itemRect(i);
             item_index = i;
             break;
         }
 
         if (item_rect.isNull()) {
             result.append(last + 1);
             return result;
         }
     }
 
     Q_ASSERT(!item_rect.isNull());
 
     QInternal::DockPosition dock_pos
         = dockPosHelper(item_rect, _pos, o, nestingEnabled, tabMode);
 
     switch (dock_pos) {
         case QInternal::LeftDock:
             if (o == Qt::Horizontal)
                 result << item_index;
             else
                 result << item_index << 0; // this subinfo doesn't exist yet, but insertGap()
                                            // handles this by inserting it
             break;
         case QInternal::RightDock:
             if (o == Qt::Horizontal)
                 result << item_index + 1;
             else
                 result << item_index << 1;
             break;
         case QInternal::TopDock:
             if (o == Qt::Horizontal)
                 result << item_index << 0;
             else
                 result << item_index;
             break;
         case QInternal::BottomDock:
             if (o == Qt::Horizontal)
                 result << item_index << 1;
             else
                 result << item_index + 1;
             break;
         case  QInternal::DockCount:
             result << (-item_index - 1) << 0;   // negative item_index means "on top of"
                                                 // -item_index - 1, insertGap()
                                                 // will insert a tabbed subinfo
             break;
         default:
             break;
     }
 
     return result;
 }

◆ hasFixedSize()

bool QDockAreaLayoutInfo::hasFixedSize ( ) const

Definition at line 1491 of file qdockarealayout.cpp.

Referenced by QDockAreaLayout::findSeparator(), and QDockAreaLayout::paintSeparators().

 {
     return perp(o, minimumSize()) == perp(o, maximumSize());
 }

◆ indexOf()

QList< int > QDockAreaLayoutInfo::indexOf ( QWidget * widget ) const

Definition at line 1457 of file qdockarealayout.cpp.

Referenced by indexOf(), and QDockAreaLayout::indexOf().

 {
     for (int i = 0; i < item_list.size(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
 
         if (item.placeHolderItem != 0)
             continue;
 
         if (item.subinfo != 0) {
             QList<int> result = item.subinfo->indexOf(widget);
             if (!result.isEmpty()) {
                 result.prepend(i);
                 return result;
             }
             continue;
         }
 
         if (!(item.flags & QDockAreaLayoutItem::GapItem) && item.widgetItem->widget() == widget) {
             QList<int> result;
             result << i;
             return result;
         }
     }
 
     return QList<int>();
 }

◆ indexOfPlaceHolder()

QList< int > QDockAreaLayoutInfo::indexOfPlaceHolder ( const QString & objectName ) const

Definition at line 1433 of file qdockarealayout.cpp.

Referenced by indexOfPlaceHolder(), and QDockAreaLayout::indexOfPlaceHolder().

 {
     for (int i = 0; i < item_list.size(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
 
         if (item.subinfo != 0) {
             QList<int> result = item.subinfo->indexOfPlaceHolder(objectName);
             if (!result.isEmpty()) {
                 result.prepend(i);
                 return result;
             }
             continue;
         }
 
         if (item.placeHolderItem != 0 && item.placeHolderItem->objectName == objectName) {
             QList<int> result;
             result << i;
             return result;
         }
     }
 
     return QList<int>();
 }

◆ info() [1/2]

QDockAreaLayoutInfo * QDockAreaLayoutInfo::info ( const QList< int > & path )

Definition at line 1304 of file qdockarealayout.cpp.

Referenced by info(), and QDockAreaLayout::info().

 {
     int index = path.first();
     if (index < 0)
         index = -index - 1;
     if (index >= item_list.count())
         return this;
     if (path.count() == 1 || item_list[index].subinfo == 0)
         return this;
     return item_list[index].subinfo->info(path.mid(1));
 }

◆ info() [2/2]

QDockAreaLayoutInfo * QDockAreaLayoutInfo::info ( QWidget * widget )

Definition at line 1280 of file qdockarealayout.cpp.

 {
     for (int i = 0; i < item_list.count(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         if (item.skip())
             continue;
 
 #ifndef QT_NO_TABBAR
         if (tabbed && widget == tabBar)
             return this;
 #endif
 
         if (item.widgetItem != 0 && item.widgetItem->widget() == widget)
             return this;
 
         if (item.subinfo != 0) {
             if (QDockAreaLayoutInfo *result = item.subinfo->info(widget))
                 return result;
         }
     }
 
     return 0;
 }

◆ insertGap()

bool QDockAreaLayoutInfo::insertGap	(	const QList< int > &	path,
		QLayoutItem *	dockWidgetItem
	)

Definition at line 1149 of file qdockarealayout.cpp.

Referenced by insertGap(), and QDockAreaLayout::insertGap().

 {
     Q_ASSERT(!path.isEmpty());
 
     bool insert_tabbed = false;
     int index = path.first();
     if (index < 0) {
         insert_tabbed = true;
         index = -index - 1;
     }
 
 //    dump(qDebug() << "insertGap() before:" << index << tabIndex, *this, QString());
 
     if (path.count() > 1) {
         QDockAreaLayoutItem &item = item_list[index];
 
         if (item.subinfo == 0
 #ifndef QT_NO_TABBAR
             || (item.subinfo->tabbed && !insert_tabbed)
 #endif
             ) {
 
             // this is not yet a nested layout - make it
 
             QDockAreaLayoutInfo *subinfo = item.subinfo;
             QLayoutItem *widgetItem = item.widgetItem;
             QPlaceHolderItem *placeHolderItem = item.placeHolderItem;
             QRect r = subinfo == 0 ? widgetItem ? dockedGeometry(widgetItem->widget()) : placeHolderItem->topLevelRect : subinfo->rect;
 
             Qt::Orientation opposite = o == Qt::Horizontal ? Qt::Vertical : Qt::Horizontal;
 #ifdef QT_NO_TABBAR
             const int tabBarShape = 0;
 #endif
             QDockAreaLayoutInfo *new_info
                 = new QDockAreaLayoutInfo(sep, dockPos, opposite, tabBarShape, mainWindow);
 
             //item become a new top-level
             item.subinfo = new_info;
             item.widgetItem = 0;
             item.placeHolderItem = 0;
 
             QDockAreaLayoutItem new_item
                 = widgetItem == 0
                     ? QDockAreaLayoutItem(subinfo)
                     : widgetItem ? QDockAreaLayoutItem(widgetItem) : QDockAreaLayoutItem(placeHolderItem);
             new_item.size = pick(opposite, r.size());
             new_item.pos = pick(opposite, r.topLeft());
             new_info->item_list.append(new_item);
 #ifndef QT_NO_TABBAR
             if (insert_tabbed) {
                 new_info->tabbed = true;
             }
 #endif
         }
 
         return item.subinfo->insertGap(path.mid(1), dockWidgetItem);
     }
 
     // create the gap item
     QDockAreaLayoutItem gap_item;
     gap_item.flags |= QDockAreaLayoutItem::GapItem;
     gap_item.widgetItem = dockWidgetItem;   // so minimumSize(), maximumSize() and
                                             // sizeHint() will work
 #ifndef QT_NO_TABBAR
     if (!tabbed)
 #endif
     {
         int prev = this->prev(index);
         int next = this->next(index - 1);
         // find out how much space we have in the layout
         int space = 0;
         if (isEmpty()) {
             // I am an empty dock area, therefore I am a top-level dock area.
             switch (dockPos) {
                 case QInternal::LeftDock:
                 case QInternal::RightDock:
                     if (o == Qt::Vertical) {
                         // the "size" is the height of the dock area (remember we are empty)
                         space = pick(Qt::Vertical, rect.size());
                     } else {
                         space = pick(Qt::Horizontal, dockWidgetItem->widget()->size());
                     }
                     break;
                 case QInternal::TopDock:
                 case QInternal::BottomDock:
                 default:
                     if (o == Qt::Horizontal) {
                         // the "size" is width of the dock area
                         space = pick(Qt::Horizontal, rect.size());
                     } else {
                         space = pick(Qt::Vertical, dockWidgetItem->widget()->size());
                     }
                     break;
             }
         } else {
             for (int i = 0; i < item_list.count(); ++i) {
                 const QDockAreaLayoutItem &item = item_list.at(i);
                 if (item.skip())
                     continue;
                 Q_ASSERT(!(item.flags & QDockAreaLayoutItem::GapItem));
                 space += item.size - pick(o, item.minimumSize());
             }
         }
 
         // find the actual size of the gap
         int gap_size = 0;
         int sep_size = 0;
         if (isEmpty()) {
             gap_size = space;
             sep_size = 0;
         } else {
             QRect r = dockedGeometry(dockWidgetItem->widget());
             gap_size = pick(o, r.size());
         if (prev != -1 && !(item_list.at(prev).flags & QDockAreaLayoutItem::GapItem))
                 sep_size += *sep;
             if (next != -1 && !(item_list.at(next).flags & QDockAreaLayoutItem::GapItem))
                 sep_size += *sep;
         }
         if (gap_size + sep_size > space)
             gap_size = pick(o, gap_item.minimumSize());
         gap_item.size = gap_size + sep_size;
     }
 
     // finally, insert the gap
     item_list.insert(index, gap_item);
 
 //    dump(qDebug() << "insertGap() after:" << index << tabIndex, *this, QString());
 
     return true;
 }

◆ isEmpty()

bool QDockAreaLayoutInfo::isEmpty ( ) const

Definition at line 264 of file qdockarealayout.cpp.

Referenced by QDockAreaLayout::findSeparator(), QDockAreaLayout::gapIndex(), QDockAreaLayout::getGrid(), insertGap(), maximumSize(), minimumSize(), QDockAreaLayout::minimumSize(), paintSeparators(), QDockAreaLayout::paintSeparators(), QDockAreaLayout::saveState(), QDockAreaLayout::separatorRect(), separatorRegion(), QDockAreaLayout::separatorRegion(), size(), sizeHint(), QDockAreaLayout::sizeHint(), and QDockAreaLayout::updateSeparatorWidgets().

 {
     return next(-1) == -1;
 }

◆ item()

QDockAreaLayoutItem & QDockAreaLayoutInfo::item ( const QList< int > & path )

Definition at line 1714 of file qdockarealayout.cpp.

Referenced by apply(), deleteAllLayoutItems(), findSeparator(), fitItems(), gapIndex(), indexOf(), indexOfPlaceHolder(), info(), insertGap(), item(), QDockAreaLayout::item(), itemAt(), itemRect(), maximumSize(), minimumSize(), paintSeparators(), plug(), realMaxSize(), realMinSize(), remove(), restoreState(), saveState(), separatorMove(), separatorRect(), separatorRegion(), setTabBarShape(), sizeHint(), takeAt(), unnest(), unplug(), updateSeparatorWidgets(), updateTabBar(), usedSeparatorWidgets(), and usedTabBars().

 {
     Q_ASSERT(!path.isEmpty());
     const int index = path.first();
     if (path.count() > 1) {
         const QDockAreaLayoutItem &item = item_list[index];
         Q_ASSERT(item.subinfo != 0);
         return item.subinfo->item(path.mid(1));
     }
     return item_list[index];
 }

◆ itemAt()

QLayoutItem * QDockAreaLayoutInfo::itemAt	(	int *	x,
		int	index
	)		const

Definition at line 1726 of file qdockarealayout.cpp.

Referenced by itemAt(), and QDockAreaLayout::itemAt().

 {
     for (int i = 0; i < item_list.count(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         if (item.placeHolderItem != 0)
             continue;
         if (item.subinfo) {
             if (QLayoutItem *ret = item.subinfo->itemAt(x, index))
                 return ret;
         } else if (item.widgetItem) {
             if ((*x)++ == index)
                 return item.widgetItem;
         }
     }
     return 0;
 }

◆ itemRect() [1/2]

QRect QDockAreaLayoutInfo::itemRect ( int index ) const

Definition at line 1316 of file qdockarealayout.cpp.

Referenced by apply(), fitItems(), gapIndex(), itemRect(), QDockAreaLayout::itemRect(), and separatorMove().

 {
     const QDockAreaLayoutItem &item = item_list.at(index);
 
     if (item.skip())
         return QRect();
 
     QRect result;
 
 #ifndef QT_NO_TABBAR
     if (tabbed) {
         if (tabId(item) == currentTabId())
             result = tabContentRect();
     } else
 #endif
     {
         QPoint pos;
         rpick(o, pos) = item.pos;
         rperp(o, pos) = perp(o, rect.topLeft());
         QSize s;
         rpick(o, s) = item.size;
         rperp(o, s) = perp(o, rect.size());
         result = QRect(pos, s);
     }
 
     return result;
 }

◆ itemRect() [2/2]

QRect QDockAreaLayoutInfo::itemRect ( const QList< int > & path ) const

Definition at line 1344 of file qdockarealayout.cpp.

 {
     Q_ASSERT(!path.isEmpty());
 
     const int index = path.first();
     if (path.count() > 1) {
         const QDockAreaLayoutItem &item = item_list.at(index);
         Q_ASSERT(item.subinfo != 0);
         return item.subinfo->itemRect(path.mid(1));
     }
 
     return itemRect(index);
 }

◆ mainWindowLayout()

QMainWindowLayout * QDockAreaLayoutInfo::mainWindowLayout ( ) const

Definition at line 1484 of file qdockarealayout.cpp.

Referenced by apply(), updateSeparatorWidgets(), and updateTabBar().

 {
     QMainWindowLayout *result = qt_mainwindow_layout(mainWindow);
     Q_ASSERT(result != 0);
     return result;
 }

◆ maximumSize()

QSize QDockAreaLayoutInfo::maximumSize ( ) const

Definition at line 328 of file qdockarealayout.cpp.

Referenced by QDockAreaLayout::getGrid(), hasFixedSize(), and QDockAreaLayoutItem::maximumSize().

 {
     if (isEmpty())
         return QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
 
     int a = 0, b = QWIDGETSIZE_MAX;
 #ifndef QT_NO_TABBAR
     if (tabbed)
         a = QWIDGETSIZE_MAX;
 #endif
 
     int min_perp = 0;
 
     bool first = true;
     for (int i = 0; i < item_list.size(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         if (item.skip())
             continue;
 
         QSize max_size = item.maximumSize();
         min_perp = qMax(min_perp, perp(o, item.minimumSize()));
 
 #ifndef QT_NO_TABBAR
         if (tabbed) {
             a = qMin(a, pick(o, max_size));
         } else
 #endif
         {
             if (!first)
                 a += *sep;
             a += pick(o, max_size);
         }
         b = qMin(b, perp(o, max_size));
 
         a = qMin(a, int(QWIDGETSIZE_MAX));
         b = qMin(b, int(QWIDGETSIZE_MAX));
 
         first = false;
     }
 
     b = qMax(b, min_perp);
 
     QSize result;
     rpick(o, result) = a;
     rperp(o, result) = b;
 
 #ifndef QT_NO_TABBAR
     QSize tbh = tabBarSizeHint();
     if (!tbh.isNull()) {
         switch (tabBarShape) {
             case QTabBar::RoundedNorth:
             case QTabBar::RoundedSouth:
                 result.rheight() += tbh.height();
                 break;
             case QTabBar::RoundedEast:
             case QTabBar::RoundedWest:
                 result.rwidth() += tbh.width();
                 break;
             default:
                 break;
         }
     }
 #endif // QT_NO_TABBAR
 
     return result;
 }

◆ minimumSize()

QSize QDockAreaLayoutInfo::minimumSize ( ) const

Definition at line 269 of file qdockarealayout.cpp.

Referenced by QDockAreaLayout::getGrid(), hasFixedSize(), QDockAreaLayoutItem::minimumSize(), and QDockAreaLayout::minimumSize().

 {
     if (isEmpty())
         return QSize(0, 0);
 
     int a = 0, b = 0;
     bool first = true;
     for (int i = 0; i < item_list.size(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         if (item.skip())
             continue;
 
         QSize min_size = item.minimumSize();
 #ifndef QT_NO_TABBAR
         if (tabbed) {
             a = qMax(a, pick(o, min_size));
         } else
 #endif
         {
             if (!first)
                 a += *sep;
             a += pick(o, min_size);
         }
         b = qMax(b, perp(o, min_size));
 
         first = false;
     }
 
     QSize result;
     rpick(o, result) = a;
     rperp(o, result) = b;
 
 #ifndef QT_NO_TABBAR
     QSize tbm = tabBarMinimumSize();
     if (!tbm.isNull()) {
         switch (tabBarShape) {
             case QTabBar::RoundedNorth:
             case QTabBar::RoundedSouth:
             case QTabBar::TriangularNorth:
             case QTabBar::TriangularSouth:
                 result.rheight() += tbm.height();
                 result.rwidth() = qMax(tbm.width(), result.width());
                 break;
             case QTabBar::RoundedEast:
             case QTabBar::RoundedWest:
             case QTabBar::TriangularEast:
             case QTabBar::TriangularWest:
                 result.rheight() = qMax(tbm.height(), result.height());
                 result.rwidth() += tbm.width();
                 break;
             default:
                 break;
         }
     }
 #endif // QT_NO_TABBAR
 
     return result;
 }

◆ next()

int QDockAreaLayoutInfo::next ( int idx ) const

Definition at line 1654 of file qdockarealayout.cpp.

Referenced by findSeparator(), QDockAreaLayout::gapRect(), insertGap(), isEmpty(), paintSeparators(), plug(), separatorRegion(), unplug(), and updateSeparatorWidgets().

 {
     for (int i = index + 1; i < item_list.size(); ++i) {
         if (!item_list.at(i).skip())
             return i;
     }
     return -1;
 }

◆ paintSeparators()

void QDockAreaLayoutInfo::paintSeparators	(	QPainter *	p,
		QWidget *	widget,
		const QRegion &	clip,
		const QPoint &	mouse
	)		const

Definition at line 1619 of file qdockarealayout.cpp.

Referenced by paintSeparators(), and QDockAreaLayout::paintSeparators().

 {
     if (isEmpty())
         return;
 #ifndef QT_NO_TABBAR
     if (tabbed)
         return;
 #endif
 
     for (int i = 0; i < item_list.count(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
 
         if (item.skip())
             continue;
 
         int next = this->next(i);
         if ((item.flags & QDockAreaLayoutItem::GapItem)
                 || (next != -1 && (item_list.at(next).flags & QDockAreaLayoutItem::GapItem)))
             continue;
 
         if (item.subinfo) {
             if (clip.contains(item.subinfo->rect))
                 item.subinfo->paintSeparators(p, widget, clip, mouse);
         }
 
         if (next == -1)
             break;
         QRect r = separatorRect(i);
         if (clip.contains(r) && !item.hasFixedSize(o))
             paintSep(p, widget, r, o, r.contains(mouse));
     }
 }

◆ plug()

QLayoutItem * QDockAreaLayoutInfo::plug ( const QList< int > & path )

Definition at line 1018 of file qdockarealayout.cpp.

Referenced by plug(), and QDockAreaLayout::plug().

 {
     Q_ASSERT(!path.isEmpty());
 
     int index = path.first();
     if (index < 0)
         index = -index - 1;
 
     if (path.count() > 1) {
         const QDockAreaLayoutItem &item = item_list.at(index);
         Q_ASSERT(item.subinfo != 0);
         return item.subinfo->plug(path.mid(1));
     }
 
     QDockAreaLayoutItem &item = item_list[index];
 
     Q_ASSERT(item.widgetItem != 0);
     Q_ASSERT(item.flags & QDockAreaLayoutItem::GapItem);
     item.flags &= ~QDockAreaLayoutItem::GapItem;
 
     QRect result;
 
 #ifndef QT_NO_TABBAR
     if (tabbed) {
     } else
 #endif
     {
         int prev = this->prev(index);
         int next = this->next(index);
 
         if (prev != -1 && !(item_list.at(prev).flags & QDockAreaLayoutItem::GapItem)) {
             item.pos += *sep;
             item.size -= *sep;
         }
         if (next != -1 && !(item_list.at(next).flags & QDockAreaLayoutItem::GapItem))
             item.size -= *sep;
 
         QPoint pos;
         rpick(o, pos) = item.pos;
         rperp(o, pos) = perp(o, rect.topLeft());
         QSize s;
         rpick(o, s) = item.size;
         rperp(o, s) = perp(o, rect.size());
         result = QRect(pos, s);
     }
 
     return item.widgetItem;
 }

◆ prev()

int QDockAreaLayoutInfo::prev ( int idx ) const

Definition at line 1663 of file qdockarealayout.cpp.

Referenced by QDockAreaLayout::gapRect(), insertGap(), plug(), and unplug().

 {
     for (int i = index - 1; i >= 0; --i) {
         if (!item_list.at(i).skip())
             return i;
     }
     return -1;
 }

◆ remove()

void QDockAreaLayoutInfo::remove ( const QList< int > & path )

Definition at line 1002 of file qdockarealayout.cpp.

Referenced by remove(), and QDockAreaLayout::remove().

 {
     Q_ASSERT(!path.isEmpty());
 
     if (path.count() > 1) {
         const int index = path.first();
         QDockAreaLayoutItem &item = item_list[index];
         Q_ASSERT(item.subinfo != 0);
         item.subinfo->remove(path.mid(1));
         unnest(index);
     } else {
         int index = path.first();
         item_list.removeAt(index);
     }
 }

◆ restoreState()

bool QDockAreaLayoutInfo::restoreState	(	QDataStream &	stream,
		QList< QDockWidget *> &	widgets,
		bool	testing
	)

Definition at line 1878 of file qdockarealayout.cpp.

Referenced by restoreState().

 {
     uchar marker;
     stream >> marker;
     if (marker != TabMarker && marker != SequenceMarker)
         return false;
 
 #ifndef QT_NO_TABBAR
     tabbed = marker == TabMarker;
 
     int index = -1;
     if (tabbed)
         stream >> index;
 #endif
 
     uchar orientation;
     stream >> orientation;
     o = static_cast<Qt::Orientation>(orientation);
 
     int cnt;
     stream >> cnt;
 
     for (int i = 0; i < cnt; ++i) {
         uchar nextMarker;
         stream >> nextMarker;
         if (nextMarker == WidgetMarker) {
             QString name;
             uchar flags;
             stream >> name >> flags;
             if (name.isEmpty()) {
                 int dummy;
                 stream >> dummy >> dummy >> dummy >> dummy;
                 continue;
             }
 
             QDockWidget *widget = 0;
             for (int j = 0; j < widgets.count(); ++j) {
                 if (widgets.at(j)->objectName() == name) {
                     widget = widgets.takeAt(j);
                     break;
                 }
             }
 
             if (widget == 0) {
                 QPlaceHolderItem *placeHolder = new QPlaceHolderItem;
                 QDockAreaLayoutItem item(placeHolder);
 
                 placeHolder->objectName = name;
                 placeHolder->window = flags & StateFlagFloating;
                 placeHolder->hidden = !(flags & StateFlagVisible);
                 if (placeHolder->window) {
                     int x, y, w, h;
                     stream >> x >> y >> w >> h;
                     placeHolder->topLevelRect = QRect(x, y, w, h);
                 } else {
                     int dummy;
                     stream >> item.pos >> item.size >> dummy >> dummy;
                 }
                 if (item.size != -1)
                     item.flags |= QDockAreaLayoutItem::KeepSize;
                 if (!testing)
                     item_list.append(item);
             } else {
                 QDockAreaLayoutItem item(new QDockWidgetItem(widget));
                 if (flags & StateFlagFloating) {
                     bool drawer = false;
 #ifdef Q_WS_MAC // drawer support
                     extern bool qt_mac_is_macdrawer(const QWidget *); //qwidget_mac.cpp
                     extern bool qt_mac_set_drawer_preferred_edge(QWidget *, Qt::DockWidgetArea); //qwidget_mac.cpp
                     drawer = qt_mac_is_macdrawer(widget);
 #endif
 
                     if (!testing) {
                         widget->hide();
                         if (!drawer)
                             widget->setFloating(true);
                     }
 
                     int x, y, w, h;
                     stream >> x >> y >> w >> h;
 
 #ifdef Q_WS_MAC // drawer support
                     if (drawer) {
                         mainWindow->window()->createWinId();
                         widget->window()->createWinId();
                         qt_mac_set_drawer_preferred_edge(widget, toDockWidgetArea(dockPos));
                     } else
 #endif
                     if (!testing) {
                         QRect r(x, y, w, h);
                         QDesktopWidget *desktop = QApplication::desktop();
                         if (desktop->isVirtualDesktop())
                             r = constrainedRect(r, desktop->screenGeometry(desktop->screenNumber(r.topLeft())));
                         else
                             r = constrainedRect(r, desktop->screenGeometry(widget));
                         widget->move(r.topLeft());
                         widget->resize(r.size());
                     }
 
                     if (!testing) {
                         widget->setVisible(flags & StateFlagVisible);
                         item_list.append(item);
                     }
                 } else {
                     int dummy;
                     stream >> item.pos >> item.size >> dummy >> dummy;
                     if (!testing) {
                         item_list.append(item);
                         widget->setFloating(false);
                         widget->setVisible(flags & StateFlagVisible);
                         emit widget->dockLocationChanged(toDockWidgetArea(dockPos));
                     }
                 }
         if (testing) {
           //was it is not really added to the layout, we need to delete the object here
           delete item.widgetItem;
         }
             }
         } else if (nextMarker == SequenceMarker) {
             int dummy;
 #ifdef QT_NO_TABBAR
             const int tabBarShape = 0;
 #endif
             QDockAreaLayoutItem item(new QDockAreaLayoutInfo(sep, dockPos, o,
                                                                 tabBarShape, mainWindow));
             stream >> item.pos >> item.size >> dummy >> dummy;
             //we need to make sure the element is in the list so the dock widget can eventually be docked correctly
             if (!testing)
                 item_list.append(item);
             
             //here we need to make sure we change the item in the item_list
             QDockAreaLayoutItem &lastItem = testing ? item : item_list.last();
 
             if (!lastItem.subinfo->restoreState(stream, widgets, testing))
                 return false;
 
         } else {
             return false;
         }
     }
 
 #ifndef QT_NO_TABBAR
     if (!testing && tabbed && index >= 0 && index < item_list.count()) {
         updateTabBar();
         setCurrentTabId(tabId(item_list.at(index)));
     }
     if (!testing && *sep == 1)
         updateSeparatorWidgets();
 #endif
 
     return true;
 }

◆ saveState()

void QDockAreaLayoutInfo::saveState ( QDataStream & stream ) const

Definition at line 1781 of file qdockarealayout.cpp.

Referenced by saveState(), and QDockAreaLayout::saveState().

 {
 #ifndef QT_NO_TABBAR
     if (tabbed) {
         stream << (uchar) TabMarker;
 
         // write the index in item_list of the widget that's currently on top.
         quintptr id = currentTabId();
         int index = -1;
         for (int i = 0; i < item_list.count(); ++i) {
             if (tabId(item_list.at(i)) == id) {
                 index = i;
                 break;
             }
         }
         stream << index;
     } else
 #endif // QT_NO_TABBAR
     {
         stream << (uchar) SequenceMarker;
     }
 
     stream << (uchar) o << item_list.count();
 
     for (int i = 0; i < item_list.count(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         if (item.widgetItem != 0) {
             stream << (uchar) WidgetMarker;
             QWidget *w = item.widgetItem->widget();
             QString name = w->objectName();
             if (name.isEmpty()) {
                 qWarning("QMainWindow::saveState(): 'objectName' not set for QDockWidget %p '%s;",
                          w, qPrintable(w->windowTitle()));
             }
             stream << name;
 
             uchar flags = 0;
             if (!w->isHidden())
                 flags |= StateFlagVisible;
             if (w->isWindow())
                 flags |= StateFlagFloating;
             stream << flags;
 
             if (w->isWindow()) {
                 stream << w->x() << w->y() << w->width() << w->height();
             } else {
                 stream << item.pos << item.size << pick(o, item.minimumSize())
                         << pick(o, item.maximumSize());
             }
         } else if (item.placeHolderItem != 0) {
             stream << (uchar) WidgetMarker;
             stream << item.placeHolderItem->objectName;
             uchar flags = 0;
             if (!item.placeHolderItem->hidden)
                 flags |= StateFlagVisible;
             if (item.placeHolderItem->window)
                 flags |= StateFlagFloating;
             stream << flags;
             if (item.placeHolderItem->window) {
                 QRect r = item.placeHolderItem->topLevelRect;
                 stream << r.x() << r.y() << r.width() << r.height();
             } else {
                 stream << item.pos << item.size << (int)0 << (int)0;
             }
         } else if (item.subinfo != 0) {
             stream << (uchar) SequenceMarker << item.pos << item.size << pick(o, item.minimumSize()) << pick(o, item.maximumSize());
             item.subinfo->saveState(stream);
         }
     }
 }

◆ separatorMove()

int QDockAreaLayoutInfo::separatorMove	(	int	index,
		int	delta
	)

Definition at line 932 of file qdockarealayout.cpp.

Referenced by QDockAreaLayout::separatorMove().

 {
 #ifndef QT_NO_TABBAR
     Q_ASSERT(!tabbed);
 #endif
 
     QVector<QLayoutStruct> list(item_list.size());
     for (int i = 0; i < list.size(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         QLayoutStruct &ls = list[i];
         Q_ASSERT(!(item.flags & QDockAreaLayoutItem::GapItem));
         if (item.skip()) {
             ls.empty = true;
         } else {
             const int separatorSpace = item.hasFixedSize(o) ? 0 : *sep;
             ls.empty = false;
             ls.pos = item.pos;
             ls.size = item.size + separatorSpace;
             ls.minimumSize = pick(o, item.minimumSize()) + separatorSpace;
             ls.maximumSize = pick(o, item.maximumSize()) + separatorSpace;
 
         }
     }
 
     //the separator space has been added to the size, so we pass 0 as a parameter
     delta = separatorMoveHelper(list, index, delta, 0 /*separator*/);
 
     for (int i = 0; i < list.size(); ++i) {
         QDockAreaLayoutItem &item = item_list[i];
         if (item.skip())
             continue;
         QLayoutStruct &ls = list[i];
         const int separatorSpace = item.hasFixedSize(o) ? 0 : *sep;
         item.size = ls.size - separatorSpace;
         item.pos = ls.pos;
         if (item.subinfo != 0) {
             item.subinfo->rect = itemRect(i);
             item.subinfo->fitItems();
         }
     }
 
     return delta;
 }

◆ separatorRect() [1/2]

QRect QDockAreaLayoutInfo::separatorRect ( int index ) const

Definition at line 1358 of file qdockarealayout.cpp.

Referenced by findSeparator(), paintSeparators(), separatorRect(), QDockAreaLayout::separatorRect(), separatorRegion(), and updateSeparatorWidgets().

 {
 #ifndef QT_NO_TABBAR
     if (tabbed)
         return QRect();
 #endif
 
     const QDockAreaLayoutItem &item = item_list.at(index);
     if (item.skip())
         return QRect();
 
     QPoint pos = rect.topLeft();
     rpick(o, pos) = item.pos + item.size;
     QSize s = rect.size();
     rpick(o, s) = *sep;
 
     return QRect(pos, s);
 }

◆ separatorRect() [2/2]

QRect QDockAreaLayoutInfo::separatorRect ( const QList< int > & path ) const

Definition at line 1377 of file qdockarealayout.cpp.

 {
     Q_ASSERT(!path.isEmpty());
 
     const int index = path.first();
     if (path.count() > 1) {
         const QDockAreaLayoutItem &item = item_list.at(index);
         Q_ASSERT(item.subinfo != 0);
         return item.subinfo->separatorRect(path.mid(1));
     }
     return separatorRect(index);
 }

◆ separatorRegion()

QRegion QDockAreaLayoutInfo::separatorRegion ( ) const

Definition at line 1589 of file qdockarealayout.cpp.

Referenced by separatorRegion(), and QDockAreaLayout::separatorRegion().

 {
     QRegion result;
 
     if (isEmpty())
         return result;
 #ifndef QT_NO_TABBAR
     if (tabbed)
         return result;
 #endif
 
     for (int i = 0; i < item_list.count(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
 
         if (item.skip())
             continue;
 
         int next = this->next(i);
 
         if (item.subinfo)
             result |= item.subinfo->separatorRegion();
 
         if (next == -1)
             break;
         result |= separatorRect(i);
     }
 
     return result;
 }

◆ setCurrentTab()

void QDockAreaLayoutInfo::setCurrentTab ( QWidget * widget )

Definition at line 1115 of file qdockarealayout.cpp.

Referenced by QMainWindowLayout::raise(), and tab().

 {
     setCurrentTabId(reinterpret_cast<quintptr>(widget));
 }

◆ setCurrentTabId()

void QDockAreaLayoutInfo::setCurrentTabId ( quintptr id )

Definition at line 1120 of file qdockarealayout.cpp.

Referenced by QDockAreaLayout::addDockWidget(), restoreState(), and setCurrentTab().

 {
     if (!tabbed || tabBar == 0)
         return;
 
     for (int i = 0; i < tabBar->count(); ++i) {
         if (qvariant_cast<quintptr>(tabBar->tabData(i)) == id) {
             tabBar->setCurrentIndex(i);
             return;
         }
     }
 }

◆ setTabBarShape()

void QDockAreaLayoutInfo::setTabBarShape ( int shape )

Definition at line 2156 of file qdockarealayout.cpp.

Referenced by setTabBarShape(), and QMainWindowLayout::updateTabBarShapes().

 {
     if (shape == tabBarShape)
         return;
     tabBarShape = shape;
     if (tabBar != 0)
         tabBar->setShape(static_cast<QTabBar::Shape>(shape));
 
     for (int i = 0; i < item_list.count(); ++i) {
         QDockAreaLayoutItem &item = item_list[i];
         if (item.subinfo != 0)
             item.subinfo->setTabBarShape(shape);
     }
 }

◆ size()

QSize QDockAreaLayoutInfo::size ( ) const

Definition at line 249 of file qdockarealayout.cpp.

Referenced by fitItems(), and QDockAreaLayout::getGrid().

 {
     return isEmpty() ? QSize(0, 0) : rect.size();
 }

◆ sizeHint()

QSize QDockAreaLayoutInfo::sizeHint ( ) const

Definition at line 395 of file qdockarealayout.cpp.

Referenced by QDockAreaLayoutItem::sizeHint(), and QDockAreaLayout::sizeHint().

 {
     if (isEmpty())
         return QSize(0, 0);
 
     int a = 0, b = 0;
     int min_perp = 0;
     int max_perp = QWIDGETSIZE_MAX;
     const QDockAreaLayoutItem *previous = 0;
     for (int i = 0; i < item_list.size(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         if (item.skip())
             continue;
 
         bool gap = item.flags & QDockAreaLayoutItem::GapItem;
 
         QSize size_hint = item.sizeHint();
         min_perp = qMax(min_perp, perp(o, item.minimumSize()));
         max_perp = qMin(max_perp, perp(o, item.maximumSize()));
 
 #ifndef QT_NO_TABBAR
         if (tabbed) {
             a = qMax(a, gap ? item.size : pick(o, size_hint));
         } else
 #endif
         {
             if (previous && !gap && !(previous->flags &  QDockAreaLayoutItem::GapItem)
                 && !previous->hasFixedSize(o)) {
                 a += *sep;
             }
             a += gap ? item.size : pick(o, size_hint);
         }
         b = qMax(b, perp(o, size_hint));
 
         previous = &item;
     }
 
     max_perp = qMax(max_perp, min_perp);
     b = qMax(b, min_perp);
     b = qMin(b, max_perp);
 
     QSize result;
     rpick(o, result) = a;
     rperp(o, result) = b;
 
 #ifndef QT_NO_TABBAR
     if (tabbed) {
         QSize tbh = tabBarSizeHint();
         switch (tabBarShape) {
             case QTabBar::RoundedNorth:
             case QTabBar::RoundedSouth:
             case QTabBar::TriangularNorth:
             case QTabBar::TriangularSouth:
                 result.rheight() += tbh.height();
                 result.rwidth() = qMax(tbh.width(), result.width());
                 break;
             case QTabBar::RoundedEast:
             case QTabBar::RoundedWest:
             case QTabBar::TriangularEast:
             case QTabBar::TriangularWest:
                 result.rheight() = qMax(tbh.height(), result.height());
                 result.rwidth() += tbh.width();
                 break;
             default:
                 break;
         }
     }
 #endif // QT_NO_TABBAR
 
     return result;
 }

◆ split()

void QDockAreaLayoutInfo::split	(	int	index,
		Qt::Orientation	orientation,
		QLayoutItem *	dockWidgetItem
	)

Definition at line 1696 of file qdockarealayout.cpp.

Referenced by QDockAreaLayout::splitDockWidget().

 {
     if (orientation == o) {
         item_list.insert(index + 1, QDockAreaLayoutItem(dockWidgetItem));
     } else {
 #ifdef QT_NO_TABBAR
         const int tabBarShape = 0;
 #endif
         QDockAreaLayoutInfo *new_info
             = new QDockAreaLayoutInfo(sep, dockPos, orientation, tabBarShape, mainWindow);
         item_list[index].subinfo = new_info;
         new_info->item_list.append(item_list.at(index).widgetItem);
         item_list[index].widgetItem = 0;
         new_info->item_list.append(dockWidgetItem);
     }
 }

◆ tab()

void QDockAreaLayoutInfo::tab	(	int	index,
		QLayoutItem *	dockWidgetItem
	)

Definition at line 1672 of file qdockarealayout.cpp.

Referenced by QDockAreaLayout::tabifyDockWidget().

 {
 #ifdef QT_NO_TABBAR
     Q_UNUSED(index);
     Q_UNUSED(dockWidgetItem);
 #else
     if (tabbed) {
         item_list.append(QDockAreaLayoutItem(dockWidgetItem));
         updateTabBar();
         setCurrentTab(dockWidgetItem->widget());
     } else {
         QDockAreaLayoutInfo *new_info
             = new QDockAreaLayoutInfo(sep, dockPos, o, tabBarShape, mainWindow);
         item_list[index].subinfo = new_info;
         new_info->item_list.append(item_list.at(index).widgetItem);
         item_list[index].widgetItem = 0;
         new_info->item_list.append(dockWidgetItem);
         new_info->tabbed = true;
         new_info->updateTabBar();
         new_info->setCurrentTab(dockWidgetItem->widget());
     }
 #endif // QT_NO_TABBAR
 }

◆ tabBarMinimumSize()

QSize QDockAreaLayoutInfo::tabBarMinimumSize ( ) const

Definition at line 2171 of file qdockarealayout.cpp.

Referenced by minimumSize().

 {
     if (!updateTabBar())
         return QSize(0, 0);
 
     return tabBar->minimumSizeHint();
 }

◆ tabBarSizeHint()

QSize QDockAreaLayoutInfo::tabBarSizeHint ( ) const

Definition at line 2179 of file qdockarealayout.cpp.

Referenced by apply(), maximumSize(), sizeHint(), and tabContentRect().

 {
     if (!updateTabBar())
         return QSize(0, 0);
 
     return tabBar->sizeHint();
 }

◆ tabContentRect()

QRect QDockAreaLayoutInfo::tabContentRect ( ) const

Definition at line 2223 of file qdockarealayout.cpp.

Referenced by gapIndex(), QDockAreaLayout::gapRect(), and itemRect().

 {
     if (!tabbed)
         return QRect();
 
     QRect result = rect;
     QSize tbh = tabBarSizeHint();
 
     if (!tbh.isNull()) {
         switch (tabBarShape) {
             case QTabBar::RoundedNorth:
             case QTabBar::TriangularNorth:
                 result.adjust(0, tbh.height(), 0, 0);
                 break;
             case QTabBar::RoundedSouth:
             case QTabBar::TriangularSouth:
                 result.adjust(0, 0, 0, -tbh.height());
                 break;
             case QTabBar::RoundedEast:
             case QTabBar::TriangularEast:
                 result.adjust(0, 0, -tbh.width(), 0);
                 break;
             case QTabBar::RoundedWest:
             case QTabBar::TriangularWest:
                 result.adjust(tbh.width(), 0, 0, 0);
                 break;
             default:
                 break;
         }
     }
 
     return result;
 }

◆ takeAt()

QLayoutItem * QDockAreaLayoutInfo::takeAt	(	int *	x,
		int	index
	)

Definition at line 1743 of file qdockarealayout.cpp.

Referenced by takeAt(), and QDockAreaLayout::takeAt().

 {
     for (int i = 0; i < item_list.count(); ++i) {
         QDockAreaLayoutItem &item = item_list[i];
         if (item.placeHolderItem != 0)
             continue;
         else if (item.subinfo) {
             if (QLayoutItem *ret = item.subinfo->takeAt(x, index)) {
                 unnest(i);
                 return ret;
             }
         } else if (item.widgetItem) {
             if ((*x)++ == index) {
                 item.placeHolderItem = new QPlaceHolderItem(item.widgetItem->widget());
                 QLayoutItem *ret = item.widgetItem;
                 item.widgetItem = 0;
                 if (item.size != -1)
                     item.flags |= QDockAreaLayoutItem::KeepSize;
                 return ret;
             }
         }
     }
     return 0;
 }

◆ unnest()

void QDockAreaLayoutInfo::unnest ( int index )

Definition at line 976 of file qdockarealayout.cpp.

Referenced by remove(), and takeAt().

 {
     QDockAreaLayoutItem &item = item_list[index];
     if (item.subinfo == 0)
         return;
     if (item.subinfo->item_list.count() > 1)
         return;
 
     if (item.subinfo->item_list.count() == 0) {
         item_list.removeAt(index);
     } else if (item.subinfo->item_list.count() == 1) {
         QDockAreaLayoutItem &child = item.subinfo->item_list.first();
         if (child.widgetItem != 0) {
             item.widgetItem = child.widgetItem;
             delete item.subinfo;
             item.subinfo = 0;
         } else if (child.subinfo != 0) {
             QDockAreaLayoutInfo *tmp = item.subinfo;
             item.subinfo = child.subinfo;
             child.subinfo = 0;
             tmp->item_list.clear();
             delete tmp;
         }
     }
 }

◆ unplug()

QLayoutItem * QDockAreaLayoutInfo::unplug ( const QList< int > & path )

Definition at line 1067 of file qdockarealayout.cpp.

Referenced by unplug(), and QDockAreaLayout::unplug().

 {
     Q_ASSERT(!path.isEmpty());
 
     const int index = path.first();
     if (path.count() > 1) {
         const QDockAreaLayoutItem &item = item_list.at(index);
         Q_ASSERT(item.subinfo != 0);
         return item.subinfo->unplug(path.mid(1));
     }
 
     QDockAreaLayoutItem &item = item_list[index];
     int prev = this->prev(index);
     int next = this->next(index);
 
     Q_ASSERT(!(item.flags & QDockAreaLayoutItem::GapItem));
     item.flags |= QDockAreaLayoutItem::GapItem;
 
 #ifndef QT_NO_TABBAR
     if (tabbed) {
     } else
 #endif
     {
         if (prev != -1 && !(item_list.at(prev).flags & QDockAreaLayoutItem::GapItem)) {
             item.pos -= *sep;
             item.size += *sep;
         }
         if (next != -1 && !(item_list.at(next).flags & QDockAreaLayoutItem::GapItem))
             item.size += *sep;
     }
 
     return item.widgetItem;
 }

◆ updateSeparatorWidgets()

void QDockAreaLayoutInfo::updateSeparatorWidgets ( ) const

Definition at line 2032 of file qdockarealayout.cpp.

Referenced by apply(), restoreState(), and updateSeparatorWidgets().

 {
     if (tabbed) {
         separatorWidgets.clear();
         return;
     }
 
     int j = 0;
     for (int i = 0; i < item_list.count(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
 
         if (item.skip())
             continue;
 
         int next = this->next(i);
         if ((item.flags & QDockAreaLayoutItem::GapItem)
                 || (next != -1 && (item_list.at(next).flags & QDockAreaLayoutItem::GapItem)))
             continue;
 
         if (item.subinfo) {
             item.subinfo->updateSeparatorWidgets();
         }
 
         if (next == -1)
             break;
 
         QWidget *sepWidget;
         if (j < separatorWidgets.size() && separatorWidgets.at(j)) {
             sepWidget = separatorWidgets.at(j);
         } else {
             sepWidget = mainWindowLayout()->getSeparatorWidget();
             separatorWidgets.append(sepWidget);
         }
         j++;
 
 #ifndef QT_MAC_USE_COCOA
         sepWidget->raise();
 #endif
         QRect sepRect = separatorRect(i).adjusted(-2, -2, 2, 2);
         sepWidget->setGeometry(sepRect);
         sepWidget->setMask( QRegion(separatorRect(i).translated( - sepRect.topLeft())));
         sepWidget->show();
     }
 
     for (int k = j; k < separatorWidgets.size(); ++k) {
         separatorWidgets[k]->hide();
     }
     separatorWidgets.resize(j);
     Q_ASSERT(separatorWidgets.size() == j);
 }

◆ updateTabBar()

bool QDockAreaLayoutInfo::updateTabBar ( ) const

Definition at line 2086 of file qdockarealayout.cpp.

Referenced by QDockAreaLayout::addDockWidget(), restoreState(), tab(), tabBarMinimumSize(), tabBarSizeHint(), and usedTabBars().

 {
     if (!tabbed)
         return false;
 
     QDockAreaLayoutInfo *that = const_cast<QDockAreaLayoutInfo*>(this);
 
     if (that->tabBar == 0) {
         that->tabBar = mainWindowLayout()->getTabBar();
         that->tabBar->setShape(static_cast<QTabBar::Shape>(tabBarShape));
         that->tabBar->setDrawBase(true);
     }
 
     bool blocked = tabBar->blockSignals(true);
     bool gap = false;
 
     int tab_idx = 0;
     for (int i = 0; i < item_list.count(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         if (item.skip())
             continue;
         if (item.flags & QDockAreaLayoutItem::GapItem) {
             gap = true;
             continue;
         }
         if (item.widgetItem == 0)
             continue;
 
         QDockWidget *dw = qobject_cast<QDockWidget*>(item.widgetItem->widget());
         QString title = dw->d_func()->fixedWindowTitle;
         quintptr id = tabId(item);
         if (tab_idx == tabBar->count()) {
             tabBar->insertTab(tab_idx, title);
 #ifndef QT_NO_TOOLTIP
             tabBar->setTabToolTip(tab_idx, title);
 #endif
             tabBar->setTabData(tab_idx, id);
         } else if (qvariant_cast<quintptr>(tabBar->tabData(tab_idx)) != id) {
             if (tab_idx + 1 < tabBar->count()
                     && qvariant_cast<quintptr>(tabBar->tabData(tab_idx + 1)) == id)
                 tabBar->removeTab(tab_idx);
             else {
                 tabBar->insertTab(tab_idx, title);
 #ifndef QT_NO_TOOLTIP
                 tabBar->setTabToolTip(tab_idx, title);
 #endif
                 tabBar->setTabData(tab_idx, id);
             }
         }
 
         if (title != tabBar->tabText(tab_idx)) {
             tabBar->setTabText(tab_idx, title);
 #ifndef QT_NO_TOOLTIP
             tabBar->setTabToolTip(tab_idx, title);
 #endif
         }
 
         ++tab_idx;
     }
 
     while (tab_idx < tabBar->count()) {
         tabBar->removeTab(tab_idx);
     }
 
     tabBar->blockSignals(blocked);
 
     //returns if the tabbar is visible or not
     return ( (gap ? 1 : 0) + tabBar->count()) > 1;
 }

◆ usedSeparatorWidgets()

QSet< QWidget * > QDockAreaLayoutInfo::usedSeparatorWidgets ( ) const

Definition at line 2207 of file qdockarealayout.cpp.

Referenced by usedSeparatorWidgets(), and QDockAreaLayout::usedSeparatorWidgets().

 {
     QSet<QWidget*> result;
 
     for (int i = 0; i < separatorWidgets.count(); ++i)
         result << separatorWidgets.at(i);
 
     for (int i = 0; i < item_list.count(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         if (item.subinfo != 0)
             result += item.subinfo->usedSeparatorWidgets();
     }
 
     return result;
 }

◆ usedTabBars()

QSet< QTabBar * > QDockAreaLayoutInfo::usedTabBars ( ) const

Definition at line 2187 of file qdockarealayout.cpp.

Referenced by usedTabBars(), and QDockAreaLayout::usedTabBars().

 {
     QSet<QTabBar*> result;
 
     if (tabbed) {
         updateTabBar();
         result.insert(tabBar);
     }
 
     for (int i = 0; i < item_list.count(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         if (item.subinfo != 0)
             result += item.subinfo->usedTabBars();
     }
 
     return result;
 }

Properties

◆ dockPos

QInternal::DockPosition QDockAreaLayoutInfo::dockPos

Definition at line 194 of file qdockarealayout_p.h.

Referenced by insertGap(), restoreState(), split(), and tab().

◆ item_list

QList<QDockAreaLayoutItem> QDockAreaLayoutInfo::item_list

◆ mainWindow

QMainWindow* QDockAreaLayoutInfo::mainWindow

Definition at line 197 of file qdockarealayout_p.h.

Referenced by insertGap(), mainWindowLayout(), restoreState(), split(), and tab().

◆ o

Qt::Orientation QDockAreaLayoutInfo::o

◆ rect

QRect QDockAreaLayoutInfo::rect

◆ sep

const int* QDockAreaLayoutInfo::sep

Definition at line 192 of file qdockarealayout_p.h.

Referenced by apply(), findSeparator(), fitItems(), insertGap(), maximumSize(), minimumSize(), plug(), realMaxSize(), realMinSize(), restoreState(), separatorMove(), separatorMoveHelper(), separatorRect(), sizeHint(), split(), tab(), and unplug().

◆ separatorWidgets

QVector<QWidget*> QDockAreaLayoutInfo::separatorWidgets

mutable

Definition at line 193 of file qdockarealayout_p.h.

Referenced by updateSeparatorWidgets(), and usedSeparatorWidgets().

◆ tabBar

QTabBar* QDockAreaLayoutInfo::tabBar

Definition at line 210 of file qdockarealayout_p.h.

Referenced by apply(), clear(), currentTabId(), info(), setCurrentTabId(), setTabBarShape(), tabBarMinimumSize(), tabBarSizeHint(), QMainWindow::tabifiedDockWidgets(), updateTabBar(), and usedTabBars().

◆ tabBarShape

int QDockAreaLayoutInfo::tabBarShape

Definition at line 211 of file qdockarealayout_p.h.

Referenced by QDockAreaLayout::addDockWidget(), apply(), insertGap(), maximumSize(), minimumSize(), restoreState(), setTabBarShape(), sizeHint(), split(), tab(), tabContentRect(), and updateTabBar().

◆ tabbed

bool QDockAreaLayoutInfo::tabbed

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

/src/gui/widgets/qdockarealayout_p.h
/src/gui/widgets/qdockarealayout.cpp

Public Types

Public Functions

Public Variables

Detailed Description

Enumerations

◆ anonymous enum

◆ TabMode

Constructors and Destructors

◆ QDockAreaLayoutInfo() [1/2]

◆ QDockAreaLayoutInfo() [2/2]

Functions

◆ apply()

◆ changeSize()

◆ clear()

◆ currentTabId()

◆ deleteAllLayoutItems()

◆ expansive()

◆ findSeparator()

◆ fitItems()

◆ gapIndex()

◆ hasFixedSize()

◆ indexOf()

◆ indexOfPlaceHolder()

◆ info() [1/2]

◆ info() [2/2]

◆ insertGap()

◆ isEmpty()

◆ item()

◆ itemAt()

◆ itemRect() [1/2]

◆ itemRect() [2/2]

◆ mainWindowLayout()

◆ maximumSize()

◆ minimumSize()

◆ next()

◆ paintSeparators()

◆ plug()

◆ prev()

◆ remove()

◆ restoreState()

◆ saveState()

◆ separatorMove()

◆ separatorRect() [1/2]

◆ separatorRect() [2/2]

◆ separatorRegion()

◆ setCurrentTab()

◆ setCurrentTabId()

◆ setTabBarShape()

◆ size()

◆ sizeHint()

◆ split()

◆ tab()

◆ tabBarMinimumSize()

◆ tabBarSizeHint()

◆ tabContentRect()

◆ takeAt()

◆ unnest()

◆ unplug()

◆ updateSeparatorWidgets()

◆ updateTabBar()

◆ usedSeparatorWidgets()

◆ usedTabBars()

Properties

◆ dockPos

◆ item_list

◆ mainWindow

◆ o

◆ rect

◆ sep

◆ separatorWidgets

◆ tabBar

◆ tabBarShape

◆ tabbed