feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

debugger: merger DebuggerMainWindow and DebuggerUISwitcher

Browse Source
This commit is contained in:
hjk
2010-12-02 17:33:39 +01:00
parent def49bf9a6
commit 05f6151d33
9 changed files with 200 additions and 334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/plugins/debugger/debugger.pro
View File

@@ -28,7 +28,6 @@ HEADERS += breakhandler.h \
debuggerconstants.h \ debuggerconstants.h \
debuggerdialogs.h \ debuggerdialogs.h \
debuggerengine.h \ debuggerengine.h \
debuggermainwindow.h \
debuggerplugin.h \ debuggerplugin.h \
debuggerrunner.h \ debuggerrunner.h \
debuggerstreamops.h \ debuggerstreamops.h \
@@ -69,7 +68,6 @@ SOURCES += breakhandler.cpp \
debuggeragents.cpp \ debuggeragents.cpp \
debuggerdialogs.cpp \ debuggerdialogs.cpp \
debuggerengine.cpp \ debuggerengine.cpp \
debuggermainwindow.cpp \
debuggerplugin.cpp \ debuggerplugin.cpp \
debuggerrunner.cpp \ debuggerrunner.cpp \
debuggerstreamops.cpp \ debuggerstreamops.cpp \

78
src/plugins/debugger/debuggermainwindow.cpp
View File

@@ -1,78 +0,0 @@
/**************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** Commercial Usage
**
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
**
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at http://qt.nokia.com/contact.
**
**************************************************************************/
#include "debuggermainwindow.h"
#include "debuggeruiswitcher.h"
#include <QtGui/QMenu>
#include <QtGui/QDockWidget>
#include <QtCore/QDebug>
namespace Debugger {
namespace Internal {
DebuggerMainWindow::DebuggerMainWindow(DebuggerUISwitcher *uiSwitcher, QWidget *parent) :
FancyMainWindow(parent), m_uiSwitcher(uiSwitcher)
{
// TODO how to "append" style sheet?
// QString sheet;
// After setting it, all prev. style stuff seem to be ignored.
/* sheet = QLatin1String(
"Debugger--DebuggerMainWindow::separator {"
" background: black;"
" width: 1px;"
" height: 1px;"
"}"
);
setStyleSheet(sheet);
*/
}
QMenu *DebuggerMainWindow::createPopupMenu()
{
QMenu *menu = 0;
const QList<QDockWidget* > dockwidgets = m_uiSwitcher->dockWidgets();
if (!dockwidgets.isEmpty()) {
menu = FancyMainWindow::createPopupMenu();
foreach (QDockWidget *dockWidget, dockwidgets) {
if (dockWidget->parentWidget() == this)
menu->addAction(dockWidget->toggleViewAction());
}
menu->addSeparator();
}
return menu;
}
} // namespace Internal
} // namespace Debugger

58
src/plugins/debugger/debuggermainwindow.h
View File

@@ -1,58 +0,0 @@
/**************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** Commercial Usage
**
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
**
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at http://qt.nokia.com/contact.
**
**************************************************************************/
#ifndef DEBUGGERMAINWINDOW_H
#define DEBUGGERMAINWINDOW_H
#include <utils/fancymainwindow.h>
QT_FORWARD_DECLARE_CLASS(QMenu);
namespace Debugger {
class DebuggerUISwitcher;
namespace Internal {
class DebuggerMainWindow : public Utils::FancyMainWindow
{
Q_OBJECT
public:
explicit DebuggerMainWindow(DebuggerUISwitcher *uiSwitcher, QWidget *parent = 0);
protected:
virtual QMenu *createPopupMenu();
private:
DebuggerUISwitcher *m_uiSwitcher;
};
} // namespace Internal
} // namespace Debugger
#endif // DEBUGGERMAINWINDOW_H

150
src/plugins/debugger/debuggerplugin.cpp
View File

