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

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

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

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

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

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

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