MCL/sf/mw/qt: comparison src/gui/widgets/qdockarealayout.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 // this is not yet a nested layout - make it
 QDockAreaLayoutInfo *subinfo = item.subinfo;
 QLayoutItem *widgetItem = item.widgetItem;
-QRect r = subinfo == 0 ? dockedGeometry(widgetItem->widget()) : subinfo->rect;
+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)
-: QDockAreaLayoutItem(widgetItem);
+: 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) {
 int index = path.first();
 if (index < 0)
 index = -index - 1;
 if (index >= item_list.count())
 return this;
-if (path.count() == 1 || item_list.at(index).subinfo == 0)
+if (path.count() == 1 || item_list[index].subinfo == 0)
 return this;
-return item_list.at(index).subinfo->info(path.mid(1));
+return item_list[index].subinfo->info(path.mid(1));
 }
 QRect QDockAreaLayoutInfo::itemRect(int index) const
 {
 const QDockAreaLayoutItem &item = item_list.at(index);
 && (geo.right() < 0 || geo.bottom() < 0)) {
 emit dw->visibilityChanged(true);
 }
 }
 }
+#ifndef QT_NO_TABBAR
 if (sep == 1)
 updateSeparatorWidgets();
+#endif //QT_NO_TABBAR
 }
 static void paintSep(QPainter *p, QWidget *w, const QRect &r, Qt::Orientation o, bool mouse_over)
 {
 QStyleOption opt(0);
 item.subinfo->saveState(stream);
 }
 }
 }
-#ifdef Q_WS_MAC
 static Qt::DockWidgetArea toDockWidgetArea(QInternal::DockPosition pos)
 {
 switch (pos) {
 case QInternal::LeftDock:   return Qt::LeftDockWidgetArea;
 case QInternal::RightDock:  return Qt::RightDockWidgetArea;
 case QInternal::BottomDock: return Qt::BottomDockWidgetArea;
 default: break;
 }
 return Qt::NoDockWidgetArea;
 }
-#endif
 static QRect constrainedRect(QRect rect, const QRect &desktop)
 {
 if (desktop.isValid()) {
 rect.setWidth(qMin(rect.width(), desktop.width()));
 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) {
-item_list.append(item);
-}
 }
 } else if (nextMarker == SequenceMarker) {
 int dummy;
 #ifdef QT_NO_TABBAR
 const int tabBarShape = 0;
 #ifndef QT_NO_TABBAR
 if (!testing && tabbed && index >= 0 && index < item_list.count()) {
 updateTabBar();
 setCurrentTabId(tabId(item_list.at(index)));
 }
-#endif
 if (!testing && sep == 1)
 updateSeparatorWidgets();
+#endif
 return true;
 }
+#ifndef QT_NO_TABBAR
 void QDockAreaLayoutInfo::updateSeparatorWidgets() const
 {
 if (tabbed) {
 separatorWidgets.clear();
 return;
 separatorWidgets[k]->hide();
 }
 separatorWidgets.resize(j);
 Q_ASSERT(separatorWidgets.size() == j);
 }
