QDesignerWorkbench Class Reference

#include <qdesigner_workbench.h>

Inheritance diagram for QDesignerWorkbench:

[legend]Collaboration diagram for QDesignerWorkbench:

[legend]List of all members.

---

Detailed Description

Definition at line 56 of file qdesigner_workbench.h.

Public Types
enum	UIMode
Public Slots
void	addToolWindow (QDesignerToolWindow *toolWindow)
void	addFormWindow (QDesignerFormWindow *formWindow)
void	removeToolWindow (QDesignerToolWindow *toolWindow)
void	removeFormWindow (QDesignerFormWindow *formWindow)
void	setUIMode (UIMode mode)
void	switchToNeutralMode ()
void	switchToDockedMode ()
void	switchToTopLevelMode ()
void	initializeCorePlugins ()
Signals
void	modeChanged (UIMode mode)
void	initialized ()
Public Member Functions
	QDesignerWorkbench ()
virtual	~QDesignerWorkbench ()
UIMode	mode () const
QDesignerFormEditorInterface *	core () const
QDesignerToolWindow *	findToolWindow (QWidget *widget) const
QDesignerFormWindow *	findFormWindow (QWidget *widget) const
QDesignerFormWindow *	createFormWindow ()
int	toolWindowCount () const
QDesignerToolWindow *	toolWindow (int index) const
int	formWindowCount () const
QDesignerFormWindow *	formWindow (int index) const
QDesignerActions *	actionManager () const
QActionGroup *	modeActionGroup () const
QRect	availableGeometry () const
int	marginHint () const
void	saveSettings () const
bool	readInForm (const QString &fileName) const
bool	writeOutForm (QDesignerFormWindowInterface *formWindow, const QString &fileName) const
bool	saveForm (QDesignerFormWindowInterface *fw)
bool	handleClose ()
void	closeAllToolWindows ()
Private Slots
void	initialize ()
void	activateWorkspaceChildWindow (QWidget *widget)
void	updateWindowMenu (QDesignerFormWindowInterface *fw)
void	formWindowActionTriggered (QAction *a)
void	showToolBars ()
void	adjustFormPositions ()
Private Member Functions
QWidget *	magicalParent () const
Qt::WindowFlags	magicalWindowFlags (const QWidget *widgetForFlags) const
QDockWidget *	magicalDockWidget (QWidget *widget) const
QDesignerFormWindowManagerInterface *	formWindowManager () const
void	changeBringToFrontVisiblity (bool visible)
bool	eventFilter (QObject *object, QEvent *event)
Private Attributes
QDesignerFormEditorInterface *	m_core
qdesigner_internal::QDesignerIntegration *	m_integration
QDesignerActions *	m_actionManager
QActionGroup *	m_toolActions
QActionGroup *	m_windowActions
QMenu *	m_fileMenu
QMenu *	m_editMenu
QMenu *	m_formMenu
QMenu *	m_toolMenu
QMenu *	m_windowMenu
QMenu *	m_helpMenu
QMenuBar *	m_globalMenuBar
QToolBar *	m_toolToolBar
QToolBar *	m_formToolBar
QToolBar *	m_editToolBar
UIMode	m_mode
QList< QDesignerToolWindow * >	m_toolWindows
QList< QDesignerFormWindow * >	m_formWindows
QWorkspace *	m_workspace
QHash< QWidget *, bool >	m_visibilities
QHash< QWidget *, QRect >	m_geometries
QHash< QDesignerToolWindow *, ToolWindowExtra >	m_toolWindowExtras
QHash< QDesignerFormWindow *, FormWindowExtra >	m_formWindowExtras
bool	m_initializing
Classes
class	FormWindowExtra
class	ToolWindowExtra

---

Member Enumeration Documentation

enum QDesignerWorkbench::UIMode

Definition at line 60 of file qdesigner_workbench.h.

    {
        NeutralMode,
        TopLevelMode,
        DockedMode
    };

---

Constructor & Destructor Documentation

QDesignerWorkbench::QDesignerWorkbench

(

)

Definition at line 59 of file qdesigner_workbench.cpp.

References initialize(), m_initializing, and setUIMode().

    : m_mode(QDesignerWorkbench::NeutralMode), m_workspace(0)
{
    m_initializing = true;
    initialize();

    setUIMode(UIMode(QDesignerSettings().uiMode()));
    m_initializing = false;
}

QDesignerWorkbench::~QDesignerWorkbench

(

)

[virtual]

Definition at line 69 of file qdesigner_workbench.cpp.

References DockedMode, QList< T >::isEmpty(), m_mode, m_toolWindows, m_workspace, QMainWindow::saveState(), QDesignerSettings::setMainWindowState(), QList< T >::takeLast(), and QWidget::window().

{
    if (m_mode == DockedMode) {
        Q_ASSERT(m_workspace != 0);
        QMainWindow *mw = qobject_cast<QMainWindow*>(m_workspace->window());
        Q_ASSERT(mw != 0);

        QDesignerSettings settings;
        settings.setMainWindowState(mw->saveState(2));
    }

    while (!m_toolWindows.isEmpty())
        delete m_toolWindows.takeLast();
}

Here is the call graph for this function:

---

Member Function Documentation

QDesignerWorkbench::UIMode QDesignerWorkbench::mode

(

)

const

Definition at line 84 of file qdesigner_workbench.cpp.

References m_mode.

Referenced by QDesignerActions::minimizeForm().

{
    return m_mode;
}

QDesignerFormEditorInterface * QDesignerWorkbench::core

(

)

const

Definition at line 602 of file qdesigner_workbench.cpp.

References m_core.

Referenced by activateWorkspaceChildWindow(), availableGeometry(), initialize(), initializeCorePlugins(), QDesignerActionEditor::QDesignerActionEditor(), QDesignerActions::QDesignerActions(), QDesignerFormWindow::QDesignerFormWindow(), QDesignerObjectInspector::QDesignerObjectInspector(), QDesignerPropertyEditor::QDesignerPropertyEditor(), QDesignerResourceEditor::QDesignerResourceEditor(), QDesignerSignalSlotEditor::QDesignerSignalSlotEditor(), QDesignerWidgetBox::QDesignerWidgetBox(), switchToDockedMode(), and switchToTopLevelMode().

{
    return m_core;
}

QDesignerToolWindow * QDesignerWorkbench::findToolWindow

(

QWidget *

widget

)

const

Definition at line 736 of file qdesigner_workbench.cpp.

References QMainWindow::centralWidget(), m_toolWindows, and toolWindow().

Referenced by availableGeometry(), switchToDockedMode(), and switchToTopLevelMode().

{
    foreach (QDesignerToolWindow *toolWindow, m_toolWindows) {
        if (toolWindow->centralWidget() == widget)
            return toolWindow;
    }

    return 0;
}

Here is the call graph for this function:

QDesignerFormWindow * QDesignerWorkbench::findFormWindow

(

QWidget *

widget

)

const

Definition at line 746 of file qdesigner_workbench.cpp.

References QMainWindow::centralWidget(), formWindow(), and m_formWindows.

Referenced by QDesignerActions::showFormSettings().

