1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qmainwindowlayout_p.h"

    43 #include "qdockarealayout_p.h"

    44 

    45 #ifndef QT_NO_MAINWINDOW

    46 #include "qdockwidget.h"

    47 #include "qdockwidget_p.h"

    48 #include "qtoolbar_p.h"

    49 #include "qmainwindow.h"

    50 #include "qmainwindowlayout_p.h"

    51 #include "qtoolbar.h"

    52 #include "qtoolbarlayout_p.h"

    53 #include "qwidgetanimator_p.h"

    54 #include "qrubberband.h"

    55 #include "qdockwidget_p.h"

    56 #include "qtabbar_p.h"

    57 

    58 #include <qapplication.h>

    59 #include <qstatusbar.h>

    60 #include <qstring.h>

    61 #include <qstyle.h>

    62 #include <qvarlengtharray.h>

    63 #include <qstack.h>

    64 #include <qmap.h>

    65 #include <qtimer.h>

    66 

    67 #include <qdebug.h>

    68 

    69 #include <private/qapplication_p.h>

    70 #include <private/qlayoutengine_p.h>

    71 #ifdef Q_WS_MAC

    72 #   include <private/qcore_mac_p.h>

    73 #   include <private/qt_cocoa_helpers_mac_p.h>

    74 #endif

    75 

    76 #ifdef Q_DEBUG_MAINWINDOW_LAYOUT

    77 #   include <QTextStream>

    78 #endif

    79 

    80 QT_BEGIN_NAMESPACE

    81 

    82 /******************************************************************************

    83 ** debug

    84 */

    85 

    86 #if defined(Q_DEBUG_MAINWINDOW_LAYOUT) && !defined(QT_NO_DOCKWIDGET)

    87 

    88 static QTextStream qout(stderr, QIODevice::WriteOnly);

    89 

    90 static void dumpLayout(QTextStream &qout, const QDockAreaLayoutInfo &layout, QString indent);

    91 

    92 static void dumpLayout(QTextStream &qout, const QDockAreaLayoutItem &item, QString indent)

    93 {

    94     qout << indent << "QDockAreaLayoutItem: "

    95             << "pos: " << item.pos << " size:" << item.size

    96             << " gap:" << (item.flags & QDockAreaLayoutItem::GapItem)

    97             << " keepSize:" << (item.flags & QDockAreaLayoutItem::KeepSize) << '\n';

    98     indent += QLatin1String("  ");

    99     if (item.widgetItem != 0) {

   100         qout << indent << "widget: "

   101             << item.widgetItem->widget()->metaObject()->className()

   102             << ' ' << item.widgetItem->widget()->windowTitle() << '\n';

   103     } else if (item.subinfo != 0) {

   104         qout << indent << "subinfo:\n";

   105         dumpLayout(qout, *item.subinfo, indent + QLatin1String("  "));

   106     } else if (item.placeHolderItem != 0) {

   107         QRect r = item.placeHolderItem->topLevelRect;

   108         qout << indent << "placeHolder: "

   109             << "pos: " << item.pos << " size:" << item.size

   110             << " gap:" << (item.flags & QDockAreaLayoutItem::GapItem)

   111             << " keepSize:" << (item.flags & QDockAreaLayoutItem::KeepSize)

   112             << " objectName:" << item.placeHolderItem->objectName

   113             << " hidden:" << item.placeHolderItem->hidden

   114             << " window:" << item.placeHolderItem->window

   115             << " rect:" << r.x() << ',' << r.y() << ' '

   116             << r.width() << 'x' << r.height() << '\n';

   117     }

   118     qout.flush();

   119 }

   120 

   121 static void dumpLayout(QTextStream &qout, const QDockAreaLayoutInfo &layout, QString indent)

   122 {

   123     qout << indent << "QDockAreaLayoutInfo: "

   124             << layout.rect.left() << ','

   125             << layout.rect.top() << ' '

   126             << layout.rect.width() << 'x'

   127             << layout.rect.height()

   128             << " orient:" << layout.o

   129             << " tabbed:" << layout.tabbed

   130             << " tbshape:" << layout.tabBarShape << '\n';

   131 

   132     indent += QLatin1String("  ");

   133 

   134     for (int i = 0; i < layout.item_list.count(); ++i) {

   135         qout << indent << "Item: " << i << '\n';

   136         dumpLayout(qout, layout.item_list.at(i), indent + QLatin1String("  "));

   137     }

   138     qout.flush();

   139 };

   140 

   141 static void dumpLayout(QTextStream &qout, const QDockAreaLayout &layout, QString indent)

   142 {

   143     qout << indent << "QDockAreaLayout: "

   144             << layout.rect.left() << ','

   145             << layout.rect.top() << ' '

   146             << layout.rect.width() << 'x'

   147             << layout.rect.height() << '\n';

   148 

   149     qout << indent << "TopDockArea:\n";

   150     dumpLayout(qout, layout.docks[QInternal::TopDock], indent + QLatin1String("  "));

   151     qout << indent << "LeftDockArea:\n";

   152     dumpLayout(qout, layout.docks[QInternal::LeftDock], indent + QLatin1String("  "));

   153     qout << indent << "RightDockArea:\n";

   154     dumpLayout(qout, layout.docks[QInternal::RightDock], indent + QLatin1String("  "));

   155     qout << indent << "BottomDockArea:\n";

   156     dumpLayout(qout, layout.docks[QInternal::BottomDock], indent + QLatin1String("  "));

   157 

   158     qout.flush();

   159 };

   160 

   161 void qt_dumpLayout(QTextStream &qout, QMainWindow *window)

   162 {

   163     QMainWindowLayout *layout = qobject_cast<QMainWindowLayout*>(window->layout());

   164     dumpLayout(qout, layout->layoutState.dockAreaLayout, QString());

   165 }

   166 

   167 #endif // Q_DEBUG_MAINWINDOW_LAYOUT && !QT_NO_DOCKWIDGET

   168 

   169 /******************************************************************************

   170 ** QMainWindowLayoutState

   171 */

   172 

   173 // we deal with all the #ifndefferry here so QMainWindowLayout code is clean

   174 

   175 QMainWindowLayoutState::QMainWindowLayoutState(QMainWindow *win)

   176     :

   177 #ifndef QT_NO_TOOLBAR

   178     toolBarAreaLayout(win),

   179 #endif

   180 #ifndef QT_NO_DOCKWIDGET

   181     dockAreaLayout(win)

   182 #else

   183     centralWidgetItem(0)

   184 #endif

   185 

   186 {

   187     mainWindow = win;

   188 }

   189 

   190 QSize QMainWindowLayoutState::sizeHint() const

   191 {

   192 

   193     QSize result(0, 0);

   194 

   195 #ifndef QT_NO_DOCKWIDGET

   196     result = dockAreaLayout.sizeHint();

   197 #else

   198     if (centralWidgetItem != 0)

   199         result = centralWidgetItem->sizeHint();

   200 #endif

   201 

   202 #ifndef QT_NO_TOOLBAR

   203     result = toolBarAreaLayout.sizeHint(result);

   204 #endif // QT_NO_TOOLBAR

   205 

   206     return result;

   207 }

   208 

   209 QSize QMainWindowLayoutState::minimumSize() const

   210 {

   211     QSize result(0, 0);

   212 

   213 #ifndef QT_NO_DOCKWIDGET

   214     result = dockAreaLayout.minimumSize();

   215 #else

   216     if (centralWidgetItem != 0)

   217         result = centralWidgetItem->minimumSize();

   218 #endif

   219 

   220 #ifndef QT_NO_TOOLBAR

   221     result = toolBarAreaLayout.minimumSize(result);

   222 #endif // QT_NO_TOOLBAR

   223 

   224     return result;

   225 }

   226 

   227 void QMainWindowLayoutState::apply(bool animated)

   228 {

   229 #ifndef QT_NO_TOOLBAR

   230     toolBarAreaLayout.apply(animated);

   231 #endif

   232 

   233 #ifndef QT_NO_DOCKWIDGET

   234 //    dumpLayout(dockAreaLayout, QString());

   235     dockAreaLayout.apply(animated);

   236 #else

   237     if (centralWidgetItem != 0) {

   238         QMainWindowLayout *layout = qobject_cast<QMainWindowLayout*>(mainWindow->layout());

   239         Q_ASSERT(layout != 0);

   240         layout->widgetAnimator.animate(centralWidgetItem->widget(), centralWidgetRect, animated);

   241     }

   242 #endif

   243 }

   244 

   245 void QMainWindowLayoutState::fitLayout()

   246 {

   247     QRect r;

   248 #ifdef QT_NO_TOOLBAR

   249     r = rect;

   250 #else

   251     toolBarAreaLayout.rect = rect;

   252     r = toolBarAreaLayout.fitLayout();

   253 #endif // QT_NO_TOOLBAR

   254 

   255 #ifndef QT_NO_DOCKWIDGET

   256     dockAreaLayout.rect = r;

   257     dockAreaLayout.fitLayout();

   258 #else

   259     centralWidgetRect = r;

   260 #endif

   261 }

   262 

   263 void QMainWindowLayoutState::deleteAllLayoutItems()

   264 {

   265 #ifndef QT_NO_TOOLBAR

   266     toolBarAreaLayout.deleteAllLayoutItems();

   267 #endif

   268 

   269 #ifndef QT_NO_DOCKWIDGET

   270     dockAreaLayout.deleteAllLayoutItems();

   271 #endif

   272 }

   273 

   274 void QMainWindowLayoutState::deleteCentralWidgetItem()

   275 {

   276 #ifndef QT_NO_DOCKWIDGET

   277     delete dockAreaLayout.centralWidgetItem;

   278     dockAreaLayout.centralWidgetItem = 0;

   279 #else

   280     delete centralWidgetItem;

   281     centralWidgetItem = 0;

   282 #endif

   283 }

   284 

   285 QLayoutItem *QMainWindowLayoutState::itemAt(int index, int *x) const

   286 {

   287 #ifndef QT_NO_TOOLBAR

   288     if (QLayoutItem *ret = toolBarAreaLayout.itemAt(x, index))

   289         return ret;

   290 #endif

   291 

   292 #ifndef QT_NO_DOCKWIDGET

   293     if (QLayoutItem *ret = dockAreaLayout.itemAt(x, index))

   294         return ret;

   295 #else

   296     if (centralWidgetItem != 0 && (*x)++ == index)

   297         return centralWidgetItem;

   298 #endif

   299 

   300     return 0;

   301 }

   302 

   303 QLayoutItem *QMainWindowLayoutState::takeAt(int index, int *x)

   304 {

   305 #ifndef QT_NO_TOOLBAR

   306     if (QLayoutItem *ret = toolBarAreaLayout.takeAt(x, index))

   307         return ret;

   308 #endif

   309 

   310 #ifndef QT_NO_DOCKWIDGET

   311     if (QLayoutItem *ret = dockAreaLayout.takeAt(x, index))

   312         return ret;

   313 #else

   314     if (centralWidgetItem != 0 && (*x)++ == index) {

   315         QLayoutItem *ret = centralWidgetItem;

   316         centralWidgetItem = 0;

   317         return ret;

   318     }

   319 #endif

   320 

   321     return 0;

   322 }

   323 

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

   325 {

   326     QList<int> result;

   327 

   328 #ifndef QT_NO_TOOLBAR

   329     // is it a toolbar?

   330     if (QToolBar *toolBar = qobject_cast<QToolBar*>(widget)) {

   331         result = toolBarAreaLayout.indexOf(toolBar);

   332         if (!result.isEmpty())

   333             result.prepend(0);

   334         return result;

   335     }

   336 #endif

   337 

   338 #ifndef QT_NO_DOCKWIDGET

   339     // is it a dock widget?

   340     if (QDockWidget *dockWidget = qobject_cast<QDockWidget *>(widget)) {

   341         result = dockAreaLayout.indexOf(dockWidget);

   342         if (!result.isEmpty())

   343             result.prepend(1);

   344         return result;

   345     }

   346 #endif //QT_NO_DOCKWIDGET

   347 

   348     return result;

   349 }

   350 

   351 bool QMainWindowLayoutState::contains(QWidget *widget) const

   352 {

   353 #ifndef QT_NO_DOCKWIDGET

   354     if (dockAreaLayout.centralWidgetItem != 0 && dockAreaLayout.centralWidgetItem->widget() == widget)

   355         return true;

   356     if (!dockAreaLayout.indexOf(widget).isEmpty())

   357         return true;

   358 #else

   359     if (centralWidgetItem != 0 && centralWidgetItem->widget() == widget)

   360         return true;

   361 #endif

   362 

   363 #ifndef QT_NO_TOOLBAR

   364     if (!toolBarAreaLayout.indexOf(widget).isEmpty())

   365         return true;

   366 #endif

   367     return false;

   368 }

   369 

   370 void QMainWindowLayoutState::setCentralWidget(QWidget *widget)

   371 {

   372     QLayoutItem *item = 0;

   373     //make sure we remove the widget

   374     deleteCentralWidgetItem();

   375 

   376     if (widget != 0)

   377         item = new QWidgetItemV2(widget);

   378 

   379 #ifndef QT_NO_DOCKWIDGET

   380     dockAreaLayout.centralWidgetItem = item;

   381 #else

   382     centralWidgetItem = item;

   383 #endif

   384 }

   385 

   386 QWidget *QMainWindowLayoutState::centralWidget() const

   387 {

   388     QLayoutItem *item = 0;

   389 

   390 #ifndef QT_NO_DOCKWIDGET

   391     item = dockAreaLayout.centralWidgetItem;

   392 #else

   393     item = centralWidgetItem;

   394 #endif

   395 

   396     if (item != 0)

   397         return item->widget();

   398     return 0;

   399 }

   400 

   401 QList<int> QMainWindowLayoutState::gapIndex(QWidget *widget,

   402                                             const QPoint &pos) const

   403 {

   404     QList<int> result;

   405 

   406 #ifndef QT_NO_TOOLBAR

   407     // is it a toolbar?

   408     if (qobject_cast<QToolBar*>(widget) != 0) {

   409         result = toolBarAreaLayout.gapIndex(pos);

   410         if (!result.isEmpty())

   411             result.prepend(0);

   412         return result;

   413     }

   414 #endif

   415 

   416 #ifndef QT_NO_DOCKWIDGET

   417     // is it a dock widget?

   418     if (qobject_cast<QDockWidget *>(widget) != 0) {

   419         result = dockAreaLayout.gapIndex(pos);

   420         if (!result.isEmpty())

   421             result.prepend(1);

   422         return result;

   423     }

   424 #endif //QT_NO_DOCKWIDGET

   425 

   426     return result;

   427 }

   428 

   429 bool QMainWindowLayoutState::insertGap(const QList<int> &path, QLayoutItem *item)

   430 {

   431     if (path.isEmpty())

   432         return false;

   433 

   434     int i = path.first();

   435 

   436 #ifndef QT_NO_TOOLBAR

   437     if (i == 0) {

   438         Q_ASSERT(qobject_cast<QToolBar*>(item->widget()) != 0);

   439         return toolBarAreaLayout.insertGap(path.mid(1), item);

   440     }

   441 #endif

   442 

   443 #ifndef QT_NO_DOCKWIDGET

   444     if (i == 1) {

   445         Q_ASSERT(qobject_cast<QDockWidget*>(item->widget()) != 0);

   446         return dockAreaLayout.insertGap(path.mid(1), item);

   447     }

   448 #endif //QT_NO_DOCKWIDGET

   449 

   450     return false;

   451 }

   452 

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

   454 {

   455     int i = path.first();

   456 

   457 #ifndef QT_NO_TOOLBAR

   458     if (i == 0)

   459         toolBarAreaLayout.remove(path.mid(1));

   460 #endif

   461 

   462 #ifndef QT_NO_DOCKWIDGET

   463     if (i == 1)

   464         dockAreaLayout.remove(path.mid(1));

   465 #endif //QT_NO_DOCKWIDGET

   466 }

   467 

   468 void QMainWindowLayoutState::remove(QLayoutItem *item)

   469 {

   470 #ifndef QT_NO_TOOLBAR

   471     toolBarAreaLayout.remove(item);

   472 #endif

   473 

   474 #ifndef QT_NO_DOCKWIDGET

   475     // is it a dock widget?

   476     if (QDockWidget *dockWidget = qobject_cast<QDockWidget *>(item->widget())) {

   477         QList<int> path = dockAreaLayout.indexOf(dockWidget);

   478         if (!path.isEmpty())

   479             dockAreaLayout.remove(path);

   480     }

   481 #endif //QT_NO_DOCKWIDGET

   482 }

   483 

   484 void QMainWindowLayoutState::clear()

   485 {

   486 #ifndef QT_NO_TOOLBAR

   487     toolBarAreaLayout.clear();

   488 #endif

   489 

   490 #ifndef QT_NO_DOCKWIDGET

   491     dockAreaLayout.clear();

   492 #else

   493     centralWidgetRect = QRect();

   494 #endif

   495 

   496     rect = QRect();

   497 }

   498 

   499 bool QMainWindowLayoutState::isValid() const

   500 {

   501     return rect.isValid();

   502 }

   503 

   504 QLayoutItem *QMainWindowLayoutState::item(const QList<int> &path)

   505 {

   506     int i = path.first();

   507 

   508 #ifndef QT_NO_TOOLBAR

   509     if (i == 0)

   510         return toolBarAreaLayout.item(path.mid(1)).widgetItem;

   511 #endif

   512 

   513 #ifndef QT_NO_DOCKWIDGET

   514     if (i == 1)

   515         return dockAreaLayout.item(path.mid(1)).widgetItem;

   516 #endif //QT_NO_DOCKWIDGET

   517 

   518     return 0;

   519 }

   520 

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

   522 {

   523     int i = path.first();

   524 

   525 #ifndef QT_NO_TOOLBAR

   526     if (i == 0)

   527         return toolBarAreaLayout.itemRect(path.mid(1));

   528 #endif

   529 

   530 #ifndef QT_NO_DOCKWIDGET

   531     if (i == 1)

   532         return dockAreaLayout.itemRect(path.mid(1));

   533 #endif //QT_NO_DOCKWIDGET

   534 

   535     return QRect();

   536 }

   537 

   538 QRect QMainWindowLayoutState::gapRect(const QList<int> &path) const

   539 {

   540     int i = path.first();

   541 

   542 #ifndef QT_NO_TOOLBAR

   543     if (i == 0)

   544         return toolBarAreaLayout.itemRect(path.mid(1));

   545 #endif

   546 

   547 #ifndef QT_NO_DOCKWIDGET

   548     if (i == 1)

   549         return dockAreaLayout.gapRect(path.mid(1));

   550 #endif //QT_NO_DOCKWIDGET

   551 

   552     return QRect();

   553 }

   554 

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

   556 {

   557     int i = path.first();

   558 

   559 #ifndef QT_NO_TOOLBAR

   560     if (i == 0)

   561         return toolBarAreaLayout.plug(path.mid(1));

   562 #endif

   563 

   564 #ifndef QT_NO_DOCKWIDGET

   565     if (i == 1)

   566         return dockAreaLayout.plug(path.mid(1));

   567 #endif //QT_NO_DOCKWIDGET

   568 

   569     return 0;

   570 }

   571 

   572 QLayoutItem *QMainWindowLayoutState::unplug(const QList<int> &path, QMainWindowLayoutState *other)

   573 {

   574     int i = path.first();

   575 

   576 #ifdef QT_NO_TOOLBAR

   577     Q_UNUSED(other);

   578 #else

   579     if (i == 0)

   580         return toolBarAreaLayout.unplug(path.mid(1), other ? &other->toolBarAreaLayout : 0);

   581 #endif

   582 

   583 #ifndef QT_NO_DOCKWIDGET

   584     if (i == 1)

   585         return dockAreaLayout.unplug(path.mid(1));

   586 #endif //QT_NO_DOCKWIDGET

   587 

   588     return 0;

   589 }

   590 

   591 void QMainWindowLayoutState::saveState(QDataStream &stream) const

   592 {

   593 #ifndef QT_NO_DOCKWIDGET

   594     dockAreaLayout.saveState(stream);

   595 #endif

   596 #ifndef QT_NO_TOOLBAR

   597     toolBarAreaLayout.saveState(stream);

   598 #endif

   599 }

   600 

   601 template <typename T>

   602 static QList<T> findChildrenHelper(const QObject *o)

   603 {

   604     const QObjectList &list = o->children();

   605     QList<T> result;

   606 

   607     for (int i=0; i < list.size(); ++i) {

   608         if (T t = qobject_cast<T>(list[i])) {

   609             result.append(t);

   610         }

   611     }

   612 

   613     return result;

   614 }

   615 

   616 //pre4.3 tests the format that was used before 4.3

   617 bool QMainWindowLayoutState::checkFormat(QDataStream &stream, bool pre43)

   618 {

   619 #ifdef QT_NO_TOOLBAR

   620     Q_UNUSED(pre43);

   621 #endif

   622     while (!stream.atEnd()) {

   623         uchar marker;

   624         stream >> marker;

   625         switch(marker)

   626         {

   627 #ifndef QT_NO_TOOLBAR

   628             case QToolBarAreaLayout::ToolBarStateMarker:

   629             case QToolBarAreaLayout::ToolBarStateMarkerEx:

   630                 {

   631                     QList<QToolBar *> toolBars = findChildrenHelper<QToolBar*>(mainWindow);

   632                     if (!toolBarAreaLayout.restoreState(stream, toolBars, marker,

   633                         pre43 /*testing 4.3 format*/, true /*testing*/)) {

   634                             return false;

   635                     }

   636                 }

   637                 break;

   638 #endif // QT_NO_TOOLBAR

   639 

   640 #ifndef QT_NO_DOCKWIDGET

   641             case QDockAreaLayout::DockWidgetStateMarker:

   642                 {

   643                     QList<QDockWidget *> dockWidgets = findChildrenHelper<QDockWidget*>(mainWindow);

   644                     if (!dockAreaLayout.restoreState(stream, dockWidgets, true /*testing*/)) {

   645                         return false;

   646                     }

   647                 }

   648                 break;

   649 #endif

   650             default:

   651                 //there was an error during the parsing

   652                 return false;

   653         }// switch

   654     } //while

   655 

   656     //everything went fine: it must be a pre-4.3 saved state

   657     return true;

   658 }

   659 

   660 bool QMainWindowLayoutState::restoreState(QDataStream &_stream,

   661                                         const QMainWindowLayoutState &oldState)

   662 {

   663     //make a copy of the data so that we can read it more than once

   664     QByteArray copy;

   665     while(!_stream.atEnd()) {

   666         int length = 1024;

   667         QByteArray ba(length, '\0');

   668         length = _stream.readRawData(ba.data(), ba.size());

   669         ba.resize(length);

   670         copy += ba;

   671     }

   672 

   673     QDataStream ds(copy);

   674     const bool oldFormat = !checkFormat(ds, false);

   675     if (oldFormat) {

   676         //we should try with the old format

   677         QDataStream ds2(copy);

   678         if (!checkFormat(ds2, true)) {

   679             return false; //format unknown

   680         }

   681     }

   682 

   683     QDataStream stream(copy);

   684 

   685     while (!stream.atEnd()) {

   686         uchar marker;

   687         stream >> marker;

   688         switch(marker)

   689         {

   690 #ifndef QT_NO_DOCKWIDGET

   691             case QDockAreaLayout::DockWidgetStateMarker:

   692                 {

   693                     QList<QDockWidget *> dockWidgets = findChildrenHelper<QDockWidget*>(mainWindow);

   694                     if (!dockAreaLayout.restoreState(stream, dockWidgets))

   695                         return false;

   696 

   697                     for (int i = 0; i < dockWidgets.size(); ++i) {

   698                         QDockWidget *w = dockWidgets.at(i);

   699                         QList<int> path = dockAreaLayout.indexOf(w);

   700                         if (path.isEmpty()) {

   701                             QList<int> oldPath = oldState.dockAreaLayout.indexOf(w);

   702                             if (oldPath.isEmpty()) {

   703                                 continue;

   704                             }

   705                             QDockAreaLayoutInfo *info = dockAreaLayout.info(oldPath);

   706                             if (info == 0) {

   707                                 continue;

   708                             }

   709                             info->item_list.append(QDockAreaLayoutItem(new QDockWidgetItem(w)));

   710                         }

   711                     }

   712                 }

   713                 break;

   714 #endif // QT_NO_DOCKWIDGET

   715 

   716 #ifndef QT_NO_TOOLBAR

   717             case QToolBarAreaLayout::ToolBarStateMarker:

   718             case QToolBarAreaLayout::ToolBarStateMarkerEx:

   719                 {

   720                     QList<QToolBar *> toolBars = findChildrenHelper<QToolBar*>(mainWindow);

   721                     if (!toolBarAreaLayout.restoreState(stream, toolBars, marker, oldFormat))

   722                         return false;

   723 

   724                     for (int i = 0; i < toolBars.size(); ++i) {

   725                         QToolBar *w = toolBars.at(i);

   726                         QList<int> path = toolBarAreaLayout.indexOf(w);

   727                         if (path.isEmpty()) {

   728                             QList<int> oldPath = oldState.toolBarAreaLayout.indexOf(w);

   729                             if (oldPath.isEmpty()) {

   730                                 continue;

   731                             }

   732                             toolBarAreaLayout.docks[oldPath.at(0)].insertToolBar(0, w);

   733                         }

   734                     }

   735                 }

   736                 break;

   737 #endif //QT_NO_TOOLBAR

   738             default:

   739                 return false;

   740         }// switch

   741     } //while

   742 

   743 

   744     return true;

   745 }

   746 

   747 /******************************************************************************

   748 ** QMainWindowLayoutState - toolbars

   749 */

   750 

   751 #ifndef QT_NO_TOOLBAR

   752 

   753 static inline void validateToolBarArea(Qt::ToolBarArea &area)

   754 {

   755     switch (area) {

   756     case Qt::LeftToolBarArea:

   757     case Qt::RightToolBarArea:

   758     case Qt::TopToolBarArea:

   759     case Qt::BottomToolBarArea:

   760         break;

   761     default:

   762         area = Qt::TopToolBarArea;

   763     }

   764 }

   765 

   766 static QInternal::DockPosition toDockPos(Qt::ToolBarArea area)

   767 {

   768     switch (area) {

   769         case Qt::LeftToolBarArea: return QInternal::LeftDock;

   770         case Qt::RightToolBarArea: return QInternal::RightDock;

   771         case Qt::TopToolBarArea: return QInternal::TopDock;

   772         case Qt::BottomToolBarArea: return QInternal::BottomDock;

   773         default:

   774             break;

   775     }

   776 

   777     return QInternal::DockCount;

   778 }

   779 

   780 static Qt::ToolBarArea toToolBarArea(QInternal::DockPosition pos)

   781 {

   782     switch (pos) {

   783         case QInternal::LeftDock:   return Qt::LeftToolBarArea;

   784         case QInternal::RightDock:  return Qt::RightToolBarArea;

   785         case QInternal::TopDock:    return Qt::TopToolBarArea;

   786         case QInternal::BottomDock: return Qt::BottomToolBarArea;

   787         default: break;

   788     }

   789     return Qt::NoToolBarArea;

   790 }

   791 

   792 static inline Qt::ToolBarArea toToolBarArea(int pos)

   793 {

   794     return toToolBarArea(static_cast<QInternal::DockPosition>(pos));

   795 }

   796 

   797 void QMainWindowLayout::addToolBarBreak(Qt::ToolBarArea area)

   798 {

   799     validateToolBarArea(area);

   800 

   801     layoutState.toolBarAreaLayout.addToolBarBreak(toDockPos(area));

   802     if (savedState.isValid())

   803         savedState.toolBarAreaLayout.addToolBarBreak(toDockPos(area));

   804 

   805     invalidate();

   806 }

   807 

   808 void QMainWindowLayout::insertToolBarBreak(QToolBar *before)

   809 {

   810     layoutState.toolBarAreaLayout.insertToolBarBreak(before);

   811     if (savedState.isValid())

   812         savedState.toolBarAreaLayout.insertToolBarBreak(before);

   813     invalidate();

   814 }

   815 

   816 void QMainWindowLayout::removeToolBarBreak(QToolBar *before)

   817 {

   818     layoutState.toolBarAreaLayout.removeToolBarBreak(before);

   819     if (savedState.isValid())

   820         savedState.toolBarAreaLayout.removeToolBarBreak(before);

   821     invalidate();

   822 }

   823 

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

   825 {

   826     layoutState.toolBarAreaLayout.moveToolBar(toolbar, pos);

   827     if (savedState.isValid())

   828         savedState.toolBarAreaLayout.moveToolBar(toolbar, pos);

   829     invalidate();

   830 }

   831 

   832 /* Removes the toolbar from the mainwindow so that it can be added again. Does not

   833    explicitly hide the toolbar. */

   834 void QMainWindowLayout::removeToolBar(QToolBar *toolbar)

   835 {

   836     if (toolbar) {

   837         QObject::disconnect(parentWidget(), SIGNAL(iconSizeChanged(QSize)),

   838                    toolbar, SLOT(_q_updateIconSize(QSize)));

   839         QObject::disconnect(parentWidget(), SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)),

   840                    toolbar, SLOT(_q_updateToolButtonStyle(Qt::ToolButtonStyle)));

   841 

   842 #ifdef Q_WS_MAC

   843         if (usesHIToolBar(toolbar)) {

   844             removeFromMacToolbar(toolbar);

   845         } else

   846 #endif // Q_WS_MAC

   847         {

   848             removeWidget(toolbar);

   849         }

   850     }

   851 }

   852 

   853 /*!

   854     Adds \a toolbar to \a area, continuing the current line.

   855 */

   856 void QMainWindowLayout::addToolBar(Qt::ToolBarArea area,

   857                                    QToolBar *toolbar,

   858                                    bool)

   859 {

   860     validateToolBarArea(area);

   861 #ifdef Q_WS_MAC

   862     if ((area == Qt::TopToolBarArea)

   863             && layoutState.mainWindow->unifiedTitleAndToolBarOnMac()) {

   864         insertIntoMacToolbar(0, toolbar);

   865     } else

   866 #endif

   867     {

   868         //let's add the toolbar to the layout

   869         addChildWidget(toolbar);

   870         QLayoutItem * item = layoutState.toolBarAreaLayout.addToolBar(toDockPos(area), toolbar);

   871         if (savedState.isValid() && item) {

   872             // copy the toolbar also in the saved state

   873             savedState.toolBarAreaLayout.insertItem(toDockPos(area), item);

   874         }

   875         invalidate();

   876 

   877         //this ensures that the toolbar has the right window flags (not floating any more)

   878         toolbar->d_func()->updateWindowFlags(false /*floating*/);

   879     }

   880 }

   881 

   882 /*!

   883     Adds \a toolbar before \a before

   884 */

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

   886 {

   887 #ifdef Q_WS_MAC

   888     if (usesHIToolBar(before)) {

   889         insertIntoMacToolbar(before, toolbar);

   890     } else

   891 #endif // Q_WS_MAC

   892     {

   893         addChildWidget(toolbar);

   894         QLayoutItem * item = layoutState.toolBarAreaLayout.insertToolBar(before, toolbar);

   895         if (savedState.isValid() && item) {

   896             // copy the toolbar also in the saved state

   897             savedState.toolBarAreaLayout.insertItem(before, item);

   898         }

   899         if (!currentGapPos.isEmpty() && currentGapPos.first() == 0) {

   900             currentGapPos = layoutState.toolBarAreaLayout.currentGapIndex();

   901             if (!currentGapPos.isEmpty()) {

   902                 currentGapPos.prepend(0);

   903                 currentGapRect = layoutState.itemRect(currentGapPos);

   904             }

   905         }

   906         invalidate();

   907     }

   908 }

   909 

   910 Qt::ToolBarArea QMainWindowLayout::toolBarArea(QToolBar *toolbar) const

   911 {

   912     QInternal::DockPosition pos = layoutState.toolBarAreaLayout.findToolBar(toolbar);

   913     switch (pos) {

   914         case QInternal::LeftDock:   return Qt::LeftToolBarArea;

   915         case QInternal::RightDock:  return Qt::RightToolBarArea;

   916         case QInternal::TopDock:    return Qt::TopToolBarArea;

   917         case QInternal::BottomDock: return Qt::BottomToolBarArea;

   918         default: break;

   919     }

   920 #ifdef Q_WS_MAC

   921     if (pos == QInternal::DockCount) {

   922         if (qtoolbarsInUnifiedToolbarList.contains(toolbar))

   923             return Qt::TopToolBarArea;

   924     }

   925 #endif

   926     return Qt::NoToolBarArea;

   927 }

   928 

   929 bool QMainWindowLayout::toolBarBreak(QToolBar *toolBar) const

   930 {

   931     return layoutState.toolBarAreaLayout.toolBarBreak(toolBar);

   932 }

   933 

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

   935 {

   936     option->toolBarArea = toolBarArea(toolBar);

   937     layoutState.toolBarAreaLayout.getStyleOptionInfo(option, toolBar);

   938 }

   939 

   940 void QMainWindowLayout::toggleToolBarsVisible()

   941 {

   942     bool updateNonUnifiedParts = true;

   943 #ifdef Q_WS_MAC

   944     if (layoutState.mainWindow->unifiedTitleAndToolBarOnMac()) {

   945         // If we hit this case, someone has pressed the "toolbar button" which will

   946         // toggle the unified toolbar visiblity, because that's what the user wants.

   947         // We might be in a situation where someone has hidden all the toolbars

   948         // beforehand (maybe in construction), but now they've hit this button and

   949         // and are expecting the items to show. What do we do?

   950         // 1) Check the visibility of all the toolbars, if one is visible, do nothing, this

   951         //    preserves what people would expect (these toolbars were visible when I clicked last time).

   952         // 2) If NONE are visible, then show them all. Again, this preserves the user expectation

   953         //    of, "I want to see the toolbars." The user may get more toolbars than expected, but this

   954         //    is better seeing nothing.

   955         // Don't worry about any of this if we are going invisible. This does mean we may get

   956         // into issues when switching into and out of fullscreen mode, but this is probably minor.

   957         // If we ever need to do hiding, that would have to be taken care of after the unified toolbar

   958         // has finished hiding.

   959         // People can of course handle the QEvent::ToolBarChange event themselves and do

   960         // WHATEVER they want if they don't like what we are doing (though the unified toolbar

   961         // will fire regardless).

   962 

   963         // Check if we REALLY need to update the geometry below. If we only have items in the

   964         // unified toolbar, all the docks will be empty, so there's very little point

   965         // in doing the geometry as Apple will do it (we also avoid flicker in Cocoa as well).

   966         // FWIW, layoutState.toolBarAreaLayout.visible and the state of the unified toolbar

   967         // visibility can get out of sync. I really don't think it's a big issue. It is kept

   968         // to a minimum because we only change the visibility if we absolutely must.

   969         // update the "non unified parts."

   970         updateNonUnifiedParts = !layoutState.toolBarAreaLayout.isEmpty();

   971 

   972         // We get this function before the unified toolbar does its thing.

   973         // So, the value will be opposite of what we expect.

   974         bool goingVisible = !macWindowToolbarIsVisible(qt_mac_window_for(layoutState.mainWindow));

   975         if (goingVisible) {

   976             const int ToolBarCount = qtoolbarsInUnifiedToolbarList.size();

   977             bool needAllVisible = true;

   978             for (int i = 0; i < ToolBarCount; ++i) {

   979                 if (!qtoolbarsInUnifiedToolbarList.at(i)->isHidden()) {

   980                     needAllVisible = false;

   981                     break;

   982                 }

   983             }

   984             if (needAllVisible) {

   985                 QBoolBlocker blocker(blockVisiblityCheck);  // Disable the visibilty check because

   986                                                             // the toggle has already happened.

   987                 for (int i = 0; i < ToolBarCount; ++i)

   988                     qtoolbarsInUnifiedToolbarList.at(i)->setVisible(true);

   989             }

   990         }

   991         if (!updateNonUnifiedParts)

   992             layoutState.toolBarAreaLayout.visible = goingVisible;

   993     }

   994 #endif

   995     if (updateNonUnifiedParts) {

   996         layoutState.toolBarAreaLayout.visible = !layoutState.toolBarAreaLayout.visible;

   997         if (!layoutState.mainWindow->isMaximized()) {

   998             QPoint topLeft = parentWidget()->geometry().topLeft();

   999             QRect r = parentWidget()->geometry();

  1000             r = layoutState.toolBarAreaLayout.rectHint(r);

  1001             r.moveTo(topLeft);

  1002             parentWidget()->setGeometry(r);

  1003         } else {

  1004             update();

  1005         }

  1006     }

  1007 }

  1008 

  1009 #endif // QT_NO_TOOLBAR

  1010 

  1011 /******************************************************************************

  1012 ** QMainWindowLayoutState - dock areas

  1013 */

  1014 

  1015 #ifndef QT_NO_DOCKWIDGET

  1016 

  1017 static inline void validateDockWidgetArea(Qt::DockWidgetArea &area)

  1018 {

  1019     switch (area) {

  1020     case Qt::LeftDockWidgetArea:

  1021     case Qt::RightDockWidgetArea:

  1022     case Qt::TopDockWidgetArea:

  1023     case Qt::BottomDockWidgetArea:

  1024         break;

  1025     default:

  1026         area = Qt::LeftDockWidgetArea;

  1027     }

  1028 }

  1029 

  1030 static QInternal::DockPosition toDockPos(Qt::DockWidgetArea area)

  1031 {

  1032     switch (area) {

  1033         case Qt::LeftDockWidgetArea: return QInternal::LeftDock;

  1034         case Qt::RightDockWidgetArea: return QInternal::RightDock;

  1035         case Qt::TopDockWidgetArea: return QInternal::TopDock;

  1036         case Qt::BottomDockWidgetArea: return QInternal::BottomDock;

  1037         default:

  1038             break;

  1039     }

  1040 

  1041     return QInternal::DockCount;

  1042 }

  1043 

  1044 static Qt::DockWidgetArea toDockWidgetArea(QInternal::DockPosition pos)

  1045 {

  1046     switch (pos) {

  1047         case QInternal::LeftDock : return Qt::LeftDockWidgetArea;

  1048         case QInternal::RightDock : return Qt::RightDockWidgetArea;

  1049         case QInternal::TopDock : return Qt::TopDockWidgetArea;

  1050         case QInternal::BottomDock : return Qt::BottomDockWidgetArea;

  1051         default:

  1052             break;

  1053     }

  1054 

  1055     return Qt::NoDockWidgetArea;

  1056 }

  1057 

  1058 inline static Qt::DockWidgetArea toDockWidgetArea(int pos)

  1059 {

  1060     return toDockWidgetArea(static_cast<QInternal::DockPosition>(pos));

  1061 }

  1062 

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

  1064 {

  1065     if (layoutState.dockAreaLayout.corners[corner] == area)

  1066         return;

  1067     layoutState.dockAreaLayout.corners[corner] = area;

  1068     if (savedState.isValid())

  1069         savedState.dockAreaLayout.corners[corner] = area;

  1070     invalidate();

  1071 }

  1072 

  1073 Qt::DockWidgetArea QMainWindowLayout::corner(Qt::Corner corner) const

  1074 {

  1075     return layoutState.dockAreaLayout.corners[corner];

  1076 }

  1077 

  1078 void QMainWindowLayout::addDockWidget(Qt::DockWidgetArea area,

  1079                                              QDockWidget *dockwidget,

  1080                                              Qt::Orientation orientation)

  1081 {

  1082     addChildWidget(dockwidget);

  1083 

  1084     // If we are currently moving a separator, then we need to abort the move, since each

  1085     // time we move the mouse layoutState is replaced by savedState modified by the move.

  1086     if (!movingSeparator.isEmpty())

  1087         endSeparatorMove(movingSeparatorPos);

  1088 

  1089     layoutState.dockAreaLayout.addDockWidget(toDockPos(area), dockwidget, orientation);

  1090     emit dockwidget->dockLocationChanged(area);

  1091     invalidate();

  1092 }

  1093 

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

  1095 {

  1096     addChildWidget(second);

  1097     layoutState.dockAreaLayout.tabifyDockWidget(first, second);

  1098     emit second->dockLocationChanged(dockWidgetArea(first));

  1099     invalidate();

  1100 }

  1101 

  1102 bool QMainWindowLayout::restoreDockWidget(QDockWidget *dockwidget)

  1103 {

  1104     addChildWidget(dockwidget);

  1105     if (!layoutState.dockAreaLayout.restoreDockWidget(dockwidget))

  1106         return false;

  1107     emit dockwidget->dockLocationChanged(dockWidgetArea(dockwidget));

  1108     invalidate();

  1109     return true;

  1110 }

  1111 

  1112 #ifndef QT_NO_TABBAR

  1113 bool QMainWindowLayout::documentMode() const

  1114 {

  1115     return _documentMode;

  1116 }

  1117 

  1118 void QMainWindowLayout::setDocumentMode(bool enabled)

  1119 {

  1120     if (_documentMode == enabled)

  1121         return;

  1122 

  1123     _documentMode = enabled;

  1124 

  1125     // Update the document mode for all tab bars

  1126     foreach (QTabBar *bar, usedTabBars)

  1127         bar->setDocumentMode(_documentMode);

  1128     foreach (QTabBar *bar, unusedTabBars)

  1129         bar->setDocumentMode(_documentMode);

  1130 }

  1131 #endif // QT_NO_TABBAR

  1132 

  1133 void QMainWindowLayout::setVerticalTabsEnabled(bool enabled)

  1134 {