feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity
Files
9f8b5af3b20d9fb3d3d2d8bac163de84d143cacd
qt-creator/src/plugins/debugger/snapshothandler.cpp

295 lines
8.2 KiB
C++
Raw Normal View History

debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
/**************************************************************************
**
** This file is part of Qt Creator
**
Long live the king!
2010-03-05 11:25:49 +01:00
** Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
**
** 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 "snapshothandler.h"
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
#include "sessionengine.h"
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
#include "debuggeractions.h"
debugger: move SnapshotHandler from DebuggerManager to DebuggerRunControl
2010-06-15 12:15:25 +02:00
#include "debuggerconstants.h"
debugger: The DebuggerEngine refactoring. This replaces the (de facto) singleton engines and data handlers by classes that are instantiated per run. The DebuggerRunControl will now create an object of (a class derived from) DebuggerEngine that contains all the relevant "dynamic" data. DebuggerManager is no more. The "singleton" bits are merged into DebuggerPlugin, whereas the data bits went to DebuggerEngine. There is no formal notion of a "current" DebuggerEngine. However, as there's only one DebuggerEngine at a time that has its data models connected to the view, there's still some "de facto" notion of a "current" engine. Calling SomeModel::setData(int role, QVariant data) with custom role is used as the primary dispatch mechanism from the views to the "current" data models (and the engine, as all data models know their engine).
2010-06-16 11:08:54 +02:00
#include "debuggerengine.h"
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
#include "debuggerrunner.h"
#include "debuggerplugin.h"
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
#include <utils/qtcassert.h>
Header cleaning spree in Core/Debugger and Symbian/Maemo-code of Qt4.
2010-03-18 10:59:06 +01:00
#include <utils/savedaction.h>
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
#include <QtCore/QAbstractTableModel>
#include <QtCore/QDebug>
#include <QtCore/QFileInfo>
#include <QtCore/QDir>
namespace Debugger {
namespace Internal {
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
#if 0
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
SnapshotData::SnapshotData()
{}
void SnapshotData::clear()
{
m_frames.clear();
m_location.clear();
m_date = QDateTime();
}
QString SnapshotData::function() const
{
if (m_frames.isEmpty())
return QString();
const StackFrame &frame = m_frames.at(0);
return frame.function + ":" + QString::number(frame.line);
}
QString SnapshotData::toString() const
{
QString res;
QTextStream str(&res);
str << SnapshotHandler::tr("Function:") << ' ' << function() << ' '
<< SnapshotHandler::tr("File:") << ' ' << m_location << ' '
<< SnapshotHandler::tr("Date:") << ' ' << m_date.toString();
return res;
}
QString SnapshotData::toToolTip() const
{
QString res;
QTextStream str(&res);
str << "<html><body><table>"
<< "<tr><td>" << SnapshotHandler::tr("Function:")
<< "</td><td>" << function() << "</td></tr>"
<< "<tr><td>" << SnapshotHandler::tr("File:")
<< "</td><td>" << QDir::toNativeSeparators(m_location) << "</td></tr>"
<< "</table></body></html>";
return res;
}
QDebug operator<<(QDebug d, const SnapshotData &f)
{
QString res;
QTextStream str(&res);
str << f.location();
/*
str << "level=" << f.level << " address=" << f.address;
if (!f.function.isEmpty())
str << ' ' << f.function;
if (!f.location.isEmpty())
str << ' ' << f.location << ':' << f.line;
if (!f.from.isEmpty())
str << " from=" << f.from;
if (!f.to.isEmpty())
str << " to=" << f.to;
*/
d.nospace() << res;
return d;
}
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
#endif
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
////////////////////////////////////////////////////////////////////////
//
// SnapshotHandler
//
////////////////////////////////////////////////////////////////////////
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
SnapshotHandler::SnapshotHandler(SessionEngine *engine)
debugger: The DebuggerEngine refactoring. This replaces the (de facto) singleton engines and data handlers by classes that are instantiated per run. The DebuggerRunControl will now create an object of (a class derived from) DebuggerEngine that contains all the relevant "dynamic" data. DebuggerManager is no more. The "singleton" bits are merged into DebuggerPlugin, whereas the data bits went to DebuggerEngine. There is no formal notion of a "current" DebuggerEngine. However, as there's only one DebuggerEngine at a time that has its data models connected to the view, there's still some "de facto" notion of a "current" engine. Calling SomeModel::setData(int role, QVariant data) with custom role is used as the primary dispatch mechanism from the views to the "current" data models (and the engine, as all data models know their engine).
2010-06-16 11:08:54 +02:00
: m_engine(engine),
Avoid pulling in the svg plugin.
2010-03-05 14:30:08 +01:00
m_positionIcon(QIcon(":/debugger/images/location_16.png")),
debugger: remove or rename a few images.
2010-03-22 15:04:24 +01:00
m_emptyIcon(QIcon(":/debugger/images/debugger_empty_14.png"))
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
{
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
m_currentIndex = -1;
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
}
SnapshotHandler::~SnapshotHandler()
{
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
for (int i = m_snapshots.size(); --i >= 0; ) {
debugger: remove finished engines from snapshot list
2010-07-13 17:57:39 +02:00
if (DebuggerEngine *engine = engineAt(i)) {
QString fileName = engine->startParameters().coreFile;
if (!fileName.isEmpty())
QFile::remove(fileName);
}
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
}
}
DebuggerEngine *SnapshotHandler::engineAt(int i) const
{
debugger: remove finished engines from snapshot list
2010-07-13 17:57:39 +02:00
DebuggerEngine *engine = m_snapshots.at(i)->engine();
QTC_ASSERT(engine, qDebug() << "ENGINE AT " << i << "DELETED");
return engine;
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
}
int SnapshotHandler::rowCount(const QModelIndex &parent) const
{
// Since the stack is not a tree, row count is 0 for any valid parent
return parent.isValid() ? 0 : m_snapshots.size();
}
int SnapshotHandler::columnCount(const QModelIndex &parent) const
{
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
return parent.isValid() ? 0 : 2;
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
}
QVariant SnapshotHandler::data(const QModelIndex &index, int role) const
{
if (!index.isValid() || index.row() >= m_snapshots.size())
return QVariant();
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
const DebuggerEngine *engine = engineAt(index.row());
debugger: remove finished engines from snapshot list
2010-07-13 17:57:39 +02:00
if (role == SnapshotCapabilityRole)
return engine && (engine->debuggerCapabilities() & SnapshotCapability);
if (!engine)
return QLatin1String("<finished>");
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
const DebuggerStartParameters &sp = engine->startParameters();
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
if (role == Qt::DisplayRole) {
switch (index.column()) {
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
case 0:
return sp.displayName;
case 1:
return sp.coreFile.isEmpty() ? sp.executable : sp.coreFile;
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
}
return QVariant();
}
if (role == Qt::ToolTipRole) {
//: Tooltip for variable
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
//return snapshot.toToolTip();
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
}
if (role == Qt::DecorationRole && index.column() == 0) {
// Return icon that indicates whether this is the active stack frame
return (index.row() == m_currentIndex) ? m_positionIcon : m_emptyIcon;
}
return QVariant();
}
QVariant SnapshotHandler::headerData(int section, Qt::Orientation orientation, int role) const
{
if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
switch (section) {
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
case 0: return tr("Name");
case 1: return tr("File");
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
};
}
return QVariant();
}
Qt::ItemFlags SnapshotHandler::flags(const QModelIndex &index) const
{
if (index.row() >= m_snapshots.size())
return 0;
if (index.row() == m_snapshots.size())
return QAbstractTableModel::flags(index);
return true ? QAbstractTableModel::flags(index) : Qt::ItemFlags(0);
}
debugger: move SnapshotHandler from DebuggerManager to DebuggerRunControl
2010-06-15 12:15:25 +02:00
bool SnapshotHandler::setData
(const QModelIndex &index, const QVariant &value, int role)
{
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
Q_UNUSED(value);
if (index.isValid() && role == RequestMakeSnapshotRole) {
debugger: remove finished engines from snapshot list
2010-07-13 17:57:39 +02:00
DebuggerEngine *engine = engineAt(index.row());
QTC_ASSERT(engine, return false);
engine->makeSnapshot();
debugger: move SnapshotHandler from DebuggerManager to DebuggerRunControl
2010-06-15 12:15:25 +02:00
return true;
}
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
if (index.isValid() && role == RequestActivateSnapshotRole) {
m_currentIndex = index.row();
qDebug() << "ACTIVATING INDEX: " << m_currentIndex
<< " OF " << size();
DebuggerPlugin::displayDebugger(m_snapshots.at(m_currentIndex));
reset();
debugger: move SnapshotHandler from DebuggerManager to DebuggerRunControl
2010-06-15 12:15:25 +02:00
return true;
}
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
return false;
debugger: move SnapshotHandler from DebuggerManager to DebuggerRunControl
2010-06-15 12:15:25 +02:00
}
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
#if 0
// See http://sourceware.org/bugzilla/show_bug.cgi?id=11241.
setState(EngineSetupRequested);
postCommand("set stack-cache off");
QMessageBox *mb = showMessageBox(QMessageBox::Critical,
tr("Snapshot Reloading"),
tr("In order to load snapshots the debugged process needs "
"to be stopped. Continuation will not be possible afterwards.\n"
"Do you want to stop the debugged process and load the selected "
"snapshot?"), QMessageBox::Ok | QMessageBox::Cancel);
if (mb->exec() == QMessageBox::Cancel)
#endif
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
void SnapshotHandler::removeAll()
{
m_snapshots.clear();
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
m_currentIndex = -1;
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
reset();
}
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
void SnapshotHandler::appendSnapshot(DebuggerRunControl *rc)
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
{
debugger: remove finished engines from snapshot list
2010-07-13 17:57:39 +02:00
//return; // FIXME
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
m_snapshots.append(rc);
m_currentIndex = size() - 1;
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
reset();
}
debugger: remove finished engines from snapshot list
2010-07-13 17:57:39 +02:00
void SnapshotHandler::removeSnapshot(DebuggerRunControl *rc)
{
int index = m_snapshots.indexOf(rc);
QTC_ASSERT(index != -1, return);
removeSnapshot(index);
}
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
void SnapshotHandler::removeSnapshot(int index)
{
debugger: remove finished engines from snapshot list
2010-07-13 17:57:39 +02:00
const DebuggerEngine *engine = engineAt(index);
QTC_ASSERT(engine, return);
QString fileName = engine->startParameters().coreFile;
if (!fileName.isEmpty())
QFile::remove(fileName);
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
m_snapshots.removeAt(index);
if (index == m_currentIndex)
m_currentIndex = -1;
else if (index < m_currentIndex)
--m_currentIndex;
reset();
}
debuygger: make snapshots using true parallel engines
2010-07-13 15:57:34 +02:00
void SnapshotHandler::setCurrentIndex(int index)
debugger: make handling multiple core files a bit more convenient
2010-02-02 17:25:14 +01:00
{
m_currentIndex = index;
reset();
}
} // namespace Internal
} // namespace Debugger
Copy Permalink