{
    foreach (QDesignerFormWindow *formWindow, m_formWindows) {
        if (formWindow->centralWidget() == widget)
            return formWindow;
    }

    return 0;
}

Here is the call graph for this function:

QDesignerFormWindow * QDesignerWorkbench::createFormWindow

(

)

Definition at line 572 of file qdesigner_workbench.cpp.

References addFormWindow(), QWorkspace::addWindow(), availableGeometry(), center(), formWindow(), g, QDesignerFormWindow::geometryHint(), m_workspace, magicalParent(), magicalWindowFlags(), QWidget::move(), QWidget::resize(), QWorkspace::setActiveWindow(), QWidget::setAttribute(), QWidget::setParent(), and Qt::WA_DeleteOnClose.

Referenced by NewForm::on_buttonBox_clicked(), and QDesignerActions::readInForm().

{
    QDesignerFormWindow *formWindow = new QDesignerFormWindow(/*formWindow=*/ 0, this);

    if (m_workspace) {
        m_workspace->addWindow(formWindow, magicalWindowFlags(formWindow));
    } else {
        formWindow->setParent(magicalParent(), magicalWindowFlags(formWindow));
    }

    formWindow->setAttribute(Qt::WA_DeleteOnClose, true);

    addFormWindow(formWindow);

    QRect g = formWindow->geometryHint();
    formWindow->resize(g.size());
    formWindow->move(availableGeometry().center() - g.center());

    if (m_workspace) {
        m_workspace->setActiveWindow(formWindow);
    }

    return formWindow;
}

Here is the call graph for this function:

int QDesignerWorkbench::toolWindowCount

(

)

const

Definition at line 607 of file qdesigner_workbench.cpp.

References QList< T >::count(), and m_toolWindows.

Referenced by QDesignerActions::bringAllToFront().

{
    return m_toolWindows.count();
}

Here is the call graph for this function:

QDesignerToolWindow * QDesignerWorkbench::toolWindow

(

int

index

)

const

Definition at line 612 of file qdesigner_workbench.cpp.

References QList< T >::at(), and m_toolWindows.

Referenced by addToolWindow(), QDesignerActions::bringAllToFront(), findToolWindow(), and removeToolWindow().

{
    return m_toolWindows.at(index);
}

Here is the call graph for this function:

int QDesignerWorkbench::formWindowCount

(

)

const

Definition at line 617 of file qdesigner_workbench.cpp.

References QList< T >::count(), and m_formWindows.

Referenced by QDesignerActions::bringAllToFront(), NewForm::on_buttonBox_clicked(), and removeFormWindow().

{
    return m_formWindows.count();
}

Here is the call graph for this function:

QDesignerFormWindow * QDesignerWorkbench::formWindow

(

int

index

)

const

Definition at line 622 of file qdesigner_workbench.cpp.

References QList< T >::at(), and m_formWindows.

Referenced by addFormWindow(), QDesignerActions::bringAllToFront(), createFormWindow(), findFormWindow(), NewForm::on_buttonBox_clicked(), removeFormWindow(), and writeOutForm().

{
    return m_formWindows.at(index);
}

Here is the call graph for this function:

QDesignerActions * QDesignerWorkbench::actionManager

(

)

const

Definition at line 808 of file qdesigner_workbench.cpp.

References m_actionManager.

Referenced by QDesigner::callCreateForm(), and NewForm::on_buttonBox_clicked().

{
    return m_actionManager;
}

QActionGroup* QDesignerWorkbench::modeActionGroup

(

)

const

QRect QDesignerWorkbench::availableGeometry

(

)

const

Definition at line 627 of file qdesigner_workbench.cpp.

References QDesktopWidget::availableGeometry(), core(), findToolWindow(), QWidget::geometry(), m_workspace, qDesigner, and QDesktopWidget::screenNumber().

Referenced by createFormWindow(), QDesignerResourceEditor::geometryHint(), QDesignerSignalSlotEditor::geometryHint(), QDesignerPropertyEditor::geometryHint(), QDesignerObjectInspector::geometryHint(), QDesignerWidgetBox::geometryHint(), and QDesignerActionEditor::geometryHint().

{
    if (m_workspace)
        return m_workspace->geometry();

    QDesktopWidget *desktop = qDesigner->desktop();

    QWidget *window = findToolWindow(core()->widgetBox());
    if (window)
        return desktop->availableGeometry(desktop->screenNumber(window));
    return desktop->availableGeometry(0);
}

Here is the call graph for this function:

int QDesignerWorkbench::marginHint

(

)

const

Definition at line 640 of file qdesigner_workbench.cpp.

Referenced by QDesignerResourceEditor::geometryHint(), QDesignerObjectInspector::geometryHint(), QDesignerPropertyEditor::geometryHint(), QDesignerSignalSlotEditor::geometryHint(), and QDesignerActionEditor::geometryHint().

{
    return 20;
}

void QDesignerWorkbench::saveSettings

(

)

const

Definition at line 706 of file qdesigner_workbench.cpp.

References DockedMode, m_mode, m_toolWindows, qDesigner, QDesignerSettings::saveGeometryFor(), and QSettings::setValue().

Referenced by handleClose().

{
    QDesignerSettings settings;
    if (m_mode == DockedMode) {
        if (qFindChild<QWorkspace *>(qDesigner->mainWindow())) {
            settings.saveGeometryFor(qDesigner->mainWindow());
            settings.setValue(qDesigner->mainWindow()->objectName() + QLatin1String("/visible"), false);
        }
    } else {
        foreach (QDesignerToolWindow *tw, m_toolWindows) {
            settings.saveGeometryFor(tw);
        }
    }
}

Here is the call graph for this function:

bool QDesignerWorkbench::readInForm

(

const QString &

fileName

)

const

Definition at line 721 of file qdesigner_workbench.cpp.

References m_actionManager, and QDesignerActions::readInForm().

Referenced by QDesigner::event(), eventFilter(), and QDesigner::initialize().

{
    return m_actionManager->readInForm(fileName);
}

Here is the call graph for this function:

bool QDesignerWorkbench::writeOutForm	(	QDesignerFormWindowInterface *	formWindow,
		const QString &	fileName
	)			const

Definition at line 726 of file qdesigner_workbench.cpp.

References formWindow(), m_actionManager, and QDesignerActions::writeOutForm().

{
    return m_actionManager->writeOutForm(formWindow, fileName);
}

Here is the call graph for this function:

bool QDesignerWorkbench::saveForm

(

QDesignerFormWindowInterface *

fw

)

Definition at line 731 of file qdesigner_workbench.cpp.

References m_actionManager, and QDesignerActions::saveForm().

Referenced by QDesignerFormWindow::closeEvent().

{
    return m_actionManager->saveForm(frm);
}

Here is the call graph for this function:

bool QDesignerWorkbench::handleClose

(

)

Definition at line 756 of file qdesigner_workbench.cpp.

