1 | /**************************************************************************** |
2 | ** |
3 | ** Copyright (C) 2016 The Qt Company Ltd. |
4 | ** Copyright (C) 2015 Olivier Goffart <ogoffart@woboq.com> |
5 | ** Contact: https://www.qt.io/licensing/ |
6 | ** |
7 | ** This file is part of the QtWidgets module of the Qt Toolkit. |
8 | ** |
9 | ** $QT_BEGIN_LICENSE:LGPL$ |
10 | ** Commercial License Usage |
11 | ** Licensees holding valid commercial Qt licenses may use this file in |
12 | ** accordance with the commercial license agreement provided with the |
13 | ** Software or, alternatively, in accordance with the terms contained in |
14 | ** a written agreement between you and The Qt Company. For licensing terms |
15 | ** and conditions see https://www.qt.io/terms-conditions. For further |
16 | ** information use the contact form at https://www.qt.io/contact-us. |
17 | ** |
18 | ** GNU Lesser General Public License Usage |
19 | ** Alternatively, this file may be used under the terms of the GNU Lesser |
20 | ** General Public License version 3 as published by the Free Software |
21 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
22 | ** packaging of this file. Please review the following information to |
23 | ** ensure the GNU Lesser General Public License version 3 requirements |
24 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
25 | ** |
26 | ** GNU General Public License Usage |
27 | ** Alternatively, this file may be used under the terms of the GNU |
28 | ** General Public License version 2.0 or (at your option) the GNU General |
29 | ** Public license version 3 or any later version approved by the KDE Free |
30 | ** Qt Foundation. The licenses are as published by the Free Software |
31 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
32 | ** included in the packaging of this file. Please review the following |
33 | ** information to ensure the GNU General Public License requirements will |
34 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
35 | ** https://www.gnu.org/licenses/gpl-3.0.html. |
36 | ** |
37 | ** $QT_END_LICENSE$ |
38 | ** |
39 | ****************************************************************************/ |
40 | |
41 | #include "qmainwindowlayout_p.h" |
42 | |
43 | #if QT_CONFIG(dockwidget) |
44 | #include "qdockarealayout_p.h" |
45 | #include "qdockwidget.h" |
46 | #include "qdockwidget_p.h" |
47 | #endif |
48 | #if QT_CONFIG(toolbar) |
49 | #include "qtoolbar_p.h" |
50 | #include "qtoolbar.h" |
51 | #include "qtoolbarlayout_p.h" |
52 | #endif |
53 | #include "qmainwindow.h" |
54 | #include "qwidgetanimator_p.h" |
55 | #if QT_CONFIG(rubberband) |
56 | #include "qrubberband.h" |
57 | #endif |
58 | #if QT_CONFIG(tabbar) |
59 | #include "qtabbar_p.h" |
60 | #endif |
61 | |
62 | #include <qapplication.h> |
63 | #if QT_CONFIG(statusbar) |
64 | #include <qstatusbar.h> |
65 | #endif |
66 | #include <qstring.h> |
67 | #include <qstyle.h> |
68 | #include <qstylepainter.h> |
69 | #include <qvarlengtharray.h> |
70 | #include <qstack.h> |
71 | #include <qmap.h> |
72 | #include <qtimer.h> |
73 | #include <qpointer.h> |
74 | |
75 | #ifndef QT_NO_DEBUG_STREAM |
76 | # include <qdebug.h> |
77 | # include <qtextstream.h> |
78 | #endif |
79 | |
80 | #include <private/qmenu_p.h> |
81 | #include <private/qapplication_p.h> |
82 | #include <private/qlayoutengine_p.h> |
83 | #include <private/qwidgetresizehandler_p.h> |
84 | |
85 | QT_BEGIN_NAMESPACE |
86 | |
87 | extern QMainWindowLayout *qt_mainwindow_layout(const QMainWindow *window); |
88 | |
89 | /****************************************************************************** |
90 | ** debug |
91 | */ |
92 | |
93 | #if QT_CONFIG(dockwidget) && !defined(QT_NO_DEBUG_STREAM) |
94 | |
95 | static void dumpLayout(QTextStream &qout, const QDockAreaLayoutInfo &layout, QString indent); |
96 | |
97 | static void dumpLayout(QTextStream &qout, const QDockAreaLayoutItem &item, QString indent) |
98 | { |
99 | qout << indent << "QDockAreaLayoutItem: " |
100 | << "pos: " << item.pos << " size:" << item.size |
101 | << " gap:" << (item.flags & QDockAreaLayoutItem::GapItem) |
102 | << " keepSize:" << (item.flags & QDockAreaLayoutItem::KeepSize) << '\n'; |
103 | indent += QLatin1String(" " ); |
104 | if (item.widgetItem != nullptr) { |
105 | qout << indent << "widget: " |
106 | << item.widgetItem->widget()->metaObject()->className() |
107 | << " \"" << item.widgetItem->widget()->windowTitle() << "\"\n" ; |
108 | } else if (item.subinfo != nullptr) { |
109 | qout << indent << "subinfo:\n" ; |
110 | dumpLayout(qout, layout: *item.subinfo, indent: indent + QLatin1String(" " )); |
111 | } else if (item.placeHolderItem != nullptr) { |
112 | QRect r = item.placeHolderItem->topLevelRect; |
113 | qout << indent << "placeHolder: " |
114 | << "pos: " << item.pos << " size:" << item.size |
115 | << " gap:" << (item.flags & QDockAreaLayoutItem::GapItem) |
116 | << " keepSize:" << (item.flags & QDockAreaLayoutItem::KeepSize) |
117 | << " objectName:" << item.placeHolderItem->objectName |
118 | << " hidden:" << item.placeHolderItem->hidden |
119 | << " window:" << item.placeHolderItem->window |
120 | << " rect:" << r.x() << ',' << r.y() << ' ' |
121 | << r.width() << 'x' << r.height() << '\n'; |
122 | } |
123 | } |
124 | |
125 | static void dumpLayout(QTextStream &qout, const QDockAreaLayoutInfo &layout, QString indent) |
126 | { |
127 | const QSize minSize = layout.minimumSize(); |
128 | qout << indent << "QDockAreaLayoutInfo: " |
129 | << layout.rect.left() << ',' |
130 | << layout.rect.top() << ' ' |
131 | << layout.rect.width() << 'x' |
132 | << layout.rect.height() |
133 | << " min size: " << minSize.width() << ',' << minSize.height() |
134 | << " orient:" << layout.o |
135 | #if QT_CONFIG(tabbar) |
136 | << " tabbed:" << layout.tabbed |
137 | << " tbshape:" << layout.tabBarShape |
138 | #endif |
139 | << '\n'; |
140 | |
141 | indent += QLatin1String(" " ); |
142 | |
143 | for (int i = 0; i < layout.item_list.count(); ++i) { |
144 | qout << indent << "Item: " << i << '\n'; |
145 | dumpLayout(qout, item: layout.item_list.at(i), indent: indent + QLatin1String(" " )); |
146 | } |
147 | } |
148 | |
149 | static void dumpLayout(QTextStream &qout, const QDockAreaLayout &layout) |
150 | { |
151 | qout << "QDockAreaLayout: " |
152 | << layout.rect.left() << ',' |
153 | << layout.rect.top() << ' ' |
154 | << layout.rect.width() << 'x' |
155 | << layout.rect.height() << '\n'; |
156 | |
157 | qout << "TopDockArea:\n" ; |
158 | dumpLayout(qout, layout: layout.docks[QInternal::TopDock], indent: QLatin1String(" " )); |
159 | qout << "LeftDockArea:\n" ; |
160 | dumpLayout(qout, layout: layout.docks[QInternal::LeftDock], indent: QLatin1String(" " )); |
161 | qout << "RightDockArea:\n" ; |
162 | dumpLayout(qout, layout: layout.docks[QInternal::RightDock], indent: QLatin1String(" " )); |
163 | qout << "BottomDockArea:\n" ; |
164 | dumpLayout(qout, layout: layout.docks[QInternal::BottomDock], indent: QLatin1String(" " )); |
165 | } |
166 | |
167 | QDebug operator<<(QDebug debug, const QDockAreaLayout &layout) |
168 | { |
169 | QString s; |
170 | QTextStream str(&s); |
171 | dumpLayout(qout&: str, layout); |
172 | debug << s; |
173 | return debug; |
174 | } |
175 | |
176 | QDebug operator<<(QDebug debug, const QMainWindowLayout *layout) |
177 | { |
178 | debug << layout->layoutState.dockAreaLayout; |
179 | return debug; |
180 | } |
181 | |
182 | #endif // QT_CONFIG(dockwidget) && !defined(QT_NO_DEBUG) |
183 | |
184 | /****************************************************************************** |
185 | ** QDockWidgetGroupWindow |
186 | */ |
187 | // QDockWidgetGroupWindow is the floating window containing several QDockWidgets floating together. |
188 | // (QMainWindow::GroupedDragging feature) |
189 | // QDockWidgetGroupLayout is the layout of that window and use a QDockAreaLayoutInfo to layout |
190 | // the QDockWidgets inside it. |
191 | // If there is only one QDockWidgets, or all QDockWidgets are tabbed together, it is equivalent |
192 | // of a floating QDockWidget (the title of the QDockWidget is the title of the window). But if there |
193 | // are nested QDockWidget, an additional title bar is there. |
194 | #if QT_CONFIG(dockwidget) |
195 | class QDockWidgetGroupLayout : public QLayout, |
196 | public QMainWindowLayoutSeparatorHelper<QDockWidgetGroupLayout> |
197 | { |
198 | QWidgetResizeHandler *resizer; |
199 | public: |
200 | QDockWidgetGroupLayout(QDockWidgetGroupWindow* parent) : QLayout(parent) { |
201 | setSizeConstraint(QLayout::SetMinAndMaxSize); |
202 | resizer = new QWidgetResizeHandler(parent); |
203 | resizer->setMovingEnabled(false); |
204 | } |
205 | ~QDockWidgetGroupLayout() { |
206 | layoutState.deleteAllLayoutItems(); |
207 | } |
208 | |
209 | void addItem(QLayoutItem*) override { Q_UNREACHABLE(); } |
210 | int count() const override { return 0; } |
211 | QLayoutItem* itemAt(int index) const override |
212 | { |
213 | int x = 0; |
214 | return layoutState.itemAt(x: &x, index); |
215 | } |
216 | QLayoutItem* takeAt(int index) override |
217 | { |
218 | int x = 0; |
219 | QLayoutItem *ret = layoutState.takeAt(x: &x, index); |
220 | if (savedState.rect.isValid() && ret->widget()) { |
221 | // we need to remove the item also from the saved state to prevent crash |
222 | QList<int> path = savedState.indexOf(widget: ret->widget()); |
223 | if (!path.isEmpty()) |
224 | savedState.remove(path); |
225 | // Also, the item may be contained several times as a gap item. |
226 | path = layoutState.indexOf(widget: ret->widget()); |
227 | if (!path.isEmpty()) |
228 | layoutState.remove(path); |
229 | } |
230 | return ret; |
231 | } |
232 | QSize sizeHint() const override |
233 | { |
234 | int fw = frameWidth(); |
235 | return layoutState.sizeHint() + QSize(fw, fw); |
236 | } |
237 | QSize minimumSize() const override |
238 | { |
239 | int fw = frameWidth(); |
240 | return layoutState.minimumSize() + QSize(fw, fw); |
241 | } |
242 | QSize maximumSize() const override |
243 | { |
244 | int fw = frameWidth(); |
245 | return layoutState.maximumSize() + QSize(fw, fw); |
246 | } |
247 | void setGeometry(const QRect&r) override |
248 | { |
249 | groupWindow()->destroyOrHideIfEmpty(); |
250 | QDockAreaLayoutInfo *li = dockAreaLayoutInfo(); |
251 | if (li->isEmpty()) |
252 | return; |
253 | int fw = frameWidth(); |
254 | #if QT_CONFIG(tabbar) |
255 | li->reparentWidgets(p: parentWidget()); |
256 | #endif |
257 | li->rect = r.adjusted(xp1: fw, yp1: fw, xp2: -fw, yp2: -fw); |
258 | li->fitItems(); |
259 | li->apply(animate: false); |
260 | if (savedState.rect.isValid()) |
261 | savedState.rect = li->rect; |
262 | resizer->setActive(ac: QWidgetResizeHandler::Resize, b: !nativeWindowDeco()); |
263 | } |
264 | |
265 | QDockAreaLayoutInfo *dockAreaLayoutInfo() { return &layoutState; } |
266 | |
267 | bool nativeWindowDeco() const |
268 | { |
269 | return groupWindow()->hasNativeDecos(); |
270 | } |
271 | |
272 | int frameWidth() const |
273 | { |
274 | return nativeWindowDeco() ? 0 : |
275 | parentWidget()->style()->pixelMetric(metric: QStyle::PM_DockWidgetFrameWidth, option: nullptr, widget: parentWidget()); |
276 | } |
277 | |
278 | QDockWidgetGroupWindow *groupWindow() const |
279 | { |
280 | return static_cast<QDockWidgetGroupWindow *>(parent()); |
281 | } |
282 | |
283 | QDockAreaLayoutInfo layoutState; |
284 | QDockAreaLayoutInfo savedState; |
285 | }; |
286 | |
287 | bool QDockWidgetGroupWindow::event(QEvent *e) |
288 | { |
289 | auto lay = static_cast<QDockWidgetGroupLayout *>(layout()); |
290 | if (lay && lay->windowEvent(e)) |
291 | return true; |
292 | |
293 | switch (e->type()) { |
294 | case QEvent::Close: |
295 | #if QT_CONFIG(tabbar) |
296 | // Forward the close to the QDockWidget just as if its close button was pressed |
297 | if (QDockWidget *dw = activeTabbedDockWidget()) { |
298 | e->ignore(); |
299 | dw->close(); |
300 | adjustFlags(); |
301 | } |
302 | #endif |
303 | return true; |
304 | case QEvent::Move: |
305 | #if QT_CONFIG(tabbar) |
306 | // Let QDockWidgetPrivate::moseEvent handle the dragging |
307 | if (QDockWidget *dw = activeTabbedDockWidget()) |
308 | static_cast<QDockWidgetPrivate *>(QObjectPrivate::get(o: dw))->moveEvent(event: static_cast<QMoveEvent*>(e)); |
309 | #endif |
310 | return true; |
311 | case QEvent::NonClientAreaMouseMove: |
312 | case QEvent::NonClientAreaMouseButtonPress: |
313 | case QEvent::NonClientAreaMouseButtonRelease: |
314 | case QEvent::NonClientAreaMouseButtonDblClick: |
315 | #if QT_CONFIG(tabbar) |
316 | // Let the QDockWidgetPrivate of the currently visible dock widget handle the drag and drop |
317 | if (QDockWidget *dw = activeTabbedDockWidget()) |
318 | static_cast<QDockWidgetPrivate *>(QObjectPrivate::get(o: dw))->nonClientAreaMouseEvent(event: static_cast<QMouseEvent*>(e)); |
319 | #endif |
320 | return true; |
321 | case QEvent::ChildAdded: |
322 | if (qobject_cast<QDockWidget *>(object: static_cast<QChildEvent*>(e)->child())) |
323 | adjustFlags(); |
324 | break; |
325 | case QEvent::LayoutRequest: |
326 | // We might need to show the widget again |
327 | destroyOrHideIfEmpty(); |
328 | break; |
329 | case QEvent::Resize: |
330 | updateCurrentGapRect(); |
331 | emit resized(); |
332 | default: |
333 | break; |
334 | } |
335 | return QWidget::event(event: e); |
336 | } |
337 | |
338 | void QDockWidgetGroupWindow::paintEvent(QPaintEvent *) |
339 | { |
340 | QDockWidgetGroupLayout *lay = static_cast<QDockWidgetGroupLayout *>(layout()); |
341 | bool nativeDeco = lay->nativeWindowDeco(); |
342 | |
343 | if (!nativeDeco) { |
344 | QStyleOptionFrame framOpt; |
345 | framOpt.init(w: this); |
346 | QStylePainter p(this); |
347 | p.drawPrimitive(pe: QStyle::PE_FrameDockWidget, opt: framOpt); |
348 | } |
349 | } |
350 | |
351 | QDockAreaLayoutInfo *QDockWidgetGroupWindow::layoutInfo() const |
352 | { |
353 | return static_cast<QDockWidgetGroupLayout *>(layout())->dockAreaLayoutInfo(); |
354 | } |
355 | |
356 | #if QT_CONFIG(tabbar) |
357 | /*! \internal |
358 | If this is a floating tab bar returns the currently the QDockWidgetGroupWindow that contains |
359 | tab, otherwise, return nullptr; |
360 | \note: if there is only one QDockWidget, it's still considered as a floating tab |
361 | */ |
362 | const QDockAreaLayoutInfo *QDockWidgetGroupWindow::tabLayoutInfo() const |
363 | { |
364 | const QDockAreaLayoutInfo *info = layoutInfo(); |
365 | while (info && !info->tabbed) { |
366 | // There should be only one tabbed subinfo otherwise we are not a floating tab but a real |
367 | // window |
368 | const QDockAreaLayoutInfo *next = nullptr; |
369 | bool isSingle = false; |
370 | for (const auto &item : info->item_list) { |
371 | if (item.skip() || (item.flags & QDockAreaLayoutItem::GapItem)) |
372 | continue; |
373 | if (next || isSingle) // Two visible things |
374 | return nullptr; |
375 | if (item.subinfo) |
376 | next = item.subinfo; |
377 | else if (item.widgetItem) |
378 | isSingle = true; |
379 | } |
380 | if (isSingle) |
381 | return info; |
382 | info = next; |
383 | } |
384 | return info; |
385 | } |
386 | |
387 | /*! \internal |
388 | If this is a floating tab bar returns the currently active QDockWidget, otherwise nullptr |
389 | */ |
390 | QDockWidget *QDockWidgetGroupWindow::activeTabbedDockWidget() const |
391 | { |
392 | QDockWidget *dw = nullptr; |
393 | const QDockAreaLayoutInfo *info = tabLayoutInfo(); |
394 | if (!info) |
395 | return nullptr; |
396 | if (info->tabBar && info->tabBar->currentIndex() >= 0) { |
397 | int i = info->tabIndexToListIndex(info->tabBar->currentIndex()); |
398 | if (i >= 0) { |
399 | const QDockAreaLayoutItem &item = info->item_list.at(i); |
400 | if (item.widgetItem) |
401 | dw = qobject_cast<QDockWidget *>(object: item.widgetItem->widget()); |
402 | } |
403 | } |
404 | if (!dw) { |
405 | for (int i = 0; !dw && i < info->item_list.count(); ++i) { |
406 | const QDockAreaLayoutItem &item = info->item_list.at(i); |
407 | if (item.skip()) |
408 | continue; |
409 | if (!item.widgetItem) |
410 | continue; |
411 | dw = qobject_cast<QDockWidget *>(object: item.widgetItem->widget()); |
412 | } |
413 | } |
414 | return dw; |
415 | } |
416 | #endif // QT_CONFIG(tabbar) |
417 | |
418 | /*! \internal |
419 | Destroy or hide this window if there is no more QDockWidget in it. |
420 | Otherwise make sure it is shown. |
421 | */ |
422 | void QDockWidgetGroupWindow::destroyOrHideIfEmpty() |
423 | { |
424 | if (!layoutInfo()->isEmpty()) { |
425 | show(); // It might have been hidden, |
426 | return; |
427 | } |
428 | // There might still be placeholders |
429 | if (!layoutInfo()->item_list.isEmpty()) { |
430 | hide(); |
431 | return; |
432 | } |
433 | |
434 | // Make sure to reparent the possibly floating or hidden QDockWidgets to the parent |
435 | const auto dockWidgets = findChildren<QDockWidget *>(aName: QString(), options: Qt::FindDirectChildrenOnly); |
436 | for (QDockWidget *dw : dockWidgets) { |
437 | bool wasFloating = dw->isFloating(); |
438 | bool wasHidden = dw->isHidden(); |
439 | dw->setParent(parentWidget()); |
440 | if (wasFloating) { |
441 | dw->setFloating(true); |
442 | } else { |
443 | // maybe it was hidden, we still have to put it back in the main layout. |
444 | QMainWindowLayout *ml = |
445 | qt_mainwindow_layout(window: static_cast<QMainWindow *>(parentWidget())); |
446 | Qt::DockWidgetArea area = ml->dockWidgetArea(widget: this); |
447 | if (area == Qt::NoDockWidgetArea) |
448 | area = Qt::LeftDockWidgetArea; |
449 | static_cast<QMainWindow *>(parentWidget())->addDockWidget(area, dockwidget: dw); |
450 | } |
451 | if (!wasHidden) |
452 | dw->show(); |
453 | } |
454 | #if QT_CONFIG(tabbar) |
455 | const auto tabBars = findChildren<QTabBar *>(aName: QString(), options: Qt::FindDirectChildrenOnly); |
456 | for (QTabBar *tb : tabBars) |
457 | tb->setParent(parentWidget()); |
458 | #endif |
459 | deleteLater(); |
460 | } |
461 | |
462 | /*! \internal |
463 | Sets the flags of this window in accordance to the capabilities of the dock widgets |
464 | */ |
465 | void QDockWidgetGroupWindow::adjustFlags() |
466 | { |
467 | Qt::WindowFlags oldFlags = windowFlags(); |
468 | Qt::WindowFlags flags = oldFlags; |
469 | |
470 | #if QT_CONFIG(tabbar) |
471 | QDockWidget *top = activeTabbedDockWidget(); |
472 | #else |
473 | QDockWidget *top = nullptr; |
474 | #endif |
475 | if (!top) { // nested tabs, show window decoration |
476 | flags = |
477 | ((oldFlags & ~Qt::FramelessWindowHint) | Qt::CustomizeWindowHint | Qt::WindowTitleHint); |
478 | } else if (static_cast<QDockWidgetGroupLayout *>(layout())->nativeWindowDeco()) { |
479 | flags |= Qt::CustomizeWindowHint | Qt::WindowTitleHint; |
480 | flags.setFlag(flag: Qt::WindowCloseButtonHint, on: top->features() & QDockWidget::DockWidgetClosable); |
481 | flags &= ~Qt::FramelessWindowHint; |
482 | } else { |
483 | flags &= ~(Qt::WindowCloseButtonHint | Qt::CustomizeWindowHint | Qt::WindowTitleHint); |
484 | flags |= Qt::FramelessWindowHint; |
485 | } |
486 | |
487 | if (oldFlags != flags) { |
488 | if (!windowHandle()) |
489 | create(); // The desired geometry is forgotten if we call setWindowFlags before having a window |
490 | setWindowFlags(flags); |
491 | const bool gainedNativeDecos = (oldFlags & Qt::FramelessWindowHint) && !(flags & Qt::FramelessWindowHint); |
492 | const bool lostNativeDecos = !(oldFlags & Qt::FramelessWindowHint) && (flags & Qt::FramelessWindowHint); |
493 | |
494 | // Adjust the geometry after gaining/losing decos, so that the client area appears always |
495 | // at the same place when tabbing |
496 | if (lostNativeDecos) { |
497 | QRect newGeometry = geometry(); |
498 | newGeometry.setTop(frameGeometry().top()); |
499 | const int bottomFrame = geometry().top() - frameGeometry().top(); |
500 | m_removedFrameSize = QSize((frameSize() - size()).width(), bottomFrame); |
501 | setGeometry(newGeometry); |
502 | } else if (gainedNativeDecos && m_removedFrameSize.isValid()) { |
503 | QRect r = geometry(); |
504 | r.adjust(dx1: -m_removedFrameSize.width() / 2, dy1: 0, |
505 | dx2: -m_removedFrameSize.width() / 2, dy2: -m_removedFrameSize.height()); |
506 | setGeometry(r); |
507 | m_removedFrameSize = QSize(); |
508 | } |
509 | |
510 | show(); // setWindowFlags hides the window |
511 | } |
512 | |
513 | QWidget *titleBarOf = top ? top : parentWidget(); |
514 | setWindowTitle(titleBarOf->windowTitle()); |
515 | setWindowIcon(titleBarOf->windowIcon()); |
516 | } |
517 | |
518 | bool QDockWidgetGroupWindow::hasNativeDecos() const |
519 | { |
520 | #if QT_CONFIG(tabbar) |
521 | QDockWidget *dw = activeTabbedDockWidget(); |
522 | if (!dw) // We have a group of nested QDockWidgets (not just floating tabs) |
523 | return true; |
524 | |
525 | if (!QDockWidgetLayout::wmSupportsNativeWindowDeco()) |
526 | return false; |
527 | |
528 | return dw->titleBarWidget() == nullptr; |
529 | #else |
530 | return true; |
531 | #endif |
532 | } |
533 | |
534 | /* |
535 | The given widget is hovered over this floating group. |
536 | This function will save the state and create a gap in the actual state. |
537 | currentGapRect and currentGapPos will be set. |
538 | One must call restore() or apply() after this function. |
539 | Returns true if there was any change in the currentGapPos |
540 | */ |
541 | bool QDockWidgetGroupWindow::hover(QLayoutItem *widgetItem, const QPoint &mousePos) |
542 | { |
543 | QDockAreaLayoutInfo &savedState = static_cast<QDockWidgetGroupLayout *>(layout())->savedState; |
544 | if (savedState.isEmpty()) |
545 | savedState = *layoutInfo(); |
546 | |
547 | QMainWindow::DockOptions opts = static_cast<QMainWindow *>(parentWidget())->dockOptions(); |
548 | QDockAreaLayoutInfo newState = savedState; |
549 | bool nestingEnabled = |
550 | (opts & QMainWindow::AllowNestedDocks) && !(opts & QMainWindow::ForceTabbedDocks); |
551 | QDockAreaLayoutInfo::TabMode tabMode = |
552 | #if !QT_CONFIG(tabbar) |
553 | QDockAreaLayoutInfo::NoTabs; |
554 | #else |
555 | nestingEnabled ? QDockAreaLayoutInfo::AllowTabs : QDockAreaLayoutInfo::ForceTabs; |
556 | if (auto group = qobject_cast<QDockWidgetGroupWindow *>(object: widgetItem->widget())) { |
557 | if (!group->tabLayoutInfo()) |
558 | tabMode = QDockAreaLayoutInfo::NoTabs; |
559 | } |
560 | if (newState.tabbed) { |
561 | // insertion into a top-level tab |
562 | newState.item_list = { QDockAreaLayoutItem(new QDockAreaLayoutInfo(newState)) }; |
563 | newState.item_list.first().size = pick(o: savedState.o, size: savedState.rect.size()); |
564 | newState.tabbed = false; |
565 | newState.tabBar = nullptr; |
566 | } |
567 | #endif |
568 | |
569 | auto newGapPos = newState.gapIndex(pos: mousePos, nestingEnabled, tabMode); |
570 | Q_ASSERT(!newGapPos.isEmpty()); |
571 | if (newGapPos == currentGapPos) |
572 | return false; // gap is already there |
573 | currentGapPos = newGapPos; |
574 | newState.insertGap(path: currentGapPos, dockWidgetItem: widgetItem); |
575 | newState.fitItems(); |
576 | *layoutInfo() = std::move(newState); |
577 | updateCurrentGapRect(); |
578 | layoutInfo()->apply(animate: opts & QMainWindow::AnimatedDocks); |
579 | return true; |
580 | } |
581 | |
582 | void QDockWidgetGroupWindow::updateCurrentGapRect() |
583 | { |
584 | if (!currentGapPos.isEmpty()) |
585 | currentGapRect = layoutInfo()->info(path: currentGapPos)->itemRect(index: currentGapPos.last(), isGap: true); |
586 | } |
587 | |
588 | /* |
589 | Remove the gap that was created by hover() |
590 | */ |
591 | void QDockWidgetGroupWindow::restore() |
592 | { |
593 | QDockAreaLayoutInfo &savedState = static_cast<QDockWidgetGroupLayout *>(layout())->savedState; |
594 | if (!savedState.isEmpty()) { |
595 | *layoutInfo() = savedState; |
596 | savedState = QDockAreaLayoutInfo(); |
597 | } |
598 | currentGapRect = QRect(); |
599 | currentGapPos.clear(); |
600 | adjustFlags(); |
601 | layoutInfo()->fitItems(); |
602 | layoutInfo()->apply(animate: static_cast<QMainWindow *>(parentWidget())->dockOptions() |
603 | & QMainWindow::AnimatedDocks); |
604 | } |
605 | |
606 | /* |
607 | Apply the state that was created by hover |
608 | */ |
609 | void QDockWidgetGroupWindow::apply() |
610 | { |
611 | static_cast<QDockWidgetGroupLayout *>(layout())->savedState.clear(); |
612 | currentGapRect = QRect(); |
613 | layoutInfo()->plug(path: currentGapPos); |
614 | currentGapPos.clear(); |
615 | adjustFlags(); |
616 | layoutInfo()->apply(animate: false); |
617 | } |
618 | |
619 | #endif |
620 | |
621 | /****************************************************************************** |
622 | ** QMainWindowLayoutState |
623 | */ |
624 | |
625 | // we deal with all the #ifndefferry here so QMainWindowLayout code is clean |
626 | |
627 | QMainWindowLayoutState::QMainWindowLayoutState(QMainWindow *win) |
628 | : |
629 | #if QT_CONFIG(toolbar) |
630 | toolBarAreaLayout(win), |
631 | #endif |
632 | #if QT_CONFIG(dockwidget) |
633 | dockAreaLayout(win) |
634 | #else |
635 | centralWidgetItem(0) |
636 | #endif |
637 | |
638 | { |
639 | mainWindow = win; |
640 | } |
641 | |
642 | QSize QMainWindowLayoutState::sizeHint() const |
643 | { |
644 | |
645 | QSize result(0, 0); |
646 | |
647 | #if QT_CONFIG(dockwidget) |
648 | result = dockAreaLayout.sizeHint(); |
649 | #else |
650 | if (centralWidgetItem != 0) |
651 | result = centralWidgetItem->sizeHint(); |
652 | #endif |
653 | |
654 | #if QT_CONFIG(toolbar) |
655 | result = toolBarAreaLayout.sizeHint(center: result); |
656 | #endif // QT_CONFIG(toolbar) |
657 | |
658 | return result; |
659 | } |
660 | |
661 | QSize QMainWindowLayoutState::minimumSize() const |
662 | { |
663 | QSize result(0, 0); |
664 | |
665 | #if QT_CONFIG(dockwidget) |
666 | result = dockAreaLayout.minimumSize(); |
667 | #else |
668 | if (centralWidgetItem != 0) |
669 | result = centralWidgetItem->minimumSize(); |
670 | #endif |
671 | |
672 | #if QT_CONFIG(toolbar) |
673 | result = toolBarAreaLayout.minimumSize(centerMin: result); |
674 | #endif // QT_CONFIG(toolbar) |
675 | |
676 | return result; |
677 | } |
678 | |
679 | void QMainWindowLayoutState::apply(bool animated) |
680 | { |
681 | #if QT_CONFIG(toolbar) |
682 | toolBarAreaLayout.apply(animate: animated); |
683 | #endif |
684 | |
685 | #if QT_CONFIG(dockwidget) |
686 | // dumpLayout(dockAreaLayout, QString()); |
687 | dockAreaLayout.apply(animate: animated); |
688 | #else |
689 | if (centralWidgetItem != 0) { |
690 | QMainWindowLayout *layout = qt_mainwindow_layout(mainWindow); |
691 | Q_ASSERT(layout != 0); |
692 | layout->widgetAnimator.animate(centralWidgetItem->widget(), centralWidgetRect, animated); |
693 | } |
694 | #endif |
695 | } |
696 | |
697 | void QMainWindowLayoutState::fitLayout() |
698 | { |
699 | QRect r; |
700 | #if !QT_CONFIG(toolbar) |
701 | r = rect; |
702 | #else |
703 | toolBarAreaLayout.rect = rect; |
704 | r = toolBarAreaLayout.fitLayout(); |
705 | #endif // QT_CONFIG(toolbar) |
706 | |
707 | #if QT_CONFIG(dockwidget) |
708 | dockAreaLayout.rect = r; |
709 | dockAreaLayout.fitLayout(); |
710 | #else |
711 | centralWidgetRect = r; |
712 | #endif |
713 | } |
714 | |
715 | void QMainWindowLayoutState::deleteAllLayoutItems() |
716 | { |
717 | #if QT_CONFIG(toolbar) |
718 | toolBarAreaLayout.deleteAllLayoutItems(); |
719 | #endif |
720 | |
721 | #if QT_CONFIG(dockwidget) |
722 | dockAreaLayout.deleteAllLayoutItems(); |
723 | #endif |
724 | } |
725 | |
726 | void QMainWindowLayoutState::deleteCentralWidgetItem() |
727 | { |
728 | #if QT_CONFIG(dockwidget) |
729 | delete dockAreaLayout.centralWidgetItem; |
730 | dockAreaLayout.centralWidgetItem = nullptr; |
731 | #else |
732 | delete centralWidgetItem; |
733 | centralWidgetItem = 0; |
734 | #endif |
735 | } |
736 | |
737 | QLayoutItem *QMainWindowLayoutState::itemAt(int index, int *x) const |
738 | { |
739 | #if QT_CONFIG(toolbar) |
740 | if (QLayoutItem *ret = toolBarAreaLayout.itemAt(x, index)) |
741 | return ret; |
742 | #endif |
743 | |
744 | #if QT_CONFIG(dockwidget) |
745 | if (QLayoutItem *ret = dockAreaLayout.itemAt(x, index)) |
746 | return ret; |
747 | #else |
748 | if (centralWidgetItem != 0 && (*x)++ == index) |
749 | return centralWidgetItem; |
750 | #endif |
751 | |
752 | return nullptr; |
753 | } |
754 | |
755 | QLayoutItem *QMainWindowLayoutState::takeAt(int index, int *x) |
756 | { |
757 | #if QT_CONFIG(toolbar) |
758 | if (QLayoutItem *ret = toolBarAreaLayout.takeAt(x, index)) |
759 | return ret; |
760 | #endif |
761 | |
762 | #if QT_CONFIG(dockwidget) |
763 | if (QLayoutItem *ret = dockAreaLayout.takeAt(x, index)) |
764 | return ret; |
765 | #else |
766 | if (centralWidgetItem != 0 && (*x)++ == index) { |
767 | QLayoutItem *ret = centralWidgetItem; |
768 | centralWidgetItem = 0; |
769 | return ret; |
770 | } |
771 | #endif |
772 | |
773 | return nullptr; |
774 | } |
775 | |
776 | QList<int> QMainWindowLayoutState::indexOf(QWidget *widget) const |
777 | { |
778 | QList<int> result; |
779 | |
780 | #if QT_CONFIG(toolbar) |
781 | // is it a toolbar? |
782 | if (QToolBar *toolBar = qobject_cast<QToolBar*>(object: widget)) { |
783 | result = toolBarAreaLayout.indexOf(toolBar); |
784 | if (!result.isEmpty()) |
785 | result.prepend(t: 0); |
786 | return result; |
787 | } |
788 | #endif |
789 | |
790 | #if QT_CONFIG(dockwidget) |
791 | // is it a dock widget? |
792 | if (qobject_cast<QDockWidget *>(object: widget) || qobject_cast<QDockWidgetGroupWindow *>(object: widget)) { |
793 | result = dockAreaLayout.indexOf(dockWidget: widget); |
794 | if (!result.isEmpty()) |
795 | result.prepend(t: 1); |
796 | return result; |
797 | } |
798 | #endif // QT_CONFIG(dockwidget) |
799 | |
800 | return result; |
801 | } |
802 | |
803 | bool QMainWindowLayoutState::contains(QWidget *widget) const |
804 | { |
805 | #if QT_CONFIG(dockwidget) |
806 | if (dockAreaLayout.centralWidgetItem != nullptr && dockAreaLayout.centralWidgetItem->widget() == widget) |
807 | return true; |
808 | if (!dockAreaLayout.indexOf(dockWidget: widget).isEmpty()) |
809 | return true; |
810 | #else |
811 | if (centralWidgetItem != 0 && centralWidgetItem->widget() == widget) |
812 | return true; |
813 | #endif |
814 | |
815 | #if QT_CONFIG(toolbar) |
816 | if (!toolBarAreaLayout.indexOf(toolBar: widget).isEmpty()) |
817 | return true; |
818 | #endif |
819 | return false; |
820 | } |
821 | |
822 | void QMainWindowLayoutState::setCentralWidget(QWidget *widget) |
823 | { |
824 | QLayoutItem *item = nullptr; |
825 | //make sure we remove the widget |
826 | deleteCentralWidgetItem(); |
827 | |
828 | if (widget != nullptr) |
829 | item = new QWidgetItemV2(widget); |
830 | |
831 | #if QT_CONFIG(dockwidget) |
832 | dockAreaLayout.centralWidgetItem = item; |
833 | #else |
834 | centralWidgetItem = item; |
835 | #endif |
836 | } |
837 | |
838 | QWidget *QMainWindowLayoutState::centralWidget() const |
839 | { |
840 | QLayoutItem *item = nullptr; |
841 | |
842 | #if QT_CONFIG(dockwidget) |
843 | item = dockAreaLayout.centralWidgetItem; |
844 | #else |
845 | item = centralWidgetItem; |
846 | #endif |
847 | |
848 | if (item != nullptr) |
849 | return item->widget(); |
850 | return nullptr; |
851 | } |
852 | |
853 | QList<int> QMainWindowLayoutState::gapIndex(QWidget *widget, |
854 | const QPoint &pos) const |
855 | { |
856 | QList<int> result; |
857 | |
858 | #if QT_CONFIG(toolbar) |
859 | // is it a toolbar? |
860 | if (qobject_cast<QToolBar*>(object: widget) != 0) { |
861 | result = toolBarAreaLayout.gapIndex(pos); |
862 | if (!result.isEmpty()) |
863 | result.prepend(t: 0); |
864 | return result; |
865 | } |
866 | #endif |
867 | |
868 | #if QT_CONFIG(dockwidget) |
869 | // is it a dock widget? |
870 | if (qobject_cast<QDockWidget *>(object: widget) != 0 |
871 | || qobject_cast<QDockWidgetGroupWindow *>(object: widget)) { |
872 | bool disallowTabs = false; |
873 | #if QT_CONFIG(tabbar) |
874 | if (auto *group = qobject_cast<QDockWidgetGroupWindow *>(object: widget)) { |
875 | if (!group->tabLayoutInfo()) // Disallow to drop nested docks as a tab |
876 | disallowTabs = true; |
877 | } |
878 | #endif |
879 | result = dockAreaLayout.gapIndex(pos, disallowTabs); |
880 | if (!result.isEmpty()) |
881 | result.prepend(t: 1); |
882 | return result; |
883 | } |
884 | #endif // QT_CONFIG(dockwidget) |
885 | |
886 | return result; |
887 | } |
888 | |
889 | bool QMainWindowLayoutState::insertGap(const QList<int> &path, QLayoutItem *item) |
890 | { |
891 | if (path.isEmpty()) |
892 | return false; |
893 | |
894 | int i = path.first(); |
895 | |
896 | #if QT_CONFIG(toolbar) |
897 | if (i == 0) { |
898 | Q_ASSERT(qobject_cast<QToolBar*>(item->widget()) != 0); |
899 | return toolBarAreaLayout.insertGap(path: path.mid(pos: 1), item); |
900 | } |
901 | #endif |
902 | |
903 | #if QT_CONFIG(dockwidget) |
904 | if (i == 1) { |
905 | Q_ASSERT(qobject_cast<QDockWidget*>(item->widget()) || qobject_cast<QDockWidgetGroupWindow*>(item->widget())); |
906 | return dockAreaLayout.insertGap(path: path.mid(pos: 1), dockWidgetItem: item); |
907 | } |
908 | #endif // QT_CONFIG(dockwidget) |
909 | |
910 | return false; |
911 | } |
912 | |
913 | void QMainWindowLayoutState::remove(const QList<int> &path) |
914 | { |
915 | int i = path.first(); |
916 | |
917 | #if QT_CONFIG(toolbar) |
918 | if (i == 0) |
919 | toolBarAreaLayout.remove(path: path.mid(pos: 1)); |
920 | #endif |
921 | |
922 | #if QT_CONFIG(dockwidget) |
923 | if (i == 1) |
924 | dockAreaLayout.remove(path: path.mid(pos: 1)); |
925 | #endif // QT_CONFIG(dockwidget) |
926 | } |
927 | |
928 | void QMainWindowLayoutState::remove(QLayoutItem *item) |
929 | { |
930 | #if QT_CONFIG(toolbar) |
931 | toolBarAreaLayout.remove(item); |
932 | #endif |
933 | |
934 | #if QT_CONFIG(dockwidget) |
935 | // is it a dock widget? |
936 | if (QDockWidget *dockWidget = qobject_cast<QDockWidget *>(object: item->widget())) { |
937 | QList<int> path = dockAreaLayout.indexOf(dockWidget); |
938 | if (!path.isEmpty()) |
939 | dockAreaLayout.remove(path); |
940 | } |
941 | #endif // QT_CONFIG(dockwidget) |
942 | } |
943 | |
944 | void QMainWindowLayoutState::clear() |
945 | { |
946 | #if QT_CONFIG(toolbar) |
947 | toolBarAreaLayout.clear(); |
948 | #endif |
949 | |
950 | #if QT_CONFIG(dockwidget) |
951 | dockAreaLayout.clear(); |
952 | #else |
953 | centralWidgetRect = QRect(); |
954 | #endif |
955 | |
956 | rect = QRect(); |
957 | } |
958 | |
959 | bool QMainWindowLayoutState::isValid() const |
960 | { |
961 | return rect.isValid(); |
962 | } |
963 | |
964 | QLayoutItem *QMainWindowLayoutState::item(const QList<int> &path) |
965 | { |
966 | int i = path.first(); |
967 | |
968 | #if QT_CONFIG(toolbar) |
969 | if (i == 0) { |
970 | const QToolBarAreaLayoutItem *tbItem = toolBarAreaLayout.item(path: path.mid(pos: 1)); |
971 | Q_ASSERT(tbItem); |
972 | return tbItem->widgetItem; |
973 | } |
974 | #endif |
975 | |
976 | #if QT_CONFIG(dockwidget) |
977 | if (i == 1) |
978 | return dockAreaLayout.item(path: path.mid(pos: 1)).widgetItem; |
979 | #endif // QT_CONFIG(dockwidget) |
980 | |
981 | return nullptr; |
982 | } |
983 | |
984 | QRect QMainWindowLayoutState::itemRect(const QList<int> &path) const |
985 | { |
986 | int i = path.first(); |
987 | |
988 | #if QT_CONFIG(toolbar) |
989 | if (i == 0) |
990 | return toolBarAreaLayout.itemRect(path: path.mid(pos: 1)); |
991 | #endif |
992 | |
993 | #if QT_CONFIG(dockwidget) |
994 | if (i == 1) |
995 | return dockAreaLayout.itemRect(path: path.mid(pos: 1)); |
996 | #endif // QT_CONFIG(dockwidget) |
997 | |
998 | return QRect(); |
999 | } |
1000 | |
1001 | QRect QMainWindowLayoutState::gapRect(const QList<int> &path) const |
1002 | { |
1003 | int i = path.first(); |
1004 | |
1005 | #if QT_CONFIG(toolbar) |
1006 | if (i == 0) |
1007 | return toolBarAreaLayout.itemRect(path: path.mid(pos: 1)); |
1008 | #endif |
1009 | |
1010 | #if QT_CONFIG(dockwidget) |
1011 | if (i == 1) |
1012 | return dockAreaLayout.gapRect(path: path.mid(pos: 1)); |
1013 | #endif // QT_CONFIG(dockwidget) |
1014 | |
1015 | return QRect(); |
1016 | } |
1017 | |
1018 | QLayoutItem *QMainWindowLayoutState::plug(const QList<int> &path) |
1019 | { |
1020 | int i = path.first(); |
1021 | |
1022 | #if QT_CONFIG(toolbar) |
1023 | if (i == 0) |
1024 | return toolBarAreaLayout.plug(path: path.mid(pos: 1)); |
1025 | #endif |
1026 | |
1027 | #if QT_CONFIG(dockwidget) |
1028 | if (i == 1) |
1029 | return dockAreaLayout.plug(path: path.mid(pos: 1)); |
1030 | #endif // QT_CONFIG(dockwidget) |
1031 | |
1032 | return nullptr; |
1033 | } |
1034 | |
1035 | QLayoutItem *QMainWindowLayoutState::unplug(const QList<int> &path, QMainWindowLayoutState *other) |
1036 | { |
1037 | int i = path.first(); |
1038 | |
1039 | #if !QT_CONFIG(toolbar) |
1040 | Q_UNUSED(other); |
1041 | #else |
1042 | if (i == 0) |
1043 | return toolBarAreaLayout.unplug(path: path.mid(pos: 1), other: other ? &other->toolBarAreaLayout : nullptr); |
1044 | #endif |
1045 | |
1046 | #if QT_CONFIG(dockwidget) |
1047 | if (i == 1) |
1048 | return dockAreaLayout.unplug(path: path.mid(pos: 1)); |
1049 | #endif // QT_CONFIG(dockwidget) |
1050 | |
1051 | return nullptr; |
1052 | } |
1053 | |
1054 | void QMainWindowLayoutState::saveState(QDataStream &stream) const |
1055 | { |
1056 | #if QT_CONFIG(dockwidget) |
1057 | dockAreaLayout.saveState(stream); |
1058 | #if QT_CONFIG(tabbar) |
1059 | const QList<QDockWidgetGroupWindow *> floatingTabs = |
1060 | mainWindow->findChildren<QDockWidgetGroupWindow *>(aName: QString(), options: Qt::FindDirectChildrenOnly); |
1061 | |
1062 | for (QDockWidgetGroupWindow *floating : floatingTabs) { |
1063 | if (floating->layoutInfo()->isEmpty()) |
1064 | continue; |
1065 | stream << uchar(QDockAreaLayout::FloatingDockWidgetTabMarker) << floating->geometry(); |
1066 | floating->layoutInfo()->saveState(stream); |
1067 | } |
1068 | #endif |
1069 | #endif |
1070 | #if QT_CONFIG(toolbar) |
1071 | toolBarAreaLayout.saveState(stream); |
1072 | #endif |
1073 | } |
1074 | |
1075 | template <typename T> |
1076 | static QList<T> findChildrenHelper(const QObject *o) |
1077 | { |
1078 | const QObjectList &list = o->children(); |
1079 | QList<T> result; |
1080 | |
1081 | for (int i=0; i < list.size(); ++i) { |
1082 | if (T t = qobject_cast<T>(list[i])) { |
1083 | result.append(t); |
1084 | } |
1085 | } |
1086 | |
1087 | return result; |
1088 | } |
1089 | |
1090 | #if QT_CONFIG(dockwidget) |
1091 | static QList<QDockWidget*> allMyDockWidgets(const QWidget *mainWindow) |
1092 | { |
1093 | QList<QDockWidget*> result; |
1094 | for (QObject *c : mainWindow->children()) { |
1095 | if (auto *dw = qobject_cast<QDockWidget*>(object: c)) { |
1096 | result.append(t: dw); |
1097 | } else if (auto *gw = qobject_cast<QDockWidgetGroupWindow*>(object: c)) { |
1098 | for (QObject *c : gw->children()) { |
1099 | if (auto *dw = qobject_cast<QDockWidget*>(object: c)) |
1100 | result.append(t: dw); |
1101 | } |
1102 | } |
1103 | } |
1104 | |
1105 | return result; |
1106 | } |
1107 | #endif // QT_CONFIG(dockwidget) |
1108 | |
1109 | //pre4.3 tests the format that was used before 4.3 |
1110 | bool QMainWindowLayoutState::checkFormat(QDataStream &stream) |
1111 | { |
1112 | while (!stream.atEnd()) { |
1113 | uchar marker; |
1114 | stream >> marker; |
1115 | switch(marker) |
1116 | { |
1117 | #if QT_CONFIG(toolbar) |
1118 | case QToolBarAreaLayout::ToolBarStateMarker: |
1119 | case QToolBarAreaLayout::ToolBarStateMarkerEx: |
1120 | { |
1121 | QList<QToolBar *> toolBars = findChildrenHelper<QToolBar*>(o: mainWindow); |
1122 | if (!toolBarAreaLayout.restoreState(stream, toolBars, tmarker: marker, testing: true /*testing*/)) { |
1123 | return false; |
1124 | } |
1125 | } |
1126 | break; |
1127 | #endif // QT_CONFIG(toolbar) |
1128 | |
1129 | #if QT_CONFIG(dockwidget) |
1130 | case QDockAreaLayout::DockWidgetStateMarker: |
1131 | { |
1132 | const auto dockWidgets = allMyDockWidgets(mainWindow); |
1133 | if (!dockAreaLayout.restoreState(stream, widgets: dockWidgets, testing: true /*testing*/)) { |
1134 | return false; |
1135 | } |
1136 | } |
1137 | break; |
1138 | #if QT_CONFIG(tabbar) |
1139 | case QDockAreaLayout::FloatingDockWidgetTabMarker: |
1140 | { |
1141 | QRect geom; |
1142 | stream >> geom; |
1143 | QDockAreaLayoutInfo info; |
1144 | auto dockWidgets = allMyDockWidgets(mainWindow); |
1145 | if (!info.restoreState(stream, widgets&: dockWidgets, testing: true /* testing*/)) |
1146 | return false; |
1147 | } |
1148 | break; |
1149 | #endif // QT_CONFIG(tabbar) |
1150 | #endif // QT_CONFIG(dockwidget) |
1151 | default: |
1152 | //there was an error during the parsing |
1153 | return false; |
1154 | }// switch |
1155 | } //while |
1156 | |
1157 | //everything went fine: it must be a pre-4.3 saved state |
1158 | return true; |
1159 | } |
1160 | |
1161 | bool QMainWindowLayoutState::restoreState(QDataStream &_stream, |
1162 | const QMainWindowLayoutState &oldState) |
1163 | { |
1164 | //make a copy of the data so that we can read it more than once |
1165 | QByteArray copy; |
1166 | while(!_stream.atEnd()) { |
1167 | int length = 1024; |
1168 | QByteArray ba(length, '\0'); |
1169 | length = _stream.readRawData(ba.data(), len: ba.size()); |
1170 | ba.resize(size: length); |
1171 | copy += ba; |
1172 | } |
1173 | |
1174 | QDataStream ds(copy); |
1175 | if (!checkFormat(stream&: ds)) |
1176 | return false; |
1177 | |
1178 | QDataStream stream(copy); |
1179 | |
1180 | while (!stream.atEnd()) { |
1181 | uchar marker; |
1182 | stream >> marker; |
1183 | switch(marker) |
1184 | { |
1185 | #if QT_CONFIG(dockwidget) |
1186 | case QDockAreaLayout::DockWidgetStateMarker: |
1187 | { |
1188 | const auto dockWidgets = allMyDockWidgets(mainWindow); |
1189 | if (!dockAreaLayout.restoreState(stream, widgets: dockWidgets)) |
1190 | return false; |
1191 | |
1192 | for (int i = 0; i < dockWidgets.size(); ++i) { |
1193 | QDockWidget *w = dockWidgets.at(i); |
1194 | QList<int> path = dockAreaLayout.indexOf(dockWidget: w); |
1195 | if (path.isEmpty()) { |
1196 | QList<int> oldPath = oldState.dockAreaLayout.indexOf(dockWidget: w); |
1197 | if (oldPath.isEmpty()) { |
1198 | continue; |
1199 | } |
1200 | QDockAreaLayoutInfo *info = dockAreaLayout.info(path: oldPath); |
1201 | if (info == nullptr) { |
1202 | continue; |
1203 | } |
1204 | info->item_list.append(t: QDockAreaLayoutItem(new QDockWidgetItem(w))); |
1205 | } |
1206 | } |
1207 | } |
1208 | break; |
1209 | #if QT_CONFIG(tabwidget) |
1210 | case QDockAreaLayout::FloatingDockWidgetTabMarker: |
1211 | { |
1212 | auto dockWidgets = allMyDockWidgets(mainWindow); |
1213 | QDockWidgetGroupWindow* floatingTab = qt_mainwindow_layout(window: mainWindow)->createTabbedDockWindow(); |
1214 | *floatingTab->layoutInfo() = QDockAreaLayoutInfo(&dockAreaLayout.sep, QInternal::LeftDock, |
1215 | Qt::Horizontal, QTabBar::RoundedSouth, mainWindow); |
1216 | QRect geometry; |
1217 | stream >> geometry; |
1218 | QDockAreaLayoutInfo *info = floatingTab->layoutInfo(); |
1219 | if (!info->restoreState(stream, widgets&: dockWidgets, testing: false)) |
1220 | return false; |
1221 | geometry = QDockAreaLayout::constrainedRect(rect: geometry, widget: floatingTab); |
1222 | floatingTab->move(geometry.topLeft()); |
1223 | floatingTab->resize(geometry.size()); |
1224 | |
1225 | // Don't show an empty QDockWidgetGroupWindow if no dock widget is available yet. |
1226 | // reparentWidgets() would be triggered by show(), so do it explicitly here. |
1227 | if (info->onlyHasPlaceholders()) |
1228 | info->reparentWidgets(p: floatingTab); |
1229 | else |
1230 | floatingTab->show(); |
1231 | } |
1232 | break; |
1233 | #endif // QT_CONFIG(tabwidget) |
1234 | #endif // QT_CONFIG(dockwidget) |
1235 | |
1236 | #if QT_CONFIG(toolbar) |
1237 | case QToolBarAreaLayout::ToolBarStateMarker: |
1238 | case QToolBarAreaLayout::ToolBarStateMarkerEx: |
1239 | { |
1240 | QList<QToolBar *> toolBars = findChildrenHelper<QToolBar*>(o: mainWindow); |
1241 | if (!toolBarAreaLayout.restoreState(stream, toolBars, tmarker: marker)) |
1242 | return false; |
1243 | |
1244 | for (int i = 0; i < toolBars.size(); ++i) { |
1245 | QToolBar *w = toolBars.at(i); |
1246 | QList<int> path = toolBarAreaLayout.indexOf(toolBar: w); |
1247 | if (path.isEmpty()) { |
1248 | QList<int> oldPath = oldState.toolBarAreaLayout.indexOf(toolBar: w); |
1249 | if (oldPath.isEmpty()) { |
1250 | continue; |
1251 | } |
1252 | toolBarAreaLayout.docks[oldPath.at(i: 0)].insertToolBar(before: nullptr, toolBar: w); |
1253 | } |
1254 | } |
1255 | } |
1256 | break; |
1257 | #endif // QT_CONFIG(toolbar) |
1258 | default: |
1259 | return false; |
1260 | }// switch |
1261 | } //while |
1262 | |
1263 | |
1264 | return true; |
1265 | } |
1266 | |
1267 | /****************************************************************************** |
1268 | ** QMainWindowLayoutState - toolbars |
1269 | */ |
1270 | |
1271 | #if QT_CONFIG(toolbar) |
1272 | |
1273 | static inline void validateToolBarArea(Qt::ToolBarArea &area) |
1274 | { |
1275 | switch (area) { |
1276 | case Qt::LeftToolBarArea: |
1277 | case Qt::RightToolBarArea: |
1278 | case Qt::TopToolBarArea: |
1279 | case Qt::BottomToolBarArea: |
1280 | break; |
1281 | default: |
1282 | area = Qt::TopToolBarArea; |
1283 | } |
1284 | } |
1285 | |
1286 | static QInternal::DockPosition toDockPos(Qt::ToolBarArea area) |
1287 | { |
1288 | switch (area) { |
1289 | case Qt::LeftToolBarArea: return QInternal::LeftDock; |
1290 | case Qt::RightToolBarArea: return QInternal::RightDock; |
1291 | case Qt::TopToolBarArea: return QInternal::TopDock; |
1292 | case Qt::BottomToolBarArea: return QInternal::BottomDock; |
1293 | default: |
1294 | break; |
1295 | } |
1296 | |
1297 | return QInternal::DockCount; |
1298 | } |
1299 | |
1300 | static Qt::ToolBarArea toToolBarArea(QInternal::DockPosition pos) |
1301 | { |
1302 | switch (pos) { |
1303 | case QInternal::LeftDock: return Qt::LeftToolBarArea; |
1304 | case QInternal::RightDock: return Qt::RightToolBarArea; |
1305 | case QInternal::TopDock: return Qt::TopToolBarArea; |
1306 | case QInternal::BottomDock: return Qt::BottomToolBarArea; |
1307 | default: break; |
1308 | } |
1309 | return Qt::NoToolBarArea; |
1310 | } |
1311 | |
1312 | static inline Qt::ToolBarArea toToolBarArea(int pos) |
1313 | { |
1314 | return toToolBarArea(pos: static_cast<QInternal::DockPosition>(pos)); |
1315 | } |
1316 | |
1317 | void QMainWindowLayout::addToolBarBreak(Qt::ToolBarArea area) |
1318 | { |
1319 | validateToolBarArea(area); |
1320 | |
1321 | layoutState.toolBarAreaLayout.addToolBarBreak(pos: toDockPos(area)); |
1322 | if (savedState.isValid()) |
1323 | savedState.toolBarAreaLayout.addToolBarBreak(pos: toDockPos(area)); |
1324 | |
1325 | invalidate(); |
1326 | } |
1327 | |
1328 | void QMainWindowLayout::insertToolBarBreak(QToolBar *before) |
1329 | { |
1330 | layoutState.toolBarAreaLayout.insertToolBarBreak(before); |
1331 | if (savedState.isValid()) |
1332 | savedState.toolBarAreaLayout.insertToolBarBreak(before); |
1333 | invalidate(); |
1334 | } |
1335 | |
1336 | void QMainWindowLayout::removeToolBarBreak(QToolBar *before) |
1337 | { |
1338 | layoutState.toolBarAreaLayout.removeToolBarBreak(before); |
1339 | if (savedState.isValid()) |
1340 | savedState.toolBarAreaLayout.removeToolBarBreak(before); |
1341 | invalidate(); |
1342 | } |
1343 | |
1344 | void QMainWindowLayout::moveToolBar(QToolBar *toolbar, int pos) |
1345 | { |
1346 | layoutState.toolBarAreaLayout.moveToolBar(toolbar, pos); |
1347 | if (savedState.isValid()) |
1348 | savedState.toolBarAreaLayout.moveToolBar(toolbar, pos); |
1349 | invalidate(); |
1350 | } |
1351 | |
1352 | /* Removes the toolbar from the mainwindow so that it can be added again. Does not |
1353 | explicitly hide the toolbar. */ |
1354 | void QMainWindowLayout::removeToolBar(QToolBar *toolbar) |
1355 | { |
1356 | if (toolbar) { |
1357 | QObject::disconnect(sender: parentWidget(), SIGNAL(iconSizeChanged(QSize)), |
1358 | receiver: toolbar, SLOT(_q_updateIconSize(QSize))); |
1359 | QObject::disconnect(sender: parentWidget(), SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)), |
1360 | receiver: toolbar, SLOT(_q_updateToolButtonStyle(Qt::ToolButtonStyle))); |
1361 | |
1362 | removeWidget(w: toolbar); |
1363 | } |
1364 | } |
1365 | |
1366 | /*! |
1367 | Adds \a toolbar to \a area, continuing the current line. |
1368 | */ |
1369 | void QMainWindowLayout::addToolBar(Qt::ToolBarArea area, |
1370 | QToolBar *toolbar, |
1371 | bool) |
1372 | { |
1373 | validateToolBarArea(area); |
1374 | // let's add the toolbar to the layout |
1375 | addChildWidget(w: toolbar); |
1376 | QLayoutItem *item = layoutState.toolBarAreaLayout.addToolBar(pos: toDockPos(area), toolBar: toolbar); |
1377 | if (savedState.isValid() && item) { |
1378 | // copy the toolbar also in the saved state |
1379 | savedState.toolBarAreaLayout.insertItem(pos: toDockPos(area), item); |
1380 | } |
1381 | invalidate(); |
1382 | |
1383 | // this ensures that the toolbar has the right window flags (not floating any more) |
1384 | toolbar->d_func()->updateWindowFlags(floating: false /*floating*/); |
1385 | } |
1386 | |
1387 | /*! |
1388 | Adds \a toolbar before \a before |
1389 | */ |
1390 | void QMainWindowLayout::insertToolBar(QToolBar *before, QToolBar *toolbar) |
1391 | { |
1392 | addChildWidget(w: toolbar); |
1393 | QLayoutItem *item = layoutState.toolBarAreaLayout.insertToolBar(before, toolBar: toolbar); |
1394 | if (savedState.isValid() && item) { |
1395 | // copy the toolbar also in the saved state |
1396 | savedState.toolBarAreaLayout.insertItem(before, item); |
1397 | } |
1398 | if (!currentGapPos.isEmpty() && currentGapPos.constFirst() == 0) { |
1399 | currentGapPos = layoutState.toolBarAreaLayout.currentGapIndex(); |
1400 | if (!currentGapPos.isEmpty()) { |
1401 | currentGapPos.prepend(t: 0); |
1402 | currentGapRect = layoutState.itemRect(path: currentGapPos); |
1403 | } |
1404 | } |
1405 | invalidate(); |
1406 | } |
1407 | |
1408 | Qt::ToolBarArea QMainWindowLayout::toolBarArea(const QToolBar *toolbar) const |
1409 | { |
1410 | QInternal::DockPosition pos = layoutState.toolBarAreaLayout.findToolBar(toolBar: toolbar); |
1411 | switch (pos) { |
1412 | case QInternal::LeftDock: return Qt::LeftToolBarArea; |
1413 | case QInternal::RightDock: return Qt::RightToolBarArea; |
1414 | case QInternal::TopDock: return Qt::TopToolBarArea; |
1415 | case QInternal::BottomDock: return Qt::BottomToolBarArea; |
1416 | default: break; |
1417 | } |
1418 | return Qt::NoToolBarArea; |
1419 | } |
1420 | |
1421 | bool QMainWindowLayout::toolBarBreak(QToolBar *toolBar) const |
1422 | { |
1423 | return layoutState.toolBarAreaLayout.toolBarBreak(toolBar); |
1424 | } |
1425 | |
1426 | void QMainWindowLayout::getStyleOptionInfo(QStyleOptionToolBar *option, QToolBar *toolBar) const |
1427 | { |
1428 | option->toolBarArea = toolBarArea(toolbar: toolBar); |
1429 | layoutState.toolBarAreaLayout.getStyleOptionInfo(option, toolBar); |
1430 | } |
1431 | |
1432 | void QMainWindowLayout::toggleToolBarsVisible() |
1433 | { |
1434 | layoutState.toolBarAreaLayout.visible = !layoutState.toolBarAreaLayout.visible; |
1435 | if (!layoutState.mainWindow->isMaximized()) { |
1436 | QPoint topLeft = parentWidget()->geometry().topLeft(); |
1437 | QRect r = parentWidget()->geometry(); |
1438 | r = layoutState.toolBarAreaLayout.rectHint(r); |
1439 | r.moveTo(p: topLeft); |
1440 | parentWidget()->setGeometry(r); |
1441 | } else { |
1442 | update(); |
1443 | } |
1444 | } |
1445 | |
1446 | #endif // QT_CONFIG(toolbar) |
1447 | |
1448 | /****************************************************************************** |
1449 | ** QMainWindowLayoutState - dock areas |
1450 | */ |
1451 | |
1452 | #if QT_CONFIG(dockwidget) |
1453 | |
1454 | static QInternal::DockPosition toDockPos(Qt::DockWidgetArea area) |
1455 | { |
1456 | switch (area) { |
1457 | case Qt::LeftDockWidgetArea: return QInternal::LeftDock; |
1458 | case Qt::RightDockWidgetArea: return QInternal::RightDock; |
1459 | case Qt::TopDockWidgetArea: return QInternal::TopDock; |
1460 | case Qt::BottomDockWidgetArea: return QInternal::BottomDock; |
1461 | default: |
1462 | break; |
1463 | } |
1464 | |
1465 | return QInternal::DockCount; |
1466 | } |
1467 | |
1468 | static Qt::DockWidgetArea toDockWidgetArea(QInternal::DockPosition pos) |
1469 | { |
1470 | switch (pos) { |
1471 | case QInternal::LeftDock : return Qt::LeftDockWidgetArea; |
1472 | case QInternal::RightDock : return Qt::RightDockWidgetArea; |
1473 | case QInternal::TopDock : return Qt::TopDockWidgetArea; |
1474 | case QInternal::BottomDock : return Qt::BottomDockWidgetArea; |
1475 | default: |
1476 | break; |
1477 | } |
1478 | |
1479 | return Qt::NoDockWidgetArea; |
1480 | } |
1481 | |
1482 | inline static Qt::DockWidgetArea toDockWidgetArea(int pos) |
1483 | { |
1484 | return toDockWidgetArea(pos: static_cast<QInternal::DockPosition>(pos)); |
1485 | } |
1486 | |
1487 | void QMainWindowLayout::setCorner(Qt::Corner corner, Qt::DockWidgetArea area) |
1488 | { |
1489 | if (layoutState.dockAreaLayout.corners[corner] == area) |
1490 | return; |
1491 | layoutState.dockAreaLayout.corners[corner] = area; |
1492 | if (savedState.isValid()) |
1493 | savedState.dockAreaLayout.corners[corner] = area; |
1494 | invalidate(); |
1495 | } |
1496 | |
1497 | Qt::DockWidgetArea QMainWindowLayout::corner(Qt::Corner corner) const |
1498 | { |
1499 | return layoutState.dockAreaLayout.corners[corner]; |
1500 | } |
1501 | |
1502 | void QMainWindowLayout::addDockWidget(Qt::DockWidgetArea area, |
1503 | QDockWidget *dockwidget, |
1504 | Qt::Orientation orientation) |
1505 | { |
1506 | addChildWidget(w: dockwidget); |
1507 | |
1508 | // If we are currently moving a separator, then we need to abort the move, since each |
1509 | // time we move the mouse layoutState is replaced by savedState modified by the move. |
1510 | if (!movingSeparator.isEmpty()) |
1511 | endSeparatorMove(pos: movingSeparatorPos); |
1512 | |
1513 | layoutState.dockAreaLayout.addDockWidget(pos: toDockPos(area), dockWidget: dockwidget, orientation); |
1514 | emit dockwidget->dockLocationChanged(area); |
1515 | invalidate(); |
1516 | } |
1517 | |
1518 | bool QMainWindowLayout::restoreDockWidget(QDockWidget *dockwidget) |
1519 | { |
1520 | addChildWidget(w: dockwidget); |
1521 | if (!layoutState.dockAreaLayout.restoreDockWidget(dockWidget: dockwidget)) |
1522 | return false; |
1523 | emit dockwidget->dockLocationChanged(area: dockWidgetArea(widget: dockwidget)); |
1524 | invalidate(); |
1525 | return true; |
1526 | } |
1527 | |
1528 | #if QT_CONFIG(tabbar) |
1529 | void QMainWindowLayout::tabifyDockWidget(QDockWidget *first, QDockWidget *second) |
1530 | { |
1531 | addChildWidget(w: second); |
1532 | layoutState.dockAreaLayout.tabifyDockWidget(first, second); |
1533 | emit second->dockLocationChanged(area: dockWidgetArea(widget: first)); |
1534 | invalidate(); |
1535 | } |
1536 | |
1537 | bool QMainWindowLayout::documentMode() const |
1538 | { |
1539 | return _documentMode; |
1540 | } |
1541 | |
1542 | void QMainWindowLayout::setDocumentMode(bool enabled) |
1543 | { |
1544 | if (_documentMode == enabled) |
1545 | return; |
1546 | |
1547 | _documentMode = enabled; |
1548 | |
1549 | // Update the document mode for all tab bars |
1550 | for (QTabBar *bar : qAsConst(t&: usedTabBars)) |
1551 | bar->setDocumentMode(_documentMode); |
1552 | for (QTabBar *bar : qAsConst(t&: unusedTabBars)) |
1553 | bar->setDocumentMode(_documentMode); |
1554 | } |
1555 | |
1556 | void QMainWindowLayout::setVerticalTabsEnabled(bool enabled) |
1557 | { |
1558 | if (verticalTabsEnabled == enabled) |
1559 | return; |
1560 | |
1561 | verticalTabsEnabled = enabled; |
1562 | |
1563 | updateTabBarShapes(); |
1564 | } |
1565 | |
1566 | #if QT_CONFIG(tabwidget) |
1567 | QTabWidget::TabShape QMainWindowLayout::tabShape() const |
1568 | { |
1569 | return _tabShape; |
1570 | } |
1571 | |
1572 | void QMainWindowLayout::setTabShape(QTabWidget::TabShape tabShape) |
1573 | { |
1574 | if (_tabShape == tabShape) |
1575 | return; |
1576 | |
1577 | _tabShape = tabShape; |
1578 | |
1579 | updateTabBarShapes(); |
1580 | } |
1581 | |
1582 | QTabWidget::TabPosition QMainWindowLayout::tabPosition(Qt::DockWidgetArea area) const |
1583 | { |
1584 | const auto dockPos = toDockPos(area); |
1585 | if (dockPos < QInternal::DockCount) |
1586 | return tabPositions[dockPos]; |
1587 | qWarning(msg: "QMainWindowLayout::tabPosition called with out-of-bounds value '%d'" , int(area)); |
1588 | return QTabWidget::North; |
1589 | } |
1590 | |
1591 | void QMainWindowLayout::setTabPosition(Qt::DockWidgetAreas areas, QTabWidget::TabPosition tabPosition) |
1592 | { |
1593 | const Qt::DockWidgetArea dockWidgetAreas[] = { |
1594 | Qt::TopDockWidgetArea, |
1595 | Qt::LeftDockWidgetArea, |
1596 | Qt::BottomDockWidgetArea, |
1597 | Qt::RightDockWidgetArea |
1598 | }; |
1599 | const QInternal::DockPosition dockPositions[] = { |
1600 | QInternal::TopDock, |
1601 | QInternal::LeftDock, |
1602 | QInternal::BottomDock, |
1603 | QInternal::RightDock |
1604 | }; |
1605 | |
1606 | for (int i = 0; i < QInternal::DockCount; ++i) |
1607 | if (areas & dockWidgetAreas[i]) |
1608 | tabPositions[dockPositions[i]] = tabPosition; |
1609 | |
1610 | updateTabBarShapes(); |
1611 | } |
1612 | |
1613 | static inline QTabBar::Shape tabBarShapeFrom(QTabWidget::TabShape shape, QTabWidget::TabPosition position) |
1614 | { |
1615 | const bool rounded = (shape == QTabWidget::Rounded); |
1616 | if (position == QTabWidget::North) |
1617 | return rounded ? QTabBar::RoundedNorth : QTabBar::TriangularNorth; |
1618 | if (position == QTabWidget::South) |
1619 | return rounded ? QTabBar::RoundedSouth : QTabBar::TriangularSouth; |
1620 | if (position == QTabWidget::East) |
1621 | return rounded ? QTabBar::RoundedEast : QTabBar::TriangularEast; |
1622 | if (position == QTabWidget::West) |
1623 | return rounded ? QTabBar::RoundedWest : QTabBar::TriangularWest; |
1624 | return QTabBar::RoundedNorth; |
1625 | } |
1626 | #endif // QT_CONFIG(tabwidget) |
1627 | |
1628 | void QMainWindowLayout::updateTabBarShapes() |
1629 | { |
1630 | #if QT_CONFIG(tabwidget) |
1631 | const QTabWidget::TabPosition vertical[] = { |
1632 | QTabWidget::West, |
1633 | QTabWidget::East, |
1634 | QTabWidget::North, |
1635 | QTabWidget::South |
1636 | }; |
1637 | #else |
1638 | const QTabBar::Shape vertical[] = { |
1639 | QTabBar::RoundedWest, |
1640 | QTabBar::RoundedEast, |
1641 | QTabBar::RoundedNorth, |
1642 | QTabBar::RoundedSouth |
1643 | }; |
1644 | #endif |
1645 | |
1646 | QDockAreaLayout &layout = layoutState.dockAreaLayout; |
1647 | |
1648 | for (int i = 0; i < QInternal::DockCount; ++i) { |
1649 | #if QT_CONFIG(tabwidget) |
1650 | QTabWidget::TabPosition pos = verticalTabsEnabled ? vertical[i] : tabPositions[i]; |
1651 | QTabBar::Shape shape = tabBarShapeFrom(shape: _tabShape, position: pos); |
1652 | #else |
1653 | QTabBar::Shape shape = verticalTabsEnabled ? vertical[i] : QTabBar::RoundedSouth; |
1654 | #endif |
1655 | layout.docks[i].setTabBarShape(shape); |
1656 | } |
1657 | } |
1658 | #endif // QT_CONFIG(tabbar) |
1659 | |
1660 | void QMainWindowLayout::splitDockWidget(QDockWidget *after, |
1661 | QDockWidget *dockwidget, |
1662 | Qt::Orientation orientation) |
1663 | { |
1664 | addChildWidget(w: dockwidget); |
1665 | layoutState.dockAreaLayout.splitDockWidget(after, dockWidget: dockwidget, orientation); |
1666 | emit dockwidget->dockLocationChanged(area: dockWidgetArea(widget: after)); |
1667 | invalidate(); |
1668 | } |
1669 | |
1670 | Qt::DockWidgetArea QMainWindowLayout::dockWidgetArea(QWidget *widget) const |
1671 | { |
1672 | const QList<int> pathToWidget = layoutState.dockAreaLayout.indexOf(dockWidget: widget); |
1673 | if (pathToWidget.isEmpty()) |
1674 | return Qt::NoDockWidgetArea; |
1675 | return toDockWidgetArea(pos: pathToWidget.first()); |
1676 | } |
1677 | |
1678 | void QMainWindowLayout::keepSize(QDockWidget *w) |
1679 | { |
1680 | layoutState.dockAreaLayout.keepSize(w); |
1681 | } |
1682 | |
1683 | #if QT_CONFIG(tabbar) |
1684 | |
1685 | // Handle custom tooltip, and allow to drag tabs away. |
1686 | class QMainWindowTabBar : public QTabBar |
1687 | { |
1688 | QMainWindow *mainWindow; |
1689 | QPointer<QDockWidget> draggingDock; // Currently dragging (detached) dock widget |
1690 | public: |
1691 | QMainWindowTabBar(QMainWindow *parent); |
1692 | protected: |
1693 | bool event(QEvent *e) override; |
1694 | void mouseReleaseEvent(QMouseEvent*) override; |
1695 | void mouseMoveEvent(QMouseEvent*) override; |
1696 | |
1697 | }; |
1698 | |
1699 | QMainWindowTabBar::QMainWindowTabBar(QMainWindow *parent) |
1700 | : QTabBar(parent), mainWindow(parent) |
1701 | { |
1702 | setExpanding(false); |
1703 | } |
1704 | |
1705 | void QMainWindowTabBar::mouseMoveEvent(QMouseEvent *e) |
1706 | { |
1707 | // The QTabBar handles the moving (reordering) of tabs. |
1708 | // When QTabBarPrivate::dragInProgress is true, and that the mouse is outside of a region |
1709 | // around the QTabBar, we will consider the user wants to drag that QDockWidget away from this |
1710 | // tab area. |
1711 | |
1712 | QTabBarPrivate *d = static_cast<QTabBarPrivate*>(d_ptr.data()); |
1713 | if (!draggingDock && (mainWindow->dockOptions() & QMainWindow::GroupedDragging)) { |
1714 | int offset = QApplication::startDragDistance() + 1; |
1715 | offset *= 3; |
1716 | QRect r = rect().adjusted(xp1: -offset, yp1: -offset, xp2: offset, yp2: offset); |
1717 | if (d->dragInProgress && !r.contains(p: e->pos()) && d->validIndex(index: d->pressedIndex)) { |
1718 | QMainWindowLayout* mlayout = qt_mainwindow_layout(window: mainWindow); |
1719 | QDockAreaLayoutInfo *info = mlayout->dockInfo(w: this); |
1720 | Q_ASSERT(info); |
1721 | int idx = info->tabIndexToListIndex(d->pressedIndex); |
1722 | const QDockAreaLayoutItem &item = info->item_list.at(i: idx); |
1723 | if (item.widgetItem |
1724 | && (draggingDock = qobject_cast<QDockWidget *>(object: item.widgetItem->widget()))) { |
1725 | // We should drag this QDockWidget away by unpluging it. |
1726 | // First cancel the QTabBar's internal move |
1727 | d->moveTabFinished(index: d->pressedIndex); |
1728 | d->pressedIndex = -1; |
1729 | if (d->movingTab) |
1730 | d->movingTab->setVisible(false); |
1731 | d->dragStartPosition = QPoint(); |
1732 | |
1733 | // Then starts the drag using QDockWidgetPrivate's API |
1734 | QDockWidgetPrivate *dockPriv = static_cast<QDockWidgetPrivate *>(QObjectPrivate::get(o: draggingDock)); |
1735 | QDockWidgetLayout *dwlayout = static_cast<QDockWidgetLayout *>(draggingDock->layout()); |
1736 | dockPriv->initDrag(pos: dwlayout->titleArea().center(), nca: true); |
1737 | dockPriv->startDrag(group: false); |
1738 | if (dockPriv->state) |
1739 | dockPriv->state->ctrlDrag = e->modifiers() & Qt::ControlModifier; |
1740 | } |
1741 | } |
1742 | } |
1743 | |
1744 | if (draggingDock) { |
1745 | QDockWidgetPrivate *dockPriv = static_cast<QDockWidgetPrivate *>(QObjectPrivate::get(o: draggingDock)); |
1746 | if (dockPriv->state && dockPriv->state->dragging) { |
1747 | QPoint pos = e->globalPos() - dockPriv->state->pressPos; |
1748 | draggingDock->move(pos); |
1749 | // move will call QMainWindowLayout::hover |
1750 | } |
1751 | } |
1752 | QTabBar::mouseMoveEvent(e); |
1753 | } |
1754 | |
1755 | void QMainWindowTabBar::mouseReleaseEvent(QMouseEvent *e) |
1756 | { |
1757 | if (draggingDock && e->button() == Qt::LeftButton) { |
1758 | QDockWidgetPrivate *dockPriv = static_cast<QDockWidgetPrivate *>(QObjectPrivate::get(o: draggingDock)); |
1759 | if (dockPriv->state && dockPriv->state->dragging) { |
1760 | dockPriv->endDrag(); |
1761 | } |
1762 | draggingDock = nullptr; |
1763 | } |
1764 | QTabBar::mouseReleaseEvent(e); |
1765 | } |
1766 | |
1767 | bool QMainWindowTabBar::event(QEvent *e) |
1768 | { |
1769 | // show the tooltip if tab is too small to fit label |
1770 | |
1771 | if (e->type() != QEvent::ToolTip) |
1772 | return QTabBar::event(e); |
1773 | QSize size = this->size(); |
1774 | QSize hint = sizeHint(); |
1775 | if (shape() == QTabBar::RoundedWest || shape() == QTabBar::RoundedEast) { |
1776 | size = size.transposed(); |
1777 | hint = hint.transposed(); |
1778 | } |
1779 | if (size.width() < hint.width()) |
1780 | return QTabBar::event(e); |
1781 | e->accept(); |
1782 | return true; |
1783 | } |
1784 | |
1785 | QTabBar *QMainWindowLayout::getTabBar() |
1786 | { |
1787 | if (!usedTabBars.isEmpty()) { |
1788 | /* |
1789 | If dock widgets have been removed and added while the main window was |
1790 | hidden, then the layout hasn't been activated yet, and tab bars from empty |
1791 | docking areas haven't been put in the cache yet. |
1792 | */ |
1793 | activate(); |
1794 | } |
1795 | |
1796 | QTabBar *result = nullptr; |
1797 | if (!unusedTabBars.isEmpty()) { |
1798 | result = unusedTabBars.takeLast(); |
1799 | } else { |
1800 | result = new QMainWindowTabBar(static_cast<QMainWindow *>(parentWidget())); |
1801 | result->setDrawBase(true); |
1802 | result->setElideMode(Qt::ElideRight); |
1803 | result->setDocumentMode(_documentMode); |
1804 | result->setMovable(true); |
1805 | connect(sender: result, SIGNAL(currentChanged(int)), receiver: this, SLOT(tabChanged())); |
1806 | connect(sender: result, signal: &QTabBar::tabMoved, receiver: this, slot: &QMainWindowLayout::tabMoved); |
1807 | } |
1808 | |
1809 | usedTabBars.insert(value: result); |
1810 | return result; |
1811 | } |
1812 | |
1813 | // Allocates a new separator widget if needed |
1814 | QWidget *QMainWindowLayout::getSeparatorWidget() |
1815 | { |
1816 | QWidget *result = nullptr; |
1817 | if (!unusedSeparatorWidgets.isEmpty()) { |
1818 | result = unusedSeparatorWidgets.takeLast(); |
1819 | } else { |
1820 | result = new QWidget(parentWidget()); |
1821 | result->setAttribute(Qt::WA_MouseNoMask, on: true); |
1822 | result->setAutoFillBackground(false); |
1823 | result->setObjectName(QLatin1String("qt_qmainwindow_extended_splitter" )); |
1824 | } |
1825 | usedSeparatorWidgets.insert(value: result); |
1826 | return result; |
1827 | } |
1828 | |
1829 | /*! \internal |
1830 | Returns a pointer QDockAreaLayoutInfo which contains this \a widget directly |
1831 | (in its internal list) |
1832 | */ |
1833 | QDockAreaLayoutInfo *QMainWindowLayout::dockInfo(QWidget *widget) |
1834 | { |
1835 | QDockAreaLayoutInfo *info = layoutState.dockAreaLayout.info(widget); |
1836 | if (info) |
1837 | return info; |
1838 | const auto groups = |
1839 | parent()->findChildren<QDockWidgetGroupWindow*>(aName: QString(), options: Qt::FindDirectChildrenOnly); |
1840 | for (QDockWidgetGroupWindow *dwgw : groups) { |
1841 | info = dwgw->layoutInfo()->info(widget); |
1842 | if (info) |
1843 | return info; |
1844 | } |
1845 | return nullptr; |
1846 | } |
1847 | |
1848 | void QMainWindowLayout::tabChanged() |
1849 | { |
1850 | QTabBar *tb = qobject_cast<QTabBar*>(object: sender()); |
1851 | if (tb == nullptr) |
1852 | return; |
1853 | QDockAreaLayoutInfo *info = dockInfo(widget: tb); |
1854 | if (info == nullptr) |
1855 | return; |
1856 | |
1857 | QDockWidget *activated = info->apply(animate: false); |
1858 | |
1859 | if (activated) |
1860 | emit static_cast<QMainWindow *>(parentWidget())->tabifiedDockWidgetActivated(dockWidget: activated); |
1861 | |
1862 | if (auto dwgw = qobject_cast<QDockWidgetGroupWindow*>(object: tb->parentWidget())) |
1863 | dwgw->adjustFlags(); |
1864 | |
1865 | if (QWidget *w = centralWidget()) |
1866 | w->raise(); |
1867 | } |
1868 | |
1869 | void QMainWindowLayout::tabMoved(int from, int to) |
1870 | { |
1871 | QTabBar *tb = qobject_cast<QTabBar*>(object: sender()); |
1872 | Q_ASSERT(tb); |
1873 | QDockAreaLayoutInfo *info = dockInfo(widget: tb); |
1874 | Q_ASSERT(info); |
1875 | |
1876 | info->moveTab(from, to); |
1877 | } |
1878 | |
1879 | void QMainWindowLayout::raise(QDockWidget *widget) |
1880 | { |
1881 | QDockAreaLayoutInfo *info = dockInfo(widget); |
1882 | if (info == nullptr) |
1883 | return; |
1884 | if (!info->tabbed) |
1885 | return; |
1886 | info->setCurrentTab(widget); |
1887 | } |
1888 | #endif // QT_CONFIG(tabbar) |
1889 | |
1890 | #endif // QT_CONFIG(dockwidget) |
1891 | |
1892 | |
1893 | /****************************************************************************** |
1894 | ** QMainWindowLayoutState - layout interface |
1895 | */ |
1896 | |
1897 | int QMainWindowLayout::count() const |
1898 | { |
1899 | qWarning(msg: "QMainWindowLayout::count: ?" ); |
1900 | return 0; //################################################# |
1901 | } |
1902 | |
1903 | QLayoutItem *QMainWindowLayout::itemAt(int index) const |
1904 | { |
1905 | int x = 0; |
1906 | |
1907 | if (QLayoutItem *ret = layoutState.itemAt(index, x: &x)) |
1908 | return ret; |
1909 | |
1910 | if (statusbar && x++ == index) |
1911 | return statusbar; |
1912 | |
1913 | return nullptr; |
1914 | } |
1915 | |
1916 | QLayoutItem *QMainWindowLayout::takeAt(int index) |
1917 | { |
1918 | int x = 0; |
1919 | |
1920 | if (QLayoutItem *ret = layoutState.takeAt(index, x: &x)) { |
1921 | // the widget might in fact have been destroyed by now |
1922 | if (QWidget *w = ret->widget()) { |
1923 | widgetAnimator.abort(widget: w); |
1924 | if (w == pluggingWidget) |
1925 | pluggingWidget = nullptr; |
1926 | } |
1927 | |
1928 | if (savedState.isValid() ) { |
1929 | //we need to remove the item also from the saved state to prevent crash |
1930 | savedState.remove(item: ret); |
1931 | //Also, the item may be contained several times as a gap item. |
1932 | layoutState.remove(item: ret); |
1933 | } |
1934 | |
1935 | #if QT_CONFIG(toolbar) |
1936 | if (!currentGapPos.isEmpty() && currentGapPos.constFirst() == 0) { |
1937 | currentGapPos = layoutState.toolBarAreaLayout.currentGapIndex(); |
1938 | if (!currentGapPos.isEmpty()) { |
1939 | currentGapPos.prepend(t: 0); |
1940 | currentGapRect = layoutState.itemRect(path: currentGapPos); |
1941 | } |
1942 | } |
1943 | #endif |
1944 | |
1945 | return ret; |
1946 | } |
1947 | |
1948 | if (statusbar && x++ == index) { |
1949 | QLayoutItem *ret = statusbar; |
1950 | statusbar = nullptr; |
1951 | return ret; |
1952 | } |
1953 | |
1954 | return nullptr; |
1955 | } |
1956 | |
1957 | void QMainWindowLayout::setGeometry(const QRect &_r) |
1958 | { |
1959 | if (savedState.isValid()) |
1960 | return; |
1961 | |
1962 | QRect r = _r; |
1963 | |
1964 | QLayout::setGeometry(r); |
1965 | |
1966 | if (statusbar) { |
1967 | QRect sbr(QPoint(r.left(), 0), |
1968 | QSize(r.width(), statusbar->heightForWidth(r.width())) |
1969 | .expandedTo(otherSize: statusbar->minimumSize())); |
1970 | sbr.moveBottom(pos: r.bottom()); |
1971 | QRect vr = QStyle::visualRect(direction: parentWidget()->layoutDirection(), boundingRect: _r, logicalRect: sbr); |
1972 | statusbar->setGeometry(vr); |
1973 | r.setBottom(sbr.top() - 1); |
1974 | } |
1975 | |
1976 | layoutState.rect = r; |
1977 | layoutState.fitLayout(); |
1978 | applyState(newState&: layoutState, animate: false); |
1979 | } |
1980 | |
1981 | void QMainWindowLayout::addItem(QLayoutItem *) |
1982 | { qWarning(msg: "QMainWindowLayout::addItem: Please use the public QMainWindow API instead" ); } |
1983 | |
1984 | QSize QMainWindowLayout::sizeHint() const |
1985 | { |
1986 | if (!szHint.isValid()) { |
1987 | szHint = layoutState.sizeHint(); |
1988 | const QSize sbHint = statusbar ? statusbar->sizeHint() : QSize(0, 0); |
1989 | szHint = QSize(qMax(a: sbHint.width(), b: szHint.width()), |
1990 | sbHint.height() + szHint.height()); |
1991 | } |
1992 | return szHint; |
1993 | } |
1994 | |
1995 | QSize QMainWindowLayout::minimumSize() const |
1996 | { |
1997 | if (!minSize.isValid()) { |
1998 | minSize = layoutState.minimumSize(); |
1999 | const QSize sbMin = statusbar ? statusbar->minimumSize() : QSize(0, 0); |
2000 | minSize = QSize(qMax(a: sbMin.width(), b: minSize.width()), |
2001 | sbMin.height() + minSize.height()); |
2002 | } |
2003 | return minSize; |
2004 | } |
2005 | |
2006 | void QMainWindowLayout::invalidate() |
2007 | { |
2008 | QLayout::invalidate(); |
2009 | minSize = szHint = QSize(); |
2010 | } |
2011 | |
2012 | #if QT_CONFIG(dockwidget) |
2013 | void QMainWindowLayout::setCurrentHoveredFloat(QDockWidgetGroupWindow *w) |
2014 | { |
2015 | if (currentHoveredFloat != w) { |
2016 | if (currentHoveredFloat) { |
2017 | disconnect(sender: currentHoveredFloat.data(), signal: &QObject::destroyed, |
2018 | receiver: this, slot: &QMainWindowLayout::updateGapIndicator); |
2019 | disconnect(sender: currentHoveredFloat.data(), signal: &QDockWidgetGroupWindow::resized, |
2020 | receiver: this, slot: &QMainWindowLayout::updateGapIndicator); |
2021 | if (currentHoveredFloat) |
2022 | currentHoveredFloat->restore(); |
2023 | } else if (w) { |
2024 | restore(keepSavedState: true); |
2025 | } |
2026 | |
2027 | currentHoveredFloat = w; |
2028 | |
2029 | if (w) { |
2030 | connect(sender: w, signal: &QObject::destroyed, |
2031 | receiver: this, slot: &QMainWindowLayout::updateGapIndicator, type: Qt::UniqueConnection); |
2032 | connect(sender: w, signal: &QDockWidgetGroupWindow::resized, |
2033 | receiver: this, slot: &QMainWindowLayout::updateGapIndicator, type: Qt::UniqueConnection); |
2034 | } |
2035 | |
2036 | updateGapIndicator(); |
2037 | } |
2038 | } |
2039 | #endif // QT_CONFIG(dockwidget) |
2040 | |
2041 | /****************************************************************************** |
2042 | ** QMainWindowLayout - remaining stuff |
2043 | */ |
2044 | |
2045 | static void fixToolBarOrientation(QLayoutItem *item, int dockPos) |
2046 | { |
2047 | #if QT_CONFIG(toolbar) |
2048 | QToolBar *toolBar = qobject_cast<QToolBar*>(object: item->widget()); |
2049 | if (toolBar == nullptr) |
2050 | return; |
2051 | |
2052 | QRect oldGeo = toolBar->geometry(); |
2053 | |
2054 | QInternal::DockPosition pos |
2055 | = static_cast<QInternal::DockPosition>(dockPos); |
2056 | Qt::Orientation o = pos == QInternal::TopDock || pos == QInternal::BottomDock |
2057 | ? Qt::Horizontal : Qt::Vertical; |
2058 | if (o != toolBar->orientation()) |
2059 | toolBar->setOrientation(o); |
2060 | |
2061 | QSize hint = toolBar->sizeHint().boundedTo(otherSize: toolBar->maximumSize()) |
2062 | .expandedTo(otherSize: toolBar->minimumSize()); |
2063 | |
2064 | if (toolBar->size() != hint) { |
2065 | QRect newGeo(oldGeo.topLeft(), hint); |
2066 | if (toolBar->layoutDirection() == Qt::RightToLeft) |
2067 | newGeo.moveRight(pos: oldGeo.right()); |
2068 | toolBar->setGeometry(newGeo); |
2069 | } |
2070 | |
2071 | #else |
2072 | Q_UNUSED(item); |
2073 | Q_UNUSED(dockPos); |
2074 | #endif |
2075 | } |
2076 | |
2077 | void QMainWindowLayout::revert(QLayoutItem *widgetItem) |
2078 | { |
2079 | if (!savedState.isValid()) |
2080 | return; |
2081 | |
2082 | QWidget *widget = widgetItem->widget(); |
2083 | layoutState = savedState; |
2084 | currentGapPos = layoutState.indexOf(widget); |
2085 | if (currentGapPos.isEmpty()) |
2086 | return; |
2087 | fixToolBarOrientation(item: widgetItem, dockPos: currentGapPos.at(i: 1)); |
2088 | layoutState.unplug(path: currentGapPos); |
2089 | layoutState.fitLayout(); |
2090 | currentGapRect = layoutState.itemRect(path: currentGapPos); |
2091 | |
2092 | plug(widgetItem); |
2093 | } |
2094 | |
2095 | bool QMainWindowLayout::plug(QLayoutItem *widgetItem) |
2096 | { |
2097 | #if QT_CONFIG(dockwidget) && QT_CONFIG(tabwidget) && QT_CONFIG(tabbar) |
2098 | if (currentHoveredFloat) { |
2099 | QWidget *widget = widgetItem->widget(); |
2100 | QList<int> previousPath = layoutState.indexOf(widget); |
2101 | if (!previousPath.isEmpty()) |
2102 | layoutState.remove(path: previousPath); |
2103 | previousPath = currentHoveredFloat->layoutInfo()->indexOf(widget); |
2104 | // Let's remove the widget from any possible group window |
2105 | const auto groups = |
2106 | parent()->findChildren<QDockWidgetGroupWindow*>(aName: QString(), options: Qt::FindDirectChildrenOnly); |
2107 | for (QDockWidgetGroupWindow *dwgw : groups) { |
2108 | if (dwgw == currentHoveredFloat) |
2109 | continue; |
2110 | QList<int> path = dwgw->layoutInfo()->indexOf(widget); |
2111 | if (!path.isEmpty()) |
2112 | dwgw->layoutInfo()->remove(path); |
2113 | } |
2114 | currentGapRect = QRect(); |
2115 | currentHoveredFloat->apply(); |
2116 | if (!previousPath.isEmpty()) |
2117 | currentHoveredFloat->layoutInfo()->remove(path: previousPath); |
2118 | QRect globalRect = currentHoveredFloat->currentGapRect; |
2119 | globalRect.moveTopLeft(p: currentHoveredFloat->mapToGlobal(globalRect.topLeft())); |
2120 | pluggingWidget = widget; |
2121 | widgetAnimator.animate(widget, final_geometry: globalRect, animate: dockOptions & QMainWindow::AnimatedDocks); |
2122 | return true; |
2123 | } |
2124 | #endif |
2125 | |
2126 | if (!parentWidget()->isVisible() || parentWidget()->isMinimized() || currentGapPos.isEmpty()) |
2127 | return false; |
2128 | |
2129 | fixToolBarOrientation(item: widgetItem, dockPos: currentGapPos.at(i: 1)); |
2130 | |
2131 | QWidget *widget = widgetItem->widget(); |
2132 | |
2133 | #if QT_CONFIG(dockwidget) |
2134 | // Let's remove the widget from any possible group window |
2135 | const auto groups = |
2136 | parent()->findChildren<QDockWidgetGroupWindow*>(aName: QString(), options: Qt::FindDirectChildrenOnly); |
2137 | for (QDockWidgetGroupWindow *dwgw : groups) { |
2138 | QList<int> path = dwgw->layoutInfo()->indexOf(widget); |
2139 | if (!path.isEmpty()) |
2140 | dwgw->layoutInfo()->remove(path); |
2141 | } |
2142 | #endif |
2143 | |
2144 | QList<int> previousPath = layoutState.indexOf(widget); |
2145 | |
2146 | const QLayoutItem *it = layoutState.plug(path: currentGapPos); |
2147 | if (!it) |
2148 | return false; |
2149 | Q_ASSERT(it == widgetItem); |
2150 | if (!previousPath.isEmpty()) |
2151 | layoutState.remove(path: previousPath); |
2152 | |
2153 | pluggingWidget = widget; |
2154 | QRect globalRect = currentGapRect; |
2155 | globalRect.moveTopLeft(p: parentWidget()->mapToGlobal(globalRect.topLeft())); |
2156 | #if QT_CONFIG(dockwidget) |
2157 | if (qobject_cast<QDockWidget*>(object: widget) != 0) { |
2158 | QDockWidgetLayout *layout = qobject_cast<QDockWidgetLayout*>(object: widget->layout()); |
2159 | if (layout->nativeWindowDeco()) { |
2160 | globalRect.adjust(dx1: 0, dy1: layout->titleHeight(), dx2: 0, dy2: 0); |
2161 | } else { |
2162 | int fw = widget->style()->pixelMetric(metric: QStyle::PM_DockWidgetFrameWidth, option: nullptr, widget); |
2163 | globalRect.adjust(dx1: -fw, dy1: -fw, dx2: fw, dy2: fw); |
2164 | } |
2165 | } |
2166 | #endif |
2167 | widgetAnimator.animate(widget, final_geometry: globalRect, animate: dockOptions & QMainWindow::AnimatedDocks); |
2168 | |
2169 | return true; |
2170 | } |
2171 | |
2172 | void QMainWindowLayout::animationFinished(QWidget *widget) |
2173 | { |
2174 | //this function is called from within the Widget Animator whenever an animation is finished |
2175 | //on a certain widget |
2176 | #if QT_CONFIG(toolbar) |
2177 | if (QToolBar *tb = qobject_cast<QToolBar*>(object: widget)) { |
2178 | QToolBarLayout *tbl = qobject_cast<QToolBarLayout*>(object: tb->layout()); |
2179 | if (tbl->animating) { |
2180 | tbl->animating = false; |
2181 | if (tbl->expanded) |
2182 | tbl->layoutActions(size: tb->size()); |
2183 | tb->update(); |
2184 | } |
2185 | } |
2186 | #endif |
2187 | |
2188 | if (widget == pluggingWidget) { |
2189 | |
2190 | #if QT_CONFIG(dockwidget) |
2191 | #if QT_CONFIG(tabbar) |
2192 | if (QDockWidgetGroupWindow *dwgw = qobject_cast<QDockWidgetGroupWindow *>(object: widget)) { |
2193 | // When the animated widget was a QDockWidgetGroupWindow, it means each of the |
2194 | // embedded QDockWidget needs to be plugged back into the QMainWindow layout. |
2195 | savedState.clear(); |
2196 | QDockAreaLayoutInfo *srcInfo = dwgw->layoutInfo(); |
2197 | const QDockAreaLayoutInfo *srcTabInfo = dwgw->tabLayoutInfo(); |
2198 | QDockAreaLayoutInfo *dstParentInfo; |
2199 | QList<int> dstPath; |
2200 | |
2201 | if (currentHoveredFloat) { |
2202 | dstPath = currentHoveredFloat->layoutInfo()->indexOf(widget); |
2203 | Q_ASSERT(dstPath.size() >= 1); |
2204 | dstParentInfo = currentHoveredFloat->layoutInfo()->info(path: dstPath); |
2205 | } else { |
2206 | dstPath = layoutState.dockAreaLayout.indexOf(dockWidget: widget); |
2207 | Q_ASSERT(dstPath.size() >= 2); |
2208 | dstParentInfo = layoutState.dockAreaLayout.info(path: dstPath); |
2209 | } |
2210 | Q_ASSERT(dstParentInfo); |
2211 | int idx = dstPath.constLast(); |
2212 | Q_ASSERT(dstParentInfo->item_list[idx].widgetItem->widget() == dwgw); |
2213 | if (dstParentInfo->tabbed && srcTabInfo) { |
2214 | // merge the two tab widgets |
2215 | delete dstParentInfo->item_list[idx].widgetItem; |
2216 | dstParentInfo->item_list.removeAt(i: idx); |
2217 | std::copy(srcTabInfo->item_list.cbegin(), srcTabInfo->item_list.cend(), |
2218 | std::inserter(x&: dstParentInfo->item_list, |
2219 | i: dstParentInfo->item_list.begin() + idx)); |
2220 | quintptr currentId = srcTabInfo->currentTabId(); |
2221 | *srcInfo = QDockAreaLayoutInfo(); |
2222 | dstParentInfo->reparentWidgets(p: currentHoveredFloat ? currentHoveredFloat.data() |
2223 | : parentWidget()); |
2224 | dstParentInfo->updateTabBar(); |
2225 | dstParentInfo->setCurrentTabId(currentId); |
2226 | } else { |
2227 | QDockAreaLayoutItem &item = dstParentInfo->item_list[idx]; |
2228 | Q_ASSERT(item.widgetItem->widget() == dwgw); |
2229 | delete item.widgetItem; |
2230 | item.widgetItem = nullptr; |
2231 | item.subinfo = new QDockAreaLayoutInfo(std::move(*srcInfo)); |
2232 | *srcInfo = QDockAreaLayoutInfo(); |
2233 | item.subinfo->reparentWidgets(p: currentHoveredFloat ? currentHoveredFloat.data() |
2234 | : parentWidget()); |
2235 | item.subinfo->setTabBarShape(dstParentInfo->tabBarShape); |
2236 | } |
2237 | dwgw->destroyOrHideIfEmpty(); |
2238 | } |
2239 | #endif |
2240 | |
2241 | if (QDockWidget *dw = qobject_cast<QDockWidget*>(object: widget)) { |
2242 | dw->setParent(currentHoveredFloat ? currentHoveredFloat.data() : parentWidget()); |
2243 | dw->show(); |
2244 | dw->d_func()->plug(rect: currentGapRect); |
2245 | } |
2246 | #endif |
2247 | #if QT_CONFIG(toolbar) |
2248 | if (QToolBar *tb = qobject_cast<QToolBar*>(object: widget)) |
2249 | tb->d_func()->plug(r: currentGapRect); |
2250 | #endif |
2251 | |
2252 | savedState.clear(); |
2253 | currentGapPos.clear(); |
2254 | pluggingWidget = nullptr; |
2255 | #if QT_CONFIG(dockwidget) |
2256 | setCurrentHoveredFloat(nullptr); |
2257 | #endif |
2258 | //applying the state will make sure that the currentGap is updated correctly |
2259 | //and all the geometries (especially the one from the central widget) is correct |
2260 | layoutState.apply(animated: false); |
2261 | |
2262 | #if QT_CONFIG(dockwidget) |
2263 | #if QT_CONFIG(tabbar) |
2264 | if (qobject_cast<QDockWidget*>(object: widget) != 0) { |
2265 | // info() might return null if the widget is destroyed while |
2266 | // animating but before the animationFinished signal is received. |
2267 | if (QDockAreaLayoutInfo *info = dockInfo(widget)) |
2268 | info->setCurrentTab(widget); |
2269 | } |
2270 | #endif |
2271 | #endif |
2272 | } |
2273 | |
2274 | if (!widgetAnimator.animating()) { |
2275 | //all animations are finished |
2276 | #if QT_CONFIG(dockwidget) |
2277 | parentWidget()->update(layoutState.dockAreaLayout.separatorRegion()); |
2278 | #if QT_CONFIG(tabbar) |
2279 | const auto usedTabBarsCopy = usedTabBars; // list potentially modified by animations |
2280 | for (QTabBar *tab_bar : usedTabBarsCopy) |
2281 | tab_bar->show(); |
2282 | #endif // QT_CONFIG(tabbar) |
2283 | #endif // QT_CONFIG(dockwidget) |
2284 | } |
2285 | |
2286 | updateGapIndicator(); |
2287 | } |
2288 | |
2289 | void QMainWindowLayout::restore(bool keepSavedState) |
2290 | { |
2291 | if (!savedState.isValid()) |
2292 | return; |
2293 | |
2294 | layoutState = savedState; |
2295 | applyState(newState&: layoutState); |
2296 | if (!keepSavedState) |
2297 | savedState.clear(); |
2298 | currentGapPos.clear(); |
2299 | pluggingWidget = nullptr; |
2300 | updateGapIndicator(); |
2301 | } |
2302 | |
2303 | QMainWindowLayout::QMainWindowLayout(QMainWindow *mainwindow, QLayout *parentLayout) |
2304 | : QLayout(parentLayout ? static_cast<QWidget *>(nullptr) : mainwindow) |
2305 | , layoutState(mainwindow) |
2306 | , savedState(mainwindow) |
2307 | , dockOptions(QMainWindow::AnimatedDocks | QMainWindow::AllowTabbedDocks) |
2308 | , statusbar(nullptr) |
2309 | #if QT_CONFIG(dockwidget) |
2310 | #if QT_CONFIG(tabbar) |
2311 | , _documentMode(false) |
2312 | , verticalTabsEnabled(false) |
2313 | #if QT_CONFIG(tabwidget) |
2314 | , _tabShape(QTabWidget::Rounded) |
2315 | #endif |
2316 | #endif |
2317 | #endif // QT_CONFIG(dockwidget) |
2318 | , widgetAnimator(this) |
2319 | , pluggingWidget(nullptr) |
2320 | { |
2321 | if (parentLayout) |
2322 | setParent(parentLayout); |
2323 | |
2324 | #if QT_CONFIG(dockwidget) |
2325 | #if QT_CONFIG(tabbar) |
2326 | sep = mainwindow->style()->pixelMetric(metric: QStyle::PM_DockWidgetSeparatorExtent, option: nullptr, widget: mainwindow); |
2327 | #endif |
2328 | |
2329 | #if QT_CONFIG(tabwidget) |
2330 | for (int i = 0; i < QInternal::DockCount; ++i) |
2331 | tabPositions[i] = QTabWidget::South; |
2332 | #endif |
2333 | #endif // QT_CONFIG(dockwidget) |
2334 | pluggingWidget = nullptr; |
2335 | |
2336 | setObjectName(mainwindow->objectName() + QLatin1String("_layout" )); |
2337 | } |
2338 | |
2339 | QMainWindowLayout::~QMainWindowLayout() |
2340 | { |
2341 | layoutState.deleteAllLayoutItems(); |
2342 | layoutState.deleteCentralWidgetItem(); |
2343 | |
2344 | delete statusbar; |
2345 | } |
2346 | |
2347 | void QMainWindowLayout::setDockOptions(QMainWindow::DockOptions opts) |
2348 | { |
2349 | if (opts == dockOptions) |
2350 | return; |
2351 | |
2352 | dockOptions = opts; |
2353 | |
2354 | #if QT_CONFIG(dockwidget) && QT_CONFIG(tabbar) |
2355 | setVerticalTabsEnabled(opts & QMainWindow::VerticalTabs); |
2356 | #endif |
2357 | |
2358 | invalidate(); |
2359 | } |
2360 | |
2361 | #if QT_CONFIG(statusbar) |
2362 | QStatusBar *QMainWindowLayout::statusBar() const |
2363 | { return statusbar ? qobject_cast<QStatusBar *>(object: statusbar->widget()) : 0; } |
2364 | |
2365 | void QMainWindowLayout::setStatusBar(QStatusBar *sb) |
2366 | { |
2367 | if (sb) |
2368 | addChildWidget(w: sb); |
2369 | delete statusbar; |
2370 | statusbar = sb ? new QWidgetItemV2(sb) : nullptr; |
2371 | invalidate(); |
2372 | } |
2373 | #endif // QT_CONFIG(statusbar) |
2374 | |
2375 | QWidget *QMainWindowLayout::centralWidget() const |
2376 | { |
2377 | return layoutState.centralWidget(); |
2378 | } |
2379 | |
2380 | void QMainWindowLayout::setCentralWidget(QWidget *widget) |
2381 | { |
2382 | if (widget != nullptr) |
2383 | addChildWidget(w: widget); |
2384 | layoutState.setCentralWidget(widget); |
2385 | if (savedState.isValid()) { |
2386 | #if QT_CONFIG(dockwidget) |
2387 | savedState.dockAreaLayout.centralWidgetItem = layoutState.dockAreaLayout.centralWidgetItem; |
2388 | savedState.dockAreaLayout.fallbackToSizeHints = true; |
2389 | #else |
2390 | savedState.centralWidgetItem = layoutState.centralWidgetItem; |
2391 | #endif |
2392 | } |
2393 | invalidate(); |
2394 | } |
2395 | |
2396 | #if QT_CONFIG(dockwidget) && QT_CONFIG(tabwidget) |
2397 | /*! \internal |
2398 | This helper function is called by QMainWindowLayout::unplug if QMainWindow::GroupedDragging is |
2399 | set and we are dragging the title bar of a non-floating QDockWidget. |
2400 | If one should unplug the whole group, do so and return true, otherwise return false. |
2401 | \a item is pointing to the QLayoutItem that holds the QDockWidget, but will be updated to the |
2402 | QLayoutItem that holds the new QDockWidgetGroupWindow if the group is unplugged. |
2403 | */ |
2404 | static bool unplugGroup(QMainWindowLayout *layout, QLayoutItem **item, |
2405 | QDockAreaLayoutItem &parentItem) |
2406 | { |
2407 | if (!parentItem.subinfo || !parentItem.subinfo->tabbed) |
2408 | return false; |
2409 | |
2410 | // The QDockWidget is part of a group of tab and we need to unplug them all. |
2411 | |
2412 | QDockWidgetGroupWindow *floatingTabs = layout->createTabbedDockWindow(); |
2413 | QDockAreaLayoutInfo *info = floatingTabs->layoutInfo(); |
2414 | *info = std::move(*parentItem.subinfo); |
2415 | delete parentItem.subinfo; |
2416 | parentItem.subinfo = nullptr; |
2417 | floatingTabs->setGeometry(info->rect.translated(p: layout->parentWidget()->pos())); |
2418 | floatingTabs->show(); |
2419 | floatingTabs->raise(); |
2420 | *item = new QDockWidgetGroupWindowItem(floatingTabs); |
2421 | parentItem.widgetItem = *item; |
2422 | return true; |
2423 | } |
2424 | #endif |
2425 | |
2426 | /*! \internal |
2427 | Unplug \a widget (QDockWidget or QToolBar) from it's parent container. |
2428 | |
2429 | If \a group is true we might actually unplug the group of tabs this |
2430 | widget is part if QMainWindow::GroupedDragging is set. When \a group |
2431 | is false, the widget itself is always unplugged alone |
2432 | |
2433 | Returns the QLayoutItem of the dragged element. |
2434 | The layout item is kept in the layout but set as a gap item. |
2435 | */ |
2436 | QLayoutItem *QMainWindowLayout::unplug(QWidget *widget, bool group) |
2437 | { |
2438 | #if QT_CONFIG(dockwidget) && QT_CONFIG(tabwidget) |
2439 | auto *groupWindow = qobject_cast<const QDockWidgetGroupWindow *>(object: widget->parentWidget()); |
2440 | if (!widget->isWindow() && groupWindow) { |
2441 | if (group && groupWindow->tabLayoutInfo()) { |
2442 | // We are just dragging a floating window as it, not need to do anything, we just have to |
2443 | // look up the corresponding QWidgetItem* if it exists |
2444 | if (QDockAreaLayoutInfo *info = dockInfo(widget: widget->parentWidget())) { |
2445 | QList<int> groupWindowPath = info->indexOf(widget: widget->parentWidget()); |
2446 | return groupWindowPath.isEmpty() ? nullptr : info->item(path: groupWindowPath).widgetItem; |
2447 | } |
2448 | return nullptr; |
2449 | } |
2450 | QList<int> path = groupWindow->layoutInfo()->indexOf(widget); |
2451 | QLayoutItem *item = groupWindow->layoutInfo()->item(path).widgetItem; |
2452 | if (group && path.size() > 1 |
2453 | && unplugGroup(layout: this, item: &item, |
2454 | parentItem&: groupWindow->layoutInfo()->item(path: path.mid(pos: 0, alength: path.size() - 1)))) { |
2455 | return item; |
2456 | } else { |
2457 | // We are unplugging a dock widget from a floating window. |
2458 | QDockWidget *dw = qobject_cast<QDockWidget *>(object: widget); |
2459 | Q_ASSERT(dw); // cannot be a QDockWidgetGroupWindow because it's not floating. |
2460 | dw->d_func()->unplug(rect: widget->geometry()); |
2461 | groupWindow->layoutInfo()->fitItems(); |
2462 | groupWindow->layoutInfo()->apply(animate: dockOptions & QMainWindow::AnimatedDocks); |
2463 | return item; |
2464 | } |
2465 | } |
2466 | #endif |
2467 | QList<int> path = layoutState.indexOf(widget); |
2468 | if (path.isEmpty()) |
2469 | return nullptr; |
2470 | |
2471 | QLayoutItem *item = layoutState.item(path); |
2472 | if (widget->isWindow()) |
2473 | return item; |
2474 | |
2475 | QRect r = layoutState.itemRect(path); |
2476 | savedState = layoutState; |
2477 | |
2478 | #if QT_CONFIG(dockwidget) |
2479 | if (QDockWidget *dw = qobject_cast<QDockWidget*>(object: widget)) { |
2480 | Q_ASSERT(path.constFirst() == 1); |
2481 | #if QT_CONFIG(tabwidget) |
2482 | if (group && (dockOptions & QMainWindow::GroupedDragging) && path.size() > 3 |
2483 | && unplugGroup(layout: this, item: &item, |
2484 | parentItem&: layoutState.dockAreaLayout.item(path: path.mid(pos: 1, alength: path.size() - 2)))) { |
2485 | path.removeLast(); |
2486 | savedState = layoutState; |
2487 | } else |
2488 | #endif // QT_CONFIG(tabwidget) |
2489 | { |
2490 | dw->d_func()->unplug(rect: r); |
2491 | } |
2492 | } |
2493 | #endif // QT_CONFIG(dockwidget) |
2494 | #if QT_CONFIG(toolbar) |
2495 | if (QToolBar *tb = qobject_cast<QToolBar*>(object: widget)) { |
2496 | tb->d_func()->unplug(r); |
2497 | } |
2498 | #endif |
2499 | |
2500 | #if !QT_CONFIG(dockwidget) || !QT_CONFIG(tabbar) |
2501 | Q_UNUSED(group); |
2502 | #endif |
2503 | |
2504 | layoutState.unplug(path ,other: &savedState); |
2505 | savedState.fitLayout(); |
2506 | currentGapPos = path; |
2507 | currentGapRect = r; |
2508 | updateGapIndicator(); |
2509 | |
2510 | fixToolBarOrientation(item, dockPos: currentGapPos.at(i: 1)); |
2511 | |
2512 | return item; |
2513 | } |
2514 | |
2515 | void QMainWindowLayout::updateGapIndicator() |
2516 | { |
2517 | #if QT_CONFIG(rubberband) |
2518 | if (!widgetAnimator.animating() && (!currentGapPos.isEmpty() |
2519 | #if QT_CONFIG(dockwidget) |
2520 | || currentHoveredFloat |
2521 | #endif |
2522 | )) { |
2523 | QWidget *expectedParent = |
2524 | #if QT_CONFIG(dockwidget) |
2525 | currentHoveredFloat ? currentHoveredFloat.data() : |
2526 | #endif |
2527 | parentWidget(); |
2528 | if (!gapIndicator) { |
2529 | gapIndicator = new QRubberBand(QRubberBand::Rectangle, expectedParent); |
2530 | // For accessibility to identify this special widget. |
2531 | gapIndicator->setObjectName(QLatin1String("qt_rubberband" )); |
2532 | } else if (gapIndicator->parent() != expectedParent) { |
2533 | gapIndicator->setParent(expectedParent); |
2534 | } |
2535 | |
2536 | #if QT_CONFIG(dockwidget) |
2537 | if (currentHoveredFloat) |
2538 | gapIndicator->setGeometry(currentHoveredFloat->currentGapRect); |
2539 | else |
2540 | #endif |
2541 | gapIndicator->setGeometry(currentGapRect); |
2542 | gapIndicator->show(); |
2543 | gapIndicator->raise(); |
2544 | } else if (gapIndicator) { |
2545 | gapIndicator->hide(); |
2546 | } |
2547 | #endif // QT_CONFIG(rubberband) |
2548 | } |
2549 | |
2550 | #if QT_CONFIG(dockwidget) && QT_CONFIG(tabwidget) |
2551 | static QTabBar::Shape tabwidgetPositionToTabBarShape(QWidget *w) |
2552 | { |
2553 | QTabBar::Shape result = QTabBar::RoundedSouth; |
2554 | if (qobject_cast<QDockWidget *>(object: w)) { |
2555 | switch (static_cast<QDockWidgetPrivate *>(qt_widget_private(widget: w))->tabPosition) { |
2556 | case QTabWidget::North: |
2557 | result = QTabBar::RoundedNorth; |
2558 | break; |
2559 | case QTabWidget::South: |
2560 | result = QTabBar::RoundedSouth; |
2561 | break; |
2562 | case QTabWidget::West: |
2563 | result = QTabBar::RoundedWest; |
2564 | break; |
2565 | case QTabWidget::East: |
2566 | result = QTabBar::RoundedEast; |
2567 | break; |
2568 | } |
2569 | } |
2570 | return result; |
2571 | } |
2572 | #endif // QT_CONFIG(dockwidget) && QT_CONFIG(tabwidget) |
2573 | |
2574 | void QMainWindowLayout::hover(QLayoutItem *widgetItem, const QPoint &mousePos) |
2575 | { |
2576 | if (!parentWidget()->isVisible() || parentWidget()->isMinimized() |
2577 | || pluggingWidget != nullptr || widgetItem == nullptr) |
2578 | return; |
2579 | |
2580 | QWidget *widget = widgetItem->widget(); |
2581 | |
2582 | #if QT_CONFIG(dockwidget) |
2583 | if ((dockOptions & QMainWindow::GroupedDragging) && (qobject_cast<QDockWidget*>(object: widget) |
2584 | || qobject_cast<QDockWidgetGroupWindow *>(object: widget))) { |
2585 | |
2586 | // Check if we are over another floating dock widget |
2587 | QVarLengthArray<QWidget *, 10> candidates; |
2588 | const auto siblings = parentWidget()->children(); |
2589 | for (QObject *c : siblings) { |
2590 | QWidget *w = qobject_cast<QWidget*>(o: c); |
2591 | if (!w) |
2592 | continue; |
2593 | if (!qobject_cast<QDockWidget*>(object: w) && !qobject_cast<QDockWidgetGroupWindow *>(object: w)) |
2594 | continue; |
2595 | if (w != widget && w->isTopLevel() && w->isVisible() && !w->isMinimized()) |
2596 | candidates << w; |
2597 | if (QDockWidgetGroupWindow *group = qobject_cast<QDockWidgetGroupWindow *>(object: w)) { |
2598 | // Sometimes, there are floating QDockWidget that have a QDockWidgetGroupWindow as a parent. |
2599 | const auto groupChildren = group->children(); |
2600 | for (QObject *c : groupChildren) { |
2601 | if (QDockWidget *dw = qobject_cast<QDockWidget*>(object: c)) { |
2602 | if (dw != widget && dw->isFloating() && dw->isVisible() && !dw->isMinimized()) |
2603 | candidates << dw; |
2604 | } |
2605 | } |
2606 | } |
2607 | } |
2608 | for (QWidget *w : candidates) { |
2609 | const QScreen *screen1 = qt_widget_private(widget)->associatedScreen(); |
2610 | const QScreen *screen2 = qt_widget_private(widget: w)->associatedScreen(); |
2611 | if (screen1 && screen2 && screen1 != screen2) |
2612 | continue; |
2613 | if (!w->geometry().contains(p: mousePos)) |
2614 | continue; |
2615 | |
2616 | #if QT_CONFIG(tabwidget) |
2617 | if (auto dropTo = qobject_cast<QDockWidget *>(object: w)) { |
2618 | // dropping to a normal widget, we mutate it in a QDockWidgetGroupWindow with two |
2619 | // tabs |
2620 | QDockWidgetGroupWindow *floatingTabs = createTabbedDockWindow(); // FIXME |
2621 | floatingTabs->setGeometry(dropTo->geometry()); |
2622 | QDockAreaLayoutInfo *info = floatingTabs->layoutInfo(); |
2623 | const QTabBar::Shape shape = tabwidgetPositionToTabBarShape(w: dropTo); |
2624 | *info = QDockAreaLayoutInfo(&layoutState.dockAreaLayout.sep, QInternal::LeftDock, |
2625 | Qt::Horizontal, shape, |
2626 | static_cast<QMainWindow *>(parentWidget())); |
2627 | info->tabbed = true; |
2628 | QLayout *parentLayout = dropTo->parentWidget()->layout(); |
2629 | info->item_list.append( |
2630 | t: QDockAreaLayoutItem(parentLayout->takeAt(index: parentLayout->indexOf(dropTo)))); |
2631 | |
2632 | dropTo->setParent(floatingTabs); |
2633 | dropTo->show(); |
2634 | dropTo->d_func()->plug(rect: QRect()); |
2635 | w = floatingTabs; |
2636 | widget->raise(); // raise, as our newly created drop target is now on top |
2637 | } |
2638 | #endif |
2639 | Q_ASSERT(qobject_cast<QDockWidgetGroupWindow *>(w)); |
2640 | auto group = static_cast<QDockWidgetGroupWindow *>(w); |
2641 | if (group->hover(widgetItem, mousePos: group->mapFromGlobal(mousePos))) { |
2642 | setCurrentHoveredFloat(group); |
2643 | applyState(newState&: layoutState); // update the tabbars |
2644 | } |
2645 | return; |
2646 | } |
2647 | } |
2648 | setCurrentHoveredFloat(nullptr); |
2649 | layoutState.dockAreaLayout.fallbackToSizeHints = false; |
2650 | #endif // QT_CONFIG(dockwidget) |
2651 | |
2652 | QPoint pos = parentWidget()->mapFromGlobal(mousePos); |
2653 | |
2654 | if (!savedState.isValid()) |
2655 | savedState = layoutState; |
2656 | |
2657 | QList<int> path = savedState.gapIndex(widget, pos); |
2658 | |
2659 | if (!path.isEmpty()) { |
2660 | bool allowed = false; |
2661 | |
2662 | #if QT_CONFIG(dockwidget) |
2663 | if (QDockWidget *dw = qobject_cast<QDockWidget*>(object: widget)) |
2664 | allowed = dw->isAreaAllowed(area: toDockWidgetArea(pos: path.at(i: 1))); |
2665 | |
2666 | // Read permissions from a DockWidgetGroupWindow depending on its DockWidget children |
2667 | if (QDockWidgetGroupWindow* dwgw = qobject_cast<QDockWidgetGroupWindow *>(object: widget)) { |
2668 | const QList<QDockWidget*> children = dwgw->findChildren<QDockWidget*>(aName: QString(), options: Qt::FindDirectChildrenOnly); |
2669 | |
2670 | if (children.count() == 1) { |
2671 | // Group window has a single child => read its permissions |
2672 | allowed = children.at(i: 0)->isAreaAllowed(area: toDockWidgetArea(pos: path.at(i: 1))); |
2673 | } else { |
2674 | // Group window has more than one or no children => dock it anywhere |
2675 | allowed = true; |
2676 | } |
2677 | } |
2678 | #endif |
2679 | #if QT_CONFIG(toolbar) |
2680 | if (QToolBar *tb = qobject_cast<QToolBar*>(object: widget)) |
2681 | allowed = tb->isAreaAllowed(area: toToolBarArea(pos: path.at(i: 1))); |
2682 | #endif |
2683 | |
2684 | if (!allowed) |
2685 | path.clear(); |
2686 | } |
2687 | |
2688 | if (path == currentGapPos) |
2689 | return; // the gap is already there |
2690 | |
2691 | currentGapPos = path; |
2692 | if (path.isEmpty()) { |
2693 | fixToolBarOrientation(item: widgetItem, dockPos: 2); // 2 = top dock, ie. horizontal |
2694 | restore(keepSavedState: true); |
2695 | return; |
2696 | } |
2697 | |
2698 | fixToolBarOrientation(item: widgetItem, dockPos: currentGapPos.at(i: 1)); |
2699 | |
2700 | QMainWindowLayoutState newState = savedState; |
2701 | |
2702 | if (!newState.insertGap(path, item: widgetItem)) { |
2703 | restore(keepSavedState: true); // not enough space |
2704 | return; |
2705 | } |
2706 | |
2707 | QSize min = newState.minimumSize(); |
2708 | QSize size = newState.rect.size(); |
2709 | |
2710 | if (min.width() > size.width() || min.height() > size.height()) { |
2711 | restore(keepSavedState: true); |
2712 | return; |
2713 | } |
2714 | |
2715 | newState.fitLayout(); |
2716 | |
2717 | currentGapRect = newState.gapRect(path: currentGapPos); |
2718 | |
2719 | #if QT_CONFIG(dockwidget) |
2720 | parentWidget()->update(layoutState.dockAreaLayout.separatorRegion()); |
2721 | #endif |
2722 | layoutState = std::move(newState); |
2723 | applyState(newState&: layoutState); |
2724 | |
2725 | updateGapIndicator(); |
2726 | } |
2727 | |
2728 | #if QT_CONFIG(dockwidget) && QT_CONFIG(tabwidget) |
2729 | QDockWidgetGroupWindow *QMainWindowLayout::createTabbedDockWindow() |
2730 | { |
2731 | QDockWidgetGroupWindow* f = new QDockWidgetGroupWindow(parentWidget(), Qt::Tool); |
2732 | new QDockWidgetGroupLayout(f); |
2733 | return f; |
2734 | } |
2735 | #endif |
2736 | |
2737 | void QMainWindowLayout::applyState(QMainWindowLayoutState &newState, bool animate) |
2738 | { |
2739 | #if QT_CONFIG(dockwidget) && QT_CONFIG(tabwidget) |
2740 | QSet<QTabBar*> used = newState.dockAreaLayout.usedTabBars(); |
2741 | const auto groups = |
2742 | parent()->findChildren<QDockWidgetGroupWindow*>(aName: QString(), options: Qt::FindDirectChildrenOnly); |
2743 | for (QDockWidgetGroupWindow *dwgw : groups) |
2744 | used += dwgw->layoutInfo()->usedTabBars(); |
2745 | |
2746 | const QSet<QTabBar*> retired = usedTabBars - used; |
2747 | usedTabBars = used; |
2748 | for (QTabBar *tab_bar : retired) { |
2749 | tab_bar->hide(); |
2750 | while (tab_bar->count() > 0) |
2751 | tab_bar->removeTab(index: 0); |
2752 | unusedTabBars.append(t: tab_bar); |
2753 | } |
2754 | |
2755 | if (sep == 1) { |
2756 | const QSet<QWidget*> usedSeps = newState.dockAreaLayout.usedSeparatorWidgets(); |
2757 | const QSet<QWidget*> retiredSeps = usedSeparatorWidgets - usedSeps; |
2758 | usedSeparatorWidgets = usedSeps; |
2759 | for (QWidget *sepWidget : retiredSeps) { |
2760 | unusedSeparatorWidgets.append(t: sepWidget); |
2761 | } |
2762 | } |
2763 | |
2764 | for (int i = 0; i < QInternal::DockCount; ++i) |
2765 | newState.dockAreaLayout.docks[i].reparentWidgets(p: parentWidget()); |
2766 | |
2767 | #endif // QT_CONFIG(dockwidget) && QT_CONFIG(tabwidget) |
2768 | newState.apply(animated: dockOptions & QMainWindow::AnimatedDocks && animate); |
2769 | } |
2770 | |
2771 | void QMainWindowLayout::saveState(QDataStream &stream) const |
2772 | { |
2773 | layoutState.saveState(stream); |
2774 | } |
2775 | |
2776 | bool QMainWindowLayout::restoreState(QDataStream &stream) |
2777 | { |
2778 | savedState = layoutState; |
2779 | layoutState.clear(); |
2780 | layoutState.rect = savedState.rect; |
2781 | |
2782 | if (!layoutState.restoreState(stream&: stream, oldState: savedState)) { |
2783 | layoutState.deleteAllLayoutItems(); |
2784 | layoutState = savedState; |
2785 | if (parentWidget()->isVisible()) |
2786 | applyState(newState&: layoutState, animate: false); // hides tabBars allocated by newState |
2787 | return false; |
2788 | } |
2789 | |
2790 | if (parentWidget()->isVisible()) { |
2791 | layoutState.fitLayout(); |
2792 | applyState(newState&: layoutState, animate: false); |
2793 | } |
2794 | |
2795 | savedState.deleteAllLayoutItems(); |
2796 | savedState.clear(); |
2797 | |
2798 | #if QT_CONFIG(dockwidget) |
2799 | if (parentWidget()->isVisible()) { |
2800 | #if QT_CONFIG(tabbar) |
2801 | for (QTabBar *tab_bar : qAsConst(t&: usedTabBars)) |
2802 | tab_bar->show(); |
2803 | |
2804 | #endif |
2805 | } |
2806 | #endif // QT_CONFIG(dockwidget) |
2807 | |
2808 | return true; |
2809 | } |
2810 | |
2811 | QT_END_NAMESPACE |
2812 | |
2813 | #include "moc_qmainwindowlayout_p.cpp" |
2814 | |