Commit c0412867 authored by hjk's avatar hjk Committed by hjk

debugger: split BreakpointIndex into plugin and debugger specific part

Change-Id: I21d10cf42eb039c74475e106537b6e107d155196
Reviewed-on: http://codereview.qt.nokia.com/745Reviewed-by: default avatarhjk <qthjk@ovi.com>
parent c4713f5a
This diff is collapsed.
......@@ -73,20 +73,20 @@ public:
void handleAlienBreakpoint(const BreakpointResponse &response,
DebuggerEngine *engine);
void insertSubBreakpoint(const BreakpointResponse &data);
void removeAlienBreakpoint(BreakpointId id);
void removeAlienBreakpoint(BreakpointModelId id);
BreakpointIds allBreakpointIds() const;
BreakpointIds engineBreakpointIds(DebuggerEngine *engine) const;
BreakpointIds unclaimedBreakpointIds() const;
BreakpointModelIds allBreakpointIds() const;
BreakpointModelIds engineBreakpointIds(DebuggerEngine *engine) const;
BreakpointModelIds unclaimedBreakpointIds() const;
int size() const { return m_storage.size(); }
// Find a breakpoint matching approximately the data in needle.
BreakpointId findSimilarBreakpoint(const BreakpointResponse &needle) const;
BreakpointId findBreakpointByNumber(int bpNumber) const;
BreakpointId findWatchpoint(const BreakpointParameters &data) const;
BreakpointId findBreakpointByFunction(const QString &functionName) const;
BreakpointId findBreakpointByIndex(const QModelIndex &index) const;
BreakpointIds findBreakpointsByIndex(const QList<QModelIndex> &list) const;
BreakpointModelId findSimilarBreakpoint(const BreakpointResponse &needle) const;
BreakpointModelId findBreakpointByResponseId(const BreakpointResponseId &resultId) const;
BreakpointModelId findWatchpoint(const BreakpointParameters &data) const;
BreakpointModelId findBreakpointByFunction(const QString &functionName) const;
BreakpointModelId findBreakpointByIndex(const QModelIndex &index) const;
BreakpointModelIds findBreakpointsByIndex(const QList<QModelIndex> &list) const;
void updateMarkers();
static QIcon breakpointIcon();
......@@ -96,69 +96,69 @@ public:
static QIcon watchpointIcon();
static QIcon tracepointIcon();
BreakpointId findBreakpointByFileAndLine(const QString &fileName,
BreakpointModelId findBreakpointByFileAndLine(const QString &fileName,
int lineNumber, bool useMarkerPosition = true);
BreakpointId findBreakpointByAddress(quint64 address) const;
BreakpointModelId findBreakpointByAddress(quint64 address) const;
void breakByFunction(const QString &functionName);
void removeBreakpoint(BreakpointId id);
QIcon icon(BreakpointId id) const;
void gotoLocation(BreakpointId id) const;
void removeBreakpoint(BreakpointModelId id);
QIcon icon(BreakpointModelId id) const;
void gotoLocation(BreakpointModelId id) const;
// Getter retrieves property value.
// Setter sets property value and triggers update if changed.
BreakpointPathUsage pathUsage(BreakpointId id) const;
void setPathUsage(BreakpointId, const BreakpointPathUsage &u);
QByteArray condition(BreakpointId id) const;
void setCondition(BreakpointId, const QByteArray &condition);
int ignoreCount(BreakpointId id) const;
void setIgnoreCount(BreakpointId, const int &count);
int threadSpec(BreakpointId id) const;
void setThreadSpec(BreakpointId, const int&spec);
QString fileName(BreakpointId id) const;
void setFileName(BreakpointId, const QString &fileName);
QString functionName(BreakpointId id) const;
void setFunctionName(BreakpointId, const QString &functionName);
QString expression(BreakpointId id) const;
void setExpression(BreakpointId, const QString &expression);
BreakpointType type(BreakpointId id) const;
void setType(BreakpointId id, const BreakpointType &type);
quint64 address(BreakpointId id) const;
void setAddress(BreakpointId id, const quint64 &address);
int lineNumber(BreakpointId id) const;
void changeBreakpointData(BreakpointId id, const BreakpointParameters &data,
BreakpointPathUsage pathUsage(BreakpointModelId id) const;
void setPathUsage(BreakpointModelId, const BreakpointPathUsage &u);
QByteArray condition(BreakpointModelId id) const;
void setCondition(BreakpointModelId, const QByteArray &condition);
int ignoreCount(BreakpointModelId id) const;
void setIgnoreCount(BreakpointModelId, const int &count);
int threadSpec(BreakpointModelId id) const;
void setThreadSpec(BreakpointModelId, const int&spec);
QString fileName(BreakpointModelId id) const;
void setFileName(BreakpointModelId, const QString &fileName);
QString functionName(BreakpointModelId id) const;
void setFunctionName(BreakpointModelId, const QString &functionName);
QString expression(BreakpointModelId id) const;
void setExpression(BreakpointModelId, const QString &expression);
BreakpointType type(BreakpointModelId id) const;
void setType(BreakpointModelId id, const BreakpointType &type);
quint64 address(BreakpointModelId id) const;
void setAddress(BreakpointModelId id, const quint64 &address);
int lineNumber(BreakpointModelId id) const;
void changeBreakpointData(BreakpointModelId id, const BreakpointParameters &data,
BreakpointParts parts);
const BreakpointParameters &breakpointData(BreakpointId id) const;
BreakpointState state(BreakpointId id) const;
bool isEnabled(BreakpointId id) const;
void setEnabled(BreakpointId id, bool on);
void updateLineNumberFromMarker(BreakpointId id, int lineNumber);
void setMarkerFileAndLine(BreakpointId id,
const BreakpointParameters &breakpointData(BreakpointModelId id) const;
BreakpointState state(BreakpointModelId id) const;
bool isEnabled(BreakpointModelId id) const;
void setEnabled(BreakpointModelId id, bool on);
void updateLineNumberFromMarker(BreakpointModelId id, int lineNumber);
void setMarkerFileAndLine(BreakpointModelId id,
const QString &fileName, int lineNumber);
bool isWatchpoint(BreakpointId id) const;
bool isTracepoint(BreakpointId id) const;
void setTracepoint(BreakpointId, bool on);
DebuggerEngine *engine(BreakpointId id) const;
void setEngine(BreakpointId id, DebuggerEngine *engine);
const BreakpointResponse &response(BreakpointId id) const;
void setResponse(BreakpointId id, const BreakpointResponse &data);
bool needsChange(BreakpointId id) const;
bool isWatchpoint(BreakpointModelId id) const;
bool isTracepoint(BreakpointModelId id) const;
void setTracepoint(BreakpointModelId, bool on);
DebuggerEngine *engine(BreakpointModelId id) const;
void setEngine(BreakpointModelId id, DebuggerEngine *engine);
const BreakpointResponse &response(BreakpointModelId id) const;
void setResponse(BreakpointModelId id, const BreakpointResponse &data);
bool needsChange(BreakpointModelId id) const;
// State transitions.
void notifyBreakpointChangeAfterInsertNeeded(BreakpointId id);
void notifyBreakpointInsertProceeding(BreakpointId id);
void notifyBreakpointInsertOk(BreakpointId id);
void notifyBreakpointInsertFailed(BreakpointId id);
void notifyBreakpointChangeOk(BreakpointId id);
void notifyBreakpointChangeProceeding(BreakpointId id);
void notifyBreakpointChangeFailed(BreakpointId id);
void notifyBreakpointPending(BreakpointId id);
void notifyBreakpointRemoveProceeding(BreakpointId id);
void notifyBreakpointRemoveOk(BreakpointId id);
void notifyBreakpointRemoveFailed(BreakpointId id);
void notifyBreakpointReleased(BreakpointId id);
void notifyBreakpointNeedsReinsertion(BreakpointId id);
void notifyBreakpointAdjusted(BreakpointId id,
void notifyBreakpointChangeAfterInsertNeeded(BreakpointModelId id);
void notifyBreakpointInsertProceeding(BreakpointModelId id);
void notifyBreakpointInsertOk(BreakpointModelId id);
void notifyBreakpointInsertFailed(BreakpointModelId id);
void notifyBreakpointChangeOk(BreakpointModelId id);
void notifyBreakpointChangeProceeding(BreakpointModelId id);
void notifyBreakpointChangeFailed(BreakpointModelId id);
void notifyBreakpointPending(BreakpointModelId id);
void notifyBreakpointRemoveProceeding(BreakpointModelId id);
void notifyBreakpointRemoveOk(BreakpointModelId id);
void notifyBreakpointRemoveFailed(BreakpointModelId id);
void notifyBreakpointReleased(BreakpointModelId id);
void notifyBreakpointNeedsReinsertion(BreakpointModelId id);
void notifyBreakpointAdjusted(BreakpointModelId id,
const BreakpointParameters &data);
static QString displayFromThreadSpec(int spec);
......@@ -176,14 +176,14 @@ private:
QModelIndex createIndex(int row, int column, quint32 id) const;
QModelIndex createIndex(int row, int column, void *ptr) const;
int indexOf(BreakpointId id) const;
BreakpointId at(int index) const;
bool isEngineRunning(BreakpointId id) const;
void setState(BreakpointId id, BreakpointState state);
int indexOf(BreakpointModelId id) const;
BreakpointModelId at(int index) const;
bool isEngineRunning(BreakpointModelId id) const;
void setState(BreakpointModelId id, BreakpointState state);
void loadBreakpoints();
void saveBreakpoints();
void updateMarker(BreakpointId id);
void cleanupBreakpoint(BreakpointId id);
void updateMarker(BreakpointModelId id);
void cleanupBreakpoint(BreakpointModelId id);
struct BreakpointItem
{
......@@ -205,7 +205,7 @@ private:
BreakpointMarker *marker;
QList<BreakpointResponse> subItems;
};
typedef QHash<BreakpointId, BreakpointItem> BreakpointStorage;
typedef QHash<BreakpointModelId, BreakpointItem> BreakpointStorage;
typedef BreakpointStorage::ConstIterator ConstIterator;
typedef BreakpointStorage::Iterator Iterator;
BreakpointStorage m_storage;
......
......@@ -42,11 +42,72 @@ namespace Internal {
//////////////////////////////////////////////////////////////////
//
// BreakpointId
// BreakpointModelId
//
//////////////////////////////////////////////////////////////////
BreakpointId::BreakpointId(const QByteArray &ba)
/*!
\class Debugger::Internal::ModelId
This identifies a breakpoint in the \c BreakHandler. The
major parts are strictly increasing over time.
*/
QDebug operator<<(QDebug d, const BreakpointModelId &id)
{
d << qPrintable(id.toString());
return d;
}
QByteArray BreakpointModelId::toByteArray() const
{
if (!isValid())
return "<invalid bkpt>";
QByteArray ba = QByteArray::number(m_majorPart);
if (isMinor()) {
ba.append('.');
ba.append(QByteArray::number(m_minorPart));
}
return ba;
}
QString BreakpointModelId::toString() const
{
if (!isValid())
return "<invalid bkpt>";
if (isMinor())
return QString("%1.%2").arg(m_majorPart).arg(m_minorPart);
return QString::number(m_majorPart);
}
BreakpointModelId BreakpointModelId::parent() const
{
QTC_ASSERT(isMinor(), return BreakpointModelId());
return BreakpointModelId(m_majorPart, 0);
}
BreakpointModelId BreakpointModelId::child(int row) const
{
QTC_ASSERT(isMajor(), return BreakpointModelId());
return BreakpointModelId(m_majorPart, row + 1);
}
//////////////////////////////////////////////////////////////////
//
// BreakpointResponseId
//
//////////////////////////////////////////////////////////////////
/*!
\class Debugger::Internal::BreakpointResponseId
This is what the external debuggers use to identify a breakpoint.
It is only valid for one debugger run.
*/
BreakpointResponseId::BreakpointResponseId(const QByteArray &ba)
{
int pos = ba.indexOf('.');
if (pos == -1) {
......@@ -58,13 +119,13 @@ BreakpointId::BreakpointId(const QByteArray &ba)
}
}
QDebug operator<<(QDebug d, const BreakpointId &id)
QDebug operator<<(QDebug d, const BreakpointResponseId &id)
{
d << qPrintable(id.toString());
return d;
}
QByteArray BreakpointId::toByteArray() const
QByteArray BreakpointResponseId::toByteArray() const
{
if (!isValid())
return "<invalid bkpt>";
......@@ -76,7 +137,7 @@ QByteArray BreakpointId::toByteArray() const
return ba;
}
QString BreakpointId::toString() const
QString BreakpointResponseId::toString() const
{
if (!isValid())
return "<invalid bkpt>";
......@@ -85,16 +146,16 @@ QString BreakpointId::toString() const
return QString::number(m_majorPart);
}
BreakpointId BreakpointId::parent() const
BreakpointResponseId BreakpointResponseId::parent() const
{
QTC_ASSERT(isMinor(), return BreakpointId());
return BreakpointId(m_majorPart, 0);
QTC_ASSERT(isMinor(), return BreakpointResponseId());
return BreakpointResponseId(m_majorPart, 0);
}
BreakpointId BreakpointId::child(int row) const
BreakpointResponseId BreakpointResponseId::child(int row) const
{
QTC_ASSERT(isMajor(), return BreakpointId());
return BreakpointId(m_majorPart, row + 1);
QTC_ASSERT(isMajor(), return BreakpointResponseId());
return BreakpointResponseId(m_majorPart, row + 1);
}
//////////////////////////////////////////////////////////////////
......@@ -251,8 +312,6 @@ QString BreakpointResponse::toString() const
ts << " Function: " << functionName;
if (multiple)
ts << " Multiple: " << multiple;
if (!extra.isEmpty())
ts << " Extra: " << extra;
if (correctedLineNumber)
ts << " CorrectedLineNumber: " << correctedLineNumber;
ts << " Hit: " << hitCount << " times";
......@@ -263,10 +322,9 @@ QString BreakpointResponse::toString() const
void BreakpointResponse::fromParameters(const BreakpointParameters &p)
{
BreakpointParameters::operator=(p);
id = BreakpointId();
id = BreakpointResponseId();
fullName.clear();
multiple = false;
extra.clear();
correctedLineNumber = 0;
hitCount = 0;
}
......
......@@ -41,13 +41,19 @@
namespace Debugger {
namespace Internal {
class BreakpointId
//////////////////////////////////////////////////////////////////
//
// BreakpointModelId
//
//////////////////////////////////////////////////////////////////
class BreakpointModelId
{
public:
BreakpointId() { m_majorPart = m_minorPart = 0; }
explicit BreakpointId(quint16 ma) { m_majorPart = ma; m_minorPart = 0; }
BreakpointId(quint16 ma, quint16 mi) { m_majorPart = ma; m_minorPart = mi; }
explicit BreakpointId(const QByteArray &ba); // "21.2"
BreakpointModelId() { m_majorPart = m_minorPart = 0; }
explicit BreakpointModelId(quint16 ma) { m_majorPart = ma; m_minorPart = 0; }
BreakpointModelId(quint16 ma, quint16 mi) { m_majorPart = ma; m_minorPart = mi; }
explicit BreakpointModelId(const QByteArray &ba); // "21.2"
bool isValid() const { return m_majorPart != 0; }
bool isMajor() const { return m_majorPart != 0 && m_minorPart == 0; }
......@@ -57,22 +63,60 @@ public:
quint32 toInternalId() const { return m_majorPart | (m_minorPart << 16); }
QByteArray toByteArray() const;
QString toString() const;
bool operator==(const BreakpointId &id) const
bool operator==(const BreakpointModelId &id) const
{ return m_majorPart == id.m_majorPart && m_minorPart == id.m_minorPart; }
quint16 majorPart() const { return m_majorPart; }
quint16 minorPart() const { return m_minorPart; }
BreakpointId parent() const;
BreakpointId child(int row) const;
BreakpointModelId parent() const;
BreakpointModelId child(int row) const;
static BreakpointModelId fromInternalId(quint32 id)
{ return BreakpointModelId(id & 0xff, id >> 16); }
private:
quint16 m_majorPart;
quint16 m_minorPart;
};
QDebug operator<<(QDebug d, const BreakpointModelId &id);
//////////////////////////////////////////////////////////////////
//
// BreakpointResponseId
//
//////////////////////////////////////////////////////////////////
class BreakpointResponseId
{
public:
BreakpointResponseId() { m_majorPart = m_minorPart = 0; }
explicit BreakpointResponseId(quint16 ma) { m_majorPart = ma; m_minorPart = 0; }
BreakpointResponseId(quint16 ma, quint16 mi) { m_majorPart = ma; m_minorPart = mi; }
explicit BreakpointResponseId(const QByteArray &ba); // "21.2"
static BreakpointId fromInternalId(quint32 id)
{ return BreakpointId(id & 0xff, id >> 16); }
bool isValid() const { return m_majorPart != 0; }
bool isMajor() const { return m_majorPart != 0 && m_minorPart == 0; }
bool isMinor() const { return m_majorPart != 0 && m_minorPart != 0; }
bool operator!() const { return !isValid(); }
operator const void*() const { return isValid() ? this : 0; }
quint32 toInternalId() const { return m_majorPart | (m_minorPart << 16); }
QByteArray toByteArray() const;
QString toString() const;
bool operator==(const BreakpointResponseId &id) const
{ return m_majorPart == id.m_majorPart && m_minorPart == id.m_minorPart; }
quint16 majorPart() const { return m_majorPart; }
quint16 minorPart() const { return m_minorPart; }
BreakpointResponseId parent() const;
BreakpointResponseId child(int row) const;
private:
quint16 m_majorPart;
quint16 m_minorPart;
};
QDebug operator<<(QDebug d, const BreakpointId &id);
QDebug operator<<(QDebug d, const BreakpointModelId &id);
QDebug operator<<(QDebug d, const BreakpointResponseId &id);
//////////////////////////////////////////////////////////////////
//
......@@ -197,18 +241,17 @@ public:
public:
void fromParameters(const BreakpointParameters &p);
BreakpointId id; //!< Breakpoint number assigned by the debugger engine.
bool pending; //!< Breakpoint not fully resolved.
int hitCount; //!< Number of times this has been hit.
QString fullName; //!< Full file name acknowledged by the debugger engine.
bool multiple; //!< Happens in constructors/gdb.
QByteArray extra; //!< gdb: <PENDING>, <MULTIPLE>
BreakpointResponseId id; //!< Breakpoint number assigned by the debugger engine.
bool pending; //!< Breakpoint not fully resolved.
int hitCount; //!< Number of times this has been hit.
QString fullName; //!< Full file name acknowledged by the debugger engine.
bool multiple; //!< Happens in constructors/gdb.
int correctedLineNumber; //!< Line number as seen by gdb.
};
typedef QList<BreakpointId> BreakpointIds;
typedef QList<BreakpointModelId> BreakpointModelIds;
inline uint qHash(const Debugger::Internal::BreakpointId &id)
inline uint qHash(const Debugger::Internal::BreakpointModelId &id)
{
return id.toInternalId();
}
......@@ -216,7 +259,8 @@ inline uint qHash(const Debugger::Internal::BreakpointId &id)
} // namespace Internal
} // namespace Debugger
Q_DECLARE_METATYPE(Debugger::Internal::BreakpointId)
Q_DECLARE_METATYPE(Debugger::Internal::BreakpointModelId)
Q_DECLARE_METATYPE(Debugger::Internal::BreakpointResponseId)
#endif // DEBUGGER_BREAKPOINT_H
......@@ -46,7 +46,7 @@
namespace Debugger {
namespace Internal {
BreakpointMarker::BreakpointMarker(BreakpointId id,
BreakpointMarker::BreakpointMarker(BreakpointModelId id,
const QString &fileName, int lineNumber)
: m_id(id)
{
......
......@@ -46,13 +46,13 @@ class BreakpointMarker : public TextEditor::BaseTextMark
Q_OBJECT
public:
BreakpointMarker(BreakpointId id, const QString &fileName, int lineNumber);
BreakpointMarker(BreakpointModelId id, const QString &fileName, int lineNumber);
~BreakpointMarker();
void removedFromEditor();
void updateLineNumber(int lineNumber);
private:
BreakpointId m_id;
BreakpointModelId m_id;
friend class BreakHandler;
};
......
......@@ -495,7 +495,7 @@ void BreakWindow::keyPressEvent(QKeyEvent *ev)
QModelIndexList si = sm->selectedIndexes();
if (si.isEmpty())
si.append(currentIndex());
const BreakpointIds ids = breakHandler()->findBreakpointsByIndex(si);
const BreakpointModelIds ids = breakHandler()->findBreakpointsByIndex(si);
int row = qMin(model()->rowCount() - ids.size() - 1, currentIndex().row());
deleteBreakpoints(ids);
setCurrentIndex(si.at(0).sibling(row, 0));
......@@ -512,8 +512,8 @@ void BreakWindow::mouseDoubleClickEvent(QMouseEvent *ev)
{
QModelIndex indexUnderMouse = indexAt(ev->pos());
if (indexUnderMouse.isValid() && indexUnderMouse.column() >= 4) {
BreakpointId id = breakHandler()->findBreakpointByIndex(indexUnderMouse);
editBreakpoints(BreakpointIds() << id);
BreakpointModelId id = breakHandler()->findBreakpointByIndex(indexUnderMouse);
editBreakpoints(BreakpointModelIds() << id);
}
QTreeView::mouseDoubleClickEvent(ev);
}
......@@ -538,7 +538,7 @@ void BreakWindow::contextMenuEvent(QContextMenuEvent *ev)
selectedIndices.append(indexUnderMouse);
BreakHandler *handler = breakHandler();
BreakpointIds selectedIds = handler->findBreakpointsByIndex(selectedIndices);
BreakpointModelIds selectedIds = handler->findBreakpointsByIndex(selectedIndices);
const int rowCount = model()->rowCount();
unsigned engineCapabilities = AllDebuggerCapabilities;
......@@ -554,7 +554,7 @@ void BreakWindow::contextMenuEvent(QContextMenuEvent *ev)
// Delete by file: Find indices of breakpoints of the same file.
QAction *deleteByFileAction = 0;
BreakpointIds breakpointsInFile;
BreakpointModelIds breakpointsInFile;
if (indexUnderMouse.isValid()) {
const QModelIndex index = indexUnderMouse.sibling(indexUnderMouse.row(), 2);
const QString file = index.data().toString();
......@@ -648,21 +648,21 @@ void BreakWindow::contextMenuEvent(QContextMenuEvent *ev)
addBreakpoint();
}
void BreakWindow::setBreakpointsEnabled(const BreakpointIds &ids, bool enabled)
void BreakWindow::setBreakpointsEnabled(const BreakpointModelIds &ids, bool enabled)
{
BreakHandler *handler = breakHandler();
foreach (const BreakpointId id, ids)
foreach (const BreakpointModelId id, ids)
handler->setEnabled(id, enabled);
}
void BreakWindow::deleteBreakpoints(const BreakpointIds &ids)
void BreakWindow::deleteBreakpoints(const BreakpointModelIds &ids)
{
BreakHandler *handler = breakHandler();
foreach (const BreakpointId id, ids)
foreach (const BreakpointModelId id, ids)
handler->removeBreakpoint(id);
}
void BreakWindow::editBreakpoint(BreakpointId id, QWidget *parent)
void BreakWindow::editBreakpoint(BreakpointModelId id, QWidget *parent)
{
BreakpointParameters data = breakHandler()->breakpointData(id);
unsigned engineCapabilities = AllDebuggerCapabilities;
......@@ -684,11 +684,11 @@ void BreakWindow::addBreakpoint()
breakHandler()->appendBreakpoint(data);
}
void BreakWindow::editBreakpoints(const BreakpointIds &ids)
void BreakWindow::editBreakpoints(const BreakpointModelIds &ids)
{
QTC_ASSERT(!ids.isEmpty(), return);
const BreakpointId id = ids.at(0);
const BreakpointModelId id = ids.at(0);
if (ids.size() == 1) {
editBreakpoint(id, this);
......@@ -719,17 +719,17 @@ void BreakWindow::editBreakpoints(const BreakpointIds &ids)
&& newThreadSpec == oldThreadSpec)
return;
foreach (const BreakpointId id, ids) {
foreach (const BreakpointModelId id, ids) {
handler->setCondition(id, newCondition.toLatin1());
handler->setIgnoreCount(id, newIgnoreCount);
handler->setThreadSpec(id, newThreadSpec);
}
}
void BreakWindow::associateBreakpoint(const BreakpointIds &ids, int threadId)
void BreakWindow::associateBreakpoint(const BreakpointModelIds &ids, int threadId)
{
BreakHandler *handler = breakHandler();
foreach (const BreakpointId id, ids)
foreach (const BreakpointModelId id, ids)
handler->setThreadSpec(id, threadId);
}
......
......@@ -47,7 +47,7 @@ class BreakWindow : public QTreeView
public:
explicit BreakWindow(QWidget *parent = 0);
static void editBreakpoint(BreakpointId id, QWidget *parent);
static void editBreakpoint(BreakpointModelId id, QWidget *parent);
void setModel(QAbstractItemModel *model);
private slots:
......@@ -64,11 +64,11 @@ private:
void keyPressEvent(QKeyEvent *ev);
void mouseDoubleClickEvent(QMouseEvent *ev);
void deleteBreakpoints(const BreakpointIds &ids);
void deleteBreakpoints(const BreakpointModelIds &ids);
void addBreakpoint();
void editBreakpoints(const BreakpointIds &ids);
void associateBreakpoint(const BreakpointIds &ids, int thread);
void setBreakpointsEnabled(const BreakpointIds &ids, bool enabled);
void editBreakpoints(const BreakpointModelIds &ids);
void associateBreakpoint(const BreakpointModelIds &ids, int thread);
void setBreakpointsEnabled(const BreakpointModelIds &ids, bool enabled);
};
} // namespace Internal
......
......@@ -192,8 +192,8 @@ struct MemoryChangeCookie
struct ConditionalBreakPointCookie
{
ConditionalBreakPointCookie(BreakpointId i = BreakpointId()) : id(i) {}
BreakpointId id;
ConditionalBreakPointCookie(BreakpointModelId i