References QList< T >::at(), QMessageBox::Cancel, QWidget::close(), QMessageBox::Default, QDesignerFormWindow::editor(), QMessageBox::Escape, QDialog::exec(), m_formWindows, QMessageBox::No, saveSettings(), QMessageBox::setButtonText(), QDesignerFormWindowInterface::setDirty(), QWidget::setWindowModified(), QList< T >::size(), w, QMessageBox::Warning, and QMessageBox::Yes.

Referenced by QDesigner::event().

{
    QList<QDesignerFormWindow *> dirtyForms;
    foreach (QDesignerFormWindow *w, m_formWindows) {
        if (w->editor()->isDirty())
            dirtyForms << w;
    }

    if (dirtyForms.size()) {
        if (dirtyForms.size() == 1) {
            if (!dirtyForms.at(0)->close()) {
                return false;
            }
        } else {
            QMessageBox box(tr("Save Forms?"),
                    tr("There are %1 forms with unsaved changes."
                        " Do you want to review these changes before quitting?")
                    .arg(dirtyForms.size()),
                    QMessageBox::Warning,
                    QMessageBox::Yes | QMessageBox::Default, QMessageBox::No,
                    QMessageBox::Cancel | QMessageBox::Escape, 0);
            box.setButtonText(QMessageBox::Yes, tr("Review Changes"));
            box.setButtonText(QMessageBox::No, tr("Discard Changes"));
            switch (box.exec()) {
            case QMessageBox::Cancel:
                return false;
            case QMessageBox::Yes:
               foreach (QDesignerFormWindow *fw, dirtyForms) {
                   fw->show();
                   fw->raise();
                   if (!fw->close()) {
                       return false;
                   }
               }
               break;
            case QMessageBox::No:
              foreach (QDesignerFormWindow *fw, dirtyForms) {
                  fw->editor()->setDirty(false);
                  fw->setWindowModified(false);
              }
              break;
            }
        }
    }

    foreach (QDesignerFormWindow *fw, m_formWindows)
        fw->close();

    saveSettings();
    return true;
}

Here is the call graph for this function:

void QDesignerWorkbench::closeAllToolWindows

(

)

Definition at line 856 of file qdesigner_workbench.cpp.

References QWidget::hide(), and m_toolWindows.

{
    foreach (QDesignerToolWindow *tw, m_toolWindows)
        tw->hide();
}

void QDesignerWorkbench::modeChanged

(

UIMode

mode

)

[signal]

void QDesignerWorkbench::initialized

(

)

[signal]

Referenced by initialize().

void QDesignerWorkbench::addToolWindow

(

QDesignerToolWindow *

toolWindow

)

[slot]

Definition at line 89 of file qdesigner_workbench.cpp.

References QDesignerToolWindow::action(), QActionGroup::actions(), QWidget::actions(), QActionGroup::addAction(), QList< T >::append(), QList< T >::count(), QList< T >::first(), QWidget::insertAction(), QList< T >::isEmpty(), QString::isEmpty(), QList< T >::last(), m_toolActions, m_toolMenu, m_toolWindowExtras, m_toolWindows, toolWindow(), and QWidget::windowTitle().

Referenced by initialize().

{
    Q_ASSERT(m_toolWindowExtras.contains(toolWindow) == false);
    Q_ASSERT(toolWindow->windowTitle().isEmpty() == false);

    m_toolWindows.append(toolWindow);

    if (QAction *action = toolWindow->action()) {
        Q_ASSERT(m_toolMenu->actions().isEmpty() == false);

        QList<QAction*> lst = m_toolActions->actions();
        QAction *before = lst.count() ? lst.last() : m_toolMenu->actions().first();
        m_toolMenu->insertAction(before, action);
        m_toolActions->addAction(action);
    }
}

void QDesignerWorkbench::addFormWindow

(

QDesignerFormWindow *

formWindow

)

[slot]

Definition at line 106 of file qdesigner_workbench.cpp.

References QDesignerFormWindow::action(), QActionGroup::actions(), QMenu::addAction(), QActionGroup::addAction(), QMenu::addSeparator(), QList< T >::append(), QDesignerActions::editWidgets(), formWindow(), QList< T >::isEmpty(), m_actionManager, m_formWindowExtras, m_formWindows, m_windowActions, m_windowMenu, QDesignerActions::minimizeAction(), QAction::setChecked(), QAction::setEnabled(), and QAction::trigger().

Referenced by createFormWindow().

{
    Q_ASSERT(m_formWindowExtras.contains(formWindow) == false);
    // ### Q_ASSERT(formWindow->windowTitle().isEmpty() == false);

    m_formWindows.append(formWindow);
    if (m_windowActions->actions().isEmpty())
        m_windowMenu->addSeparator();

    if (QAction *action = formWindow->action()) {
        m_windowActions->addAction(action);
        m_windowMenu->addAction(action);
        action->setChecked(true);
    }

    m_actionManager->minimizeAction()->setEnabled(true);
    m_actionManager->editWidgets()->trigger();
}

void QDesignerWorkbench::removeToolWindow

(

QDesignerToolWindow *

toolWindow

)

[slot]

Definition at line 653 of file qdesigner_workbench.cpp.

References QDesignerToolWindow::action(), index, QList< T >::indexOf(), m_toolActions, m_toolMenu, m_toolWindowExtras, m_toolWindows, QWidget::removeAction(), QActionGroup::removeAction(), QList< T >::removeAt(), and toolWindow().

Referenced by QDesignerToolWindow::~QDesignerToolWindow().

{
    int index = m_toolWindows.indexOf(toolWindow);
    if (index != -1) {
        m_toolWindows.removeAt(index);
        m_toolWindowExtras.remove(toolWindow);
    }

    if (QAction *action = toolWindow->action()) {
        m_toolActions->removeAction(action);
        m_toolMenu->removeAction(action);
    }
}

void QDesignerWorkbench::removeFormWindow

(

QDesignerFormWindow *

formWindow

)

[slot]

Definition at line 667 of file qdesigner_workbench.cpp.

References QDesignerFormWindow::action(), QWidget::actions(), QList< T >::at(), formWindow(), formWindowCount(), i, index, QList< T >::indexOf(), m_actionManager, m_formWindowExtras, m_formWindows, m_windowActions, m_windowMenu, QDesignerActions::minimizeAction(), QWidget::removeAction(), QActionGroup::removeAction(), QList< T >::removeAt(), QAction::setEnabled(), and QList< T >::size().

Referenced by QDesignerFormWindow::~QDesignerFormWindow().

{
    int index = m_formWindows.indexOf(formWindow);
    if (index != -1) {
        m_formWindows.removeAt(index);
        m_formWindowExtras.remove(formWindow);
    }

    if (QAction *action = formWindow->action()) {
        m_windowActions->removeAction(action);
        m_windowMenu->removeAction(action);
    }

    if (formWindowCount() == 0) {
        m_actionManager->minimizeAction()->setEnabled(false);
        QList<QAction *> actions = m_windowMenu->actions();
        for (int i = actions.size() - 1; i >= 0; --i) {
            QAction *act = actions.at(i);
            if (act->isSeparator()) {
                delete act;
                break;
            }
        }
    }
}

void QDesignerWorkbench::setUIMode

(

UIMode

mode

)

[slot]

Definition at line 813 of file qdesigner_workbench.cpp.