@@ -35,7 +35,6 @@
#include "debuggercore.h" #include "debuggercore.h"
#include "debuggerdialogs.h" #include "debuggerdialogs.h"
#include "debuggerengine.h" #include "debuggerengine.h"
#include "debuggermainwindow.h"
#include "debuggerrunner.h" #include "debuggerrunner.h"
#include "debuggerstringutils.h" #include "debuggerstringutils.h"
#include "debuggertooltip.h" #include "debuggertooltip.h"
@@ -1061,7 +1060,7 @@ public slots:
void showQtDumperLibraryWarning(const QString &details); void showQtDumperLibraryWarning(const QString &details);
DebuggerMainWindow *debuggerMainWindow() const; DebuggerMainWindow *debuggerMainWindow() const;
QWidget *mainWindow() const { return m_uiSwitcher->mainWindow(); } QWidget *mainWindow() const { return m_mainWindow; }
bool isRegisterViewVisible() const; bool isRegisterViewVisible() const;
bool hasSnapshots() const { return m_snapshotHandler->size(); } bool hasSnapshots() const { return m_snapshotHandler->size(); }
@@ -1302,7 +1301,7 @@ public slots:
bool isActiveDebugLanguage(int lang) const bool isActiveDebugLanguage(int lang) const
{ {
return m_uiSwitcher->activeDebugLanguages() & lang; return m_mainWindow->activeDebugLanguages() & lang;
} }
void resetLocation(); void resetLocation();
@@ -1324,7 +1323,7 @@ public slots:
public: public:
DebuggerState m_state; DebuggerState m_state;
DebuggerUISwitcher *m_uiSwitcher; DebuggerMainWindow *m_mainWindow;
DebuggerPlugin *m_manager; DebuggerPlugin *m_manager;
DebugMode *m_debugMode; DebugMode *m_debugMode;
DebuggerRunControlFactory *m_debuggerRunControlFactory; DebuggerRunControlFactory *m_debuggerRunControlFactory;
@@ -1449,7 +1448,7 @@ DebuggerPluginPrivate::DebuggerPluginPrivate(DebuggerPlugin *plugin)
m_anyContext = Context(0); m_anyContext = Context(0);
m_debugMode = 0; m_debugMode = 0;
m_uiSwitcher = 0; m_mainWindow = 0;
m_state = DebuggerNotReady; m_state = DebuggerNotReady;
m_snapshotHandler = 0; m_snapshotHandler = 0;
m_currentEngine = 0; m_currentEngine = 0;
@@ -1468,9 +1467,9 @@ DebuggerPluginPrivate::~DebuggerPluginPrivate()
delete m_debugMode; delete m_debugMode;
m_debugMode = 0; m_debugMode = 0;
m_plugin->removeObject(m_uiSwitcher); m_plugin->removeObject(m_mainWindow);
delete m_uiSwitcher; delete m_mainWindow;
m_uiSwitcher = 0; m_mainWindow = 0;
delete m_snapshotHandler; delete m_snapshotHandler;
m_snapshotHandler = 0; m_snapshotHandler = 0;
@@ -2139,21 +2138,20 @@ void DebuggerPluginPrivate::setBusyCursor(bool busy)
void DebuggerPluginPrivate::setSimpleDockWidgetArrangement void DebuggerPluginPrivate::setSimpleDockWidgetArrangement
(Debugger::DebuggerLanguages activeLanguages) (Debugger::DebuggerLanguages activeLanguages)
{ {
DebuggerMainWindow *mw = debuggerMainWindow(); QTC_ASSERT(m_mainWindow, return);
QTC_ASSERT(mw, return); m_mainWindow->setTrackingEnabled(false);
mw->setTrackingEnabled(false);
QList<QDockWidget *> dockWidgets = mw->dockWidgets(); QList<QDockWidget *> dockWidgets = m_mainWindow->dockWidgets();
foreach (QDockWidget *dockWidget, dockWidgets) { foreach (QDockWidget *dockWidget, dockWidgets) {
dockWidget->setFloating(false); dockWidget->setFloating(false);
mw->removeDockWidget(dockWidget); m_mainWindow->removeDockWidget(dockWidget);
} }
foreach (QDockWidget *dockWidget, dockWidgets) { foreach (QDockWidget *dockWidget, dockWidgets) {
if (dockWidget == m_outputDock /*|| dockWidget == m_consoleDock*/) { if (dockWidget == m_outputDock /*|| dockWidget == m_consoleDock*/) {
mw->addDockWidget(Qt::TopDockWidgetArea, dockWidget); m_mainWindow->addDockWidget(Qt::TopDockWidgetArea, dockWidget);
} else { } else {
mw->addDockWidget(Qt::BottomDockWidgetArea, dockWidget); m_mainWindow->addDockWidget(Qt::BottomDockWidgetArea, dockWidget);
} }
dockWidget->hide(); dockWidget->hide();
} }
@@ -2171,22 +2169,22 @@ void DebuggerPluginPrivate::setSimpleDockWidgetArrangement
m_breakDock->show(); m_breakDock->show();
m_watchDock->show(); m_watchDock->show();
m_scriptConsoleDock->show(); m_scriptConsoleDock->show();
if (m_uiSwitcher->qmlInspectorWindow()) if (m_mainWindow->qmlInspectorWindow())
m_uiSwitcher->qmlInspectorWindow()->show(); m_mainWindow->qmlInspectorWindow()->show();
} }
mw->splitDockWidget(mw->toolBarDockWidget(), m_stackDock, Qt::Vertical); m_mainWindow->splitDockWidget(m_mainWindow->toolBarDockWidget(), m_stackDock, Qt::Vertical);
mw->splitDockWidget(m_stackDock, m_watchDock, Qt::Horizontal); m_mainWindow->splitDockWidget(m_stackDock, m_watchDock, Qt::Horizontal);
mw->tabifyDockWidget(m_watchDock, m_breakDock); m_mainWindow->tabifyDockWidget(m_watchDock, m_breakDock);
mw->tabifyDockWidget(m_watchDock, m_modulesDock); m_mainWindow->tabifyDockWidget(m_watchDock, m_modulesDock);
mw->tabifyDockWidget(m_watchDock, m_registerDock); m_mainWindow->tabifyDockWidget(m_watchDock, m_registerDock);
mw->tabifyDockWidget(m_watchDock, m_threadsDock); m_mainWindow->tabifyDockWidget(m_watchDock, m_threadsDock);
mw->tabifyDockWidget(m_watchDock, m_sourceFilesDock); m_mainWindow->tabifyDockWidget(m_watchDock, m_sourceFilesDock);
mw->tabifyDockWidget(m_watchDock, m_snapshotDock); m_mainWindow->tabifyDockWidget(m_watchDock, m_snapshotDock);
mw->tabifyDockWidget(m_watchDock, m_scriptConsoleDock); m_mainWindow->tabifyDockWidget(m_watchDock, m_scriptConsoleDock);
if (m_uiSwitcher->qmlInspectorWindow()) if (m_mainWindow->qmlInspectorWindow())
mw->tabifyDockWidget(m_watchDock, m_uiSwitcher->qmlInspectorWindow()); m_mainWindow->tabifyDockWidget(m_watchDock, m_mainWindow->qmlInspectorWindow());
mw->setTrackingEnabled(true); m_mainWindow->setTrackingEnabled(true);
} }
void DebuggerPluginPrivate::setInitialState() void DebuggerPluginPrivate::setInitialState()
@@ -2412,7 +2410,7 @@ void DebuggerPluginPrivate::onModeChanged(IMode *mode)
// different then the debugger mode. E.g. Welcome and Help mode and // different then the debugger mode. E.g. Welcome and Help mode and
// also on shutdown. // also on shutdown.
m_uiSwitcher->onModeChanged(mode); m_mainWindow->onModeChanged(mode);
if (mode != m_debugMode) if (mode != m_debugMode)
return; return;
@@ -2535,7 +2533,7 @@ void DebuggerPluginPrivate::coreShutdown()
void DebuggerPluginPrivate::writeSettings() const void DebuggerPluginPrivate::writeSettings() const
{ {
m_debuggerSettings->writeSettings(); m_debuggerSettings->writeSettings();
m_uiSwitcher->writeSettings(); m_mainWindow->writeSettings();
if (GdbOptionsPage::gdbBinariesChanged) if (GdbOptionsPage::gdbBinariesChanged)
GdbOptionsPage::writeGdbBinarySettings(); GdbOptionsPage::writeGdbBinarySettings();
} }
@@ -2544,7 +2542,7 @@ void DebuggerPluginPrivate::readSettings()
{ {
//qDebug() << "PLUGIN READ SETTINGS"; //qDebug() << "PLUGIN READ SETTINGS";
m_debuggerSettings->readSettings(); m_debuggerSettings->readSettings();
m_uiSwitcher->readSettings(); m_mainWindow->readSettings();
GdbOptionsPage::readGdbBinarySettings(); GdbOptionsPage::readGdbBinarySettings();
} }
@@ -2681,7 +2679,7 @@ bool DebuggerPluginPrivate::isRegisterViewVisible() const
void DebuggerPluginPrivate::createNewDock(QWidget *widget) void DebuggerPluginPrivate::createNewDock(QWidget *widget)
{ {
QDockWidget *dockWidget = QDockWidget *dockWidget =
m_uiSwitcher->createDockWidget(CppLanguage, widget); m_mainWindow->createDockWidget(CppLanguage, widget);
dockWidget->setWindowTitle(widget->windowTitle()); dockWidget->setWindowTitle(widget->windowTitle());
dockWidget->setObjectName(widget->windowTitle()); dockWidget->setObjectName(widget->windowTitle());
dockWidget->setFeatures(QDockWidget::DockWidgetClosable); dockWidget->setFeatures(QDockWidget::DockWidgetClosable);
@@ -2694,7 +2692,7 @@ void DebuggerPluginPrivate::runControlStarted(DebuggerRunControl *runControl)
{ {
activateDebugMode(); activateDebugMode();
if (!hasSnapshots()) if (!hasSnapshots())
m_uiSwitcher->updateActiveLanguages(); m_mainWindow->updateActiveLanguages();
const QString message = runControl->idString(); const QString message = runControl->idString();
showMessage(message, StatusBar); showMessage(message, StatusBar);
@@ -2745,7 +2743,7 @@ QString DebuggerPluginPrivate::gdbBinaryForToolChain(int toolChain) const
DebuggerLanguages DebuggerPluginPrivate::activeLanguages() const DebuggerLanguages DebuggerPluginPrivate::activeLanguages() const
{ {
return m_uiSwitcher->activeDebugLanguages(); return m_mainWindow->activeDebugLanguages();
} }
bool DebuggerPluginPrivate::isReverseDebugging() const bool DebuggerPluginPrivate::isReverseDebugging() const
@@ -2943,52 +2941,52 @@ void DebuggerPluginPrivate::extensionsInitialized()
SLOT(executeDebuggerCommand())); SLOT(executeDebuggerCommand()));
// Cpp/Qml ui setup // Cpp/Qml ui setup
m_uiSwitcher = new DebuggerUISwitcher(this); m_mainWindow = new DebuggerMainWindow;
m_debugMode->setWidget(m_uiSwitcher->createContents(m_debugMode)); m_debugMode->setWidget(m_mainWindow->createContents(m_debugMode));
ExtensionSystem::PluginManager::instance()->addObject(m_uiSwitcher); ExtensionSystem::PluginManager::instance()->addObject(m_mainWindow);
m_uiSwitcher->addLanguage(CppLanguage, cppDebuggercontext); m_mainWindow->addLanguage(CppLanguage, cppDebuggercontext);
m_uiSwitcher->addLanguage(QmlLanguage, qmlDebuggerContext); m_mainWindow->addLanguage(QmlLanguage, qmlDebuggerContext);
m_uiSwitcher->initialize(m_coreSettings); m_mainWindow->initialize(m_coreSettings);
readSettings(); readSettings();
// Dock widgets // Dock widgets
m_breakDock = m_uiSwitcher->createDockWidget(CppLanguage, m_breakWindow); m_breakDock = m_mainWindow->createDockWidget(CppLanguage, m_breakWindow);
m_breakDock->setObjectName(QString(DOCKWIDGET_BREAK)); m_breakDock->setObjectName(QString(DOCKWIDGET_BREAK));
//m_consoleDock = m_uiSwitcher->createDockWidget(CppLanguage, m_consoleWindow, //m_consoleDock = m_mainWindow->createDockWidget(CppLanguage, m_consoleWindow,
// Qt::TopDockWidgetArea); // Qt::TopDockWidgetArea);
//m_consoleDock->setObjectName(QString(DOCKWIDGET_OUTPUT)); //m_consoleDock->setObjectName(QString(DOCKWIDGET_OUTPUT));
m_modulesDock = m_uiSwitcher->createDockWidget(CppLanguage, m_modulesWindow, m_modulesDock = m_mainWindow->createDockWidget(CppLanguage, m_modulesWindow,
Qt::TopDockWidgetArea); Qt::TopDockWidgetArea);
m_modulesDock->setObjectName(QString(DOCKWIDGET_MODULES)); m_modulesDock->setObjectName(QString(DOCKWIDGET_MODULES));
connect(m_modulesDock->toggleViewAction(), SIGNAL(toggled(bool)), connect(m_modulesDock->toggleViewAction(), SIGNAL(toggled(bool)),
SLOT(modulesDockToggled(bool)), Qt::QueuedConnection); SLOT(modulesDockToggled(bool)), Qt::QueuedConnection);
m_registerDock = m_uiSwitcher->createDockWidget(CppLanguage, m_registerWindow, m_registerDock = m_mainWindow->createDockWidget(CppLanguage, m_registerWindow,
Qt::TopDockWidgetArea); Qt::TopDockWidgetArea);
m_registerDock->setObjectName(QString(DOCKWIDGET_REGISTER)); m_registerDock->setObjectName(QString(DOCKWIDGET_REGISTER));
connect(m_registerDock->toggleViewAction(), SIGNAL(toggled(bool)), connect(m_registerDock->toggleViewAction(), SIGNAL(toggled(bool)),
SLOT(registerDockToggled(bool)), Qt::QueuedConnection); SLOT(registerDockToggled(bool)), Qt::QueuedConnection);
m_outputDock = m_uiSwitcher->createDockWidget(AnyLanguage, m_logWindow, m_outputDock = m_mainWindow->createDockWidget(AnyLanguage, m_logWindow,
Qt::TopDockWidgetArea); Qt::TopDockWidgetArea);
m_outputDock->setObjectName(QString(DOCKWIDGET_OUTPUT)); m_outputDock->setObjectName(QString(DOCKWIDGET_OUTPUT));
m_snapshotDock = m_uiSwitcher->createDockWidget(CppLanguage, m_snapshotWindow); m_snapshotDock = m_mainWindow->createDockWidget(CppLanguage, m_snapshotWindow);
m_snapshotDock->setObjectName(QString(DOCKWIDGET_SNAPSHOTS)); m_snapshotDock->setObjectName(QString(DOCKWIDGET_SNAPSHOTS));
m_stackDock = m_uiSwitcher->createDockWidget(CppLanguage, m_stackWindow); m_stackDock = m_mainWindow->createDockWidget(CppLanguage, m_stackWindow);
m_stackDock->setObjectName(QString(DOCKWIDGET_STACK)); m_stackDock->setObjectName(QString(DOCKWIDGET_STACK));
m_sourceFilesDock = m_uiSwitcher->createDockWidget(CppLanguage, m_sourceFilesDock = m_mainWindow->createDockWidget(CppLanguage,
m_sourceFilesWindow, Qt::TopDockWidgetArea); m_sourceFilesWindow, Qt::TopDockWidgetArea);
m_sourceFilesDock->setObjectName(QString(DOCKWIDGET_SOURCE_FILES)); m_sourceFilesDock->setObjectName(QString(DOCKWIDGET_SOURCE_FILES));
connect(m_sourceFilesDock->toggleViewAction(), SIGNAL(toggled(bool)), connect(m_sourceFilesDock->toggleViewAction(), SIGNAL(toggled(bool)),
SLOT(sourceFilesDockToggled(bool)), Qt::QueuedConnection); SLOT(sourceFilesDockToggled(bool)), Qt::QueuedConnection);
m_threadsDock = m_uiSwitcher->createDockWidget(CppLanguage, m_threadsWindow); m_threadsDock = m_mainWindow->createDockWidget(CppLanguage, m_threadsWindow);
m_threadsDock->setObjectName(QString(DOCKWIDGET_THREADS)); m_threadsDock->setObjectName(QString(DOCKWIDGET_THREADS));
QSplitter *localsAndWatchers = new Core::MiniSplitter(Qt::Vertical); QSplitter *localsAndWatchers = new Core::MiniSplitter(Qt::Vertical);
@@ -3001,11 +2999,11 @@ void DebuggerPluginPrivate::extensionsInitialized()
localsAndWatchers->setStretchFactor(1, 1); localsAndWatchers->setStretchFactor(1, 1);
localsAndWatchers->setStretchFactor(2, 1); localsAndWatchers->setStretchFactor(2, 1);
m_watchDock = m_uiSwitcher->createDockWidget(CppLanguage, localsAndWatchers); m_watchDock = m_mainWindow->createDockWidget(CppLanguage, localsAndWatchers);
m_watchDock->setObjectName(QString(DOCKWIDGET_WATCHERS)); m_watchDock->setObjectName(QString(DOCKWIDGET_WATCHERS));
m_scriptConsoleDock = m_scriptConsoleDock =
m_uiSwitcher->createDockWidget(QmlLanguage, m_scriptConsoleWindow); m_mainWindow->createDockWidget(QmlLanguage, m_scriptConsoleWindow);
m_scriptConsoleDock->setObjectName(QString(DOCKWIDGET_QML_SCRIPTCONSOLE)); m_scriptConsoleDock->setObjectName(QString(DOCKWIDGET_QML_SCRIPTCONSOLE));
// Register factory of DebuggerRunControl. // Register factory of DebuggerRunControl.
@@ -3119,13 +3117,13 @@ void DebuggerPluginPrivate::extensionsInitialized()
cmd = am->registerAction(m_detachAction, cmd = am->registerAction(m_detachAction,
Constants::DETACH, globalcontext); Constants::DETACH, globalcontext);
cmd->setAttribute(Command::CA_Hide); cmd->setAttribute(Command::CA_Hide);
m_uiSwitcher->addMenuAction(cmd, AnyLanguage, CC::G_DEFAULT_ONE); m_mainWindow->addMenuAction(cmd, AnyLanguage, CC::G_DEFAULT_ONE);
cmd = am->registerAction(m_actions.exitAction, cmd = am->registerAction(m_actions.exitAction,
Constants::STOP, globalcontext); Constants::STOP, globalcontext);
//cmd->setDefaultKeySequence(QKeySequence(Constants::STOP_KEY)); //cmd->setDefaultKeySequence(QKeySequence(Constants::STOP_KEY));
cmd->setDefaultText(tr("Stop Debugger")); cmd->setDefaultText(tr("Stop Debugger"));
m_uiSwitcher->addMenuAction(cmd, AnyLanguage, CC::G_DEFAULT_ONE); m_mainWindow->addMenuAction(cmd, AnyLanguage, CC::G_DEFAULT_ONE);
cmd = am->registerAction(m_actions.interruptAction, cmd = am->registerAction(m_actions.interruptAction,
Constants::DEBUG, m_interruptibleContext); Constants::DEBUG, m_interruptibleContext);
@@ -3139,77 +3137,77 @@ void DebuggerPluginPrivate::extensionsInitialized()
Constants::RESET, globalcontext); Constants::RESET, globalcontext);
//cmd->setDefaultKeySequence(QKeySequence(Constants::RESET_KEY)); //cmd->setDefaultKeySequence(QKeySequence(Constants::RESET_KEY));
cmd->setDefaultText(tr("Reset Debugger")); cmd->setDefaultText(tr("Reset Debugger"));
m_uiSwitcher->addMenuAction(cmd, AnyLanguage, CC::G_DEFAULT_ONE); m_mainWindow->addMenuAction(cmd, AnyLanguage, CC::G_DEFAULT_ONE);
QAction *sep = new QAction(this); QAction *sep = new QAction(this);
sep->setSeparator(true); sep->setSeparator(true);
cmd = am->registerAction(sep, _("Debugger.Sep.Step"), globalcontext); cmd = am->registerAction(sep, _("Debugger.Sep.Step"), globalcontext);
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
cmd = am->registerAction(m_actions.nextAction, cmd = am->registerAction(m_actions.nextAction,
Constants::NEXT, cppDebuggercontext); Constants::NEXT, cppDebuggercontext);
cmd->setDefaultKeySequence(QKeySequence(Constants::NEXT_KEY)); cmd->setDefaultKeySequence(QKeySequence(Constants::NEXT_KEY));
cmd->setAttribute(Command::CA_Hide); cmd->setAttribute(Command::CA_Hide);
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
cmd = am->registerAction(m_actions.stepAction, cmd = am->registerAction(m_actions.stepAction,
Constants::STEP, cppDebuggercontext); Constants::STEP, cppDebuggercontext);
cmd->setDefaultKeySequence(QKeySequence(Constants::STEP_KEY)); cmd->setDefaultKeySequence(QKeySequence(Constants::STEP_KEY));
cmd->setAttribute(Command::CA_Hide); cmd->setAttribute(Command::CA_Hide);
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
cmd = am->registerAction(m_actions.stepOutAction, cmd = am->registerAction(m_actions.stepOutAction,
Constants::STEPOUT, cppDebuggercontext); Constants::STEPOUT, cppDebuggercontext);
cmd->setDefaultKeySequence(QKeySequence(Constants::STEPOUT_KEY)); cmd->setDefaultKeySequence(QKeySequence(Constants::STEPOUT_KEY));
cmd->setAttribute(Command::CA_Hide); cmd->setAttribute(Command::CA_Hide);
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
cmd = am->registerAction(m_actions.runToLineAction, cmd = am->registerAction(m_actions.runToLineAction,
Constants::RUN_TO_LINE1, cppDebuggercontext); Constants::RUN_TO_LINE1, cppDebuggercontext);
cmd->setDefaultKeySequence(QKeySequence(Constants::RUN_TO_LINE_KEY)); cmd->setDefaultKeySequence(QKeySequence(Constants::RUN_TO_LINE_KEY));
cmd->setAttribute(Command::CA_Hide); cmd->setAttribute(Command::CA_Hide);
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
cmd = am->registerAction(m_actions.runToFunctionAction, cmd = am->registerAction(m_actions.runToFunctionAction,
Constants::RUN_TO_FUNCTION, cppDebuggercontext); Constants::RUN_TO_FUNCTION, cppDebuggercontext);
cmd->setDefaultKeySequence(QKeySequence(Constants::RUN_TO_FUNCTION_KEY)); cmd->setDefaultKeySequence(QKeySequence(Constants::RUN_TO_FUNCTION_KEY));
cmd->setAttribute(Command::CA_Hide); cmd->setAttribute(Command::CA_Hide);
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
cmd = am->registerAction(m_actions.jumpToLineAction, cmd = am->registerAction(m_actions.jumpToLineAction,
Constants::JUMP_TO_LINE1, cppDebuggercontext); Constants::JUMP_TO_LINE1, cppDebuggercontext);
cmd->setAttribute(Command::CA_Hide); cmd->setAttribute(Command::CA_Hide);
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
cmd = am->registerAction(m_actions.returnFromFunctionAction, cmd = am->registerAction(m_actions.returnFromFunctionAction,
Constants::RETURN_FROM_FUNCTION, cppDebuggercontext); Constants::RETURN_FROM_FUNCTION, cppDebuggercontext);
cmd->setAttribute(Command::CA_Hide); cmd->setAttribute(Command::CA_Hide);
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
cmd = am->registerAction(m_actions.reverseDirectionAction, cmd = am->registerAction(m_actions.reverseDirectionAction,
Constants::REVERSE, cppDebuggercontext); Constants::REVERSE, cppDebuggercontext);
cmd->setDefaultKeySequence(QKeySequence(Constants::REVERSE_KEY)); cmd->setDefaultKeySequence(QKeySequence(Constants::REVERSE_KEY));
cmd->setAttribute(Command::CA_Hide); cmd->setAttribute(Command::CA_Hide);
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
sep = new QAction(this); sep = new QAction(this);
sep->setSeparator(true); sep->setSeparator(true);
cmd = am->registerAction(sep, _("Debugger.Sep.Break"), globalcontext); cmd = am->registerAction(sep, _("Debugger.Sep.Break"), globalcontext);
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
//cmd = am->registerAction(m_actions.snapshotAction, //cmd = am->registerAction(m_actions.snapshotAction,
// Constants::SNAPSHOT, cppDebuggercontext); // Constants::SNAPSHOT, cppDebuggercontext);
//cmd->setDefaultKeySequence(QKeySequence(Constants::SNAPSHOT_KEY)); //cmd->setDefaultKeySequence(QKeySequence(Constants::SNAPSHOT_KEY));
//cmd->setAttribute(Command::CA_Hide); //cmd->setAttribute(Command::CA_Hide);
//m_uiSwitcher->addMenuAction(cmd, CppLanguage); //m_mainWindow->addMenuAction(cmd, CppLanguage);
cmd = am->registerAction(m_actions.frameDownAction, cmd = am->registerAction(m_actions.frameDownAction,
Constants::FRAME_DOWN, cppDebuggercontext); Constants::FRAME_DOWN, cppDebuggercontext);
@@ -3220,13 +3218,13 @@ void DebuggerPluginPrivate::extensionsInitialized()
cmd = am->registerAction(action(OperateByInstruction), cmd = am->registerAction(action(OperateByInstruction),
Constants::OPERATE_BY_INSTRUCTION, cppDebuggercontext); Constants::OPERATE_BY_INSTRUCTION, cppDebuggercontext);
cmd->setAttribute(Command::CA_Hide); cmd->setAttribute(Command::CA_Hide);
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
cmd = am->registerAction(m_actions.breakAction, cmd = am->registerAction(m_actions.breakAction,
Constants::TOGGLE_BREAK, globalcontext); Constants::TOGGLE_BREAK, globalcontext);
cmd->setDefaultKeySequence(QKeySequence(Constants::TOGGLE_BREAK_KEY)); cmd->setDefaultKeySequence(QKeySequence(Constants::TOGGLE_BREAK_KEY));
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
connect(m_actions.breakAction, SIGNAL(triggered()), connect(m_actions.breakAction, SIGNAL(triggered()),
SLOT(toggleBreakpoint())); SLOT(toggleBreakpoint()));
@@ -3235,14 +3233,14 @@ void DebuggerPluginPrivate::extensionsInitialized()
sep = new QAction(this); sep = new QAction(this);
sep->setSeparator(true); sep->setSeparator(true);
cmd = am->registerAction(sep, _("Debugger.Sep.Watch"), globalcontext); cmd = am->registerAction(sep, _("Debugger.Sep.Watch"), globalcontext);
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
cmd = am->registerAction(m_actions.watchAction1, cmd = am->registerAction(m_actions.watchAction1,
Constants::ADD_TO_WATCH1, cppeditorcontext); Constants::ADD_TO_WATCH1, cppeditorcontext);
cmd->action()->setEnabled(true); cmd->action()->setEnabled(true);
//cmd->setDefaultKeySequence(QKeySequence(tr("Ctrl+D,Ctrl+W"))); //cmd->setDefaultKeySequence(QKeySequence(tr("Ctrl+D,Ctrl+W")));
m_uiSwitcher->addMenuAction(cmd, CppLanguage); m_mainWindow->addMenuAction(cmd, CppLanguage);
// Editor context menu // Editor context menu
@@ -3349,8 +3347,8 @@ void DebuggerPluginPrivate::extensionsInitialized()
hbox->addSpacerItem(new QSpacerItem(4, 0)); hbox->addSpacerItem(new QSpacerItem(4, 0));
hbox->addWidget(m_statusLabel, 10); hbox->addWidget(m_statusLabel, 10);
m_uiSwitcher->setToolbar(CppLanguage, toolbarContainer); m_mainWindow->setToolbar(CppLanguage, toolbarContainer);
connect(m_uiSwitcher, connect(m_mainWindow,
SIGNAL(dockResetRequested(Debugger::DebuggerLanguages)), SIGNAL(dockResetRequested(Debugger::DebuggerLanguages)),
SLOT(setSimpleDockWidgetArrangement(Debugger::DebuggerLanguages))); SLOT(setSimpleDockWidgetArrangement(Debugger::DebuggerLanguages)));
@@ -3359,7 +3357,7 @@ void DebuggerPluginPrivate::extensionsInitialized()
SLOT(enableReverseDebuggingTriggered(QVariant))); SLOT(enableReverseDebuggingTriggered(QVariant)));
// UI Switcher // UI Switcher
connect(m_uiSwitcher, connect(m_mainWindow,
SIGNAL(activeLanguagesChanged(Debugger::DebuggerLanguages)), SIGNAL(activeLanguagesChanged(Debugger::DebuggerLanguages)),
SLOT(languagesChanged(Debugger::DebuggerLanguages))); SLOT(languagesChanged(Debugger::DebuggerLanguages)));
@@ -3377,7 +3375,7 @@ void DebuggerPluginPrivate::extensionsInitialized()
QTC_ASSERT(m_coreSettings, /**/); QTC_ASSERT(m_coreSettings, /**/);
m_watchersWindow->setVisible(false); m_watchersWindow->setVisible(false);
m_returnWindow->setVisible(false); m_returnWindow->setVisible(false);
connect(m_uiSwitcher, SIGNAL(memoryEditorRequested()), connect(m_mainWindow, SIGNAL(memoryEditorRequested()),
SLOT(openMemoryEditor())); SLOT(openMemoryEditor()));
// time gdb -i mi -ex 'debuggerplugin.cpp:800' -ex r -ex q bin/qtcreator.bin // time gdb -i mi -ex 'debuggerplugin.cpp:800' -ex r -ex q bin/qtcreator.bin
@@ -3524,9 +3522,9 @@ bool DebuggerPlugin::isActiveDebugLanguage(int language)
return theDebuggerCore->isActiveDebugLanguage(language); return theDebuggerCore->isActiveDebugLanguage(language);
} }
DebuggerUISwitcher *DebuggerPlugin::uiSwitcher() DebuggerMainWindow *DebuggerPlugin::mainWindow()
{ {
return theDebuggerCore->m_uiSwitcher; return theDebuggerCore->m_mainWindow;
} }

