diff options
Diffstat (limited to 'languages/cpp/debugger/gdbbreakpointwidget.cpp')
| -rw-r--r-- | languages/cpp/debugger/gdbbreakpointwidget.cpp | 1262 |
1 files changed, 1262 insertions, 0 deletions
diff --git a/languages/cpp/debugger/gdbbreakpointwidget.cpp b/languages/cpp/debugger/gdbbreakpointwidget.cpp new file mode 100644 index 00000000..f9a83d6c --- /dev/null +++ b/languages/cpp/debugger/gdbbreakpointwidget.cpp @@ -0,0 +1,1262 @@ +/*************************************************************************** + begin : Tue May 13 2003 + copyright : (C) 2003 by John Birch + email : jbb@kdevelop.org + ***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +#include "gdbbreakpointwidget.h" +#include "gdbtable.h" +#include "debuggertracingdialog.h" +#include "gdbcommand.h" +#include "gdbcontroller.h" + +#include "breakpoint.h" +#include "domutil.h" + +#include <kdebug.h> +#include <kiconloader.h> +#include <klocale.h> +#include <kpopupmenu.h> +#include <kurl.h> +#include <kmessagebox.h> + +#include <qvbuttongroup.h> +#include <qfileinfo.h> +#include <qheader.h> +#include <qtable.h> +#include <qtoolbutton.h> +#include <qtooltip.h> +#include <qwhatsthis.h> +#include <qvbox.h> +#include <qlayout.h> +#include <qlabel.h> +#include <qpushbutton.h> +#include <qcheckbox.h> + +#include <stdlib.h> +#include <ctype.h> + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +namespace GDBDebugger +{ + +enum Column { + Control = 0, + Enable = 1, + Type = 2, + Status = 3, + Location = 4, + Condition = 5, + IgnoreCount = 6, + Hits = 7, + Tracing = 8 +}; + + +#define numCols 9 + +enum BW_ITEMS { BW_ITEM_Show, BW_ITEM_Edit, BW_ITEM_Disable, BW_ITEM_Delete, + BW_ITEM_DisableAll, BW_ITEM_EnableAll, BW_ITEM_DeleteAll}; + +static int m_activeFlag = 0; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +class BreakpointTableRow : public QTableItem +{ +public: + + BreakpointTableRow(QTable* table, EditType editType, Breakpoint* bp); + ~BreakpointTableRow(); + + bool match (Breakpoint* bp) const; + void reset (); + void setRow(); + + Breakpoint* breakpoint() { return m_breakpoint; } + +private: + void appendEmptyRow(); + +private: + Breakpoint* m_breakpoint; +}; + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +BreakpointTableRow::BreakpointTableRow(QTable* parent, EditType editType, + Breakpoint* bp) : + QTableItem(parent, editType, ""), + m_breakpoint(bp) +{ + appendEmptyRow(); + setRow(); +} + +/***************************************************************************/ + +BreakpointTableRow::~BreakpointTableRow() +{ + m_breakpoint->deleteLater(); +} + +/***************************************************************************/ + +bool BreakpointTableRow::match(Breakpoint* breakpoint) const +{ + return m_breakpoint->match(breakpoint); +} + +/***************************************************************************/ + +void BreakpointTableRow::reset() +{ + m_breakpoint->reset(); + setRow(); +} + +/***************************************************************************/ + +void BreakpointTableRow::appendEmptyRow() +{ + int row = table()->numRows(); + table()->setNumRows(row+1); + + table()->setItem(row, Control, this); + + QCheckTableItem* cti = new QCheckTableItem( table(), ""); + table()->setItem(row, Enable, cti); + + ComplexEditCell* act = new ComplexEditCell(table()); + table()->setItem(row, Tracing, act); + QObject::connect(act, SIGNAL(edit(QTableItem*)), + table()->parent(), SLOT(editTracing(QTableItem*))); +} + +/***************************************************************************/ + +void BreakpointTableRow::setRow() +{ + if ( m_breakpoint ) + { + QTableItem *item = table()->item ( row(), Enable ); + Q_ASSERT(item->rtti() == 2); + ((QCheckTableItem*)item)->setChecked(m_breakpoint->isEnabled()); + + QString status=m_breakpoint->statusDisplay(m_activeFlag); + + table()->setText(row(), Status, status); + table()->setText(row(), Condition, m_breakpoint->conditional()); + table()->setText(row(), IgnoreCount, QString::number(m_breakpoint->ignoreCount() )); + table()->setText(row(), Hits, QString::number(m_breakpoint->hits() )); + + QString displayType = m_breakpoint->displayType(); + table()->setText(row(), Location, m_breakpoint->location()); + + + QTableItem* ce = table()->item( row(), Tracing ); + ce->setText(breakpoint()->tracingEnabled() ? "Enabled" : "Disabled"); + // In case there's editor open in this cell, update it too. + static_cast<ComplexEditCell*>(ce)->updateValue(); + + + if (m_breakpoint->isTemporary()) + displayType = i18n(" temporary"); + if (m_breakpoint->isHardwareBP()) + displayType += i18n(" hw"); + + table()->setText(row(), Type, displayType); + table()->adjustColumn(Type); + table()->adjustColumn(Status); + table()->adjustColumn(Location); + table()->adjustColumn(Hits); + table()->adjustColumn(IgnoreCount); + table()->adjustColumn(Condition); + } +} + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +GDBBreakpointWidget::GDBBreakpointWidget(GDBController* controller, + QWidget *parent, const char *name) : +QHBox(parent, name), +controller_(controller) +{ + m_table = new GDBTable(0, numCols, this, name); + m_table->setSelectionMode(QTable::SingleRow); + m_table->setShowGrid (false); + m_table->setLeftMargin(0); + m_table->setFocusStyle(QTable::FollowStyle); + + m_table->hideColumn(Control); + m_table->setColumnReadOnly(Type, true); + m_table->setColumnReadOnly(Status, true); + m_table->setColumnReadOnly(Hits, true); + m_table->setColumnWidth( Enable, 20); + + QHeader *header = m_table->horizontalHeader(); + + header->setLabel( Enable, "" ); + header->setLabel( Type, i18n("Type") ); + header->setLabel( Status, i18n("Status") ); + header->setLabel( Location, i18n("Location") ); + header->setLabel( Condition, i18n("Condition") ); + header->setLabel( IgnoreCount, i18n("Ignore Count") ); + header->setLabel( Hits, i18n("Hits") ); + header->setLabel( Tracing, i18n("Tracing") ); + + QPopupMenu* newBreakpoint = new QPopupMenu(this); + newBreakpoint->insertItem(i18n("Code breakpoint", "Code"), + BP_TYPE_FilePos); + newBreakpoint->insertItem(i18n("Data breakpoint", "Data write"), + BP_TYPE_Watchpoint); + newBreakpoint->insertItem(i18n("Data read breakpoint", "Data read"), + BP_TYPE_ReadWatchpoint); + + + m_ctxMenu = new QPopupMenu( this ); + m_ctxMenu->insertItem( i18n("New breakpoint", "New"), + newBreakpoint); + m_ctxMenu->insertItem( i18n( "Show text" ), BW_ITEM_Show ); + int edit_id = + m_ctxMenu->insertItem( i18n( "Edit" ), BW_ITEM_Edit ); + m_ctxMenu->setAccel(Qt::Key_Enter, edit_id); + m_ctxMenu->insertItem( i18n( "Disable" ), BW_ITEM_Disable ); + int del_id = + m_ctxMenu->insertItem( SmallIcon("breakpoint_delete"), + i18n( "Delete" ), BW_ITEM_Delete ); + m_ctxMenu->setAccel(Qt::Key_Delete, del_id); + m_ctxMenu->insertSeparator(); + m_ctxMenu->insertItem( i18n( "Disable all"), BW_ITEM_DisableAll ); + m_ctxMenu->insertItem( i18n( "Enable all"), BW_ITEM_EnableAll ); + m_ctxMenu->insertItem( i18n( "Delete all"), BW_ITEM_DeleteAll ); + + m_table->show(); + + connect( newBreakpoint, SIGNAL(activated(int)), + this, SLOT(slotAddBlankBreakpoint(int)) ); + + connect( m_table, SIGNAL(contextMenuRequested(int, int, const QPoint &)), + this, SLOT(slotContextMenuShow(int, int, const QPoint & )) ); + connect( m_ctxMenu, SIGNAL(activated(int)), + this, SLOT(slotContextMenuSelect(int)) ); + + connect( m_table, SIGNAL(doubleClicked(int, int, int, const QPoint &)), + this, SLOT(slotRowDoubleClicked(int, int, int, const QPoint &))); + + connect( m_table, SIGNAL(valueChanged(int, int)), + this, SLOT(slotNewValue(int, int))); + + connect( m_table, SIGNAL(returnPressed()), + this, SLOT(slotEditBreakpoint())); +// connect( m_table, SIGNAL(f2Pressed()), +// this, SLOT(slotEditBreakpoint())); + connect( m_table, SIGNAL(deletePressed()), + this, SLOT(slotRemoveBreakpoint())); +// This slot doesn't exist anymore +// connect( m_table, SIGNAL(insertPressed()), +// this, SLOT(slotAddBlankBreakpoint())); + + // FIXME: maybe, all debugger components should derive from + // a base class that does this connect. + connect(controller, SIGNAL(event(GDBController::event_t)), + this, SLOT(slotEvent(GDBController::event_t))); + + connect(controller, + SIGNAL(watchpointHit(int, const QString&, const QString&)), + this, + SLOT(slotWatchpointHit(int, const QString&, const QString&))); +} + +/***************************************************************************/ + +GDBBreakpointWidget::~GDBBreakpointWidget() +{ + delete m_table; +} + +/***************************************************************************/ + +void GDBBreakpointWidget::reset() +{ + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr) + { + btr->reset(); + sendToGdb(*(btr->breakpoint())); + } + } +} + +/***************************************************************************/ + +// When a file is loaded then we need to tell the editor (display window) +// which lines contain a breakpoint. +void GDBBreakpointWidget::slotRefreshBP(const KURL &filename) +{ + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr) + { + FilePosBreakpoint* bp = dynamic_cast<FilePosBreakpoint*>(btr->breakpoint()); + if (bp && bp->hasFileAndLine() + && (bp->fileName() == filename.path())) + emit refreshBPState(*bp); + } + } +} + +void GDBBreakpointWidget::slotBreakpointHit(int id) +{ + BreakpointTableRow* br = findId(id); + + // FIXME: should produce an message, this is most likely + // an error. + if (!br) + return; + + Breakpoint* b = br->breakpoint(); + + if (b->tracingEnabled()) + { + controller_->addCommand( + new CliCommand(("printf " + + b->traceRealFormatString()).latin1(), + this, + &GDBBreakpointWidget::handleTracingPrintf)); + + controller_->addCommand(new + GDBCommand("-exec-continue")); + + } + else + { + controller_->demandAttention(); + } +} + +void GDBBreakpointWidget::slotWatchpointHit(int id, + const QString& oldValue, + const QString& newValue) +{ + BreakpointTableRow* br = findId(id); + + // FIXME: should produce an message, this is most likely + // an error. + if (!br) + return; + + Watchpoint* b = dynamic_cast<Watchpoint*>(br->breakpoint()); + + + KMessageBox::information( + 0, + i18n("<b>Data write breakpoint</b><br>" + "Expression: %1<br>" + "Address: 0x%2<br>" + "Old value: %3<br>" + "New value: %4") + .arg(b->varName()) + .arg(b->address(), 0, 16) + .arg(oldValue) + .arg(newValue)); +} + +/***************************************************************************/ + +BreakpointTableRow* GDBBreakpointWidget::find(Breakpoint *breakpoint) +{ + // NOTE:- The match doesn't have to be equal. Each type of bp + // must decide on the match criteria. + Q_ASSERT (breakpoint); + + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr && btr->match(breakpoint)) + return btr; + } + + return 0; +} + +/***************************************************************************/ + +// The Id is supplied by the debugger +BreakpointTableRow* GDBBreakpointWidget::findId(int dbgId) +{ + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr && btr->breakpoint()->dbgId() == dbgId) + return btr; + } + + return 0; +} + +/***************************************************************************/ + +// The key is a unique number supplied by us +BreakpointTableRow* GDBBreakpointWidget::findKey(int BPKey) +{ + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr && btr->breakpoint()->key() == BPKey) + return btr; + } + + return 0; +} + +bool GDBBreakpointWidget::hasWatchpointForAddress( + unsigned long long address) const +{ + for(int i = 0; i < m_table->numRows(); ++i) + { + BreakpointTableRow* br = (BreakpointTableRow*) + m_table->item(i, Control); + + Watchpoint* w = dynamic_cast<Watchpoint*>(br->breakpoint()); + if (w && w->address() == address) + return true; + } + return false; +} + +/***************************************************************************/ + +BreakpointTableRow* GDBBreakpointWidget::addBreakpoint(Breakpoint *bp) +{ + BreakpointTableRow* btr = + new BreakpointTableRow( m_table, QTableItem::WhenCurrent, bp ); + + connect(bp, SIGNAL(modified(Breakpoint*)), + this, SLOT(slotBreakpointModified(Breakpoint*))); + + sendToGdb(*bp); + + return btr; +} + +/***************************************************************************/ + +void GDBBreakpointWidget::removeBreakpoint(BreakpointTableRow* btr) +{ + if (!btr) + return; + + // Pending but the debugger hasn't started processing this bp so + // we can just remove it. + Breakpoint* bp = btr->breakpoint(); + // No gdb breakpoint, and no breakpoint addition command in the + // queue. Just remove. + if (bp->dbgId() == -1 && !bp->isDbgProcessing()) + { + bp->setActionDie(); + sendToGdb(*bp); + m_table->removeRow(btr->row()); + } + else + { + bp->setActionClear(true); + sendToGdb(*bp); + btr->setRow(); + } +} + +/***************************************************************************/ + +void GDBBreakpointWidget::slotToggleBreakpoint(const QString &fileName, int lineNum) +{ + FilePosBreakpoint *fpBP = new FilePosBreakpoint(fileName, lineNum+1); + + BreakpointTableRow* btr = find(fpBP); + if (btr) + { + removeBreakpoint(btr); + } + else + addBreakpoint(fpBP); +} + +/***************************************************************************/ + +void GDBBreakpointWidget::slotToggleBreakpointEnabled(const QString &fileName, int lineNum) +{ + FilePosBreakpoint *fpBP = new FilePosBreakpoint(fileName, lineNum+1); + + BreakpointTableRow* btr = find(fpBP); + delete fpBP; + if (btr) + { + Breakpoint* bp=btr->breakpoint(); + bp->setEnabled(!bp->isEnabled()); + sendToGdb(*bp); + } +} + +/***************************************************************************/ + +void GDBBreakpointWidget::slotToggleWatchpoint(const QString &varName) +{ + Watchpoint *watchpoint = new Watchpoint(varName, false, true); + BreakpointTableRow* btr = find(watchpoint); + if (btr) + { + removeBreakpoint(btr); + delete watchpoint; + } + else + addBreakpoint(watchpoint); +} + +void GDBBreakpointWidget::handleBreakpointList(const GDBMI::ResultRecord& r) +{ + m_activeFlag++; + + const GDBMI::Value& blist = r["BreakpointTable"]["body"]; + + for(unsigned i = 0, e = blist.size(); i != e; ++i) + { + const GDBMI::Value& b = blist[i]; + + int id = b["number"].literal().toInt(); + BreakpointTableRow* btr = findId(id); + if (btr) + { + Breakpoint *bp = btr->breakpoint(); + bp->setActive(m_activeFlag, id); + bp->setHits(b["times"].toInt()); + if (b.hasField("ignore")) + bp->setIgnoreCount(b["ignore"].toInt()); + else + bp->setIgnoreCount(0); + if (b.hasField("cond")) + bp->setConditional(b["cond"].literal()); + else + bp->setConditional(QString::null); + btr->setRow(); + emit publishBPState(*bp); + } + else + { + // It's a breakpoint added outside, most probably + // via gdb console. Add it now. + QString type = b["type"].literal(); + + if (type == "breakpoint" || type == "hw breakpoint") + { + if (b.hasField("fullname") && b.hasField("line")) + { + Breakpoint* bp = new FilePosBreakpoint( + b["fullname"].literal(), + b["line"].literal().toInt()); + + bp->setActive(m_activeFlag, id); + bp->setActionAdd(false); + bp->setPending(false); + + new BreakpointTableRow(m_table, + QTableItem::WhenCurrent, + bp); + + emit publishBPState(*bp); + } + } + + } + } + + // Remove any inactive breakpoints. + for ( int row = m_table->numRows()-1; row >= 0 ; row-- ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr) + { + Breakpoint* bp = btr->breakpoint(); + if (!(bp->isActive(m_activeFlag))) + { + // FIXME: need to review is this happens for + // as-yet unset breakpoint. + bp->removedInGdb(); + } + } + } +} + +void GDBBreakpointWidget::handleTracingPrintf(const QValueVector<QString>& s) +{ + // The first line of output is the command itself, which we don't need. + for(unsigned i = 1; i < s.size(); ++i) + emit tracingOutput(s[i].local8Bit()); +} + +/***************************************************************************/ + +void GDBBreakpointWidget::slotBreakpointSet(Breakpoint* bp) +{ + // FIXME: why 'key' is used here? + BreakpointTableRow* btr = findKey(bp->key()); + if (!btr) + { + kdDebug(9012) << "Early return\n"; + return; + } + + btr->setRow(); +} + +/***************************************************************************/ + +void GDBBreakpointWidget::slotAddBlankBreakpoint(int idx) +{ + BreakpointTableRow* btr = 0; + switch (idx) + { + case BP_TYPE_FilePos: + btr = addBreakpoint(new FilePosBreakpoint()); + break; + + case BP_TYPE_Watchpoint: + btr = addBreakpoint(new Watchpoint("")); + break; + + case BP_TYPE_ReadWatchpoint: + btr = addBreakpoint(new ReadWatchpoint("")); + break; + + default: + break; + } + + if (btr) + { + m_table->selectRow(btr->row()); + m_table->editCell(btr->row(), Location, false); + } +} + +/***************************************************************************/ + +void GDBBreakpointWidget::slotRemoveBreakpoint() +{ + int row = m_table->currentRow(); + if ( row != -1) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + removeBreakpoint(btr); + } +} + +/***************************************************************************/ + +void GDBBreakpointWidget::slotRemoveAllBreakpoints() +{ + for ( int row = m_table->numRows()-1; row>=0; row-- ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + removeBreakpoint(btr); + } +} + +/***************************************************************************/ + +void GDBBreakpointWidget::slotRowDoubleClicked(int row, int col, int btn, const QPoint &) +{ + if ( btn == Qt::LeftButton ) + { +// kdDebug(9012) << "in slotRowSelected row=" << row << endl; + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr) + { + FilePosBreakpoint* bp = dynamic_cast<FilePosBreakpoint*>(btr->breakpoint()); + if (bp && bp->hasFileAndLine()) + emit gotoSourcePosition(bp->fileName(), bp->lineNum()-1); + + // put the focus back on the clicked item if appropriate + if (col == Location || col == Condition || col == IgnoreCount) + m_table->editCell(row, col, false); + } + } +} + +void GDBBreakpointWidget::slotContextMenuShow( int row, int /*col*/, const QPoint &mousePos ) +{ + BreakpointTableRow *btr = (BreakpointTableRow *)m_table->item(row, Control ); + + if (btr == NULL) + { + btr = (BreakpointTableRow *)m_table->item(m_table->currentRow(), + Control ); + } + + if (btr != NULL) + { + m_ctxMenu->setItemEnabled( + BW_ITEM_Show, + btr->breakpoint()->hasFileAndLine()); + + if (btr->breakpoint( )->isEnabled( )) + { + m_ctxMenu->changeItem( BW_ITEM_Disable, i18n("Disable") ); + } + else + { + m_ctxMenu->changeItem( BW_ITEM_Disable, i18n("Enable") ); + } + + m_ctxMenu->setItemEnabled(BW_ITEM_Disable, true); + m_ctxMenu->setItemEnabled(BW_ITEM_Delete, true); + m_ctxMenu->setItemEnabled(BW_ITEM_Edit, true); + } + else + { + m_ctxMenu->setItemEnabled(BW_ITEM_Show, false); + m_ctxMenu->setItemEnabled(BW_ITEM_Disable, false); + m_ctxMenu->setItemEnabled(BW_ITEM_Delete, false); + m_ctxMenu->setItemEnabled(BW_ITEM_Edit, false); + } + + bool has_bps = (m_table->numRows() != 0); + m_ctxMenu->setItemEnabled(BW_ITEM_DisableAll, has_bps); + m_ctxMenu->setItemEnabled(BW_ITEM_EnableAll, has_bps); + m_ctxMenu->setItemEnabled(BW_ITEM_Delete, has_bps); + + m_ctxMenu->popup( mousePos ); +} + +void GDBBreakpointWidget::slotContextMenuSelect( int item ) +{ + int row, col; + BreakpointTableRow *btr; + Breakpoint *bp; + FilePosBreakpoint *fbp; + + row= m_table->currentRow( ); + if (row == -1) + return; + btr = (BreakpointTableRow *)m_table->item( row, Control ); + if (btr == NULL) + return; + bp = btr->breakpoint( ); + if (bp == NULL) + return; + fbp = dynamic_cast<FilePosBreakpoint*>(bp); + + switch( item ) + { + case BW_ITEM_Show: + if (fbp) + emit gotoSourcePosition(fbp->fileName(), fbp->lineNum()-1); + break; + case BW_ITEM_Edit: + col = m_table->currentColumn( ); + if (col == Location || col == Condition || col == IgnoreCount) + m_table->editCell(row, col, false); + break; + case BW_ITEM_Disable: + + bp->setEnabled( !bp->isEnabled( ) ); + btr->setRow( ); + sendToGdb( *bp ); + break; + case BW_ITEM_Delete: + slotRemoveBreakpoint( ); + break; + case BW_ITEM_DeleteAll: + slotRemoveAllBreakpoints(); + break; + case BW_ITEM_DisableAll: + case BW_ITEM_EnableAll: + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) + m_table->item(row, Control); + + if (btr) + { + btr->breakpoint()->setEnabled(item == BW_ITEM_EnableAll); + btr->setRow(); + sendToGdb(*btr->breakpoint()); + } + } + break; + default: + // oops, check it out! this case is not in sync with the + // m_ctxMenu. Check the enum in the header file. + return; + } +} + +/***************************************************************************/ + +void GDBBreakpointWidget::slotEditRow(int row, int col, const QPoint &) +{ +// kdDebug(9012) << "in slotEditRow row=" << row << endl; + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + if (btr) + { + if (col == Location || col == Condition || col == IgnoreCount) + m_table->editCell(row, col, false); + } +} + +/***************************************************************************/ + +void GDBBreakpointWidget::slotNewValue(int row, int col) +{ + BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control); + + QString new_value = m_table->text(row, col); + + if (btr) + { + Breakpoint* bp = btr->breakpoint(); + switch (col) + { + case Enable: + { + QCheckTableItem *item = + (QCheckTableItem*)m_table->item ( row, Enable ); + bp->setEnabled(item->isChecked()); + } + break; + + case Location: + { + if (bp->location() != new_value) + { + // GDB does not allow to change location of + // an existing breakpoint. So, need to remove old + // breakpoint and add another. + + // Announce to editor that breakpoit at its + // current location is dying. + bp->setActionDie(); + emit publishBPState(*bp); + + // However, we don't want the line in breakpoint + // widget to disappear and appear again. + + // Emit delete command. This won't resync breakpoint + // table (unlike clearBreakpoint), so we won't have + // nasty effect where line in the table first disappears + // and then appears again, and won't have internal issues + // as well. + if (!controller_->stateIsOn(s_dbgNotStarted)) + controller_->addCommand(bp->dbgRemoveCommand().latin1()); + + // Now add new breakpoint in gdb. It will correspond to + // the same 'Breakpoint' and 'BreakpointRow' objects in + // KDevelop is the previous, deleted, breakpoint. + + // Note: clears 'actionDie' implicitly. + bp->setActionAdd(true); + bp->setLocation(new_value); + } + break; + } + + case Condition: + { + bp->setConditional(new_value); + break; + } + + case IgnoreCount: + { + bp->setIgnoreCount(new_value.toInt()); + break; + } + default: + break; + } + + bp->setActionModify(true); + + + // This is not needed for most changes, since we've + // just read a value from table cell to breakpoint, and + // setRow will write back the same value to the cell. + // It's only really needed for tracing column changes, + // where tracing config dialog directly changes breakpoint, + // so we need to send those changes to the table. + btr->setRow(); + + + sendToGdb(*bp); + } +} + +/***************************************************************************/ + +void GDBBreakpointWidget::slotEditBreakpoint(const QString &fileName, int lineNum) +{ + FilePosBreakpoint *fpBP = new FilePosBreakpoint(fileName, lineNum+1); + + BreakpointTableRow* btr = find(fpBP); + delete fpBP; + + if (btr) + { + QTableSelection ts; + ts.init(btr->row(), 0); + ts.expandTo(btr->row(), numCols); + m_table->addSelection(ts); + m_table->editCell(btr->row(), Location, false); + } + +} + +void GDBBreakpointWidget::sendToGdb(Breakpoint& BP) +{ + // Announce the change in state. We need to do this before + // everything. For example, if debugger is not yet running, we'll + // immediate exit after setting pending flag, but we still want changes + // in "enabled" flag to be shown on the left border of the editor. + emit publishBPState(BP); + + BP.sendToGdb(controller_); +} + +void GDBBreakpointWidget::slotBreakpointModified(Breakpoint* b) +{ + emit publishBPState(*b); + + if (BreakpointTableRow* btr = find(b)) + { + if (b->isActionDie()) + { + // Breakpoint was deleted, kill the table row. + m_table->removeRow(btr->row()); + } + else + { + btr->setRow(); + } + } +} + +void GDBBreakpointWidget::slotEvent(GDBController::event_t e) +{ + switch(e) + { + case GDBController::program_state_changed: + { + controller_->addCommand( + new GDBCommand("-break-list", + this, + &GDBBreakpointWidget::handleBreakpointList)); + break; + } + + case GDBController::shared_library_loaded: + case GDBController::connected_to_program: + { + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = (BreakpointTableRow *) + m_table->item(row, Control); + + if (btr) + { + Breakpoint* bp = btr->breakpoint(); + if ( (bp->dbgId() == -1 || bp->isPending()) + && !bp->isDbgProcessing() + && bp->isValid()) + { + sendToGdb(*bp); + } + } + } + break; + } + case GDBController::program_exited: + { + for(int row = 0; row < m_table->numRows(); ++row) + { + Breakpoint* b = static_cast<BreakpointTableRow*>( + m_table->item(row, Control))->breakpoint(); + + b->applicationExited(controller_); + } + } + + default: + ; + } +} + + +/***************************************************************************/ + +void GDBBreakpointWidget::slotEditBreakpoint() +{ + m_table->editCell(m_table->currentRow(), Location, false); +} + + +void GDBBreakpointWidget::editTracing(QTableItem* item) +{ + BreakpointTableRow* btr = (BreakpointTableRow *) + m_table->item(item->row(), Control); + + DebuggerTracingDialog* d = new DebuggerTracingDialog( + btr->breakpoint(), m_table, ""); + + int r = d->exec(); + + // Note: change cell text here and explicitly call slotNewValue here. + // We want this signal to be emitted when we close the tracing dialog + // and not when we select some other cell, as happens in Qt by default. + if (r == QDialog::Accepted) + { + // The dialog has modified "btr->breakpoint()" already. + // Calling 'slotNewValue' will flush the changes back + // to the table. + slotNewValue(item->row(), item->col()); + } + + delete d; +} + + +/***************************************************************************/ + +void GDBBreakpointWidget::savePartialProjectSession(QDomElement* el) +{ + QDomDocument domDoc = el->ownerDocument(); + if (domDoc.isNull()) + return; + + QDomElement breakpointListEl = domDoc.createElement("breakpointList"); + for ( int row = 0; row < m_table->numRows(); row++ ) + { + BreakpointTableRow* btr = + (BreakpointTableRow *) m_table->item(row, Control); + Breakpoint* bp = btr->breakpoint(); + + QDomElement breakpointEl = + domDoc.createElement("breakpoint"+QString::number(row)); + + breakpointEl.setAttribute("type", bp->type()); + breakpointEl.setAttribute("location", bp->location(false)); + breakpointEl.setAttribute("enabled", bp->isEnabled()); + breakpointEl.setAttribute("condition", bp->conditional()); + breakpointEl.setAttribute("tracingEnabled", + QString::number(bp->tracingEnabled())); + breakpointEl.setAttribute("traceFormatStringEnabled", + QString::number(bp->traceFormatStringEnabled())); + breakpointEl.setAttribute("tracingFormatString", + bp->traceFormatString()); + + QDomElement tracedExpressions = + domDoc.createElement("tracedExpressions"); + + QStringList::const_iterator i, e; + for(i = bp->tracedExpressions().begin(), + e = bp->tracedExpressions().end(); + i != e; ++i) + { + QDomElement expr = domDoc.createElement("expression"); + expr.setAttribute("value", *i); + tracedExpressions.appendChild(expr); + } + + breakpointEl.appendChild(tracedExpressions); + + breakpointListEl.appendChild(breakpointEl); + } + + if (!breakpointListEl.isNull()) + el->appendChild(breakpointListEl); +} + +/***************************************************************************/ + +void GDBBreakpointWidget::restorePartialProjectSession(const QDomElement* el) +{ + /** Eventually, would be best to make each breakpoint type handle loading/ + saving it's data. The only problem is that on load, we need to allocate + with new different objects, depending on type, and that requires some + kind of global registry. Gotta find out if a solution for that exists in + KDE (Boost.Serialization is too much dependency, and rolling my own is + boring). + */ + QDomElement breakpointListEl = el->namedItem("breakpointList").toElement(); + if (!breakpointListEl.isNull()) + { + QDomElement breakpointEl; + for (breakpointEl = breakpointListEl.firstChild().toElement(); + !breakpointEl.isNull(); + breakpointEl = breakpointEl.nextSibling().toElement()) + { + Breakpoint* bp=0; + BP_TYPES type = (BP_TYPES) breakpointEl.attribute( "type", "0").toInt(); + switch (type) + { + case BP_TYPE_FilePos: + { + bp = new FilePosBreakpoint(); + break; + } + case BP_TYPE_Watchpoint: + { + bp = new Watchpoint(""); + break; + } + default: + break; + } + + // Common settings for any type of breakpoint + if (bp) + { + bp->setLocation(breakpointEl.attribute( "location", "")); + if (type == BP_TYPE_Watchpoint) + { + bp->setEnabled(false); + } + else + { + bp->setEnabled( + breakpointEl.attribute( "enabled", "1").toInt()); + } + bp->setConditional(breakpointEl.attribute( "condition", "")); + + bp->setTracingEnabled( + breakpointEl.attribute("tracingEnabled", "0").toInt()); + bp->setTraceFormatString( + breakpointEl.attribute("tracingFormatString", "")); + bp->setTraceFormatStringEnabled( + breakpointEl.attribute("traceFormatStringEnabled", "0") + .toInt()); + + QDomNode tracedExpr = + breakpointEl.namedItem("tracedExpressions"); + + if (!tracedExpr.isNull()) + { + QStringList l; + + for(QDomNode c = tracedExpr.firstChild(); !c.isNull(); + c = c.nextSibling()) + { + QDomElement el = c.toElement(); + l.push_back(el.attribute("value", "")); + } + bp->setTracedExpressions(l); + } + + // Now add the breakpoint. Don't try to check if + // breakpoint already exists. + // It's easy to check that breakpoint on the same + // line already exists, but it might have different condition, + // and checking conditions for equality is too complex thing. + // And anyway, it's will be suprising of realoading a project + // changes the set of breakpoints. + addBreakpoint(bp); + } + } + } +} + +/***************************************************************************/ + +void GDBBreakpointWidget::focusInEvent( QFocusEvent */* e*/ ) +{ + // Without the following 'if', when we first open the breakpoints + // widget, the background is all black. This happens only with + // m_table->setFocusStyle(QTable::FollowStyle); + // in constructor, so I suspect Qt bug. But anyway, without + // current cell keyboard actions like Enter for edit won't work, + // so keyboard focus does not makes much sense. + if (m_table->currentRow() == -1 || + m_table->currentColumn() == -1) + { + m_table->setCurrentCell(0, 0); + } + m_table->setFocus(); +} + +ComplexEditCell:: +ComplexEditCell(QTable* table) +: QTableItem(table, QTableItem::WhenCurrent) +{ +} + + +QWidget* ComplexEditCell::createEditor() const +{ + QHBox* box = new QHBox( table()->viewport() ); + box->setPaletteBackgroundColor( + table()->palette().active().highlight()); + + label_ = new QLabel(text(), box, "label"); + label_->setBackgroundMode(Qt::PaletteHighlight); + // Sorry for hardcode, but '2' is already hardcoded in + // Qt source, in QTableItem::paint. Since I don't want the + // text to jump 2 pixels to the right when editor is activated, + // need to set the same indent for label. + label_->setIndent(2); + QPalette p = label_->palette(); + + p.setColor(QPalette::Active, QColorGroup::Foreground, + table()->palette().active().highlightedText()); + p.setColor(QPalette::Inactive, QColorGroup::Foreground, + table()->palette().active().highlightedText()); + + label_->setPalette(p); + + QPushButton* b = new QPushButton("...", box); + // This is exactly what is done in QDesigner source in the + // similar context. Haven't had any success making the good look + // with layout, I suppose that sizeHint for button is always larger + // than 20. + b->setFixedWidth( 20 ); + + connect(b, SIGNAL(clicked()), this, SLOT(slotEdit())); + + return box; +} + +void ComplexEditCell::updateValue() +{ + if (!label_.isNull()) + { + label_->setText(table()->text(row(), col())); + } +} + +void ComplexEditCell::slotEdit() +{ + emit edit(this); +} + +} + + +#include "gdbbreakpointwidget.moc" |