References DockedMode, switchToDockedMode(), switchToTopLevelMode(), and TopLevelMode.

Referenced by QDesignerWorkbench(), and QDesignerActions::updateUIMode().

{
    switch (mode) {
        case TopLevelMode:
            switchToTopLevelMode();
            break;
        case DockedMode:
            switchToDockedMode();
            break;

        default: Q_ASSERT(0);
    }
}

void QDesignerWorkbench::switchToNeutralMode

(

)

[slot]

Definition at line 298 of file qdesigner_workbench.cpp.

References QDesktopWidget::availableGeometry(), QHash< Key, T >::clear(), QApplication::desktop(), DockedMode, QHash< Key, T >::insert(), QWidget::isVisible(), QWidget::isWindow(), m_core, m_editToolBar, m_formToolBar, m_formWindows, m_geometries, m_globalMenuBar, m_mode, m_toolToolBar, m_toolWindows, m_visibilities, m_workspace, QWidget::mapToGlobal(), NeutralMode, p, QWidget::parentWidget(), QWidget::pos(), qDesigner, QMainWindow::saveState(), QWidget::setParent(), QDesignerToolWindow::setSaveSettingsOnClose(), QDesignerFormEditorInterface::setTopLevel(), QWidget::size(), QRect::topLeft(), TopLevelMode, and QWidget::window().

Referenced by switchToDockedMode(), and switchToTopLevelMode().

{
    if (m_mode == NeutralMode) {
        return;
    } else if (m_mode == DockedMode) {
        Q_ASSERT(m_workspace != 0);
        QMainWindow *mw = qobject_cast<QMainWindow*>(m_workspace->window());
        QDesignerSettings settings;
        settings.setMainWindowState(mw->saveState(2));
    }

    QPoint desktopOffset = QPoint(0, 0);
    QPoint workspaceOffset = QPoint(0, 0);
    if (m_mode == TopLevelMode)
        desktopOffset = QApplication::desktop()->availableGeometry().topLeft();
    else if (m_mode == DockedMode)
        workspaceOffset = m_workspace->mapToGlobal(QPoint(0, 0));
    m_mode = NeutralMode;

    m_geometries.clear();
    m_visibilities.clear();

    foreach (QDesignerToolWindow *tw, m_toolWindows) {
        m_visibilities.insert(tw, tw->isVisible());
        if (tw->isVisible()) {
            // use the actual geometry
            QPoint pos = tw->window()->pos();
            if (!tw->isWindow()) {
                if (const QWidget *pw = tw->parentWidget()) {
                    pos = pw->mapTo(tw->window(), QPoint(0, 0));
                    pos += tw->window()->pos();
                }

            }
            m_geometries.insert(tw, QRect(pos - desktopOffset, tw->size()));
        }
        tw->setSaveSettingsOnClose(false);

        tw->setParent(0);
    }

    foreach (QDesignerFormWindow *fw, m_formWindows) {
        if (fw->isVisible()) {
            // use the actual geometry
            QPoint pos = fw->window()->pos();
            if (!fw->isWindow())
                if (QWidget *p = fw->parentWidget())
                    pos = p->pos(); // in workspace

            m_geometries.insert(fw, QRect(pos - desktopOffset + workspaceOffset,
                                            fw->size()));
        }

        fw->setParent(0);
    }

#ifndef Q_WS_MAC
    m_globalMenuBar->setParent(0);
#endif
    m_editToolBar->setParent(0);
    m_toolToolBar->setParent(0);
    m_formToolBar->setParent(0);
    m_core->setTopLevel(0);
    qDesigner->setMainWindow(0);

    if (m_workspace)
        delete m_workspace->parentWidget();

    m_workspace = 0;
}

void QDesignerWorkbench::switchToDockedMode

(

)

[slot]

Definition at line 369 of file qdesigner_workbench.cpp.

References QDesignerToolWindow::action(), activateWorkspaceChildWindow(), QMainWindow::addDockWidget(), QMainWindow::addToolBar(), QWorkspace::addWindow(), changeBringToFrontVisiblity(), QObject::connect(), core(), DockedMode, findToolWindow(), QWidget::hide(), QObject::installEventFilter(), QMetaObject::invokeMethod(), QHash< Key, T >::isEmpty(), m_core, m_editToolBar, m_formToolBar, m_formWindows, m_geometries, m_globalMenuBar, m_initializing, m_mode, m_toolToolBar, m_toolWindows, m_visibilities, m_workspace, magicalDockWidget(), magicalWindowFlags(), QDesignerSettings::mainWindowState(), QWidget::move(), qApp, qDesigner, Qt::QueuedConnection, QMainWindow::restoreState(), QDesignerSettings::saveGeometryFor(), QWidget::setAcceptDrops(), QMainWindow::setCentralWidget(), QDesignerSettings::setGeometryFor(), QMainWindow::setMenuBar(), QObject::setObjectName(), QDesignerToolWindow::setSaveSettingsOnClose(), QWorkspace::setScrollBarsEnabled(), QDesignerFormEditorInterface::setTopLevel(), QWidget::setVisible(), QAction::setVisible(), QDockWidget::setWidget(), QWidget::setWindowState(), QWidget::setWindowTitle(), QWidget::show(), SIGNAL, SLOT, QMainWindow::statusBar(), switchToNeutralMode(), QRect::topLeft(), TopLevelMode, QHash< Key, T >::value(), Qt::WindowMaximized, and QWidget::windowState().

Referenced by setUIMode().

