qdesigner_workbench.cpp

上传用户:binglan008
上传日期:2007-01-28
资源大小:53508k
文件大小:41k
源码类别:Linux/Unix编程
开发平台:MultiPlatform
  1. /****************************************************************************
  2. **
  3. ** Copyright (C) 1992-2007 Trolltech ASA. All rights reserved.
  4. **
  5. ** This file is part of the Qt Designer of the Qt Toolkit.
  6. **
  7. ** This file may be used under the terms of the GNU General Public
  8. ** License version 2.0 as published by the Free Software Foundation
  9. ** and appearing in the file LICENSE.GPL included in the packaging of
  10. ** this file.  Please review the following information to ensure GNU
  11. ** General Public Licensing requirements will be met:
  12. ** http://trolltech.com/products/qt/licenses/licensing/opensource/
  13. **
  14. ** If you are unsure which license is appropriate for your use, please
  15. ** review the following information:
  16. ** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
  17. ** or contact the sales department at sales@trolltech.com.
  18. **
  19. ** In addition, as a special exception, Trolltech gives you certain
  20. ** additional rights. These rights are described in the Trolltech GPL
  21. ** Exception version 1.0, which can be found at
  22. ** http://www.trolltech.com/products/qt/gplexception/ and in the file
  23. ** GPL_EXCEPTION.txt in this package.
  24. **
  25. ** In addition, as a special exception, Trolltech, as the sole copyright
  26. ** holder for Qt Designer, grants users of the Qt/Eclipse Integration
  27. ** plug-in the right for the Qt/Eclipse Integration to link to
  28. ** functionality provided by Qt Designer and its related libraries.
  29. **
  30. ** Trolltech reserves all rights not expressly granted herein.
  31. **
  32. ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  33. ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  34. **
  35. ****************************************************************************/
  36. #include "qdesigner_workbench.h"
  37. #include "qdesigner.h"
  38. #include "preferences.h"
  39. #include "qdesigner_actions.h"
  40. #include "qdesigner_toolwindow.h"
  41. #include "qdesigner_formwindow.h"
  42. #include "qdesigner_settings.h"
  43. #include "qdesigner_widgetbox.h"
  44. #include "qdesigner_propertyeditor.h"
  45. #include "qdesigner_objectinspector.h"
  46. #include "qdesigner_signalsloteditor.h"
  47. #include "qdesigner_actioneditor.h"
  48. #include "qdesigner_resourceeditor.h"
  49. #include <QtDesigner/QDesignerFormEditorInterface>
  50. #include <QtDesigner/QDesignerFormWindowInterface>
  51. #include <QtDesigner/QDesignerFormWindowManagerInterface>
  52. #include <QtDesigner/QDesignerFormEditorPluginInterface>
  53. #include <QtDesigner/QDesignerWidgetBoxInterface>
  54. #include <QtDesigner/QDesignerMetaDataBaseInterface>
  55. #include <QtDesigner/QDesignerComponents>
  56. #include <QtDesigner/private/qdesigner_integration_p.h>
  57. #include <QtDesigner/private/pluginmanager_p.h>
  58. #include <QtDesigner/private/formwindowbase_p.h>
  59. #include <QtCore/QDir>
  60. #include <QtCore/QFile>
  61. #include <QtCore/QUrl>
  62. #include <QtCore/QTimer>
  63. #include <QtCore/QPluginLoader>
  64. #include <QtCore/qdebug.h>
  65. #include <QtGui/QActionGroup>
  66. #include <QtGui/QCloseEvent>
  67. #include <QtGui/QDesktopWidget>
  68. #include <QtGui/QDockWidget>
  69. #include <QtGui/QMenu>
  70. #include <QtGui/QMenuBar>
  71. #include <QtGui/QMessageBox>
  72. #include <QtGui/QPushButton>
  73. #include <QtGui/QToolBar>
  74. #include <QtGui/QMdiArea>
  75. #include <QtGui/QMdiSubWindow>
  76. static QMdiSubWindow *mdiSubWindowOf(const QWidget *w)
  77. {
  78.     QMdiSubWindow *rc = qobject_cast<QMdiSubWindow *>(w->parentWidget());
  79.     Q_ASSERT(rc);
  80.     return rc;
  81. }
  82. static QDockWidget *dockWidgetOf(const QWidget *w)
  83. {
  84.     for (QWidget *parentWidget = w->parentWidget(); parentWidget ; parentWidget = parentWidget->parentWidget()) {
  85.         if (QDockWidget *dw = qobject_cast<QDockWidget *>(parentWidget)) {
  86.             return dw;
  87.         }
  88.     }
  89.     Q_ASSERT("Dock widget not found");
  90.     return 0;
  91. }
  92. QMdiSubWindow *createFormMdiSubWindow(QMdiArea *a, QDesignerFormWindow *fw, Qt::WindowFlags f, const QKeySequence &designerCloseActionShortCut)
  93. {
  94.     typedef QList<QAction *> ActionList;
  95.     QMdiSubWindow *rc = a->addSubWindow(fw, f);
  96.     // Make action shortcuts respond only if focused to avoid conflicts with designer menu actions
  97.     if (designerCloseActionShortCut == QKeySequence(QKeySequence::Close)) {
  98.         const ActionList systemMenuActions = rc->systemMenu()->actions();
  99.         if (!systemMenuActions.empty()) {
  100.             const ActionList::const_iterator cend = systemMenuActions.constEnd();
  101.             for (ActionList::const_iterator it = systemMenuActions.constBegin(); it != cend; ++it) {
  102.                 if ( (*it)->shortcut() == designerCloseActionShortCut) {
  103.                     (*it)->setShortcutContext(Qt::WidgetShortcut);
  104.                     break;
  105.                 }
  106.             }
  107.         }
  108.     }
  109.     rc->setMinimumSize(QSize(0, 0));
  110.     return rc;
  111. }
  112. // ------------ QDesignerWorkbench::Position
  113. QDesignerWorkbench::Position::Position(const QMdiSubWindow *mdiSubWindow, const QPoint &mdiAreaOffset) :
  114.     m_minimized(mdiSubWindow->isShaded()),
  115.     m_position(mdiSubWindow->pos() + mdiAreaOffset)
  116. {
  117. }
  118. QDesignerWorkbench::Position::Position(const QDockWidget *dockWidget) :
  119.     m_minimized(dockWidget->isMinimized()),
  120.     m_position(dockWidget->pos())
  121. {
  122. }
  123. QDesignerWorkbench::Position::Position(const QWidget *topLevelWindow, const QPoint &desktopTopLeft)
  124. {
  125.     const QWidget *window =topLevelWindow->window ();
  126.     Q_ASSERT(window);
  127.     m_minimized = window->isMinimized();
  128.     m_position = window->pos() - desktopTopLeft;
  129. }
  130. void QDesignerWorkbench::Position::applyTo(QMdiSubWindow *mdiSubWindow,
  131.                                            const QPoint &mdiAreaOffset) const
  132. {
  133.     // QMdiSubWindow attempts to resize its children to sizeHint() when switching user interface modes.
  134.     // Restore old size
  135.     const QPoint mdiAreaPos =  QPoint(qMax(0, m_position.x() - mdiAreaOffset.x()),
  136.                                       qMax(0, m_position.y() - mdiAreaOffset.y()));
  137.     mdiSubWindow->move(mdiAreaPos);
  138.     const QSize decorationSize = mdiSubWindow->size() - mdiSubWindow->contentsRect().size();
  139.     mdiSubWindow->resize(mdiSubWindow->widget()->size() + decorationSize);
  140.     mdiSubWindow->show();
  141.     if (m_minimized) {
  142.         mdiSubWindow->showShaded();
  143.     }
  144. }
  145. void QDesignerWorkbench::Position::applyTo(QWidget *topLevelWindow, const QPoint &desktopTopLeft) const
  146. {
  147.     QWidget *window = topLevelWindow->window ();
  148.     const QPoint newPos = m_position + desktopTopLeft;
  149.     window->move(newPos);
  150.     if ( m_minimized) {
  151.         topLevelWindow->showMinimized();
  152.     } else {
  153.         topLevelWindow->show();
  154.     }
  155. }
  156. void QDesignerWorkbench::Position::applyTo(QDockWidget *dockWidget) const
  157. {
  158.     dockWidget->widget()->setVisible(true);
  159.     dockWidget->setVisible(!m_minimized);
  160. }
  161. // -------- QDesignerWorkbench
  162. QDesignerWorkbench::QDesignerWorkbench()
  163.     : m_mode(NeutralMode), m_mdiArea(0), m_state(StateInitializing)
  164. {
  165.     initialize();
  166.     applyPreferences(QDesignerSettings().preferences());
  167.     m_state = StateUp;
  168. }
  169. QDesignerWorkbench::~QDesignerWorkbench()
  170. {
  171.     QDesignerSettings settings;
  172.     settings.clearBackup();
  173.     if (m_mode == DockedMode) {
  174.         Q_ASSERT(m_mdiArea != 0);
  175.         QMainWindow *mw = qobject_cast<QMainWindow*>(m_mdiArea->window());
  176.         Q_ASSERT(mw != 0);
  177.         settings.setMainWindowState(mw->saveState(2));
  178.     } else if (m_mode == TopLevelMode) {
  179.         QDesignerToolWindow *widgetBoxWrapper = findToolWindow(core()->widgetBox());
  180.         if (widgetBoxWrapper) {
  181.             settings.setToolBoxState(widgetBoxWrapper->saveState());
  182.         }
  183.     }
  184.     while (!m_toolWindows.isEmpty())
  185.         delete m_toolWindows.takeLast();
  186. }
  187. void QDesignerWorkbench::saveGeometries()
  188. {
  189.     m_Positions.clear();
  190.     switch (m_mode) {
  191.     case NeutralMode:
  192.         break;
  193.     case TopLevelMode: {
  194.         const QPoint desktopOffset = QApplication::desktop()->availableGeometry().topLeft();
  195.         foreach (QDesignerToolWindow *tw, m_toolWindows)
  196.             m_Positions.insert(tw, Position(tw, desktopOffset));
  197.         foreach (QDesignerFormWindow *fw, m_formWindows) {
  198.             m_Positions.insert(fw,  Position(fw, desktopOffset));
  199.         }
  200.     }
  201.         break;
  202.     case DockedMode: {
  203.         const QPoint mdiAreaOffset = m_mdiArea->pos();
  204.         foreach (QDesignerToolWindow *tw, m_toolWindows) {
  205.             m_Positions.insert(tw, Position(dockWidgetOf(tw)));
  206.         }
  207.         foreach (QDesignerFormWindow *fw, m_formWindows) {
  208.             m_Positions.insert(fw, Position(mdiSubWindowOf(fw), mdiAreaOffset));
  209.         }
  210.     }
  211.         break;
  212.     }
  213. }
  214. UIMode QDesignerWorkbench::mode() const
  215. {
  216.     return m_mode;
  217. }
  218. void QDesignerWorkbench::addToolWindow(QDesignerToolWindow *toolWindow)
  219. {
  220.     Q_ASSERT(m_toolWindowExtras.contains(toolWindow) == false);
  221.     Q_ASSERT(toolWindow->windowTitle().isEmpty() == false);
  222.     m_toolWindows.append(toolWindow);
  223.     if (QAction *action = toolWindow->action()) {
  224.         Q_ASSERT(m_toolMenu->actions().isEmpty() == false);
  225.         QList<QAction*> lst = m_toolActions->actions();
  226.         QAction *before = lst.count() ? lst.last() : m_toolMenu->actions().first();
  227.         m_toolMenu->insertAction(before, action);
  228.         m_toolActions->addAction(action);
  229.     }
  230. }
  231. void QDesignerWorkbench::addFormWindow(QDesignerFormWindow *formWindow)
  232. {
  233.     Q_ASSERT(m_formWindowExtras.contains(formWindow) == false);
  234.     // ### Q_ASSERT(formWindow->windowTitle().isEmpty() == false);
  235.     m_formWindows.append(formWindow);
  236.     m_actionManager->setWindowListSeparatorVisible(true);
  237.     if (QAction *action = formWindow->action()) {
  238.         m_windowActions->addAction(action);
  239.         m_windowMenu->addAction(action);
  240.         action->setChecked(true);
  241.     }
  242.     m_actionManager->minimizeAction()->setEnabled(true);
  243.     m_actionManager->minimizeAction()->setChecked(false);
  244.     connect(formWindow, SIGNAL(minimizationStateChanged(QDesignerFormWindowInterface *, bool)),
  245.             this, SLOT(minimizationStateChanged(QDesignerFormWindowInterface *, bool)));
  246.     m_actionManager->editWidgets()->trigger();
  247. }
  248. void QDesignerWorkbench::initialize()
  249. {
  250.     QDesignerSettings settings;
  251.     m_core = QDesignerComponents::createFormEditor(this);
  252.     (void) QDesignerComponents::createTaskMenu(core(), this);
  253.     initializeCorePlugins();
  254.     QDesignerComponents::initializePlugins(core());
  255.     m_toolActions = new QActionGroup(this);
  256.     m_toolActions->setExclusive(false);
  257.     m_windowActions = new QActionGroup(this);
  258.     m_windowActions->setExclusive(true);
  259.     connect(m_windowActions, SIGNAL(triggered(QAction*)), this, SLOT(formWindowActionTriggered(QAction*)));
  260.     m_actionManager = new QDesignerActions(this);
  261.     m_globalMenuBar = new QMenuBar;
  262.     m_fileMenu = m_globalMenuBar->addMenu(tr("&File"));
  263.     foreach (QAction *action, m_actionManager->fileActions()->actions()) {
  264.         m_fileMenu->addAction(action);
  265.         if (action->text() == QDesignerActions::tr("&Open Form...")) {
  266.             QMenu *recentFilesMenu = m_fileMenu->addMenu(tr("&Recent Forms"));
  267.             // Pop the "Recent Files" stuff in here.
  268.             foreach(QAction *recentAction, m_actionManager->recentFilesActions()->actions())
  269.                 recentFilesMenu->addAction(recentAction);
  270.         }
  271.     }
  272.     m_editMenu = m_globalMenuBar->addMenu(tr("&Edit"));
  273.     foreach (QAction *action, m_actionManager->editActions()->actions()) {
  274.         m_editMenu->addAction(action);
  275.     }
  276.     m_editMenu->addSeparator();
  277.     foreach (QAction *action, m_actionManager->toolActions()->actions()) {
  278.         m_editMenu->addAction(action);
  279.     }
  280.     m_editMenu->addSeparator();
  281.     m_editMenu->addAction(m_actionManager->preferencesAction());
  282.     m_formMenu = m_globalMenuBar->addMenu(tr("F&orm"));
  283.     foreach (QAction *action, m_actionManager->formActions()->actions()) {
  284.         m_formMenu->addAction(action);
  285.     }
  286.     QMenu *previewSubMenu = new QMenu(tr("Preview in"), m_formMenu);
  287.     m_formMenu->insertMenu(m_actionManager->previewFormAction(), previewSubMenu);
  288.     foreach (QAction *action, m_actionManager->styleActions()->actions()) {
  289.         previewSubMenu->addAction(action);
  290.     }
  291.     m_toolMenu = m_globalMenuBar->addMenu(tr("&Tools"));
  292.     m_toolMenu->addSeparator();
  293.     m_windowMenu = m_globalMenuBar->addMenu(tr("&Window"));
  294.     foreach (QAction *action, m_actionManager->windowActions()->actions()) {
  295.         m_windowMenu->addAction(action);
  296.     }
  297.     m_helpMenu = m_globalMenuBar->addMenu(tr("&Help"));
  298.     foreach (QAction *action, m_actionManager->helpActions()->actions()) {
  299.         m_helpMenu->addAction(action);
  300.     }
  301.     QDesignerToolWindow *tw = new QDesignerWidgetBox(this);
  302.     tw->setObjectName(QLatin1String("qt_designer_widgetbox"));
  303.     addToolWindow(tw);
  304.     tw = new QDesignerObjectInspector(this);
  305.     tw->setObjectName(QLatin1String("qt_designer_objectinspector"));
  306.     addToolWindow(tw);
  307.     tw = new QDesignerPropertyEditor(this);
  308.     tw->setObjectName(QLatin1String("qt_designer_propertyeditor"));
  309.     addToolWindow(tw);
  310.     tw = new QDesignerSignalSlotEditor(this);
  311.     tw->setObjectName(QLatin1String("qt_designer_signalsloteditor"));
  312.     addToolWindow(tw);
  313.     tw = new QDesignerResourceEditor(this);
  314.     tw->setObjectName(QLatin1String("qt_designer_resourceeditor"));
  315.     addToolWindow(tw);
  316.     tw = new QDesignerActionEditor(this);
  317.     tw->setObjectName(QLatin1String("qt_designer_actioneditor"));
  318.     addToolWindow(tw);
  319.     m_integration = new qdesigner_internal::QDesignerIntegration(core(), this);
  320.     // create the toolbars
  321.     m_fileToolBar = new QToolBar;
  322.     m_fileToolBar->setObjectName(QLatin1String("fileToolBar"));
  323.     m_fileToolBar->setWindowTitle(tr("File"));
  324.     foreach (QAction *action, m_actionManager->fileActions()->actions()) {
  325.         if (action->icon().isNull() == false)
  326.             m_fileToolBar->addAction(action);
  327.     }
  328.     m_editToolBar = new QToolBar;
  329.     m_editToolBar->setObjectName(QLatin1String("editToolBar"));
  330.     m_editToolBar->setWindowTitle(tr("Edit"));
  331.     foreach (QAction *action, m_actionManager->editActions()->actions()) {
  332.         if (action->icon().isNull() == false)
  333.             m_editToolBar->addAction(action);
  334.     }
  335.     m_toolToolBar = new QToolBar;
  336.     m_toolToolBar->setObjectName(QLatin1String("toolsToolBar"));
  337.     m_toolToolBar->setWindowTitle(tr("Tools"));
  338.     foreach (QAction *action, m_actionManager->toolActions()->actions()) {
  339.         if (action->icon().isNull() == false)
  340.             m_toolToolBar->addAction(action);
  341.     }
  342.     m_formToolBar = new QToolBar;
  343.     m_formToolBar->setObjectName(QLatin1String("formToolBar"));
  344.     m_formToolBar->setWindowTitle(tr("Form"));
  345.     foreach (QAction *action, m_actionManager->formActions()->actions()) {
  346.         if (action->icon().isNull() == false)
  347.             m_formToolBar->addAction(action);
  348.     }
  349.     QMenu *toolbarMenu = m_toolMenu->addMenu(tr("Toolbars"));
  350.     toolbarMenu->addAction(m_fileToolBar->toggleViewAction());
  351.     toolbarMenu->addAction(m_editToolBar->toggleViewAction());
  352.     toolbarMenu->addAction(m_toolToolBar->toggleViewAction());
  353.     toolbarMenu->addAction(m_formToolBar->toggleViewAction());
  354.     emit initialized();
  355.     connect(m_core->formWindowManager(), SIGNAL(activeFormWindowChanged(QDesignerFormWindowInterface*)),
  356.                 this, SLOT(updateWindowMenu(QDesignerFormWindowInterface*)));
  357. }
  358. Qt::WindowFlags QDesignerWorkbench::magicalWindowFlags(const QWidget *widgetForFlags) const
  359. {
  360.     switch (m_mode) {
  361.         case TopLevelMode: {
  362. #ifdef Q_WS_MAC
  363.             if (qobject_cast<const QDesignerToolWindow *>(widgetForFlags))
  364.                 return Qt::Tool;
  365. #else
  366.             Q_UNUSED(widgetForFlags);
  367. #endif
  368.             return Qt::Window;
  369.         }
  370.         case DockedMode:
  371.             Q_ASSERT(m_mdiArea != 0);
  372.             return Qt::Window | Qt::WindowShadeButtonHint | Qt::WindowSystemMenuHint | Qt::WindowTitleHint;
  373.         case NeutralMode:
  374.             return Qt::Window;
  375.         default:
  376.             Q_ASSERT(0);
  377.             return 0;
  378.     }
  379. }
  380. QWidget *QDesignerWorkbench::magicalParent() const
  381. {
  382.     switch (m_mode) {
  383.         case TopLevelMode:
  384.             return 0;
  385.         case DockedMode:
  386.             Q_ASSERT(m_mdiArea != 0);
  387.             return m_mdiArea;
  388.         case NeutralMode:
  389.             return 0;
  390.         default:
  391.             Q_ASSERT(0);
  392.             return 0;
  393.     }
  394. }
  395. void QDesignerWorkbench::switchToNeutralMode()
  396. {
  397.     if (m_mode == NeutralMode) {
  398.         return;
  399.     } else if (m_mode == DockedMode) {
  400.         Q_ASSERT(m_mdiArea != 0);
  401.         QMainWindow *mw = qobject_cast<QMainWindow*>(m_mdiArea->window());
  402.         QDesignerSettings settings;
  403.         settings.setMainWindowState(mw->saveState(2));
  404.     } else if (m_mode == TopLevelMode) {
  405.         QDesignerToolWindow *widgetBoxWrapper = findToolWindow(core()->widgetBox());
  406.         if (widgetBoxWrapper) {
  407.             QDesignerSettings settings;
  408.             settings.setToolBoxState(widgetBoxWrapper->saveState());
  409.         }
  410.     }
  411.     saveGeometries();
  412.     m_mode = NeutralMode;
  413.     foreach (QDesignerToolWindow *tw, m_toolWindows) {
  414.         tw->setSaveSettingsOnClose(false);
  415.         tw->setParent(0);
  416.     }
  417.     foreach (QDesignerFormWindow *fw, m_formWindows) {
  418.         fw->setParent(0);
  419.     }
  420. #ifndef Q_WS_MAC
  421.     m_globalMenuBar->setParent(0);
  422. #endif
  423.     m_fileToolBar->setParent(0);
  424.     m_editToolBar->setParent(0);
  425.     m_toolToolBar->setParent(0);
  426.     m_formToolBar->setParent(0);
  427.     m_core->setTopLevel(0);
  428.     qDesigner->setMainWindow(0);
  429.     if (m_mdiArea)
  430.         delete m_mdiArea->parentWidget();
  431.     m_mdiArea = 0;
  432. }
  433. void QDesignerWorkbench::switchToDockedMode()
  434. {
  435.     bool wasTopLevel = (m_mode == TopLevelMode);
  436.     if (m_mode == DockedMode)
  437.         return;
  438.     switchToNeutralMode();
  439.     m_mode = DockedMode;
  440.     QDesignerToolWindow *widgetBoxWrapper = 0;
  441.     if (0 != (widgetBoxWrapper = findToolWindow(core()->widgetBox()))) {
  442.         widgetBoxWrapper->action()->setVisible(true);
  443.         widgetBoxWrapper->setWindowTitle(tr("Widget Box"));
  444.     }
  445.     Q_ASSERT(m_mdiArea == 0);
  446.     QDesignerSettings settings;
  447.     QDesignerToolWindow *mw = new QDesignerToolWindow(this); // Just to have a copy of
  448.     mw->setSaveSettingsOnClose(true);
  449.     mw->setObjectName(QLatin1String("MDIWindow"));
  450.     mw->setWindowTitle(tr("Qt Designer"));
  451.     m_mdiArea = new QMdiArea(mw);
  452.     m_mdiArea->setAcceptDrops(true);
  453.     m_mdiArea->installEventFilter(this);
  454.     m_mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
  455.     m_mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
  456.     connect(m_mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)),
  457.             this, SLOT(activateMdiAreaChildWindow(QMdiSubWindow*)));
  458.     mw->setCentralWidget(m_mdiArea);
  459.     m_core->setTopLevel(mw);
  460.     (void) mw->statusBar();
  461.     if (m_Positions.isEmpty()) {
  462.         settings.setGeometryFor(mw, qApp->desktop()->availableGeometry(0));
  463.     } else {
  464.         if (QDesignerToolWindow *widgetBox = findToolWindow(core()->widgetBox())) {
  465.             const PositionMap::const_iterator pit = m_Positions.constFind(widgetBox);
  466.             const QPoint pos = pit != m_Positions.constEnd() ? pit->position() : QPoint(0, 0);
  467.             mw->move(pos);
  468.         }
  469.         mw->setWindowState(mw->windowState() | Qt::WindowMaximized);
  470.     }
  471. #ifndef Q_WS_MAC
  472.     mw->setMenuBar(m_globalMenuBar);
  473.     m_globalMenuBar->show();
  474. #endif
  475.     mw->addToolBar(m_fileToolBar);
  476.     mw->addToolBar(m_editToolBar);
  477.     mw->addToolBar(m_toolToolBar);
  478.     mw->addToolBar(m_formToolBar);
  479.     m_fileToolBar->show();
  480.     m_editToolBar->show();
  481.     m_toolToolBar->show();
  482.     m_formToolBar->show();
  483.     qDesigner->setMainWindow(mw);
  484.     foreach (QDesignerToolWindow *tw, m_toolWindows) {
  485.         if (wasTopLevel)
  486.             settings.saveGeometryFor(tw);
  487.         QDockWidget *dockWidget = magicalDockWidget(tw);
  488.         if (dockWidget == 0) {
  489.             dockWidget = new QDockWidget(mw);
  490.             dockWidget->setObjectName(tw->objectName() + QLatin1String("_dock"));
  491.             dockWidget->setWindowTitle(tw->windowTitle());
  492.             mw->addDockWidget(tw->dockWidgetAreaHint(), dockWidget);
  493.         }
  494.         dockWidget->setWidget(tw);
  495.         const PositionMap::const_iterator pit = m_Positions.constFind(tw);
  496.         if (pit != m_Positions.constEnd()) pit->applyTo(dockWidget);
  497.     }
  498.     mw->restoreState(settings.mainWindowState(), 2);
  499.     foreach (QDesignerFormWindow *fw, m_formWindows)
  500.         createFormMdiSubWindow(m_mdiArea, fw, magicalWindowFlags(fw), m_actionManager->closeFormAction()->shortcut())->hide();
  501.     m_actionManager->setBringAllToFrontVisible(false);
  502.     mw->show();
  503.     // Trigger adjustMDIFormPositions() delayed as viewport size is not yet known.
  504.     if (m_state != StateInitializing)
  505.         QMetaObject::invokeMethod(this, "adjustMDIFormPositions", Qt::QueuedConnection);
  506. }
  507. void QDesignerWorkbench::adjustMDIFormPositions()
  508. {
  509.     const QPoint mdiAreaOffset =  m_mdiArea->pos();
  510.     foreach (QDesignerFormWindow *fw, m_formWindows) {
  511.         const PositionMap::const_iterator pit = m_Positions.constFind(fw);
  512.         if (pit != m_Positions.constEnd()) pit->applyTo(mdiSubWindowOf(fw), mdiAreaOffset);
  513.     }
  514. }
  515. bool QDesignerWorkbench::eventFilter(QObject *object, QEvent *event)
  516. {
  517.     if (object == m_mdiArea) {
  518.         if (event->type() == QEvent::DragEnter) {
  519.             QDragEnterEvent *e = static_cast<QDragEnterEvent*>(event);
  520.             if (e->mimeData()->hasFormat(QLatin1String("text/uri-list"))) {
  521.                 e->acceptProposedAction();
  522.                 return true;
  523.             }
  524.         } else if (event->type() == QEvent::Drop) {
  525.             QDropEvent *e = static_cast<QDropEvent*>(event);
  526.             if (!e->mimeData()->hasFormat(QLatin1String("text/uri-list")))
  527.                 return false;
  528.             foreach (QUrl url, e->mimeData()->urls()) {
  529.                 if (!url.toLocalFile().isEmpty())
  530.                     readInForm(url.toLocalFile());
  531.             }
  532.             e->acceptProposedAction();
  533.             return true;
  534.         }
  535.     }
  536.     return false;
  537. }
  538. void QDesignerWorkbench::switchToTopLevelMode()
  539. {
  540.     if (m_mode == TopLevelMode)
  541.         return;
  542.     // make sure that the widgetbox is visible if it is different from neutral.
  543.     QDesignerToolWindow *widgetBoxWrapper = findToolWindow(core()->widgetBox());
  544.     if (m_mode != NeutralMode) {
  545.         if (widgetBoxWrapper) {
  546.             if (!widgetBoxWrapper->action()->isChecked())
  547.                 widgetBoxWrapper->action()->trigger();
  548.         }
  549.     }
  550.     switchToNeutralMode();
  551.     const QPoint desktopOffset = QApplication::desktop()->availableGeometry().topLeft();
  552.     m_mode = TopLevelMode;
  553.     // The widget box is special, it gets the menubar and gets to be the main widget.
  554.     QDesignerSettings settings;
  555.     if (widgetBoxWrapper) {
  556.         m_core->setTopLevel(widgetBoxWrapper);
  557. #ifndef Q_WS_MAC
  558.         widgetBoxWrapper->setMenuBar(m_globalMenuBar);
  559.         widgetBoxWrapper->action()->setVisible(false);
  560.         widgetBoxWrapper->setSaveSettingsOnClose(true);
  561.         qDesigner->setMainWindow(widgetBoxWrapper);
  562.         widgetBoxWrapper->setWindowTitle(tr("Qt Designer"));
  563. #endif
  564.         widgetBoxWrapper->addToolBar(m_fileToolBar);
  565.         widgetBoxWrapper->addToolBar(m_editToolBar);
  566.         widgetBoxWrapper->addToolBar(m_toolToolBar);
  567.         widgetBoxWrapper->addToolBar(m_formToolBar);
  568.         widgetBoxWrapper->restoreState(settings.toolBoxState());
  569.     }
  570.     bool found_visible_window = false;
  571.     foreach (QDesignerToolWindow *tw, m_toolWindows) {
  572.         tw->setParent(magicalParent(), magicalWindowFlags(tw));
  573.         settings.setGeometryFor(tw, tw->geometryHint());
  574.         tw->action()->setChecked(tw->isVisible());
  575.         found_visible_window |= tw->isVisible();
  576.     }
  577.     if (widgetBoxWrapper) {
  578.         if (!widgetBoxWrapper->action()->isChecked())
  579.             widgetBoxWrapper->action()->trigger();
  580.     }
  581.     if (!m_toolWindows.isEmpty() && !found_visible_window)
  582.         m_toolWindows.first()->show();
  583.     m_actionManager->setBringAllToFrontVisible(true);
  584.     foreach (QDesignerFormWindow *fw, m_formWindows) {
  585.         fw->setParent(magicalParent(), magicalWindowFlags(fw));
  586.         const PositionMap::const_iterator pit = m_Positions.constFind(fw);
  587.         if (pit != m_Positions.constEnd()) pit->applyTo(fw, desktopOffset);
  588.     }
  589. }
  590. QDesignerFormWindow *QDesignerWorkbench::createFormWindow()
  591. {
  592.     QDesignerFormWindow *formWindow = new QDesignerFormWindow(/*formWindow=*/ 0, this);
  593.     if (m_mdiArea) {
  594.         m_mdiArea->setActiveSubWindow(createFormMdiSubWindow(m_mdiArea, formWindow, magicalWindowFlags(formWindow), m_actionManager->closeFormAction()->shortcut()));
  595.     } else {
  596.         const QRect formWindowGeometryHint = formWindow->geometryHint();
  597.         formWindow->setAttribute(Qt::WA_DeleteOnClose, true);
  598.         formWindow->setParent(magicalParent(), magicalWindowFlags(formWindow));
  599.         formWindow->resize(formWindowGeometryHint.size());
  600.         formWindow->move(availableGeometry().center() - formWindowGeometryHint.center());
  601.     }
  602.     addFormWindow(formWindow);
  603.     return formWindow;
  604. }
  605. QDesignerFormWindowManagerInterface *QDesignerWorkbench::formWindowManager() const
  606. {
  607.     return m_core->formWindowManager();
  608. }
  609. QDesignerFormEditorInterface *QDesignerWorkbench::core() const
  610. {
  611.     return m_core;
  612. }
  613. int QDesignerWorkbench::toolWindowCount() const
  614. {
  615.     return m_toolWindows.count();
  616. }
  617. QDesignerToolWindow *QDesignerWorkbench::toolWindow(int index) const
  618. {
  619.     return m_toolWindows.at(index);
  620. }
  621. int QDesignerWorkbench::formWindowCount() const
  622. {
  623.     return m_formWindows.count();
  624. }
  625. QDesignerFormWindow *QDesignerWorkbench::formWindow(int index) const
  626. {
  627.     return m_formWindows.at(index);
  628. }
  629. QRect QDesignerWorkbench::availableGeometry() const
  630. {
  631.     if (m_mdiArea)
  632.         return m_mdiArea->geometry();
  633.     QDesktopWidget *desktop = qDesigner->desktop();
  634.     QWidget *window = findToolWindow(core()->widgetBox());
  635.     if (window)
  636.         return desktop->availableGeometry(desktop->screenNumber(window));
  637.     return desktop->availableGeometry(0);
  638. }
  639. int QDesignerWorkbench::marginHint() const
  640. {    return 20;
  641. }
  642. void QDesignerWorkbench::activateMdiAreaChildWindow(QMdiSubWindow *subWindow)
  643. {
  644.     if (subWindow) {
  645.         QWidget *widget = subWindow->widget();
  646.         if (QDesignerFormWindow *fw = qobject_cast<QDesignerFormWindow*>(widget)) {
  647.             core()->formWindowManager()->setActiveFormWindow(fw->editor());
  648.             m_mdiArea->setActiveSubWindow(subWindow);
  649.         }
  650.     }
  651. }
  652. void QDesignerWorkbench::removeToolWindow(QDesignerToolWindow *toolWindow)
  653. {
  654.     int index = m_toolWindows.indexOf(toolWindow);
  655.     if (index != -1) {
  656.         m_toolWindows.removeAt(index);
  657.         m_toolWindowExtras.remove(toolWindow);
  658.     }
  659.     if (QAction *action = toolWindow->action()) {
  660.         m_toolActions->removeAction(action);
  661.         m_toolMenu->removeAction(action);
  662.     }
  663. }
  664. void QDesignerWorkbench::removeFormWindow(QDesignerFormWindow *formWindow)
  665. {
  666.     QDesignerFormWindowInterface *editor = formWindow->editor();
  667.     const bool loadOk = editor->mainContainer();
  668.     updateBackup(editor);
  669.     const int index = m_formWindows.indexOf(formWindow);
  670.     if (index != -1) {
  671.         m_formWindows.removeAt(index);
  672.         m_formWindowExtras.remove(formWindow);
  673.     }
  674.     if (QAction *action = formWindow->action()) {
  675.         m_windowActions->removeAction(action);
  676.         m_windowMenu->removeAction(action);
  677.     }
  678.     if (m_formWindows.empty()) {
  679.         m_actionManager->setWindowListSeparatorVisible(false);
  680.         // Show up new form dialog unless closing
  681.         if (loadOk && m_state == StateUp &&  QDesignerSettings().showNewFormOnStartup()) {
  682.             QTimer::singleShot(200, m_actionManager, SLOT(createForm()));
  683.         }
  684.     }
  685. }
  686. void QDesignerWorkbench::initializeCorePlugins()
  687. {
  688.     QList<QObject*> plugins = QPluginLoader::staticInstances();
  689.     plugins += core()->pluginManager()->instances();
  690.     foreach (QObject *plugin, plugins) {
  691.         if (QDesignerFormEditorPluginInterface *formEditorPlugin = qobject_cast<QDesignerFormEditorPluginInterface*>(plugin)) {
  692.             if (!formEditorPlugin->isInitialized())
  693.                 formEditorPlugin->initialize(core());
  694.         }
  695.     }
  696. }
  697. void QDesignerWorkbench::saveSettings() const
  698. {
  699.     QDesignerSettings settings;
  700.     if (m_mode == DockedMode) {
  701.         if (qFindChild<QMdiArea *>(qDesigner->mainWindow())) {
  702.             settings.saveGeometryFor(qDesigner->mainWindow());
  703.             settings.setValue(qDesigner->mainWindow()->objectName() + QLatin1String("/visible"), false);
  704.         }
  705.     } else {
  706.         foreach (QDesignerToolWindow *tw, m_toolWindows) {
  707.             settings.saveGeometryFor(tw);
  708.         }
  709.     }
  710. }
  711. bool QDesignerWorkbench::readInForm(const QString &fileName) const
  712. {
  713.     return m_actionManager->readInForm(fileName);
  714. }
  715. bool QDesignerWorkbench::writeOutForm(QDesignerFormWindowInterface *formWindow, const QString &fileName) const
  716. {
  717.     return m_actionManager->writeOutForm(formWindow, fileName);
  718. }
  719. bool QDesignerWorkbench::saveForm(QDesignerFormWindowInterface *frm)
  720. {
  721.     return m_actionManager->saveForm(frm);
  722. }
  723. QDesignerToolWindow *QDesignerWorkbench::findToolWindow(QWidget *widget) const
  724. {
  725.     foreach (QDesignerToolWindow *toolWindow, m_toolWindows) {
  726.         if (toolWindow->centralWidget() == widget)
  727.             return toolWindow;
  728.     }
  729.     return 0;
  730. }
  731. QDesignerFormWindow *QDesignerWorkbench::findFormWindow(QWidget *widget) const
  732. {
  733.     foreach (QDesignerFormWindow *formWindow, m_formWindows) {
  734.         if (formWindow->editor() == widget)
  735.             return formWindow;
  736.     }
  737.     return 0;
  738. }
  739. bool QDesignerWorkbench::handleClose()
  740. {
  741.     m_state = StateClosing;
  742.     QList<QDesignerFormWindow *> dirtyForms;
  743.     foreach (QDesignerFormWindow *w, m_formWindows) {
  744.         if (w->editor()->isDirty())
  745.             dirtyForms << w;
  746.     }
  747.     if (dirtyForms.size()) {
  748.         if (dirtyForms.size() == 1) {
  749.             if (!dirtyForms.at(0)->close()) {
  750.                 m_state = StateUp;
  751.                 return false;
  752.             }
  753.         } else {
  754.             int count = dirtyForms.size();
  755.             QMessageBox box(QMessageBox::Warning, tr("Save Forms?"),
  756.                     tr("There are %n forms with unsaved changes."
  757.                         " Do you want to review these changes before quitting?", "", count),
  758.                     QMessageBox::Cancel | QMessageBox::Discard | QMessageBox::Save);
  759.             box.setInformativeText(tr("If you don't review your documents, all your changes will be lost."));
  760.             box.button(QMessageBox::Discard)->setText(tr("Discard Changes"));
  761.             QPushButton *save = static_cast<QPushButton *>(box.button(QMessageBox::Save));
  762.             save->setText(tr("Review Changes"));
  763.             box.setDefaultButton(save);
  764.             switch (box.exec()) {
  765.             case QMessageBox::Cancel:
  766.                 m_state = StateUp;
  767.                 return false;
  768.             case QMessageBox::Save:
  769.                foreach (QDesignerFormWindow *fw, dirtyForms) {
  770.                    fw->show();
  771.                    fw->raise();
  772.                    if (!fw->close()) {
  773.                        m_state = StateUp;
  774.                        return false;
  775.                    }
  776.                }
  777.                break;
  778.             case QMessageBox::Discard:
  779.               foreach (QDesignerFormWindow *fw, dirtyForms) {
  780.                   fw->editor()->setDirty(false);
  781.                   fw->setWindowModified(false);
  782.               }
  783.               break;
  784.             }
  785.         }
  786.     }
  787.     foreach (QDesignerFormWindow *fw, m_formWindows)
  788.         fw->close();
  789.     saveSettings();
  790.     return true;
  791. }
  792. QDesignerActions *QDesignerWorkbench::actionManager() const
  793. {
  794.     return m_actionManager;
  795. }
  796. void QDesignerWorkbench::setUIMode(UIMode mode)
  797. {
  798.     switch (mode) {
  799.         case TopLevelMode:
  800.             switchToTopLevelMode();
  801.             break;
  802.         case DockedMode:
  803.             switchToDockedMode();
  804.             break;
  805.         default: Q_ASSERT(0);
  806.     }
  807. }
  808. void QDesignerWorkbench::updateWindowMenu(QDesignerFormWindowInterface *fwi)
  809. {
  810.     bool minimizeChecked = false;
  811.     bool minimizeEnabled = false;
  812.     QDesignerFormWindow *activeFormWindow = 0;
  813.     do {
  814.         if (!fwi)
  815.         break;
  816.         activeFormWindow = qobject_cast<QDesignerFormWindow *>(fwi->parentWidget());
  817.         if (!activeFormWindow)
  818.             break;
  819.         minimizeEnabled = true;
  820.         minimizeChecked = isFormWindowMinimized(activeFormWindow);
  821.     } while (false) ;
  822.     m_actionManager->minimizeAction()->setEnabled(minimizeEnabled);
  823.     m_actionManager->minimizeAction()->setChecked(minimizeChecked);
  824.     if (!m_formWindows.empty()) {
  825.         const QList<QDesignerFormWindow*>::const_iterator cend = m_formWindows.constEnd();
  826.         for (QList<QDesignerFormWindow*>::const_iterator it = m_formWindows.constBegin(); it != cend; ++it)
  827.             (*it)->action()->setChecked(*it == activeFormWindow);
  828.     }
  829. }
  830. void QDesignerWorkbench::formWindowActionTriggered(QAction *a)
  831. {
  832.     QDesignerFormWindow *fw = qobject_cast<QDesignerFormWindow *>(a->parentWidget());
  833.     Q_ASSERT(fw);
  834.     if (isFormWindowMinimized(fw))
  835.         setFormWindowMinimized(fw, false);
  836.     if (m_mode == DockedMode) {
  837.         if (QMdiSubWindow *subWindow = qobject_cast<QMdiSubWindow *>(fw->parent())) {
  838.             m_mdiArea->setActiveSubWindow(subWindow);
  839.         }
  840.     } else {
  841.         fw->activateWindow();
  842.         fw->raise();
  843.     }
  844. }
  845. void QDesignerWorkbench::showToolBars()
  846. {
  847.     m_fileToolBar->show();
  848.     m_editToolBar->show();
  849.     m_toolToolBar->show();
  850.     m_formToolBar->show();
  851. }
  852. void QDesignerWorkbench::closeAllToolWindows()
  853. {
  854.     foreach (QDesignerToolWindow *tw, m_toolWindows)
  855.         tw->hide();
  856. }
  857. QDockWidget *QDesignerWorkbench::magicalDockWidget(QWidget *widget) const
  858. {
  859.     if (!m_mdiArea)
  860.         return 0;
  861.     QDockWidget *dockWidget = qFindChild<QDockWidget*>(m_mdiArea->window(), widget->objectName() + QLatin1String("_dock"));
  862.     return dockWidget;
  863. }
  864. bool QDesignerWorkbench::readInBackup()
  865. {
  866.     const QMap<QString, QString> backupFileMap = QDesignerSettings().backup();
  867.     if (backupFileMap.isEmpty())
  868.         return false;
  869.     const  QMessageBox::StandardButton answer =
  870.         QMessageBox::question(0, tr("Backup Information"),
  871.                                  tr("Designer was not correctly terminated during your last session."
  872.                                        "There are existing Backup files, do you want to load them?"),
  873.                                     QMessageBox::Yes|QMessageBox::No, QMessageBox::Yes);
  874.     if (answer == QMessageBox::No)
  875.         return false;
  876.     const QString modifiedPlaceHolder = QLatin1String("[*]");
  877.     QMapIterator<QString, QString> it(backupFileMap);
  878.     while(it.hasNext()) {
  879.         it.next();
  880.         QString fileName = it.key();
  881.         fileName.remove(modifiedPlaceHolder);
  882.         if(m_actionManager->readInForm(it.value()))
  883.             formWindowManager()->activeFormWindow()->setFileName(fileName);
  884.     }
  885.     return true;
  886. }
  887. void QDesignerWorkbench::updateBackup(QDesignerFormWindowInterface* fwi)
  888. {
  889.     QString fwn = QDir::convertSeparators(fwi->fileName());
  890.     if (fwn.isEmpty())
  891.         fwn = fwi->parentWidget()->windowTitle();
  892.     QMap<QString, QString> map = QDesignerSettings().backup();
  893.     map.remove(fwn);
  894.     QDesignerSettings().setBackup(map);
  895. }
  896. namespace {
  897.     void raiseWindow(QWidget *w) {
  898.         if (w->isMinimized())
  899.             w->setWindowState(w->windowState() & ~Qt::WindowMinimized);
  900.         w->raise();
  901.     }
  902. }
  903. void QDesignerWorkbench::bringAllToFront()
  904. {
  905.     if (m_mode !=  TopLevelMode)
  906.         return;
  907.     foreach(QDesignerToolWindow *tw, m_toolWindows)
  908.         raiseWindow(tw);
  909.     foreach(QDesignerFormWindow *dfw, m_formWindows)
  910.         raiseWindow(dfw);
  911. }
  912. // Resize a form window taking MDI decorations into account
  913. void QDesignerWorkbench::resizeForm(QDesignerFormWindow *fw, const QWidget *mainContainer) const
  914. {
  915.     const QSize containerSize = mainContainer->size();
  916.     const QSize containerMinimumSize = mainContainer->minimumSize();
  917.     const QSize containerMaximumSize = mainContainer->maximumSize();
  918.     if (m_mode != DockedMode) {
  919.         fw->resize(containerSize);
  920.         fw->setMinimumSize(containerMinimumSize);
  921.         fw->setMaximumSize(containerMaximumSize);
  922.         return;
  923.     }
  924.     // get decorations and resize MDI
  925.     QMdiSubWindow *mdiSubWindow = qobject_cast<QMdiSubWindow *>(fw->parent());
  926.     Q_ASSERT(mdiSubWindow);
  927.     const QSize decorationSize = mdiSubWindow->geometry().size() - mdiSubWindow->contentsRect().size(); // TODO new API
  928.     mdiSubWindow->resize(containerSize + decorationSize);
  929.     mdiSubWindow->setMinimumSize(containerMinimumSize + decorationSize);
  930.     if (containerMaximumSize == QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX)) {
  931.         mdiSubWindow->setMaximumSize(containerMaximumSize);
  932.     } else {
  933.         mdiSubWindow->setMaximumSize(containerMaximumSize + decorationSize);
  934.     }
  935. }
  936. // Load a form or return 0 and do cleanup. file name and editor file
  937. // name in case of loading a template file.
  938. QDesignerFormWindow * QDesignerWorkbench::loadForm(const QString &fileName,
  939.                                                    bool *uic3Converted,
  940.                                                    QString *errorMessage)
  941. {
  942.     QFile file(fileName);
  943.     if (!file.open(QFile::ReadOnly)) {
  944.         *errorMessage = tr("The file <b>%1</b> could not be opened.").arg(file.fileName());
  945.         return 0;
  946.     }
  947.     // Create a form
  948.      QDesignerFormWindowManagerInterface *formWindowManager = m_core->formWindowManager();
  949.     QDesignerFormWindow *formWindow = createFormWindow();
  950.     QDesignerFormWindowInterface *editor = formWindow->editor();
  951.     Q_ASSERT(editor);
  952.     // Temporarily set the file name. It is needed when converting a UIC 3 file.
  953.     // In this case, the file name will we be cleared on return to force a save box.
  954.     editor->setFileName(fileName);
  955.     editor->setContents(&file);
  956.     if (!editor->mainContainer()) {
  957.         removeFormWindow(formWindow);
  958.         formWindowManager->removeFormWindow(editor);
  959.         m_core->metaDataBase()->remove(editor);
  960.         *errorMessage = tr("The file <b>%1</b> is not a valid Designer ui file.").arg(file.fileName());
  961.         return 0;
  962.     }
  963.     *uic3Converted = editor->fileName().isEmpty();
  964.     editor->setDirty(false);
  965.     resizeForm(formWindow, editor->mainContainer());
  966.     formWindowManager->setActiveFormWindow(editor);
  967.     return formWindow;
  968. }
  969. QDesignerFormWindow * QDesignerWorkbench::openForm(const QString &fileName, QString *errorMessage)
  970. {
  971.     bool uic3Converted;
  972.     QDesignerFormWindow *rc =loadForm(fileName, &uic3Converted, errorMessage);
  973.     if (!rc)
  974.         return 0;
  975.     if (!uic3Converted)
  976.         rc->editor()->setFileName(fileName);
  977.     rc->firstShow();
  978.     return rc;
  979. }
  980. QDesignerFormWindow * QDesignerWorkbench::openTemplate(const QString &templateFileName,
  981.                                                        const QString &editorFileName,
  982.                                                        QString *errorMessage)
  983. {
  984.     bool uic3Converted;
  985.     QDesignerFormWindow *rc =loadForm(templateFileName, &uic3Converted, errorMessage);
  986.     if (!rc)
  987.         return 0;
  988.     if (!uic3Converted)
  989.         rc->editor()->setFileName(editorFileName);
  990.     if (qdesigner_internal::FormWindowBase *fw = qobject_cast<qdesigner_internal::FormWindowBase *>(rc->editor()))
  991.         fw->setDesignerGrid(qdesigner_internal::FormWindowBase::defaultDesignerGrid());
  992.     rc->firstShow();
  993.     return rc;
  994. }
  995. void QDesignerWorkbench::minimizationStateChanged(QDesignerFormWindowInterface *formWindow, bool minimized)
  996. {
  997.     // refresh the minimize action state
  998.     if (core()->formWindowManager()->activeFormWindow() == formWindow) {
  999.         m_actionManager->minimizeAction()->setChecked(minimized);
  1000.     }
  1001. }
  1002. void QDesignerWorkbench::toggleFormMinimizationState()
  1003. {
  1004.     QDesignerFormWindowInterface *fwi = core()->formWindowManager()->activeFormWindow();
  1005.     if (!fwi || m_mode == NeutralMode)
  1006.         return;
  1007.     QDesignerFormWindow *fw = qobject_cast<QDesignerFormWindow *>(fwi->parentWidget());
  1008.     Q_ASSERT(fw);
  1009.     setFormWindowMinimized(fw, !isFormWindowMinimized(fw));
  1010. }
  1011. bool QDesignerWorkbench::isFormWindowMinimized(const QDesignerFormWindow *fw)
  1012. {
  1013.     switch (m_mode) {
  1014.     case DockedMode:
  1015.         return mdiSubWindowOf(fw)->isShaded();
  1016.     case TopLevelMode:
  1017.         return fw->window()->isMinimized();
  1018.     default:
  1019.         break;
  1020.     }
  1021.     return fw->isMinimized();
  1022. }
  1023. void QDesignerWorkbench::setFormWindowMinimized(QDesignerFormWindow *fw, bool minimized)
  1024. {
  1025.     switch (m_mode) {
  1026.     case DockedMode: {
  1027.         QMdiSubWindow *mdiSubWindow = mdiSubWindowOf(fw);
  1028.         if (minimized) {
  1029.             mdiSubWindow->showShaded();
  1030.         } else {
  1031.             mdiSubWindow->setWindowState(mdiSubWindow->windowState() & ~Qt::WindowMinimized);
  1032.         }
  1033.     }
  1034.         break;
  1035.     case TopLevelMode:        {
  1036.         QWidget *window = fw->window();
  1037.         if (window->isMinimized()) {
  1038.             window->setWindowState(window->windowState() & ~Qt::WindowMinimized);
  1039.         } else {
  1040.             window->showMinimized();
  1041.         }
  1042.     }
  1043.         break;
  1044.     default:
  1045.         break;
  1046.     }
  1047. }
  1048. void QDesignerWorkbench::applyPreferences(const Preferences &preferences)
  1049. {
  1050.     if (preferences.m_uiMode != mode())
  1051.         setUIMode(preferences.m_uiMode);
  1052.     setDesignerUIFont(preferences.m_useFont ? preferences.m_font : qApp->font());
  1053.     qdesigner_internal::FormWindowBase::setDefaultDesignerGrid(preferences.m_defaultGrid);
  1054.     QDesignerFormWindowManagerInterface *fwm = formWindowManager();
  1055.     if (const int numWindows =  fwm->formWindowCount()) {
  1056.         for (int i = 0; i < numWindows; i++)
  1057.             if (qdesigner_internal::FormWindowBase *fwb = qobject_cast<qdesigner_internal::FormWindowBase *>( fwm->formWindow(i)))
  1058.                 if (!fwb->hasFormGrid())
  1059.                     fwb->setDesignerGrid(preferences.m_defaultGrid);
  1060.     }
  1061. }
  1062. void QDesignerWorkbench::setDesignerUIFont(const QFont &font)
  1063. {
  1064.     if (font == m_toolWindows.front()->font())
  1065.         return;
  1066.     foreach(QDesignerToolWindow *tw, m_toolWindows)
  1067.         tw->setFont(font);
  1068. }