+#endif //QT_NO_TABBAR
 #ifndef QT_NO_TABBAR
 void QDockAreaLayoutInfo::updateTabBar() const
 {
 if (!tabbed)
 /******************************************************************************
 ** QDockAreaLayout
 */
-QDockAreaLayout::QDockAreaLayout(QMainWindow *win)
+QDockAreaLayout::QDockAreaLayout(QMainWindow *win) : fallbackToSizeHints(true)
 {
 mainWindow = win;
 sep = win->style()->pixelMetric(QStyle::PM_DockWidgetSeparatorExtent, 0, win);
 #ifndef QT_NO_TABBAR
 const int tabShape = QTabBar::RoundedSouth;
 stream >> cornerData[i];
 if (stream.status() == QDataStream::Ok) {
 for (int i = 0; i < 4; ++i)
 corners[i] = static_cast<Qt::DockWidgetArea>(cornerData[i]);
 }
+if (!testing)
+fallbackToSizeHints = false;
 }
 return ok;
 }
 void QDockAreaLayout::getGrid(QVector<QLayoutStruct> *_ver_struct_list,
 QVector<QLayoutStruct> *_hor_struct_list)
 {
 QSize center_hint(0, 0);
 QSize center_min(0, 0);
-bool have_central = centralWidgetItem != 0 && !centralWidgetItem->isEmpty();
+const bool have_central = centralWidgetItem != 0 && !centralWidgetItem->isEmpty();
 if (have_central) {
 center_hint = centralWidgetRect.size();
 if (!center_hint.isValid())
 center_hint = centralWidgetItem->sizeHint();
 center_min = centralWidgetItem->minimumSize();
 center_rect.setRight(rect.right() - docks[QInternal::RightDock].rect.width() - sep);
 if (!docks[QInternal::BottomDock].isEmpty())
 center_rect.setBottom(rect.bottom() - docks[QInternal::BottomDock].rect.height() - sep);
 QSize left_hint = docks[QInternal::LeftDock].size();
-if (left_hint.isNull())
+if (left_hint.isNull() || fallbackToSizeHints)
 left_hint = docks[QInternal::LeftDock].sizeHint();
 QSize left_min = docks[QInternal::LeftDock].minimumSize();
 QSize left_max = docks[QInternal::LeftDock].maximumSize();
 left_hint = left_hint.boundedTo(left_max).expandedTo(left_min);
 QSize right_hint = docks[QInternal::RightDock].size();
-if (right_hint.isNull())
+if (right_hint.isNull() || fallbackToSizeHints)
 right_hint = docks[QInternal::RightDock].sizeHint();
 QSize right_min = docks[QInternal::RightDock].minimumSize();
 QSize right_max = docks[QInternal::RightDock].maximumSize();
 right_hint = right_hint.boundedTo(right_max).expandedTo(right_min);
 QSize top_hint = docks[QInternal::TopDock].size();
-if (top_hint.isNull())
+if (top_hint.isNull() || fallbackToSizeHints)
 top_hint = docks[QInternal::TopDock].sizeHint();
 QSize top_min = docks[QInternal::TopDock].minimumSize();
 QSize top_max = docks[QInternal::TopDock].maximumSize();
 top_hint = top_hint.boundedTo(top_max).expandedTo(top_min);
 QSize bottom_hint = docks[QInternal::BottomDock].size();
-if (bottom_hint.isNull())
+if (bottom_hint.isNull() || fallbackToSizeHints)
 bottom_hint = docks[QInternal::BottomDock].sizeHint();
 QSize bottom_min = docks[QInternal::BottomDock].minimumSize();
 QSize bottom_max = docks[QInternal::BottomDock].maximumSize();
 bottom_hint = bottom_hint.boundedTo(bottom_max).expandedTo(bottom_min);
+fallbackToSizeHints = !have_central;
 if (_ver_struct_list != 0) {
 QVector<QLayoutStruct> &ver_struct_list = *_ver_struct_list;
 ver_struct_list.resize(3);
 docks[i].apply(animate);
 if (centralWidgetItem != 0 && !centralWidgetItem->isEmpty()) {
 widgetAnimator.animate(centralWidgetItem->widget(), centralWidgetRect,
 animate);
 }
+#ifndef QT_NO_TABBAR
 if (sep == 1)
 updateSeparatorWidgets();
+#endif //QT_NO_TABBAR
 }
 void QDockAreaLayout::paintSeparators(QPainter *p, QWidget *widget,
 const QRegion &clip,
 const QPoint &mouse) const
 apply(false);
 return delta;
 }
+#ifndef QT_NO_TABBAR
 // Sets the correct positions for the seperator widgets
 // Allocates new sepearator widgets with getSeparatorWidget
 void QDockAreaLayout::updateSeparatorWidgets() const
 {
 int j = 0;
 for (int i = j; i < separatorWidgets.size(); ++i)
 separatorWidgets.at(i)->hide();
 separatorWidgets.resize(j);
 }
+#endif //QT_NO_TABBAR
 QLayoutItem *QDockAreaLayout::itemAt(int *x, int index) const
 {
 Q_ASSERT(x != 0);
 const QDockAreaLayoutInfo &dock = docks[i];
 result += dock.usedTabBars();
 }
 return result;
 }
-#endif
 // Returns the set of all used separator widgets
 QSet<QWidget*> QDockAreaLayout::usedSeparatorWidgets() const
 {
 QSet<QWidget*> result;
 const QDockAreaLayoutInfo &dock = docks[i];
 result += dock.usedSeparatorWidgets();
 }
 return result;
 }
+#endif
 QRect QDockAreaLayout::gapRect(const QList<int> &path) const
 {
 const QDockAreaLayoutInfo *info = this->info(path);
 if (info == 0)

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7