{
    bool wasTopLevel = (m_mode == TopLevelMode);
    if (m_mode == DockedMode)
        return;

    switchToNeutralMode();
    m_mode = DockedMode;

    QDesignerToolWindow *widgetBoxWrapper = 0;
    if (0 != (widgetBoxWrapper = findToolWindow(core()->widgetBox()))) {
        widgetBoxWrapper->action()->setVisible(true);
        widgetBoxWrapper->setWindowTitle(tr("Widget Box"));
    }

    Q_ASSERT(m_workspace == 0);

    QDesignerSettings settings;
    QDesignerToolWindow *mw = new QDesignerToolWindow(this); // Just to have a copy of
    mw->setSaveSettingsOnClose(true);
    mw->setObjectName(QLatin1String("MDIWindow"));
    mw->setWindowTitle(tr("Qt Designer"));
    m_workspace = new QWorkspace(mw);
    m_workspace->setAcceptDrops(true);
    m_workspace->installEventFilter(this);
    m_workspace->setScrollBarsEnabled(true);
    connect(m_workspace, SIGNAL(windowActivated(QWidget*)),
            this, SLOT(activateWorkspaceChildWindow(QWidget*)));
    mw->setCentralWidget(m_workspace);
    m_core->setTopLevel(mw);
    (void) mw->statusBar();
    if (m_geometries.isEmpty()) {
        settings.setGeometryFor(mw, qApp->desktop()->availableGeometry(0));
    } else {
        if (QDesignerToolWindow *widgetBox = findToolWindow(core()->widgetBox())) {
            QRect r = m_geometries.value(widgetBox, QRect(0, 0, 200, 200));
            mw->move(r.topLeft());
        }
        mw->setWindowState(mw->windowState() | Qt::WindowMaximized);
    }

#ifndef Q_WS_MAC
    mw->setMenuBar(m_globalMenuBar);
    m_globalMenuBar->show();
#endif
    mw->addToolBar(m_editToolBar);
    mw->addToolBar(m_toolToolBar);
    mw->addToolBar(m_formToolBar);
    m_editToolBar->show();
    m_toolToolBar->show();
    m_formToolBar->show();

    qDesigner->setMainWindow(mw);

    foreach (QDesignerToolWindow *tw, m_toolWindows) {
        if (wasTopLevel)
            settings.saveGeometryFor(tw);
        QDockWidget *dockWidget = magicalDockWidget(tw);
        if (dockWidget == 0) {
            dockWidget = new QDockWidget(mw);
            dockWidget->setObjectName(tw->objectName() + QLatin1String("_dock"));
            dockWidget->setWindowTitle(tw->windowTitle());
            mw->addDockWidget(tw->dockWidgetAreaHint(), dockWidget);
        }

        dockWidget->setWidget(tw);
    }

    foreach (QDesignerToolWindow *tw, m_toolWindows) {
        QDockWidget *dockWidget = magicalDockWidget(tw);
        tw->setVisible(true);
        dockWidget->setVisible(m_visibilities.value(tw, true));
    }

    mw->restoreState(settings.mainWindowState(), 2);

    foreach (QDesignerFormWindow *fw, m_formWindows)
        m_workspace->addWindow(fw, magicalWindowFlags(fw))->hide();
    // will be shown in adjustFormPositions

    changeBringToFrontVisiblity(false);

    mw->show();

    if (!m_initializing)
        QMetaObject::invokeMethod(this, "adjustFormPositions", Qt::QueuedConnection);
}

void QDesignerWorkbench::switchToTopLevelMode

(

)

[slot]

Definition at line 513 of file qdesigner_workbench.cpp.

References QDesignerToolWindow::action(), QMainWindow::addToolBar(), QDesktopWidget::availableGeometry(), changeBringToFrontVisiblity(), core(), QApplication::desktop(), findToolWindow(), QList< T >::first(), g, QDesignerToolWindow::geometryHint(), QDesignerFormWindow::geometryHint(), QMainWindow::insertToolBarBreak(), QList< T >::isEmpty(), QWidget::isVisible(), m_core, m_editToolBar, m_formToolBar, m_formWindows, m_geometries, m_globalMenuBar, m_mode, m_toolToolBar, m_toolWindows, magicalParent(), magicalWindowFlags(), QWidget::move(), NeutralMode, qDesigner, QWidget::resize(), QAction::setChecked(), QDesignerSettings::setGeometryFor(), QMainWindow::setMenuBar(), QWidget::setParent(), QDesignerToolWindow::setSaveSettingsOnClose(), QDesignerFormEditorInterface::setTopLevel(), QAction::setVisible(), QWidget::setWindowTitle(), QWidget::show(), switchToNeutralMode(), QRect::topLeft(), TopLevelMode, and QHash< Key, T >::value().

Referenced by setUIMode().

{
    if (m_mode == TopLevelMode)
        return;

    // make sure that the widgetbox is visible iff it is different from neutrol.
    if (m_mode != NeutralMode) {
        if (QDesignerToolWindow *widgetbox_tool = findToolWindow(core()->widgetBox())) {
            if (!widgetbox_tool->action()->isChecked())
                widgetbox_tool->action()->trigger();
        }
    }

    switchToNeutralMode();
    QPoint desktopOffset = QApplication::desktop()->availableGeometry().topLeft();
    m_mode = TopLevelMode;

    // The widget box is special, it gets the menubar and gets to be the main widget.

    QDesignerToolWindow *widgetBoxWrapper = 0;
    if (0 != (widgetBoxWrapper = findToolWindow(core()->widgetBox()))) {
        m_core->setTopLevel(widgetBoxWrapper);
#ifndef Q_WS_MAC
        widgetBoxWrapper->setMenuBar(m_globalMenuBar);
        widgetBoxWrapper->action()->setVisible(false);
        widgetBoxWrapper->setSaveSettingsOnClose(true);
        qDesigner->setMainWindow(widgetBoxWrapper);
        widgetBoxWrapper->setWindowTitle(tr("Qt Designer"));
#endif
        widgetBoxWrapper->addToolBar(m_editToolBar);
        widgetBoxWrapper->addToolBar(m_toolToolBar);
        widgetBoxWrapper->addToolBar(m_formToolBar);

        widgetBoxWrapper->insertToolBarBreak(m_formToolBar);
    }

    QDesignerSettings settings;
    bool found_visible_window = false;
    foreach (QDesignerToolWindow *tw, m_toolWindows) {
        tw->setParent(magicalParent(), magicalWindowFlags(tw));
        settings.setGeometryFor(tw, tw->geometryHint());
        tw->action()->setChecked(tw->isVisible());
        found_visible_window |= tw->isVisible();
    }

    if (!m_toolWindows.isEmpty() && !found_visible_window)
        m_toolWindows.first()->show();

    changeBringToFrontVisiblity(true);

    foreach (QDesignerFormWindow *fw, m_formWindows) {
        fw->setParent(magicalParent(), magicalWindowFlags(fw));
        QRect g = m_geometries.value(fw, fw->geometryHint());
        fw->resize(g.size());
        fw->move(g.topLeft() + desktopOffset);
        fw->show();
    }
}

void QDesignerWorkbench::initializeCorePlugins

(

)

[slot]

Definition at line 693 of file qdesigner_workbench.cpp.

References core(), QDesignerPluginManager::instances(), QDesignerFormEditorInterface::pluginManager(), and QPluginLoader::staticInstances().

Referenced by initialize().

{
    QList<QObject*> plugins = QPluginLoader::staticInstances();
    plugins += core()->pluginManager()->instances();

    foreach (QObject *plugin, plugins) {
        if (QDesignerFormEditorPluginInterface *formEditorPlugin = qobject_cast<QDesignerFormEditorPluginInterface*>(plugin)) {
            if (!formEditorPlugin->isInitialized())
                formEditorPlugin->initialize(core());
        }
    }
}

void QDesignerWorkbench::initialize

(

)

[private, slot]

Definition at line 125 of file qdesigner_workbench.cpp.

References QActionGroup::actions(), QMenu::addAction(), QToolBar::addAction(), QMenuBar::addMenu(), QMenu::addMenu(), QMenu::addSeparator(), addToolWindow(), QHash< Key, T >::clear(), QObject::connect(), core(), QDesignerComponents::createFormEditor(), QDesignerComponents::createTaskMenu(), QDesignerActions::editActions(), emit, QDesignerActions::fileActions(), QDesignerActions::formActions(), formWindowActionTriggered(), QDesignerFormEditorInterface::formWindowManager(), QDesignerActions::helpActions(), QAction::icon(), initializeCorePlugins(), initialized(), QDesignerComponents::initializePlugins(), QMenu::insertMenu(), QIcon::isNull(), m_actionManager, m_core, m_editMenu, m_editToolBar, m_fileMenu, m_formMenu, m_formToolBar, m_geometries, m_globalMenuBar, m_helpMenu, m_integration, m_toolActions, m_toolMenu, m_toolToolBar, m_windowActions, m_windowMenu, QDesignerActions::previewFormAction(), QDesignerActions::recentFilesActions(), QActionGroup::setExclusive(), QObject::setObjectName(), QWidget::setWindowTitle(), SIGNAL, SLOT, QDesignerActions::styleActions(), QAction::text(), QToolBar::toggleViewAction(), QDesignerActions::toolActions(), QDesignerActions::uiMode(), updateWindowMenu(), and QDesignerActions::windowActions().