4
src/plugins/debugger/debuggerplugin.h
View File

@@ -45,7 +45,7 @@ namespace Debugger {
class DebuggerRunControl; class DebuggerRunControl;
class DebuggerStartParameters; class DebuggerStartParameters;
class DebuggerUISwitcher; class DebuggerMainWindow;
// This is the "external" interface of the debugger plugin that's // This is the "external" interface of the debugger plugin that's
// visible from Creator core. The internal interfact to global // visible from Creator core. The internal interfact to global
@@ -65,7 +65,7 @@ public:
static void startDebugger(ProjectExplorer::RunControl *runControl); static void startDebugger(ProjectExplorer::RunControl *runControl);
static void displayDebugger(ProjectExplorer::RunControl *runControl); static void displayDebugger(ProjectExplorer::RunControl *runControl);
static bool isActiveDebugLanguage(int language); static bool isActiveDebugLanguage(int language);
static DebuggerUISwitcher *uiSwitcher(); static DebuggerMainWindow *mainWindow();
private: private:
// IPlugin implementation. // IPlugin implementation.

184
src/plugins/debugger/debuggeruiswitcher.cpp
View File

@@ -28,11 +28,11 @@
**************************************************************************/ **************************************************************************/
#include "debuggeruiswitcher.h" #include "debuggeruiswitcher.h"
#include "debuggermainwindow.h"
#include "debuggerplugin.h" #include "debuggerplugin.h"
#include <utils/styledbar.h> #include <utils/styledbar.h>
#include <utils/qtcassert.h> #include <utils/qtcassert.h>
#include <utils/fancymainwindow.h>
#include <coreplugin/actionmanager/actioncontainer.h> #include <coreplugin/actionmanager/actioncontainer.h>
#include <coreplugin/actionmanager/actionmanager.h> #include <coreplugin/actionmanager/actionmanager.h>
@@ -55,17 +55,18 @@
#include <projectexplorer/target.h> #include <projectexplorer/target.h>
#include <projectexplorer/runconfiguration.h> #include <projectexplorer/runconfiguration.h>
#include <QtGui/QStackedWidget>
#include <QtGui/QVBoxLayout>
#include <QtGui/QMenu>
#include <QtGui/QDockWidget>
#include <QtGui/QResizeEvent>
#include <QtCore/QDebug> #include <QtCore/QDebug>
#include <QtCore/QList> #include <QtCore/QList>
#include <QtCore/QMap> #include <QtCore/QMap>
#include <QtCore/QPair> #include <QtCore/QPair>
#include <QtCore/QSettings> #include <QtCore/QSettings>
#include <QtGui/QDockWidget>
#include <QtGui/QMenu>
#include <QtGui/QResizeEvent>
#include <QtGui/QStackedWidget>
#include <QtGui/QVBoxLayout>
using namespace Core; using namespace Core;
namespace Debugger { namespace Debugger {
@@ -98,14 +99,16 @@ bool DockWidgetEventFilter::eventFilter(QObject *obj, QEvent *event)
return QObject::eventFilter(obj, event); return QObject::eventFilter(obj, event);
} }
}
// first: language id, second: menu item // first: language id, second: menu item
typedef QPair<DebuggerLanguage, QAction *> ViewsMenuItems; typedef QPair<DebuggerLanguage, QAction *> ViewsMenuItems;
struct DebuggerUISwitcherPrivate class DebuggerMainWindowPrivate
{ {
explicit DebuggerUISwitcherPrivate(DebuggerUISwitcher *q); public:
explicit DebuggerMainWindowPrivate(DebuggerMainWindow *mainWindow);
public:
DebuggerMainWindow *q;
QList<ViewsMenuItems> m_viewsMenuItems; QList<ViewsMenuItems> m_viewsMenuItems;
QList<QDockWidget *> m_dockWidgets; QList<QDockWidget *> m_dockWidgets;
@@ -119,7 +122,6 @@ struct DebuggerUISwitcherPrivate
int m_languageCount; int m_languageCount;
QStackedWidget *m_toolbarStack; QStackedWidget *m_toolbarStack;
Internal::DebuggerMainWindow *m_mainWindow;
QHash<DebuggerLanguage, Context> m_contextsForLanguage; QHash<DebuggerLanguage, Context> m_contextsForLanguage;
@@ -143,8 +145,9 @@ struct DebuggerUISwitcherPrivate
QSettings *m_settings; QSettings *m_settings;
}; };
DebuggerUISwitcherPrivate::DebuggerUISwitcherPrivate(DebuggerUISwitcher *q) DebuggerMainWindowPrivate::DebuggerMainWindowPrivate(DebuggerMainWindow *mw)
: m_resizeEventFilter(new Internal::DockWidgetEventFilter(q)) : q(mw)
, m_resizeEventFilter(new Internal::DockWidgetEventFilter(mw))
, m_supportedLanguages(AnyLanguage) , m_supportedLanguages(AnyLanguage)
, m_languageCount(0) , m_languageCount(0)
, m_toolbarStack(new QStackedWidget) , m_toolbarStack(new QStackedWidget)
@@ -160,22 +163,27 @@ DebuggerUISwitcherPrivate::DebuggerUISwitcherPrivate(DebuggerUISwitcher *q)
{ {
} }
DebuggerUISwitcher::DebuggerUISwitcher(QObject *parent) } // namespace Internal
: QObject(parent), d(new DebuggerUISwitcherPrivate(this))
{}
DebuggerUISwitcher::~DebuggerUISwitcher() using namespace Internal;
DebuggerMainWindow::DebuggerMainWindow()
{
d = new DebuggerMainWindowPrivate(this);
}
DebuggerMainWindow::~DebuggerMainWindow()
{ {
delete d; delete d;
} }
void DebuggerUISwitcher::updateUiOnFileListChange() void DebuggerMainWindow::updateUiOnFileListChange()
{ {
if (d->m_previousProject) if (d->m_previousProject)
updateUiForTarget(d->m_previousProject.data()->activeTarget()); updateUiForTarget(d->m_previousProject.data()->activeTarget());
} }
void DebuggerUISwitcher::updateUiForProject(ProjectExplorer::Project *project) void DebuggerMainWindow::updateUiForProject(ProjectExplorer::Project *project)
{ {
if (!project) if (!project)
return; return;
@@ -192,7 +200,7 @@ void DebuggerUISwitcher::updateUiForProject(ProjectExplorer::Project *project)
updateUiForTarget(project->activeTarget()); updateUiForTarget(project->activeTarget());
} }
void DebuggerUISwitcher::updateUiForTarget(ProjectExplorer::Target *target) void DebuggerMainWindow::updateUiForTarget(ProjectExplorer::Target *target)
{ {
if (!target) if (!target)
return; return;
@@ -210,7 +218,7 @@ void DebuggerUISwitcher::updateUiForTarget(ProjectExplorer::Target *target)
} }
// updates default debug language settings per run config. // updates default debug language settings per run config.
void DebuggerUISwitcher::updateUiForRunConfiguration(ProjectExplorer::RunConfiguration *rc) void DebuggerMainWindow::updateUiForRunConfiguration(ProjectExplorer::RunConfiguration *rc)
{ {
if (rc) { if (rc) {
if (d->m_previousRunConfiguration) { if (d->m_previousRunConfiguration) {
@@ -227,12 +235,12 @@ void DebuggerUISwitcher::updateUiForRunConfiguration(ProjectExplorer::RunConfigu
} }
} }
void DebuggerUISwitcher::updateUiForCurrentRunConfiguration() void DebuggerMainWindow::updateUiForCurrentRunConfiguration()
{ {
updateActiveLanguages(); updateActiveLanguages();
} }
void DebuggerUISwitcher::updateActiveLanguages() void DebuggerMainWindow::updateActiveLanguages()
{ {
DebuggerLanguages newLanguages = AnyLanguage; DebuggerLanguages newLanguages = AnyLanguage;
@@ -251,27 +259,27 @@ void DebuggerUISwitcher::updateActiveLanguages()
updateUi(); updateUi();
} }
DebuggerLanguages DebuggerUISwitcher::supportedLanguages() const DebuggerLanguages DebuggerMainWindow::supportedLanguages() const
{ {
return d->m_supportedLanguages; return d->m_supportedLanguages;
} }
void DebuggerUISwitcher::addMenuAction(Command *command, void DebuggerMainWindow::addMenuAction(Command *command,
const DebuggerLanguage &language, const QString &group) const DebuggerLanguage &language, const QString &group)
{ {
d->m_debugMenu->addAction(command, group); d->m_debugMenu->addAction(command, group);
d->m_menuCommands.insert(language, command); d->m_menuCommands.insert(language, command);
} }
DebuggerLanguages DebuggerUISwitcher::activeDebugLanguages() const DebuggerLanguages DebuggerMainWindow::activeDebugLanguages() const
{ {
return d->m_activeDebugLanguages; return d->m_activeDebugLanguages;
} }
void DebuggerUISwitcher::onModeChanged(IMode *mode) void DebuggerMainWindow::onModeChanged(IMode *mode)
{ {
d->m_inDebugMode = (mode->id() == Constants::MODE_DEBUG); d->m_inDebugMode = (mode->id() == Constants::MODE_DEBUG);
d->m_mainWindow->setDockActionsVisible(d->m_inDebugMode); setDockActionsVisible(d->m_inDebugMode);
hideInactiveWidgets(); hideInactiveWidgets();
if (mode->id() != Constants::MODE_DEBUG) if (mode->id() != Constants::MODE_DEBUG)
@@ -281,7 +289,7 @@ void DebuggerUISwitcher::onModeChanged(IMode *mode)
updateActiveLanguages(); updateActiveLanguages();
} }
void DebuggerUISwitcher::hideInactiveWidgets() void DebuggerMainWindow::hideInactiveWidgets()
{ {
// Hide all the debugger windows if mode is different. // Hide all the debugger windows if mode is different.
if (d->m_inDebugMode) if (d->m_inDebugMode)
@@ -293,7 +301,7 @@ void DebuggerUISwitcher::hideInactiveWidgets()
} }
} }
void DebuggerUISwitcher::createViewsMenuItems() void DebuggerMainWindow::createViewsMenuItems()
{ {
ICore *core = ICore::instance(); ICore *core = ICore::instance();
ActionManager *am = core->actionManager(); ActionManager *am = core->actionManager();
@@ -310,21 +318,21 @@ void DebuggerUISwitcher::createViewsMenuItems()
Core::Id("Debugger.Views.OpenMemoryEditor"), Core::Id("Debugger.Views.OpenMemoryEditor"),
Core::Context(Constants::C_DEBUGMODE)); Core::Context(Constants::C_DEBUGMODE));
d->m_viewsMenu->addAction(cmd); d->m_viewsMenu->addAction(cmd);
cmd = am->registerAction(d->m_mainWindow->menuSeparator1(), cmd = am->registerAction(menuSeparator1(),
Core::Id("Debugger.Views.Separator1"), globalcontext); Core::Id("Debugger.Views.Separator1"), globalcontext);
d->m_viewsMenu->addAction(cmd); d->m_viewsMenu->addAction(cmd);
cmd = am->registerAction(d->m_mainWindow->toggleLockedAction(), cmd = am->registerAction(toggleLockedAction(),
Core::Id("Debugger.Views.ToggleLocked"), globalcontext); Core::Id("Debugger.Views.ToggleLocked"), globalcontext);
d->m_viewsMenu->addAction(cmd); d->m_viewsMenu->addAction(cmd);
cmd = am->registerAction(d->m_mainWindow->menuSeparator2(), cmd = am->registerAction(menuSeparator2(),
Core::Id("Debugger.Views.Separator2"), globalcontext); Core::Id("Debugger.Views.Separator2"), globalcontext);
d->m_viewsMenu->addAction(cmd); d->m_viewsMenu->addAction(cmd);
cmd = am->registerAction(d->m_mainWindow->resetLayoutAction(), cmd = am->registerAction(resetLayoutAction(),
Core::Id("Debugger.Views.ResetSimple"), globalcontext); Core::Id("Debugger.Views.ResetSimple"), globalcontext);
d->m_viewsMenu->addAction(cmd); d->m_viewsMenu->addAction(cmd);
} }
void DebuggerUISwitcher::addLanguage(const DebuggerLanguage &languageId, const Context &context) void DebuggerMainWindow::addLanguage(const DebuggerLanguage &languageId, const Context &context)
{ {
bool activate = (d->m_supportedLanguages == AnyLanguage); bool activate = (d->m_supportedLanguages == AnyLanguage);
d->m_supportedLanguages = d->m_supportedLanguages | languageId; d->m_supportedLanguages = d->m_supportedLanguages | languageId;
@@ -339,7 +347,7 @@ void DebuggerUISwitcher::addLanguage(const DebuggerLanguage &languageId, const C
updateUi(); updateUi();
} }
void DebuggerUISwitcher::updateUi() void DebuggerMainWindow::updateUi()
{ {
if (d->m_changingUI || !d->m_initialized || !d->m_inDebugMode) if (d->m_changingUI || !d->m_initialized || !d->m_inDebugMode)
return; return;
@@ -357,7 +365,7 @@ void DebuggerUISwitcher::updateUi()
d->m_changingUI = false; d->m_changingUI = false;
} }
void DebuggerUISwitcher::activateQmlCppLayout() void DebuggerMainWindow::activateQmlCppLayout()
{ {
ICore *core = ICore::instance(); ICore *core = ICore::instance();
Context qmlCppContext = d->m_contextsForLanguage.value(QmlLanguage); Context qmlCppContext = d->m_contextsForLanguage.value(QmlLanguage);
@@ -367,18 +375,18 @@ void DebuggerUISwitcher::activateQmlCppLayout()
d->m_toolbarStack->setCurrentWidget(d->m_toolBars.value(CppLanguage)); d->m_toolbarStack->setCurrentWidget(d->m_toolBars.value(CppLanguage));
if (d->m_previousDebugLanguages & QmlLanguage) { if (d->m_previousDebugLanguages & QmlLanguage) {
d->m_dockWidgetActiveStateQmlCpp = d->m_mainWindow->saveSettings(); d->m_dockWidgetActiveStateQmlCpp = saveSettings();
core->updateAdditionalContexts(qmlCppContext, Context()); core->updateAdditionalContexts(qmlCppContext, Context());
} else if (d->m_previousDebugLanguages & CppLanguage) { } else if (d->m_previousDebugLanguages & CppLanguage) {
d->m_dockWidgetActiveStateCpp = d->m_mainWindow->saveSettings(); d->m_dockWidgetActiveStateCpp = saveSettings();
core->updateAdditionalContexts(d->m_contextsForLanguage.value(CppLanguage), Context()); core->updateAdditionalContexts(d->m_contextsForLanguage.value(CppLanguage), Context());
} }
d->m_mainWindow->restoreSettings(d->m_dockWidgetActiveStateQmlCpp); restoreSettings(d->m_dockWidgetActiveStateQmlCpp);
core->updateAdditionalContexts(Context(), qmlCppContext); core->updateAdditionalContexts(Context(), qmlCppContext);
} }
void DebuggerUISwitcher::activateCppLayout() void DebuggerMainWindow::activateCppLayout()
{ {
ICore *core = ICore::instance(); ICore *core = ICore::instance();
Context qmlCppContext = d->m_contextsForLanguage.value(QmlLanguage); Context qmlCppContext = d->m_contextsForLanguage.value(QmlLanguage);
@@ -386,67 +394,62 @@ void DebuggerUISwitcher::activateCppLayout()
d->m_toolbarStack->setCurrentWidget(d->m_toolBars.value(CppLanguage)); d->m_toolbarStack->setCurrentWidget(d->m_toolBars.value(CppLanguage));
if (d->m_previousDebugLanguages & QmlLanguage) { if (d->m_previousDebugLanguages & QmlLanguage) {
d->m_dockWidgetActiveStateQmlCpp = d->m_mainWindow->saveSettings(); d->m_dockWidgetActiveStateQmlCpp = saveSettings();
core->updateAdditionalContexts(qmlCppContext, Context()); core->updateAdditionalContexts(qmlCppContext, Context());
} else if (d->m_previousDebugLanguages & CppLanguage) { } else if (d->m_previousDebugLanguages & CppLanguage) {
d->m_dockWidgetActiveStateCpp = d->m_mainWindow->saveSettings(); d->m_dockWidgetActiveStateCpp = saveSettings();
core->updateAdditionalContexts(d->m_contextsForLanguage.value(CppLanguage), Context()); core->updateAdditionalContexts(d->m_contextsForLanguage.value(CppLanguage), Context());
} }
d->m_mainWindow->restoreSettings(d->m_dockWidgetActiveStateCpp); restoreSettings(d->m_dockWidgetActiveStateCpp);
const Context &cppContext = d->m_contextsForLanguage.value(CppLanguage); const Context &cppContext = d->m_contextsForLanguage.value(CppLanguage);
core->updateAdditionalContexts(Context(), cppContext); core->updateAdditionalContexts(Context(), cppContext);
} }
void DebuggerUISwitcher::setToolbar(const DebuggerLanguage &language, QWidget *widget) void DebuggerMainWindow::setToolbar(const DebuggerLanguage &language, QWidget *widget)
{ {
Q_ASSERT(d->m_toolBars.contains(language)); Q_ASSERT(d->m_toolBars.contains(language));
d->m_toolBars[language] = widget; d->m_toolBars[language] = widget;
d->m_toolbarStack->addWidget(widget); d->m_toolbarStack->addWidget(widget);
} }
Utils::FancyMainWindow *DebuggerUISwitcher::mainWindow() const QDockWidget *DebuggerMainWindow::breakWindow() const
{
return d->m_mainWindow;
}
QDockWidget *DebuggerUISwitcher::breakWindow() const
{ {
return dockWidget(Constants::DOCKWIDGET_BREAK); return dockWidget(Constants::DOCKWIDGET_BREAK);
} }
QDockWidget *DebuggerUISwitcher::stackWindow() const QDockWidget *DebuggerMainWindow::stackWindow() const
{ {
return dockWidget(Constants::DOCKWIDGET_STACK); return dockWidget(Constants::DOCKWIDGET_STACK);
} }
QDockWidget *DebuggerUISwitcher::watchWindow() const QDockWidget *DebuggerMainWindow::watchWindow() const
{ {
return dockWidget(Constants::DOCKWIDGET_WATCHERS); return dockWidget(Constants::DOCKWIDGET_WATCHERS);
} }
QDockWidget *DebuggerUISwitcher::outputWindow() const QDockWidget *DebuggerMainWindow::outputWindow() const
{ {
return dockWidget(Constants::DOCKWIDGET_OUTPUT); return dockWidget(Constants::DOCKWIDGET_OUTPUT);
} }
QDockWidget *DebuggerUISwitcher::snapshotsWindow() const QDockWidget *DebuggerMainWindow::snapshotsWindow() const
{ {
return dockWidget(Constants::DOCKWIDGET_SNAPSHOTS); return dockWidget(Constants::DOCKWIDGET_SNAPSHOTS);
} }
QDockWidget *DebuggerUISwitcher::threadsWindow() const QDockWidget *DebuggerMainWindow::threadsWindow() const
{ {
return dockWidget(Constants::DOCKWIDGET_THREADS); return dockWidget(Constants::DOCKWIDGET_THREADS);
} }
QDockWidget *DebuggerUISwitcher::qmlInspectorWindow() const QDockWidget *DebuggerMainWindow::qmlInspectorWindow() const
{ {
return dockWidget(Constants::DOCKWIDGET_QML_INSPECTOR); return dockWidget(Constants::DOCKWIDGET_QML_INSPECTOR);
} }
QDockWidget *DebuggerUISwitcher::dockWidget(const QString &objectName) const QDockWidget *DebuggerMainWindow::dockWidget(const QString &objectName) const
{ {
foreach(QDockWidget *dockWidget, d->m_dockWidgets) { foreach(QDockWidget *dockWidget, d->m_dockWidgets) {
if (dockWidget->objectName() == objectName) if (dockWidget->objectName() == objectName)
@@ -458,13 +461,13 @@ QDockWidget *DebuggerUISwitcher::dockWidget(const QString &objectName) const
/*! /*!
Keep track of dock widgets so they can be shown/hidden for different languages Keep track of dock widgets so they can be shown/hidden for different languages
*/ */
QDockWidget *DebuggerUISwitcher::createDockWidget(const DebuggerLanguage &language, QDockWidget *DebuggerMainWindow::createDockWidget(const DebuggerLanguage &language,
QWidget *widget, Qt::DockWidgetArea area) QWidget *widget, Qt::DockWidgetArea area)
{ {
// qDebug() << "CREATE DOCK" << widget->objectName() << "LANGUAGE ID" << language // qDebug() << "CREATE DOCK" << widget->objectName() << "LANGUAGE ID" << language
// << "VISIBLE BY DEFAULT" << ((d->m_activeDebugLanguages & language) ? "true" : "false"); // << "VISIBLE BY DEFAULT" << ((d->m_activeDebugLanguages & language) ? "true" : "false");
QDockWidget *dockWidget = d->m_mainWindow->addDockForWidget(widget); QDockWidget *dockWidget = addDockForWidget(widget);
d->m_mainWindow->addDockWidget(area, dockWidget); addDockWidget(area, dockWidget);
d->m_dockWidgets.append(dockWidget); d->m_dockWidgets.append(dockWidget);
if (!(d->m_activeDebugLanguages & language)) if (!(d->m_activeDebugLanguages & language))
@@ -493,7 +496,7 @@ QDockWidget *DebuggerUISwitcher::createDockWidget(const DebuggerLanguage &langua
return dockWidget; return dockWidget;
} }
QWidget *DebuggerUISwitcher::createContents(IMode *mode) QWidget *DebuggerMainWindow::createContents(IMode *mode)
{ {
ICore *core = ICore::instance(); ICore *core = ICore::instance();
ActionManager *am = core->actionManager(); ActionManager *am = core->actionManager();
@@ -509,12 +512,12 @@ QWidget *DebuggerUISwitcher::createContents(IMode *mode)
d->m_viewsMenu = am->actionContainer(Core::Id(Core::Constants::M_WINDOW_VIEWS)); d->m_viewsMenu = am->actionContainer(Core::Id(Core::Constants::M_WINDOW_VIEWS));
QTC_ASSERT(d->m_viewsMenu, return 0) QTC_ASSERT(d->m_viewsMenu, return 0)
d->m_mainWindow = new Internal::DebuggerMainWindow(this); //d->m_mainWindow = new Internal::DebuggerMainWindow(this);
d->m_mainWindow->setDocumentMode(true); setDocumentMode(true);
d->m_mainWindow->setDockNestingEnabled(true); setDockNestingEnabled(true);
connect(d->m_mainWindow, SIGNAL(resetLayout()), connect(this, SIGNAL(resetLayout()),
SLOT(resetDebuggerLayout())); SLOT(resetDebuggerLayout()));
connect(d->m_mainWindow->toggleLockedAction(), SIGNAL(triggered()), connect(toggleLockedAction(), SIGNAL(triggered()),
SLOT(updateDockWidgetSettings())); SLOT(updateDockWidgetSettings()));
QBoxLayout *editorHolderLayout = new QVBoxLayout; QBoxLayout *editorHolderLayout = new QVBoxLayout;
@@ -547,11 +550,11 @@ QWidget *DebuggerUISwitcher::createContents(IMode *mode)
dock->setFeatures(QDockWidget::NoDockWidgetFeatures); dock->setFeatures(QDockWidget::NoDockWidgetFeatures);
dock->setAllowedAreas(Qt::BottomDockWidgetArea); dock->setAllowedAreas(Qt::BottomDockWidgetArea);
dock->setTitleBarWidget(new QWidget(dock)); dock->setTitleBarWidget(new QWidget(dock));
d->m_mainWindow->addDockWidget(Qt::BottomDockWidgetArea, dock); addDockWidget(Qt::BottomDockWidgetArea, dock);
d->m_mainWindow->setToolBarDockWidget(dock); setToolBarDockWidget(dock);
QWidget *centralWidget = new QWidget; QWidget *centralWidget = new QWidget;
d->m_mainWindow->setCentralWidget(centralWidget); setCentralWidget(centralWidget);
QVBoxLayout *centralLayout = new QVBoxLayout(centralWidget); QVBoxLayout *centralLayout = new QVBoxLayout(centralWidget);
centralWidget->setLayout(centralLayout); centralWidget->setLayout(centralLayout);
@@ -563,7 +566,7 @@ QWidget *DebuggerUISwitcher::createContents(IMode *mode)
// Right-side window with editor, output etc. // Right-side window with editor, output etc.
MiniSplitter *mainWindowSplitter = new MiniSplitter; MiniSplitter *mainWindowSplitter = new MiniSplitter;
mainWindowSplitter->addWidget(d->m_mainWindow); mainWindowSplitter->addWidget(this);
mainWindowSplitter->addWidget(new OutputPanePlaceHolder(mode, mainWindowSplitter)); mainWindowSplitter->addWidget(new OutputPanePlaceHolder(mode, mainWindowSplitter));
mainWindowSplitter->setStretchFactor(0, 10); mainWindowSplitter->setStretchFactor(0, 10);
mainWindowSplitter->setStretchFactor(1, 0); mainWindowSplitter->setStretchFactor(1, 0);
@@ -578,7 +581,7 @@ QWidget *DebuggerUISwitcher::createContents(IMode *mode)
return splitter; return splitter;
} }
void DebuggerUISwitcher::writeSettings() const void DebuggerMainWindow::writeSettings() const
{ {
d->m_settings->beginGroup(QLatin1String("DebugMode.CppMode")); d->m_settings->beginGroup(QLatin1String("DebugMode.CppMode"));
QHashIterator<QString, QVariant> it(d->m_dockWidgetActiveStateCpp); QHashIterator<QString, QVariant> it(d->m_dockWidgetActiveStateCpp);
@@ -597,7 +600,7 @@ void DebuggerUISwitcher::writeSettings() const
d->m_settings->endGroup(); d->m_settings->endGroup();
} }
void DebuggerUISwitcher::readSettings() void DebuggerMainWindow::readSettings()
{ {
d->m_dockWidgetActiveStateCpp.clear(); d->m_dockWidgetActiveStateCpp.clear();
d->m_dockWidgetActiveStateQmlCpp.clear(); d->m_dockWidgetActiveStateQmlCpp.clear();
@@ -625,7 +628,7 @@ void DebuggerUISwitcher::readSettings()
d->m_activeDebugLanguages = langs; d->m_activeDebugLanguages = langs;
} }
void DebuggerUISwitcher::initialize(QSettings *settings) void DebuggerMainWindow::initialize(QSettings *settings)
{ {
d->m_settings = settings; d->m_settings = settings;
createViewsMenuItems(); createViewsMenuItems();
@@ -636,47 +639,60 @@ void DebuggerUISwitcher::initialize(QSettings *settings)
updateUi(); updateUi();
hideInactiveWidgets(); hideInactiveWidgets();
d->m_mainWindow->setDockActionsVisible(false); setDockActionsVisible(false);
d->m_initialized = true; d->m_initialized = true;
} }
void DebuggerUISwitcher::resetDebuggerLayout() void DebuggerMainWindow::resetDebuggerLayout()
{ {
emit dockResetRequested(d->m_activeDebugLanguages); emit dockResetRequested(d->m_activeDebugLanguages);
if (isQmlActive()) if (isQmlActive())
d->m_dockWidgetActiveStateQmlCpp = d->m_mainWindow->saveSettings(); d->m_dockWidgetActiveStateQmlCpp = saveSettings();
else else
d->m_dockWidgetActiveStateCpp = d->m_mainWindow->saveSettings(); d->m_dockWidgetActiveStateCpp = saveSettings();
updateActiveLanguages(); updateActiveLanguages();
} }
void DebuggerUISwitcher::updateDockWidgetSettings() void DebuggerMainWindow::updateDockWidgetSettings()
{ {
if (!d->m_inDebugMode || d->m_changingUI) if (!d->m_inDebugMode || d->m_changingUI)
return; return;
if (isQmlActive()) if (isQmlActive())
d->m_dockWidgetActiveStateQmlCpp = d->m_mainWindow->saveSettings(); d->m_dockWidgetActiveStateQmlCpp = saveSettings();
else else
d->m_dockWidgetActiveStateCpp = d->m_mainWindow->saveSettings(); d->m_dockWidgetActiveStateCpp = saveSettings();
} }
bool DebuggerUISwitcher::isQmlCppActive() const bool DebuggerMainWindow::isQmlCppActive() const
{ {
return (d->m_activeDebugLanguages & CppLanguage) return (d->m_activeDebugLanguages & CppLanguage)
&& (d->m_activeDebugLanguages & QmlLanguage); && (d->m_activeDebugLanguages & QmlLanguage);
} }
bool DebuggerUISwitcher::isQmlActive() const bool DebuggerMainWindow::isQmlActive() const
{ {
return (d->m_activeDebugLanguages & QmlLanguage); return (d->m_activeDebugLanguages & QmlLanguage);
} }
QList<QDockWidget *> DebuggerUISwitcher::dockWidgets() const QMenu *DebuggerMainWindow::createPopupMenu()
{ {
return d->m_dockWidgets; QMenu *menu = 0;
const QList<QDockWidget* > dockwidgets = d->m_dockWidgets;
if (!dockwidgets.isEmpty()) {
menu = FancyMainWindow::createPopupMenu();
foreach (QDockWidget *dockWidget, dockwidgets) {
if (dockWidget->parentWidget() == this)
menu->addAction(dockWidget->toggleViewAction());
}
menu->addSeparator();
}
return menu;
} }
} // namespace Debugger } // namespace Debugger

26
src/plugins/debugger/debuggeruiswitcher.h
View File

@@ -33,11 +33,14 @@
#include "debugger_global.h" #include "debugger_global.h"
#include "debuggerconstants.h" #include "debuggerconstants.h"
#include <utils/fancymainwindow.h>
#include <QtCore/QObject> #include <QtCore/QObject>
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
class QDockWidget; class QDockWidget;
class QSettings; class QSettings;
class QMenu;
QT_END_NAMESPACE QT_END_NAMESPACE
namespace Core { namespace Core {
@@ -46,10 +49,6 @@ class Context;
class IMode; class IMode;
} }
namespace Utils {
class FancyMainWindow;
}
namespace ProjectExplorer { namespace ProjectExplorer {
class Project; class Project;
class Target; class Target;
@@ -57,19 +56,18 @@ class RunConfiguration;
} }
namespace Debugger { namespace Debugger {
struct DebuggerUISwitcherPrivate;
namespace Internal { namespace Internal {
class DebuggerMainWindow; class DebuggerMainWindowPrivate;
}; }
class DEBUGGER_EXPORT DebuggerUISwitcher : public QObject class DEBUGGER_EXPORT DebuggerMainWindow : public Utils::FancyMainWindow
{ {
Q_OBJECT Q_OBJECT
public: public:
explicit DebuggerUISwitcher(QObject *parent = 0); DebuggerMainWindow();
~DebuggerUISwitcher(); ~DebuggerMainWindow();
// debuggable languages are registered with this function. // debuggable languages are registered with this function.
void addLanguage(const DebuggerLanguage &language, const Core::Context &context); void addLanguage(const DebuggerLanguage &language, const Core::Context &context);
@@ -107,8 +105,8 @@ public:
QDockWidget *createDockWidget(const DebuggerLanguage &language, QWidget *widget, QDockWidget *createDockWidget(const DebuggerLanguage &language, QWidget *widget,
Qt::DockWidgetArea area = Qt::TopDockWidgetArea); Qt::DockWidgetArea area = Qt::TopDockWidgetArea);
Utils::FancyMainWindow *mainWindow() const;
QWidget *createContents(Core::IMode *mode); QWidget *createContents(Core::IMode *mode);
QMenu *createPopupMenu();
signals: signals:
// emit when user changes active languages from the menu. // emit when user changes active languages from the menu.
@@ -134,10 +132,6 @@ public slots:
void writeSettings() const; void writeSettings() const;
private: private:
// Used by MainWindow
friend class Internal::DebuggerMainWindow;
QList<QDockWidget *> dockWidgets() const;
void activateQmlCppLayout(); void activateQmlCppLayout();
void activateCppLayout(); void activateCppLayout();
@@ -146,7 +140,7 @@ private:
bool isQmlCppActive() const; bool isQmlCppActive() const;
bool isQmlActive() const; bool isQmlActive() const;
DebuggerUISwitcherPrivate *d; Internal::DebuggerMainWindowPrivate *d;
}; };
} // namespace Debugger } // namespace Debugger

1
src/plugins/debugger/gdb/gdbengine.cpp
View File

@@ -33,7 +33,6 @@
#include "gdboptionspage.h" #include "gdboptionspage.h"
#include "debuggeruiswitcher.h" #include "debuggeruiswitcher.h"
#include "debuggermainwindow.h"
#include "debuggercore.h" #include "debuggercore.h"
#include "debuggerplugin.h" #include "debuggerplugin.h"
#include "debuggerrunner.h" #include "debuggerrunner.h"

29
src/plugins/qmljsinspector/qmljsinspector.cpp
View File

@@ -488,8 +488,7 @@ void InspectorUi::reloadQmlViewer()
void InspectorUi::setSimpleDockWidgetArrangement(const Debugger::DebuggerLanguages &activeLanguages) void InspectorUi::setSimpleDockWidgetArrangement(const Debugger::DebuggerLanguages &activeLanguages)
{ {
Debugger::DebuggerUISwitcher *uiSwitcher = Debugger::DebuggerPlugin::uiSwitcher(); Debugger::DebuggerMainWindow *mw = Debugger::DebuggerPlugin::mainWindow();
Utils::FancyMainWindow *mw = uiSwitcher->mainWindow();
mw->setTrackingEnabled(false); mw->setTrackingEnabled(false);
@@ -502,7 +501,7 @@ void InspectorUi::setSimpleDockWidgetArrangement(const Debugger::DebuggerLanguag
mw->removeDockWidget(dockWidget); mw->removeDockWidget(dockWidget);
} }
foreach (QDockWidget *dockWidget, dockWidgets) { foreach (QDockWidget *dockWidget, dockWidgets) {
if (dockWidget == uiSwitcher->outputWindow()) { if (dockWidget == mw->outputWindow()) {
mw->addDockWidget(Qt::TopDockWidgetArea, dockWidget); mw->addDockWidget(Qt::TopDockWidgetArea, dockWidget);
} else { } else {
mw->addDockWidget(Qt::BottomDockWidgetArea, dockWidget); mw->addDockWidget(Qt::BottomDockWidgetArea, dockWidget);
@@ -515,17 +514,17 @@ void InspectorUi::setSimpleDockWidgetArrangement(const Debugger::DebuggerLanguag
} }
} }
uiSwitcher->stackWindow()->show(); mw->stackWindow()->show();
uiSwitcher->watchWindow()->show(); mw->watchWindow()->show();
uiSwitcher->breakWindow()->show(); mw->breakWindow()->show();
uiSwitcher->threadsWindow()->show(); mw->threadsWindow()->show();
uiSwitcher->snapshotsWindow()->show(); mw->snapshotsWindow()->show();
m_inspectorDockWidget->show(); m_inspectorDockWidget->show();
mw->splitDockWidget(mw->toolBarDockWidget(), uiSwitcher->stackWindow(), Qt::Vertical); mw->splitDockWidget(mw->toolBarDockWidget(), mw->stackWindow(), Qt::Vertical);
mw->splitDockWidget(uiSwitcher->stackWindow(), uiSwitcher->watchWindow(), Qt::Horizontal); mw->splitDockWidget(mw->stackWindow(), mw->watchWindow(), Qt::Horizontal);
mw->tabifyDockWidget(uiSwitcher->watchWindow(), uiSwitcher->breakWindow()); mw->tabifyDockWidget(mw->watchWindow(), mw->breakWindow());
mw->tabifyDockWidget(uiSwitcher->watchWindow(), m_inspectorDockWidget); mw->tabifyDockWidget(mw->watchWindow(), m_inspectorDockWidget);
} }
@@ -594,8 +593,6 @@ bool InspectorUi::addQuotesForData(const QVariant &value) const
void InspectorUi::setupDockWidgets() void InspectorUi::setupDockWidgets()
{ {
Debugger::DebuggerUISwitcher *uiSwitcher = Debugger::DebuggerPlugin::uiSwitcher();
m_toolbar->createActions(Core::Context(Debugger::Constants::C_QMLDEBUGGER)); m_toolbar->createActions(Core::Context(Debugger::Constants::C_QMLDEBUGGER));
m_toolbar->setObjectName("QmlInspectorToolbar"); m_toolbar->setObjectName("QmlInspectorToolbar");
@@ -618,8 +615,8 @@ void InspectorUi::setupDockWidgets()
wlay->addWidget(m_objectTreeWidget); wlay->addWidget(m_objectTreeWidget);
wlay->addWidget(m_crumblePath); wlay->addWidget(m_crumblePath);
Debugger::DebuggerMainWindow *mw = Debugger::DebuggerPlugin::mainWindow();
m_inspectorDockWidget = uiSwitcher->createDockWidget(Debugger::QmlLanguage, m_inspectorDockWidget = mw->createDockWidget(Debugger::QmlLanguage,
observerWidget, Qt::BottomDockWidgetArea); observerWidget, Qt::BottomDockWidgetArea);
m_inspectorDockWidget->setObjectName(Debugger::Constants::DOCKWIDGET_QML_INSPECTOR); m_inspectorDockWidget->setObjectName(Debugger::Constants::DOCKWIDGET_QML_INSPECTOR);
m_inspectorDockWidget->setAllowedAreas(Qt::TopDockWidgetArea | Qt::BottomDockWidgetArea); m_inspectorDockWidget->setAllowedAreas(Qt::TopDockWidgetArea | Qt::BottomDockWidgetArea);