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 Qt Designer 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 "qdesigner_command_p.h"

    43 #include "qdesigner_propertycommand_p.h"

    44 #include "qdesigner_utils_p.h"

    45 #include "layout_p.h"

    46 #include "qlayout_widget_p.h"

    47 #include "qdesigner_widget_p.h"

    48 #include "qdesigner_menu_p.h"

    49 #include "shared_enums_p.h"

    50 #include "metadatabase_p.h"

    51 #include "formwindowbase_p.h"

    52 #include <abstractformbuilder.h>

    53 

    54 #include <QtDesigner/QDesignerFormWindowInterface>

    55 #include <QtDesigner/QDesignerFormEditorInterface>

    56 #include <QtDesigner/QDesignerPropertySheetExtension>

    57 #include <QtDesigner/QDesignerActionEditorInterface>

    58 #include <QtDesigner/QDesignerPropertyEditorInterface>

    59 #include <QtDesigner/QExtensionManager>

    60 #include <QtDesigner/QDesignerContainerExtension>

    61 #include <QtDesigner/QDesignerLayoutDecorationExtension>

    62 #include <QtDesigner/QDesignerWidgetFactoryInterface>

    63 #include <QtDesigner/QDesignerObjectInspectorInterface>

    64 #include <QtDesigner/QDesignerIntegrationInterface>

    65 #include <QtDesigner/QDesignerFormWindowCursorInterface>

    66 #include <QtCore/qdebug.h>

    67 #include <QtCore/QTextStream>

    68 #include <QtCore/QQueue>

    69 

    70 #include <QtGui/QMenuBar>

    71 #include <QtGui/QStatusBar>

    72 #include <QtGui/QToolBar>

    73 #include <QtGui/QToolBox>

    74 #include <QtGui/QStackedWidget>

    75 #include <QtGui/QTabWidget>

    76 #include <QtGui/QTableWidget>

    77 #include <QtGui/QTreeWidget>

    78 #include <QtGui/QListWidget>

    79 #include <QtGui/QComboBox>

    80 #include <QtGui/QSplitter>

    81 #include <QtGui/QDockWidget>

    82 #include <QtGui/QMainWindow>

    83 #include <QtGui/QWizardPage>

    84 #include <QtGui/QApplication>

    85 #include <QtGui/QFormLayout>

    86 

    87 Q_DECLARE_METATYPE(QWidgetList)

    88 

    89 QT_BEGIN_NAMESPACE

    90 

    91 static inline void setPropertySheetWindowTitle(const QDesignerFormEditorInterface *core, QObject *o, const QString &t)

    92 {

    93     if (QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(core->extensionManager(), o)) {

    94         const int idx = sheet->indexOf(QLatin1String("windowTitle"));

    95         if (idx != -1) {

    96             sheet->setProperty(idx, t);

    97             sheet->setChanged(idx, true);

    98         }

    99     }

   100 }

   101 

   102 namespace qdesigner_internal {

   103 

   104 // Helpers for the dynamic properties that store Z/Widget order

   105 static const char *widgetOrderPropertyC = "_q_widgetOrder";

   106 static const char *zOrderPropertyC = "_q_zOrder";

   107 

   108 static void addToWidgetListDynamicProperty(QWidget *parentWidget, QWidget *widget, const char *name, int index = -1)

   109 {

   110     QWidgetList list = qVariantValue<QWidgetList>(parentWidget->property(name));

   111     list.removeAll(widget);

   112     if (index >= 0 && index < list.size()) {

   113         list.insert(index, widget);

   114     } else {

   115         list.append(widget);

   116     }

   117     parentWidget->setProperty(name, qVariantFromValue(list));

   118 }

   119 

   120 static int removeFromWidgetListDynamicProperty(QWidget *parentWidget, QWidget *widget, const char *name)

   121 {

   122     QWidgetList list = qVariantValue<QWidgetList>(parentWidget->property(name));

   123     const int firstIndex = list.indexOf(widget);

   124     if (firstIndex != -1) {

   125         list.removeAll(widget);

   126         parentWidget->setProperty(name, qVariantFromValue(list));

   127     }

   128     return firstIndex;

   129 }

   130 

   131 // ---- InsertWidgetCommand ----

   132 InsertWidgetCommand::InsertWidgetCommand(QDesignerFormWindowInterface *formWindow)  :

   133     QDesignerFormWindowCommand(QString(), formWindow),

   134     m_insertMode(QDesignerLayoutDecorationExtension::InsertWidgetMode),

   135     m_layoutHelper(0),

   136     m_widgetWasManaged(false)

   137 {

   138 }

   139 

   140 InsertWidgetCommand::~InsertWidgetCommand()

   141 {

   142     delete m_layoutHelper;

   143 }

   144 

   145 void InsertWidgetCommand::init(QWidget *widget, bool already_in_form, int layoutRow, int layoutColumn)

   146 {

   147     m_widget = widget;

   148 

   149     setText(QApplication::translate("Command", "Insert '%1'").arg(widget->objectName()));

   150 

   151     QWidget *parentWidget = m_widget->parentWidget();

   152     QDesignerFormEditorInterface *core = formWindow()->core();

   153     QDesignerLayoutDecorationExtension *deco = qt_extension<QDesignerLayoutDecorationExtension*>(core->extensionManager(), parentWidget);

   154 

   155     m_insertMode = deco ? deco->currentInsertMode() : QDesignerLayoutDecorationExtension::InsertWidgetMode;

   156     if (layoutRow >= 0 && layoutColumn >= 0) {

   157         m_cell.first = layoutRow;

   158         m_cell.second = layoutColumn;

   159     } else {

   160         m_cell = deco ? deco->currentCell() : qMakePair(0, 0);

   161     }

   162     m_widgetWasManaged = already_in_form;

   163 }

   164 

   165 static void recursiveUpdate(QWidget *w)

   166 {

   167     w->update();

   168 

   169     const QObjectList &l = w->children();

   170     const QObjectList::const_iterator cend = l.end();

   171     for ( QObjectList::const_iterator it = l.begin(); it != cend; ++it) {

   172         if (QWidget *w = qobject_cast<QWidget*>(*it))

   173             recursiveUpdate(w);

   174     }

   175 }

   176 

   177 void InsertWidgetCommand::redo()

   178 {

   179     QWidget *parentWidget = m_widget->parentWidget();

   180     Q_ASSERT(parentWidget);

   181 

   182     addToWidgetListDynamicProperty(parentWidget, m_widget, widgetOrderPropertyC);

   183     addToWidgetListDynamicProperty(parentWidget, m_widget, zOrderPropertyC);

   184 

   185     QDesignerFormEditorInterface *core = formWindow()->core();

   186     QDesignerLayoutDecorationExtension *deco = qt_extension<QDesignerLayoutDecorationExtension*>(core->extensionManager(), parentWidget);

   187 

   188     if (deco != 0) {

   189         const LayoutInfo::Type type = LayoutInfo::layoutType(core, LayoutInfo::managedLayout(core, parentWidget));

   190         m_layoutHelper = LayoutHelper::createLayoutHelper(type);

   191         m_layoutHelper->pushState(core, parentWidget);

   192         if (type == LayoutInfo::Grid) {

   193             switch (m_insertMode) {

   194                 case QDesignerLayoutDecorationExtension::InsertRowMode: {

   195                     deco->insertRow(m_cell.first);

   196                 } break;

   197 

   198                 case QDesignerLayoutDecorationExtension::InsertColumnMode: {

   199                     deco->insertColumn(m_cell.second);

   200                 } break;

   201 

   202                 default: break;

   203             } // end switch

   204         }

   205         deco->insertWidget(m_widget, m_cell);

   206     }

   207 

   208     if (!m_widgetWasManaged)

   209         formWindow()->manageWidget(m_widget);

   210     m_widget->show();

   211     formWindow()->emitSelectionChanged();

   212 

   213     if (parentWidget && parentWidget->layout()) {

   214         recursiveUpdate(parentWidget);

   215         parentWidget->layout()->invalidate();

   216     }

   217 

   218     refreshBuddyLabels();

   219 }

   220 

   221 void InsertWidgetCommand::undo()

   222 {

   223     QWidget *parentWidget = m_widget->parentWidget();

   224 

   225     QDesignerFormEditorInterface *core = formWindow()->core();

   226     QDesignerLayoutDecorationExtension *deco = qt_extension<QDesignerLayoutDecorationExtension*>(core->extensionManager(), parentWidget);

   227 

   228     if (deco) {

   229         deco->removeWidget(m_widget);

   230         m_layoutHelper->popState(core, parentWidget);

   231     }

   232 

   233     if (!m_widgetWasManaged) {

   234         formWindow()->unmanageWidget(m_widget);

   235         m_widget->hide();

   236     }

   237 

   238     removeFromWidgetListDynamicProperty(parentWidget, m_widget, widgetOrderPropertyC);

   239     removeFromWidgetListDynamicProperty(parentWidget, m_widget, zOrderPropertyC);

   240 

   241     formWindow()->emitSelectionChanged();

   242 

   243     refreshBuddyLabels();

   244 }

   245 

   246 void InsertWidgetCommand::refreshBuddyLabels()

   247 {

   248     typedef QList<QLabel*> LabelList;

   249 

   250     const LabelList label_list = qFindChildren<QLabel*>(formWindow());

   251     if (label_list.empty())

   252         return;

   253 

   254     const QString buddyProperty = QLatin1String("buddy");

   255     const QByteArray objectNameU8 = m_widget->objectName().toUtf8();

   256     // Re-set the buddy (The sheet locates the object by name and sets it)

   257     const LabelList::const_iterator cend = label_list.constEnd();

   258     for (LabelList::const_iterator it = label_list.constBegin(); it != cend; ++it ) {

   259         if (QDesignerPropertySheetExtension* sheet = propertySheet(*it)) {

   260             const int idx = sheet->indexOf(buddyProperty);

   261             if (idx != -1) {

   262                 const QVariant value = sheet->property(idx);

   263                 if (value.toByteArray() == objectNameU8)

   264                     sheet->setProperty(idx, value);

   265             }

   266         }

   267     }

   268 }

   269 

   270 // ---- ChangeZOrderCommand ----

   271 ChangeZOrderCommand::ChangeZOrderCommand(QDesignerFormWindowInterface *formWindow)

   272     : QDesignerFormWindowCommand(QString(), formWindow)

   273 {

   274 }

   275 

   276 void ChangeZOrderCommand::init(QWidget *widget)

   277 {

   278     Q_ASSERT(widget);

   279 

   280     m_widget = widget;

   281 

   282     setText(QApplication::translate("Command", "Change Z-order of '%1'").arg(widget->objectName()));

   283 

   284     m_oldParentZOrder = qVariantValue<QWidgetList>(widget->parentWidget()->property("_q_zOrder"));

   285     const int index = m_oldParentZOrder.indexOf(m_widget);

   286     if (index != -1 && index + 1 < m_oldParentZOrder.count())

   287         m_oldPreceding = m_oldParentZOrder.at(index + 1);

   288 }

   289 

   290 void ChangeZOrderCommand::redo()

   291 {

   292     m_widget->parentWidget()->setProperty("_q_zOrder", qVariantFromValue(reorderWidget(m_oldParentZOrder, m_widget)));

   293 

   294     reorder(m_widget);

   295 }

   296 

   297 void ChangeZOrderCommand::undo()

   298 {

   299     m_widget->parentWidget()->setProperty("_q_zOrder", qVariantFromValue(m_oldParentZOrder));

   300 

   301     if (m_oldPreceding)

   302         m_widget->stackUnder(m_oldPreceding);

   303     else

   304         m_widget->raise();

   305 }

   306 

   307 // ---- RaiseWidgetCommand ----

   308 RaiseWidgetCommand::RaiseWidgetCommand(QDesignerFormWindowInterface *formWindow)

   309     : ChangeZOrderCommand(formWindow)

   310 {

   311 }

   312 

   313 void RaiseWidgetCommand::init(QWidget *widget)

   314 {

   315     ChangeZOrderCommand::init(widget);

   316     setText(QApplication::translate("Command", "Raise '%1'").arg(widget->objectName()));

   317 }

   318 

   319 QWidgetList RaiseWidgetCommand::reorderWidget(const QWidgetList &list, QWidget *widget) const

   320 {

   321     QWidgetList l = list;

   322     l.removeAll(widget);

   323     l.append(widget);

   324     return l;

   325 }

   326 

   327 void RaiseWidgetCommand::reorder(QWidget *widget) const

   328 {

   329     widget->raise();

   330 }

   331 

   332 // ---- LowerWidgetCommand ----

   333 LowerWidgetCommand::LowerWidgetCommand(QDesignerFormWindowInterface *formWindow)

   334     : ChangeZOrderCommand(formWindow)

   335 {

   336 }

   337 

   338 QWidgetList LowerWidgetCommand::reorderWidget(const QWidgetList &list, QWidget *widget) const

   339 {

   340     QWidgetList l = list;

   341     l.removeAll(widget);

   342     l.prepend(widget);

   343     return l;

   344 }

   345 

   346 void LowerWidgetCommand::init(QWidget *widget)

   347 {

   348     ChangeZOrderCommand::init(widget);

   349     setText(QApplication::translate("Command", "Lower '%1'").arg(widget->objectName()));

   350 }

   351 

   352 void LowerWidgetCommand::reorder(QWidget *widget) const

   353 {

   354     widget->lower();

   355 }

   356 

   357 // ---- ManageWidgetCommandHelper

   358 ManageWidgetCommandHelper::ManageWidgetCommandHelper() :

   359     m_widget(0)

   360 {

   361 }

   362 

   363 void ManageWidgetCommandHelper::init(const QDesignerFormWindowInterface *fw, QWidget *widget)

   364 {

   365     m_widget = widget;

   366     m_managedChildren.clear();

   367 

   368     const QWidgetList children = qFindChildren<QWidget *>(m_widget);

   369     if (children.empty())

   370         return;

   371 

   372     m_managedChildren.reserve(children.size());

   373     const QWidgetList::const_iterator lcend = children.constEnd();

   374     for (QWidgetList::const_iterator it = children.constBegin(); it != lcend; ++it)

   375         if (fw->isManaged(*it))

   376             m_managedChildren.push_back(*it);

   377 }

   378 

   379 void ManageWidgetCommandHelper::init(QWidget *widget, const WidgetVector &managedChildren)

   380 {

   381     m_widget = widget;

   382     m_managedChildren = managedChildren;

   383 }

   384 

   385 void ManageWidgetCommandHelper::manage(QDesignerFormWindowInterface *fw)

   386 {

   387     // Manage the managed children after parent

   388     fw->manageWidget(m_widget);

   389     if (!m_managedChildren.empty()) {

   390         const WidgetVector::const_iterator lcend = m_managedChildren.constEnd();

   391         for (WidgetVector::const_iterator it = m_managedChildren.constBegin(); it != lcend; ++it)

   392             fw->manageWidget(*it);

   393     }

   394 }

   395 

   396 void ManageWidgetCommandHelper::unmanage(QDesignerFormWindowInterface *fw)

   397 {

   398     // Unmanage the managed children first

   399     if (!m_managedChildren.empty()) {

   400         const WidgetVector::const_iterator lcend = m_managedChildren.constEnd();

   401         for (WidgetVector::const_iterator it = m_managedChildren.constBegin(); it != lcend; ++it)

   402             fw->unmanageWidget(*it);

   403     }

   404     fw->unmanageWidget(m_widget);

   405 }

   406 

   407 // ---- DeleteWidgetCommand ----

   408 DeleteWidgetCommand::DeleteWidgetCommand(QDesignerFormWindowInterface *formWindow) :

   409     QDesignerFormWindowCommand(QString(), formWindow),

   410     m_layoutType(LayoutInfo::NoLayout),

   411     m_layoutHelper(0),

   412     m_flags(0),

   413     m_splitterIndex(-1),

   414     m_layoutSimplified(false),

   415     m_formItem(0),

   416     m_tabOrderIndex(-1),

   417     m_widgetOrderIndex(-1),

   418     m_zOrderIndex(-1)

   419 {

   420 }

   421 

   422 DeleteWidgetCommand::~DeleteWidgetCommand()

   423 {

   424     delete  m_layoutHelper;

   425 }

   426 

   427 void DeleteWidgetCommand::init(QWidget *widget, unsigned flags)

   428 {

   429     m_widget = widget;

   430     m_parentWidget = widget->parentWidget();

   431     m_geometry = widget->geometry();

   432     m_flags = flags;

   433     m_layoutType = LayoutInfo::NoLayout;

   434     m_splitterIndex = -1;

   435     bool isManaged; // Check for a managed layout

   436     QLayout *layout;

   437     m_layoutType = LayoutInfo::laidoutWidgetType(formWindow()->core(), m_widget, &isManaged, &layout);

   438     if (!isManaged)

   439         m_layoutType = LayoutInfo::NoLayout;

   440     switch (m_layoutType) {

   441     case LayoutInfo::HSplitter:

   442     case LayoutInfo::VSplitter: {

   443         QSplitter *splitter = qobject_cast<QSplitter *>(m_parentWidget);

   444         Q_ASSERT(splitter);

   445         m_splitterIndex = splitter->indexOf(widget);

   446     }

   447         break;

   448     case LayoutInfo::NoLayout:

   449         break;

   450     default:

   451         m_layoutHelper = LayoutHelper::createLayoutHelper(m_layoutType);

   452         m_layoutPosition = m_layoutHelper->itemInfo(layout, m_widget);

   453         break;

   454     }

   455 

   456     m_formItem = formWindow()->core()->metaDataBase()->item(formWindow());

   457     m_tabOrderIndex = m_formItem->tabOrder().indexOf(widget);

   458 

   459     // Build the list of managed children

   460     m_manageHelper.init(formWindow(), m_widget);

   461 

   462     setText(QApplication::translate("Command", "Delete '%1'").arg(widget->objectName()));

   463 }

   464 

   465 void DeleteWidgetCommand::redo()

   466 {

   467     formWindow()->clearSelection();

   468     QDesignerFormEditorInterface *core = formWindow()->core();

   469 

   470     if (QDesignerContainerExtension *c = qt_extension<QDesignerContainerExtension*>(core->extensionManager(), m_parentWidget)) {

   471         const int count = c->count();

   472         for (int i=0; i<count; ++i) {

   473             if (c->widget(i) == m_widget) {

   474                 c->remove(i);

   475                 return;

   476             }

   477         }

   478     }

   479 

   480     m_widgetOrderIndex = removeFromWidgetListDynamicProperty(m_parentWidget, m_widget, widgetOrderPropertyC);

   481     m_zOrderIndex = removeFromWidgetListDynamicProperty(m_parentWidget, m_widget, zOrderPropertyC);

   482 

   483     if (QDesignerLayoutDecorationExtension *deco = qt_extension<QDesignerLayoutDecorationExtension*>(core->extensionManager(), m_parentWidget))

   484         deco->removeWidget(m_widget);

   485 

   486     if (m_layoutHelper)

   487         switch (m_layoutType) {

   488         case LayoutInfo::NoLayout:

   489         case LayoutInfo::HSplitter:

   490         case LayoutInfo::VSplitter:

   491             break;

   492         default:

   493             // Attempt to simplify grids if a row/column becomes empty

   494             m_layoutSimplified = (m_flags & DoNotSimplifyLayout) ? false : m_layoutHelper->canSimplify(core, m_parentWidget, m_layoutPosition);

   495             if (m_layoutSimplified) {

   496                 m_layoutHelper->pushState(core, m_parentWidget);

   497                 m_layoutHelper->simplify(core, m_parentWidget, m_layoutPosition);

   498             }

   499             break;

   500         }

   501 

   502     if (!(m_flags & DoNotUnmanage))

   503         m_manageHelper.unmanage(formWindow());

   504 

   505     m_widget->setParent(formWindow());

   506     m_widget->hide();

   507 

   508     if (m_tabOrderIndex != -1) {

   509         QList<QWidget*> tab_order = m_formItem->tabOrder();

   510         tab_order.removeAt(m_tabOrderIndex);

   511         m_formItem->setTabOrder(tab_order);

   512     }

   513 }

   514 

   515 void DeleteWidgetCommand::undo()

   516 {

   517     QDesignerFormEditorInterface *core = formWindow()->core();

   518     formWindow()->clearSelection();

   519 

   520     m_widget->setParent(m_parentWidget);

   521 

   522     if (QDesignerContainerExtension *c = qt_extension<QDesignerContainerExtension*>(core->extensionManager(), m_parentWidget)) {

   523         c->addWidget(m_widget);

   524         return;

   525     }

   526 

   527     addToWidgetListDynamicProperty(m_parentWidget, m_widget, widgetOrderPropertyC, m_widgetOrderIndex);

   528     addToWidgetListDynamicProperty(m_parentWidget, m_widget, zOrderPropertyC, m_zOrderIndex);

   529 

   530     m_widget->setGeometry(m_geometry);

   531 

   532     if (!(m_flags & DoNotUnmanage))

   533         m_manageHelper.manage(formWindow());

   534     // ### set up alignment

   535     switch (m_layoutType) {

   536     case LayoutInfo::NoLayout:

   537         break;

   538     case LayoutInfo::HSplitter:

   539     case LayoutInfo::VSplitter: {

   540         QSplitter *splitter = qobject_cast<QSplitter *>(m_widget->parent());

   541         Q_ASSERT(splitter);

   542         splitter->insertWidget(m_splitterIndex, m_widget);

   543     } break;

   544     default: {

   545         Q_ASSERT(m_layoutHelper);

   546         if (m_layoutSimplified)

   547             m_layoutHelper->popState(core, m_parentWidget);

   548         QLayout *layout = LayoutInfo::managedLayout(core, m_parentWidget);

   549         Q_ASSERT(m_layoutType == LayoutInfo::layoutType(core, layout));

   550         m_layoutHelper->insertWidget(layout, m_layoutPosition, m_widget);

   551     }

   552         break;

   553     }

   554 

   555     m_widget->show();

   556 

   557     if (m_tabOrderIndex != -1) {

   558         QList<QWidget*> tab_order = m_formItem->tabOrder();

   559         tab_order.insert(m_tabOrderIndex, m_widget);

   560         m_formItem->setTabOrder(tab_order);

   561     }

   562 }

   563 

   564 // ---- ReparentWidgetCommand ----

   565 ReparentWidgetCommand::ReparentWidgetCommand(QDesignerFormWindowInterface *formWindow)

   566     : QDesignerFormWindowCommand(QString(), formWindow)

   567 {

   568 }

   569 

   570 void ReparentWidgetCommand::init(QWidget *widget, QWidget *parentWidget)

   571 {

   572     Q_ASSERT(widget);

   573 

   574     m_widget = widget;

   575     m_oldParentWidget = widget->parentWidget();

   576     m_newParentWidget = parentWidget;

   577 

   578     m_oldPos = m_widget->pos();

   579     m_newPos = m_newParentWidget->mapFromGlobal(m_oldParentWidget->mapToGlobal(m_oldPos));

   580 

   581     setText(QApplication::translate("Command", "Reparent '%1'").arg(widget->objectName()));

   582 

   583     m_oldParentList = qVariantValue<QWidgetList>(m_oldParentWidget->property("_q_widgetOrder"));

   584     m_oldParentZOrder = qVariantValue<QWidgetList>(m_oldParentWidget->property("_q_zOrder"));

   585 }

   586 

   587 void ReparentWidgetCommand::redo()

   588 {

   589     m_widget->setParent(m_newParentWidget);

   590     m_widget->move(m_newPos);

   591 

   592     QWidgetList oldList = m_oldParentList;

   593     oldList.removeAll(m_widget);

   594     m_oldParentWidget->setProperty("_q_widgetOrder", qVariantFromValue(oldList));

   595 

   596     QWidgetList newList = qVariantValue<QWidgetList>(m_newParentWidget->property("_q_widgetOrder"));

   597     newList.append(m_widget);

   598     m_newParentWidget->setProperty("_q_widgetOrder", qVariantFromValue(newList));

   599 

   600     QWidgetList oldZOrder = m_oldParentZOrder;

   601     oldZOrder.removeAll(m_widget);

   602     m_oldParentWidget->setProperty("_q_zOrder", qVariantFromValue(oldZOrder));

   603 

   604     QWidgetList newZOrder = qVariantValue<QWidgetList>(m_newParentWidget->property("_q_zOrder"));

   605     newZOrder.append(m_widget);

   606     m_newParentWidget->setProperty("_q_zOrder", qVariantFromValue(newZOrder));

   607 

   608     m_widget->show();

   609     core()->objectInspector()->setFormWindow(formWindow());

   610 }

   611 

   612 void ReparentWidgetCommand::undo()

   613 {

   614     m_widget->setParent(m_oldParentWidget);

   615     m_widget->move(m_oldPos);

   616 

   617     m_oldParentWidget->setProperty("_q_widgetOrder", qVariantFromValue(m_oldParentList));

   618 

   619     QWidgetList newList = qVariantValue<QWidgetList>(m_newParentWidget->property("_q_widgetOrder"));

   620     newList.removeAll(m_widget);

   621     m_newParentWidget->setProperty("_q_widgetOrder", qVariantFromValue(newList));

   622 

   623     m_oldParentWidget->setProperty("_q_zOrder", qVariantFromValue(m_oldParentZOrder));

   624 

   625     QWidgetList newZOrder = qVariantValue<QWidgetList>(m_newParentWidget->property("_q_zOrder"));

   626     m_newParentWidget->setProperty("_q_zOrder", qVariantFromValue(newZOrder));

   627 

   628     m_widget->show();

   629     core()->objectInspector()->setFormWindow(formWindow());

   630 }

   631 

   632 PromoteToCustomWidgetCommand::PromoteToCustomWidgetCommand

   633                                 (QDesignerFormWindowInterface *formWindow)

   634     : QDesignerFormWindowCommand(QApplication::translate("Command", "Promote to custom widget"), formWindow)

   635 {

   636 }

   637 

   638 void PromoteToCustomWidgetCommand::init(const WidgetList &widgets,const QString &customClassName)

   639 {

   640     m_widgets = widgets;

   641     m_customClassName = customClassName;

   642 }

   643 

   644 void PromoteToCustomWidgetCommand::redo()

   645 {

   646     foreach (QWidget *w, m_widgets) {

   647         if (w)

   648             promoteWidget(core(), w, m_customClassName);

   649     }

   650     updateSelection();

   651 }

   652 

   653 void PromoteToCustomWidgetCommand::updateSelection()

   654 {

   655     // Update class names in ObjectInspector, PropertyEditor

   656     QDesignerFormWindowInterface *fw = formWindow();

   657     QDesignerFormEditorInterface *core = fw->core();

   658     core->objectInspector()->setFormWindow(fw);

   659     if (QObject *o = core->propertyEditor()->object())

   660         core->propertyEditor()->setObject(o);

   661 }

   662 

   663 void PromoteToCustomWidgetCommand::undo()

   664 {

   665     foreach (QWidget *w, m_widgets) {

   666         if (w)

   667             demoteWidget(core(), w);

   668     }

   669     updateSelection();

   670 }

   671 

   672 // ---- DemoteFromCustomWidgetCommand ----

   673 

   674 DemoteFromCustomWidgetCommand::DemoteFromCustomWidgetCommand

   675                                     (QDesignerFormWindowInterface *formWindow) :

   676     QDesignerFormWindowCommand(QApplication::translate("Command", "Demote from custom widget"), formWindow),

   677     m_promote_cmd(formWindow)

   678 {

   679 }

   680 

   681 void DemoteFromCustomWidgetCommand::init(const WidgetList &promoted)

   682 {

   683     m_promote_cmd.init(promoted, promotedCustomClassName(core(), promoted.front()));

   684 }

   685 

   686 void DemoteFromCustomWidgetCommand::redo()

   687 {

   688     m_promote_cmd.undo();

   689 }

   690 

   691 void DemoteFromCustomWidgetCommand::undo()

   692 {

   693     m_promote_cmd.redo();

   694 }

   695 

   696 // ----------  CursorSelectionState

   697 CursorSelectionState::CursorSelectionState()

   698 {

   699 }

   700 

   701 void CursorSelectionState::save(const QDesignerFormWindowInterface *formWindow)

   702 {

   703     const QDesignerFormWindowCursorInterface *cursor = formWindow->cursor();

   704     m_selection.clear();

   705     m_current = cursor->current();

   706     if (cursor->hasSelection()) {

   707         const int count = cursor->selectedWidgetCount();

   708         for(int i = 0; i < count; i++)

   709             m_selection.push_back(cursor->selectedWidget(i));

   710     }

   711 }

   712 

   713 void CursorSelectionState::restore(QDesignerFormWindowInterface *formWindow) const

   714 {

   715     if (m_selection.empty()) {

   716         formWindow->clearSelection(true);

   717     } else {

   718         // Select current as last

   719         formWindow->clearSelection(false);

   720         const WidgetPointerList::const_iterator cend = m_selection.constEnd();

   721         for (WidgetPointerList::const_iterator it = m_selection.constBegin(); it != cend; ++it)

   722             if (QWidget *w = *it)

   723                 if (w != m_current)

   724                     formWindow->selectWidget(*it, true);

   725         if (m_current)

   726             formWindow->selectWidget(m_current, true);

   727     }

   728 }

   729 

   730 // ---- LayoutCommand ----

   731 

   732 LayoutCommand::LayoutCommand(QDesignerFormWindowInterface *formWindow) :

   733     QDesignerFormWindowCommand(QString(), formWindow),

   734     m_setup(false)

   735 {

   736 }

   737 

   738 LayoutCommand::~LayoutCommand()

   739 {

   740     delete m_layout;

   741 }

   742 

   743 void LayoutCommand::init(QWidget *parentWidget, const QWidgetList &widgets,

   744                          LayoutInfo::Type layoutType, QWidget *layoutBase,

   745                          bool reparentLayoutWidget)

   746 {

   747     m_parentWidget = parentWidget;

   748     m_widgets = widgets;

   749     formWindow()->simplifySelection(&m_widgets);

   750     m_layout = Layout::createLayout(widgets, parentWidget, formWindow(), layoutBase, layoutType);

   751     m_layout->setReparentLayoutWidget(reparentLayoutWidget);

   752 

   753     switch (layoutType) {

   754     case LayoutInfo::Grid:

   755         setText(QApplication::translate("Command", "Lay out using grid"));

   756         break;

   757     case LayoutInfo::VBox:

   758         setText(QApplication::translate("Command", "Lay out vertically"));

   759         break;

   760     case LayoutInfo::HBox:

   761         setText(QApplication::translate("Command", "Lay out horizontally"));

   762         break;

   763     default:

   764         break;

   765     }

   766     // Delayed setup to avoid confusion in case we are chained

   767     // with a BreakLayout in a morph layout macro

   768     m_setup = false;

   769 }

   770 

   771 void LayoutCommand::redo()

   772 {

   773     if (!m_setup) {

   774         m_layout->setup();

   775         m_cursorSelectionState.save(formWindow());

   776         m_setup = true;

   777     }

   778     m_layout->doLayout();

   779     core()->objectInspector()->setFormWindow(formWindow());

   780 }

   781 

   782 void LayoutCommand::undo()

   783 {

   784     QDesignerFormEditorInterface *core = formWindow()->core();

   785 

   786     QWidget *lb = m_layout->layoutBaseWidget();

   787     QDesignerLayoutDecorationExtension *deco = qt_extension<QDesignerLayoutDecorationExtension*>(core->extensionManager(), lb);

   788     m_layout->undoLayout();

   789     delete deco; // release the extension

   790 

   791     // ### generalize (put in function)

   792     if (!m_layoutBase && lb != 0 && !(qobject_cast<QLayoutWidget*>(lb) || qobject_cast<QSplitter*>(lb))) {

   793         core->metaDataBase()->add(lb);

   794         lb->show();

   795     }

   796     m_cursorSelectionState.restore(formWindow());

   797     core->objectInspector()->setFormWindow(formWindow());

   798 }

   799 

   800 // ---- BreakLayoutCommand ----

   801 BreakLayoutCommand::BreakLayoutCommand(QDesignerFormWindowInterface *formWindow) :

   802     QDesignerFormWindowCommand(QApplication::translate("Command", "Break layout"), formWindow),

   803     m_layoutHelper(0),

   804     m_properties(0),

   805     m_propertyMask(0)

   806 {

   807 }

   808 

   809 BreakLayoutCommand::~BreakLayoutCommand()

   810 {

   811     delete m_layoutHelper;

   812     delete m_layout;

   813     delete m_properties;

   814 }

   815 

   816 const LayoutProperties *BreakLayoutCommand::layoutProperties() const

   817 {

   818     return m_properties;

   819 }

   820 

   821 int BreakLayoutCommand::propertyMask() const

   822 {

   823     return m_propertyMask;

   824 }

   825 

   826 void BreakLayoutCommand::init(const QWidgetList &widgets, QWidget *layoutBase, bool reparentLayoutWidget)

   827 {

   828     enum Type { SplitterLayout, LayoutHasMarginSpacing, LayoutHasState };

   829 

   830     const QDesignerFormEditorInterface *core = formWindow()->core();

   831     m_widgets = widgets;

   832     m_layoutBase = core->widgetFactory()->containerOfWidget(layoutBase);

   833     QLayout *layoutToBeBroken;

   834     const LayoutInfo::Type layoutType = LayoutInfo::managedLayoutType(core, m_layoutBase, &layoutToBeBroken);

   835     m_layout = Layout::createLayout(widgets, m_layoutBase, formWindow(), layoutBase, layoutType);

   836     m_layout->setReparentLayoutWidget(reparentLayoutWidget);

   837 

   838     Type type = LayoutHasState;

   839     switch (layoutType) {

   840     case LayoutInfo::NoLayout:

   841     case LayoutInfo::HSplitter:

   842     case LayoutInfo::VSplitter:

   843         type = SplitterLayout;

   844         break;

   845     case LayoutInfo::HBox:

   846     case LayoutInfo::VBox: // Margin/spacing need to be saved

   847         type = LayoutHasMarginSpacing;

   848         break;

   849     default: // Margin/spacing need to be saved + has a state (empty rows/columns of a grid)

   850         type = LayoutHasState;

   851         break;

   852     }

   853     Q_ASSERT(m_layout != 0);

   854     m_layout->sort();

   855 

   856 

   857     if (type >= LayoutHasMarginSpacing) {

   858         m_properties = new LayoutProperties;

   859         m_propertyMask = m_properties->fromPropertySheet(core, layoutToBeBroken, LayoutProperties::AllProperties);

   860     }

   861     if (type >= LayoutHasState)

   862          m_layoutHelper = LayoutHelper::createLayoutHelper(layoutType);

   863     m_cursorSelectionState.save(formWindow());

   864 }

   865 

   866 void BreakLayoutCommand::redo()

   867 {

   868     if (!m_layout)

   869         return;

   870 

   871     QDesignerFormEditorInterface *core = formWindow()->core();

   872     QWidget *lb = m_layout->layoutBaseWidget();

   873     QDesignerLayoutDecorationExtension *deco = qt_extension<QDesignerLayoutDecorationExtension*>(core->extensionManager(), lb);

   874     formWindow()->clearSelection(false);

   875     if (m_layoutHelper)

   876         m_layoutHelper->pushState(core, m_layoutBase);

   877     m_layout->breakLayout();

   878     delete deco; // release the extension

   879 

   880     foreach (QWidget *widget, m_widgets) {

   881         widget->resize(widget->size().expandedTo(QSize(16, 16)));

   882     }

   883     // Update unless we are in an intermediate state of morphing layout

   884     // in which a QLayoutWidget will have no layout at all.

   885     if (m_layout->reparentLayoutWidget())

   886         core->objectInspector()->setFormWindow(formWindow());

   887 }

   888 

   889 void BreakLayoutCommand::undo()

   890 {

   891     if (!m_layout)

   892         return;

   893 

   894     formWindow()->clearSelection(false);

   895     m_layout->doLayout();

   896     if (m_layoutHelper)

   897         m_layoutHelper->popState(formWindow()->core(), m_layoutBase);

   898 

   899     QLayout *layoutToRestored = LayoutInfo::managedLayout(formWindow()->core(), m_layoutBase);

   900     if (m_properties && m_layoutBase && layoutToRestored)

   901         m_properties->toPropertySheet(formWindow()->core(), layoutToRestored, m_propertyMask);

   902      m_cursorSelectionState.restore(formWindow());

   903     core()->objectInspector()->setFormWindow(formWindow());

   904 }

   905 // ---- SimplifyLayoutCommand

   906 SimplifyLayoutCommand::SimplifyLayoutCommand(QDesignerFormWindowInterface *formWindow) :

   907     QDesignerFormWindowCommand(QApplication::translate("Command", "Simplify Grid Layout"), formWindow),

   908     m_area(0, 0, 32767, 32767),

   909     m_layoutBase(0),

   910     m_layoutHelper(0),

   911     m_layoutSimplified(false)

   912 {

   913 }

   914 

   915 SimplifyLayoutCommand::~SimplifyLayoutCommand()

   916 {

   917     delete m_layoutHelper;

   918 }

   919 

   920 bool SimplifyLayoutCommand::canSimplify(QDesignerFormEditorInterface *core, const QWidget *w, int *layoutType)

   921 {

   922     if (!w)

   923         return false;

   924     QLayout *layout;

   925     const LayoutInfo::Type type = LayoutInfo::managedLayoutType(core, w, &layout);

   926     if (layoutType)

   927         *layoutType = type;

   928     if (!layout)

   929         return false;

   930     switch (type) { // Known negatives

   931     case LayoutInfo::NoLayout:

   932     case LayoutInfo::UnknownLayout:

   933     case LayoutInfo::HSplitter:

   934     case LayoutInfo::VSplitter:

   935     case LayoutInfo::HBox:

   936     case LayoutInfo::VBox:

   937         return false;

   938     default:

   939         break;

   940     }

   941     switch (type) {

   942     case LayoutInfo::Grid:

   943         return QLayoutSupport::canSimplifyQuickCheck(qobject_cast<QGridLayout*>(layout));

   944     case LayoutInfo::Form:

   945         return QLayoutSupport::canSimplifyQuickCheck(qobject_cast<const QFormLayout*>(layout));

   946     default:

   947         break;

   948     }

   949     return false;

   950 }

   951 

   952 bool SimplifyLayoutCommand::init(QWidget *layoutBase)

   953 {

   954     QDesignerFormEditorInterface *core = formWindow()->core();

   955     m_layoutSimplified = false;

   956     int type;

   957     if (canSimplify(core, layoutBase, &type)) {

   958         m_layoutBase = layoutBase;

   959         m_layoutHelper = LayoutHelper::createLayoutHelper(type);

   960         m_layoutSimplified = m_layoutHelper->canSimplify(core, layoutBase, m_area);

   961     }

   962     return m_layoutSimplified;

   963 }

   964 

   965 void SimplifyLayoutCommand::redo()

   966 {

   967     const QDesignerFormEditorInterface *core = formWindow()->core();

   968     if (m_layoutSimplified) {

   969         m_layoutHelper->pushState(core, m_layoutBase);

   970         m_layoutHelper->simplify(core, m_layoutBase, m_area);

   971     }

   972 }

   973 void SimplifyLayoutCommand::undo()

   974 {

   975     if (m_layoutSimplified)

   976          m_layoutHelper->popState(formWindow()->core(), m_layoutBase);

   977 }

   978 

   979 // ---- ToolBoxCommand ----

   980 ToolBoxCommand::ToolBoxCommand(QDesignerFormWindowInterface *formWindow)  :

   981     QDesignerFormWindowCommand(QString(), formWindow),

   982     m_index(-1)

   983 {

   984 }

   985 

   986 ToolBoxCommand::~ToolBoxCommand()

   987 {

   988 }

   989 

   990 void ToolBoxCommand::init(QToolBox *toolBox)

   991 {

   992     m_toolBox = toolBox;

   993     m_index = m_toolBox->currentIndex();

   994     m_widget = m_toolBox->widget(m_index);

   995     m_itemText = m_toolBox->itemText(m_index);

   996     m_itemIcon = m_toolBox->itemIcon(m_index);

   997 }

   998 

   999 void ToolBoxCommand::removePage()

  1000 {

  1001     m_toolBox->removeItem(m_index);

  1002 

  1003     m_widget->hide();

  1004     m_widget->setParent(formWindow());

  1005     formWindow()->clearSelection();

  1006     formWindow()->selectWidget(m_toolBox, true);

  1007 

  1008 }

  1009 

  1010 void ToolBoxCommand::addPage()

  1011 {

  1012     m_widget->setParent(m_toolBox);

  1013     m_toolBox->insertItem(m_index, m_widget, m_itemIcon, m_itemText);

  1014     m_toolBox->setCurrentIndex(m_index);

  1015 

  1016     QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(formWindow()->core()->extensionManager(), m_toolBox);

  1017     if (sheet) {

  1018         qdesigner_internal::PropertySheetStringValue itemText(m_itemText);

  1019         sheet->setProperty(sheet->indexOf(QLatin1String("currentItemText")), qVariantFromValue(itemText));

  1020     }

  1021 

  1022     m_widget->show();

  1023     formWindow()->clearSelection();

  1024     formWindow()->selectWidget(m_toolBox, true);

  1025 }

  1026 

  1027 // ---- MoveToolBoxPageCommand ----

  1028 MoveToolBoxPageCommand::MoveToolBoxPageCommand(QDesignerFormWindowInterface *formWindow) :

  1029     ToolBoxCommand(formWindow),

  1030     m_newIndex(-1),

  1031     m_oldIndex(-1)

  1032 {

  1033 }

  1034 

  1035 MoveToolBoxPageCommand::~MoveToolBoxPageCommand()

  1036 {

  1037 }

  1038 

  1039 void MoveToolBoxPageCommand::init(QToolBox *toolBox, QWidget *page, int newIndex)

  1040 {

  1041     ToolBoxCommand::init(toolBox);

  1042     setText(QApplication::translate("Command", "Move Page"));

  1043 

  1044     m_widget = page;

  1045     m_oldIndex = m_toolBox->indexOf(m_widget);

  1046     m_itemText = m_toolBox->itemText(m_oldIndex);

  1047     m_itemIcon = m_toolBox->itemIcon(m_oldIndex);

  1048     m_newIndex = newIndex;

  1049 }

  1050 

  1051 void MoveToolBoxPageCommand::redo()

  1052 {

  1053     m_toolBox->removeItem(m_oldIndex);

  1054     m_toolBox->insertItem(m_newIndex, m_widget, m_itemIcon, m_itemText);

  1055 }

  1056 

  1057 void MoveToolBoxPageCommand::undo()

  1058 {

  1059     m_toolBox->removeItem(m_newIndex);

  1060     m_toolBox->insertItem(m_oldIndex, m_widget, m_itemIcon, m_itemText);

  1061 }

  1062 

  1063 // ---- DeleteToolBoxPageCommand ----

  1064 DeleteToolBoxPageCommand::DeleteToolBoxPageCommand(QDesignerFormWindowInterface *formWindow)

  1065     : ToolBoxCommand(formWindow)

  1066 {

  1067 }

  1068 

  1069 DeleteToolBoxPageCommand::~DeleteToolBoxPageCommand()

  1070 {

  1071 }

  1072 

  1073 void DeleteToolBoxPageCommand::init(QToolBox *toolBox)

  1074 {

  1075     ToolBoxCommand::init(toolBox);

  1076     setText(QApplication::translate("Command", "Delete Page"));

  1077 }

  1078 

  1079 void DeleteToolBoxPageCommand::redo()

  1080 {

  1081     removePage();

  1082     cheapUpdate();

  1083 }

  1084 

  1085 void DeleteToolBoxPageCommand::undo()

  1086 {

  1087     addPage();

  1088     cheapUpdate();

  1089 }

  1090 

  1091 // ---- AddToolBoxPageCommand ----

  1092 AddToolBoxPageCommand::AddToolBoxPageCommand(QDesignerFormWindowInterface *formWindow)

  1093     : ToolBoxCommand(formWindow)

  1094 {

  1095 }

  1096 

  1097 AddToolBoxPageCommand::~AddToolBoxPageCommand()

  1098 {

  1099 }

  1100 

  1101 void AddToolBoxPageCommand::init(QToolBox *toolBox)

  1102 {

  1103     init(toolBox, InsertBefore);

  1104 }

  1105 

  1106 void AddToolBoxPageCommand::init(QToolBox *toolBox, InsertionMode mode)

  1107 {

  1108     m_toolBox = toolBox;

  1109 

  1110     m_index = m_toolBox->currentIndex();

  1111     if (mode == InsertAfter)

  1112         m_index++;

  1113     m_widget = new QDesignerWidget(formWindow(), m_toolBox);

  1114     m_itemText = QApplication::translate("Command", "Page");

  1115     m_itemIcon = QIcon();

  1116     m_widget->setObjectName(QLatin1String("page"));

  1117     formWindow()->ensureUniqueObjectName(m_widget);

  1118 

  1119     setText(QApplication::translate("Command", "Insert Page"));

  1120 

  1121     QDesignerFormEditorInterface *core = formWindow()->core();

  1122     core->metaDataBase()->add(m_widget);

  1123 }

  1124 

  1125 void AddToolBoxPageCommand::redo()

  1126 {

  1127     addPage();

  1128     cheapUpdate();

  1129 }

  1130 

  1131 void AddToolBoxPageCommand::undo()

  1132 {

  1133     removePage();

  1134     cheapUpdate();