Referenced by QDesignerWorkbench().

{
    QDesignerSettings settings;
    m_core = QDesignerComponents::createFormEditor(this);

    (void) QDesignerComponents::createTaskMenu(core(), this);

    initializeCorePlugins();
    QDesignerComponents::initializePlugins(core());

    m_toolActions = new QActionGroup(this);
    m_toolActions->setExclusive(false);

    m_windowActions = new QActionGroup(this);
    m_windowActions->setExclusive(true);
    connect(m_windowActions, SIGNAL(triggered(QAction*)), this, SLOT(formWindowActionTriggered(QAction*)));

    m_actionManager = new QDesignerActions(this);

    m_globalMenuBar = new QMenuBar;

    m_fileMenu = m_globalMenuBar->addMenu(tr("&File"));
    foreach (QAction *action, m_actionManager->fileActions()->actions()) {
        m_fileMenu->addAction(action);
        if (action->text() == QDesignerActions::tr("&Open Form...")) {
            QMenu *recentFilesMenu = m_fileMenu->addMenu(tr("&Recent Forms"));
            // Pop the "Recent Files" stuff in here.
            foreach(QAction *recentAction, m_actionManager->recentFilesActions()->actions())
                recentFilesMenu->addAction(recentAction);
        }
    }

    m_editMenu = m_globalMenuBar->addMenu(tr("&Edit"));
    foreach (QAction *action, m_actionManager->editActions()->actions()) {
        m_editMenu->addAction(action);
    }

    m_editMenu->addSeparator();

    foreach (QAction *action, m_actionManager->toolActions()->actions()) {
        m_editMenu->addAction(action);
    }

    m_editMenu->addSeparator();
    QMenu *menu = m_editMenu->addMenu(tr("User Interface &Mode"));
    foreach (QAction *action, m_actionManager->uiMode()->actions())
        menu->addAction(action);


    m_formMenu = m_globalMenuBar->addMenu(tr("F&orm"));
    foreach (QAction *action, m_actionManager->formActions()->actions()) {
        m_formMenu->addAction(action);
    }

    QMenu *previewSubMenu = new QMenu(tr("Preview in"), m_formMenu);
    m_formMenu->insertMenu(m_actionManager->previewFormAction(), previewSubMenu);

    foreach (QAction *action, m_actionManager->styleActions()->actions()) {
        previewSubMenu->addAction(action);
    }

    m_toolMenu = m_globalMenuBar->addMenu(tr("&Tools"));

    m_toolMenu->addSeparator();

    m_windowMenu = m_globalMenuBar->addMenu(tr("&Window"));
    foreach (QAction *action, m_actionManager->windowActions()->actions()) {
        m_windowMenu->addAction(action);
    }

    m_helpMenu = m_globalMenuBar->addMenu(tr("&Help"));
    foreach (QAction *action, m_actionManager->helpActions()->actions()) {
        m_helpMenu->addAction(action);
    }

    QDesignerToolWindow *tw = new QDesignerWidgetBox(this);
    tw->setObjectName(QLatin1String("qt_designer_widgetbox"));
    addToolWindow(tw);
    tw = new QDesignerObjectInspector(this);
    tw->setObjectName(QLatin1String("qt_designer_objectinspector"));
    addToolWindow(tw);
    tw = new QDesignerPropertyEditor(this);
    tw->setObjectName(QLatin1String("qt_designer_propertyeditor"));
    addToolWindow(tw);
    tw = new QDesignerSignalSlotEditor(this);
    tw->setObjectName(QLatin1String("qt_designer_signalsloteditor"));
    addToolWindow(tw);
    tw = new QDesignerResourceEditor(this);
    tw->setObjectName(QLatin1String("qt_designer_resourceeditor"));
    addToolWindow(tw);
    tw = new QDesignerActionEditor(this);
    tw->setObjectName(QLatin1String("qt_designer_actioneditor"));
    addToolWindow(tw);

    m_integration = new qdesigner_internal::QDesignerIntegration(core(), this);

    // create the toolbars
    m_editToolBar = new QToolBar;
    m_editToolBar->setObjectName(QLatin1String("editToolBar"));
    m_editToolBar->setWindowTitle(tr("Edit"));
    foreach (QAction *action, m_actionManager->editActions()->actions()) {
        if (action->icon().isNull() == false)
            m_editToolBar->addAction(action);
    }

    m_toolToolBar = new QToolBar;
    m_toolToolBar->setObjectName(QLatin1String("toolsToolBar"));
    m_toolToolBar->setWindowTitle(tr("Tools"));
    foreach (QAction *action, m_actionManager->toolActions()->actions()) {
        if (action->icon().isNull() == false)
            m_toolToolBar->addAction(action);
    }

    m_formToolBar = new QToolBar;
    m_formToolBar->setObjectName(QLatin1String("formToolBar"));
    m_formToolBar->setWindowTitle(tr("Form"));
    foreach (QAction *action, m_actionManager->formActions()->actions()) {
        if (action->icon().isNull() == false)
            m_formToolBar->addAction(action);
    }

    QMenu *toolbarMenu = m_toolMenu->addMenu(tr("Toolbars"));
    toolbarMenu->addAction(m_editToolBar->toggleViewAction());
    toolbarMenu->addAction(m_toolToolBar->toggleViewAction());
    toolbarMenu->addAction(m_formToolBar->toggleViewAction());

    m_geometries.clear();

    emit initialized();

    connect(m_core->formWindowManager(), SIGNAL(activeFormWindowChanged(QDesignerFormWindowInterface*)),
                this, SLOT(updateWindowMenu(QDesignerFormWindowInterface*)));
}

void QDesignerWorkbench::activateWorkspaceChildWindow

(

QWidget *

widget

)

[private, slot]

Definition at line 645 of file qdesigner_workbench.cpp.

References core(), QDesignerFormEditorInterface::formWindowManager(), m_workspace, QDesignerFormWindowManagerInterface::setActiveFormWindow(), and QWorkspace::setActiveWindow().

Referenced by switchToDockedMode().

{
    if (QDesignerFormWindow *fw = qobject_cast<QDesignerFormWindow*>(widget)) {
        core()->formWindowManager()->setActiveFormWindow(fw->editor());
        m_workspace->setActiveWindow(widget);
    }
}

void QDesignerWorkbench::updateWindowMenu

(

QDesignerFormWindowInterface *

fw

)

[private, slot]

Definition at line 827 of file qdesigner_workbench.cpp.

References QWidget::parentWidget().

Referenced by initialize().

{
    if (!fw)
        return;
    if (QDesignerFormWindow *dfw = qobject_cast<QDesignerFormWindow *>(fw->parentWidget()))
        dfw->action()->setChecked(true);
}

void QDesignerWorkbench::formWindowActionTriggered

(

QAction *

a

)

[private, slot]

Definition at line 835 of file qdesigner_workbench.cpp.

References a, QWidget::activateWindow(), DockedMode, m_mode, m_workspace, QWidget::raise(), QWorkspace::setActiveWindow(), QWidget::setWindowState(), Qt::WindowMinimized, and QWidget::windowState().

Referenced by initialize().

{
    QWidget *widget = a->parentWidget();
    Q_ASSERT(widget != 0);

    if (m_mode == DockedMode) {
        m_workspace->setActiveWindow(widget);
    } else {
        widget->setWindowState(widget->windowState() & ~Qt::WindowMinimized);
        widget->activateWindow();
        widget->raise();
    }
}

void QDesignerWorkbench::showToolBars

(

)

[private, slot]

Definition at line 849 of file qdesigner_workbench.cpp.

References m_editToolBar, m_formToolBar, m_toolToolBar, and QWidget::show().

{
    m_toolToolBar->show();
    m_formToolBar->show();
    m_editToolBar->show();
}

void QDesignerWorkbench::adjustFormPositions

(

)

[private, slot]

Definition at line 485 of file qdesigner_workbench.cpp.

References g, QDesignerFormWindow::geometryHint(), m_formWindows, m_geometries, m_workspace, QWidget::mapToGlobal(), QWidget::move(), QWidget::parentWidget(), QWidget::resize(), QWidget::show(), and QHash< Key, T >::value().

{
    if (m_workspace == 0)
        return;

    QPoint workspace_tl = m_workspace->mapToGlobal(QPoint(0, 0));

    foreach (QDesignerFormWindow *fw, m_formWindows) {
        QWidget *frame = fw->parentWidget();
        if (frame == 0)
            continue;
        QRect g = m_geometries.value(fw, fw->geometryHint());
        frame->move(g.topLeft() - workspace_tl);
        fw->resize(g.size());
        frame->show();
    }
}

QWidget * QDesignerWorkbench::magicalParent

(

)

const [private]

Definition at line 282 of file qdesigner_workbench.cpp.

References DockedMode, m_mode, m_workspace, NeutralMode, and TopLevelMode.

Referenced by createFormWindow(), and switchToTopLevelMode().

{
    switch (m_mode) {
        case TopLevelMode:
            return 0;
        case DockedMode:
            Q_ASSERT(m_workspace != 0);
            return m_workspace;
        case NeutralMode:
            return 0;
        default:
            Q_ASSERT(0);
            return 0;
    }
}

Qt::WindowFlags QDesignerWorkbench::magicalWindowFlags

(

const QWidget *

widgetForFlags

)

const [private]

Definition at line 259 of file qdesigner_workbench.cpp.

References DockedMode, m_mode, m_workspace, NeutralMode, Qt::Tool, TopLevelMode, Qt::Window, Qt::WindowShadeButtonHint, Qt::WindowSystemMenuHint, and Qt::WindowTitleHint.

Referenced by createFormWindow(), switchToDockedMode(), and switchToTopLevelMode().

{
    switch (m_mode) {
        case TopLevelMode: {
#ifdef Q_WS_MAC
            if (qobject_cast<const QDesignerToolWindow *>(widgetForFlags))
                return Qt::Tool;
#else
            Q_UNUSED(widgetForFlags);
#endif
            return Qt::Window;
        }
        case DockedMode:
            Q_ASSERT(m_workspace != 0);
            return Qt::Window | Qt::WindowShadeButtonHint | Qt::WindowSystemMenuHint | Qt::WindowTitleHint;
        case NeutralMode:
            return Qt::Window;
        default:
            Q_ASSERT(0);
            return 0;
    }
}

QDockWidget * QDesignerWorkbench::magicalDockWidget

(

QWidget *

widget

)

const [private]

Definition at line 862 of file qdesigner_workbench.cpp.

References m_workspace, QObject::objectName(), and QWidget::window().

Referenced by switchToDockedMode().

{
    if (!m_workspace)
        return 0;

    QDockWidget *dockWidget = qFindChild<QDockWidget*>(m_workspace->window(), widget->objectName() + QLatin1String("_dock"));
    return dockWidget;
}

Here is the call graph for this function:

QDesignerFormWindowManagerInterface * QDesignerWorkbench::formWindowManager

(

)

const [private]

Definition at line 597 of file qdesigner_workbench.cpp.

References QDesignerFormEditorInterface::formWindowManager(), and m_core.

{
    return m_core->formWindowManager();
}

Here is the call graph for this function:

void QDesignerWorkbench::changeBringToFrontVisiblity

(

bool

visible

)

[private]

Definition at line 503 of file qdesigner_workbench.cpp.

References QActionGroup::actions(), QList< T >::at(), QDesignerActions::bringToFrontAction(), QList< T >::indexOf(), QAction::isSeparator(), m_actionManager, QAction::setVisible(), and QDesignerActions::windowActions().

Referenced by switchToDockedMode(), and switchToTopLevelMode().

{
    QAction *btf = m_actionManager->bringToFrontAction();
    QList<QAction *> actionList = m_actionManager->windowActions()->actions();
    btf->setVisible(visible);
    QAction *sep = actionList.at(actionList.indexOf(btf) - 1);
    if (sep->isSeparator())
        sep->setVisible(visible);
}

Here is the call graph for this function:

bool QDesignerWorkbench::eventFilter	(	QObject *	object,
		QEvent *	event
	)			[private, virtual]

Filters events if this object has been installed as an event filter for the watched object.

In your reimplementation of this function, if you want to filter the event out, i.e. stop it being handled further, return true; otherwise return false.

Example:

        class MainWindow : public QMainWindow
        {
        public:
            MainWindow();

        protected:
            bool eventFilter(QObject *obj, QEvent *ev);

        private:
            QTextEdit *textEdit;
        };

        MainWindow::MainWindow()
        {
            textEdit = new QTextEdit;
            setCentralWidget(textEdit);

            textEdit->installEventFilter(this);
        }

        bool MainWindow::eventFilter(QObject *obj, QEvent *event)
        {
            if (obj == textEdit) {
                if (event->type() == QEvent::KeyPress) {
                    QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
                    qDebug() << "Ate key press" << keyEvent->key();
                    return true;
                } else {
                    return false;
                }
            } else {
                // pass the event on to the parent class
                return QMainWindow::eventFilter(obj, event);
            }
        }

Notice in the example above that unhandled events are passed to the base class's eventFilter() function, since the base class might have reimplemented eventFilter() for its own internal purposes.

Warning:

If you delete the receiver object in this function, be sure to return true. Otherwise, Qt will forward the event to the deleted object and the program might crash.

See also:

installEventFilter()

Reimplemented from QObject.

Definition at line 457 of file qdesigner_workbench.cpp.

References QMessageBox::critical(), QEvent::DragEnter, QEvent::Drop, QObject::event(), m_workspace, object, and readInForm().

{
    if (object == m_workspace) {
        if (event->type() == QEvent::DragEnter) {
            QDragEnterEvent *e = static_cast<QDragEnterEvent*>(event);
            if (e->mimeData()->hasFormat("text/uri-list")) {
                e->acceptProposedAction();
                return true;
            }
        } else if (event->type() == QEvent::Drop) {
            QDropEvent *e = static_cast<QDropEvent*>(event);
            if (!e->mimeData()->hasFormat("text/uri-list"))
                return false;
            foreach (QUrl url, e->mimeData()->urls()) {
                QString fileName = url.toLocalFile();
                if (fileName.endsWith(".ui"))
                    readInForm(url.toLocalFile());
                else
                    QMessageBox::critical(m_workspace, tr("Opening Form"),
                        tr("Cannot open file %1!").arg(fileName));
            }
            e->acceptProposedAction();
            return true;
        }
    }
    return false;
}

Here is the call graph for this function:

---

Member Data Documentation

QDesignerFormEditorInterface* QDesignerWorkbench::m_core [private]

Definition at line 138 of file qdesigner_workbench.h.

Referenced by core(), formWindowManager(), initialize(), switchToDockedMode(), switchToNeutralMode(), and switchToTopLevelMode().

qdesigner_internal::QDesignerIntegration* QDesignerWorkbench::m_integration [private]

Definition at line 139 of file qdesigner_workbench.h.

Referenced by initialize().

QDesignerActions* QDesignerWorkbench::m_actionManager [private]

Definition at line 141 of file qdesigner_workbench.h.

Referenced by actionManager(), addFormWindow(), changeBringToFrontVisiblity(), initialize(), readInForm(), removeFormWindow(), saveForm(), and writeOutForm().

QActionGroup* QDesignerWorkbench::m_toolActions [private]

Definition at line 142 of file qdesigner_workbench.h.

Referenced by addToolWindow(), initialize(), and removeToolWindow().

QActionGroup* QDesignerWorkbench::m_windowActions [private]

Definition at line 143 of file qdesigner_workbench.h.

Referenced by addFormWindow(), initialize(), and removeFormWindow().

QMenu* QDesignerWorkbench::m_fileMenu [private]

Definition at line 145 of file qdesigner_workbench.h.

Referenced by initialize().

QMenu* QDesignerWorkbench::m_editMenu [private]

Definition at line 146 of file qdesigner_workbench.h.

Referenced by initialize().

QMenu* QDesignerWorkbench::m_formMenu [private]

Definition at line 147 of file qdesigner_workbench.h.

Referenced by initialize().

QMenu* QDesignerWorkbench::m_toolMenu [private]

Definition at line 148 of file qdesigner_workbench.h.

Referenced by addToolWindow(), initialize(), and removeToolWindow().

QMenu* QDesignerWorkbench::m_windowMenu [private]

Definition at line 149 of file qdesigner_workbench.h.

Referenced by addFormWindow(), initialize(), and removeFormWindow().

QMenu* QDesignerWorkbench::m_helpMenu [private]

Definition at line 150 of file qdesigner_workbench.h.

Referenced by initialize().

QMenuBar* QDesignerWorkbench::m_globalMenuBar [private]

Definition at line 152 of file qdesigner_workbench.h.

Referenced by initialize(), switchToDockedMode(), switchToNeutralMode(), and switchToTopLevelMode().

QToolBar* QDesignerWorkbench::m_toolToolBar [private]

Definition at line 153 of file qdesigner_workbench.h.

Referenced by initialize(), showToolBars(), switchToDockedMode(), switchToNeutralMode(), and switchToTopLevelMode().

QToolBar* QDesignerWorkbench::m_formToolBar [private]

Definition at line 154 of file qdesigner_workbench.h.

Referenced by initialize(), showToolBars(), switchToDockedMode(), switchToNeutralMode(), and switchToTopLevelMode().

QToolBar* QDesignerWorkbench::m_editToolBar [private]

Definition at line 155 of file qdesigner_workbench.h.

Referenced by initialize(), showToolBars(), switchToDockedMode(), switchToNeutralMode(), and switchToTopLevelMode().

UIMode QDesignerWorkbench::m_mode [private]

Definition at line 157 of file qdesigner_workbench.h.

Referenced by formWindowActionTriggered(), magicalParent(), magicalWindowFlags(), mode(), saveSettings(), switchToDockedMode(), switchToNeutralMode(), switchToTopLevelMode(), and ~QDesignerWorkbench().

QList<QDesignerToolWindow*> QDesignerWorkbench::m_toolWindows [private]

Definition at line 159 of file qdesigner_workbench.h.

Referenced by addToolWindow(), closeAllToolWindows(), findToolWindow(), removeToolWindow(), saveSettings(), switchToDockedMode(), switchToNeutralMode(), switchToTopLevelMode(), toolWindow(), toolWindowCount(), and ~QDesignerWorkbench().

QList<QDesignerFormWindow*> QDesignerWorkbench::m_formWindows [private]

Definition at line 160 of file qdesigner_workbench.h.

Referenced by addFormWindow(), adjustFormPositions(), findFormWindow(), formWindow(), formWindowCount(), handleClose(), removeFormWindow(), switchToDockedMode(), switchToNeutralMode(), and switchToTopLevelMode().

QWorkspace* QDesignerWorkbench::m_workspace [private]

Definition at line 162 of file qdesigner_workbench.h.

Referenced by activateWorkspaceChildWindow(), adjustFormPositions(), availableGeometry(), createFormWindow(), eventFilter(), formWindowActionTriggered(), magicalDockWidget(), magicalParent(), magicalWindowFlags(), switchToDockedMode(), switchToNeutralMode(), and ~QDesignerWorkbench().

QHash<QWidget*, bool> QDesignerWorkbench::m_visibilities [private]

Definition at line 163 of file qdesigner_workbench.h.

Referenced by switchToDockedMode(), and switchToNeutralMode().

QHash<QWidget*, QRect> QDesignerWorkbench::m_geometries [private]

Definition at line 164 of file qdesigner_workbench.h.

Referenced by adjustFormPositions(), initialize(), switchToDockedMode(), switchToNeutralMode(), and switchToTopLevelMode().

QHash<QDesignerToolWindow*, ToolWindowExtra> QDesignerWorkbench::m_toolWindowExtras [private]

Definition at line 169 of file qdesigner_workbench.h.

Referenced by addToolWindow(), and removeToolWindow().

QHash<QDesignerFormWindow*, FormWindowExtra> QDesignerWorkbench::m_formWindowExtras [private]

Definition at line 170 of file qdesigner_workbench.h.

Referenced by addFormWindow(), and removeFormWindow().

bool QDesignerWorkbench::m_initializing [private]

Definition at line 171 of file qdesigner_workbench.h.

Referenced by QDesignerWorkbench(), and switchToDockedMode().

---

The documentation for this class was generated from the following files:

• tools/designer/src/designer/qdesigner_workbench.h
• tools/designer/src/designer/qdesigner_workbench.cpp

---