← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kdevplatform/utopic-proposed

« back to all changes in this revision

Viewing changes to debugger/breakpoint/breakpointmodel.cpp

  • Committer: Package Import Robot
  • Author(s): Scarlett Clark
  • Date: 2014-08-30 03:52:11 UTC
  • mfrom: (0.3.26)
  • Revision ID: package-import@ubuntu.com-20140830035211-wndqlc843eu2v8nk
Tags: 1.7.0-0ubuntu1
* New upstream release
* Add XS-Testsuite: autopkgtest

Show diffs side-by-side

added added

removed removed

Lines of Context:
debugger/breakpoint/breakpointmodel.cpp
48
48
    : QAbstractTableModel(parent),
49
49
      m_dontUpdateMarks(false)
50
50
{
51
 
    connect(this, SIGNAL(rowsInserted(QModelIndex,int,int)), SLOT(save()));
52
 
    connect(this, SIGNAL(rowsRemoved(QModelIndex,int,int)), SLOT(save()));
53
 
    connect(this, SIGNAL(dataChanged(QModelIndex,QModelIndex)), SLOT(save()));
54
51
    connect(this, SIGNAL(dataChanged(QModelIndex,QModelIndex)), SLOT(updateMarks()));
55
52
 
56
53
    if (KDevelop::ICore::self()->partController()) { //TODO remove if
73
70
    load();
74
71
}
75
72
 
76
 
BreakpointModel::~BreakpointModel() {
 
73
BreakpointModel::~BreakpointModel()
 
74
{
 
75
    save();
 
76
 
77
77
    qDeleteAll(m_breakpoints);
78
78
}
79
79
 
208
208
 
209
209
bool KDevelop::BreakpointModel::removeRows(int row, int count, const QModelIndex& parent)
210
210
{
211
 
    if (row + count > m_breakpoints.count()) {
212
 
        count = m_breakpoints.count() - row;
213
 
        if (count <= 0) return false;
214
 
    }
 
211
    if (count < 1 || (row < 0) || (row + count) > rowCount(parent))
 
212
        return false;
 
213
 
215
214
    beginRemoveRows(parent, row, row+count-1);
216
215
    for (int i=0; i < count; ++i) {
217
216
        Breakpoint *b = m_breakpoints.at(row);
218
217
        m_breakpoints.removeAt(row);
219
218
        IF_DEBUG ( kDebug() << m_breakpoints; )
220
 
        if (!b->deleted()) b->setDeleted();
 
219
        b->setDeleted();
221
220
        emit breakpointDeleted(b);
222
221
    }
223
222
    endRemoveRows();
228
227
int KDevelop::BreakpointModel::rowCount(const QModelIndex& parent) const
229
228
{
230
229
    if (!parent.isValid()) {
231
 
        return m_breakpoints.count() + 1;
 
230
        return m_breakpoints.count();
232
231
    }
233
232
    return 0;
234
233
}
241
240
 
242
241
QVariant BreakpointModel::data(const QModelIndex& index, int role) const
243
242
{
244
 
    if (!index.parent().isValid() && index.row() == m_breakpoints.count()) {
245
 
        if (index.column() != Breakpoint::LocationColumn) {
246
 
            if (role == Qt::DisplayRole) {
247
 
                return QString();
248
 
            } else {
249
 
                return QVariant();
250
 
            }
251
 
        }
252
 
 
253
 
        if (role == Qt::DisplayRole)
254
 
            return i18n("Double-click to create new code breakpoint");
255
 
        if (role == Qt::ForegroundRole)
256
 
            // FIXME: returning hardcoded gray is bad,
257
 
            // but we don't have access to any widget, or pallette
258
 
            // thereof, at this point.
259
 
            return QColor(128, 128, 128);
260
 
        if (role == Qt::EditRole)
261
 
            return QString();
262
 
    }
263
243
    if (!index.parent().isValid() && index.row() < m_breakpoints.count()) {
264
244
        return m_breakpoints.at(index.row())->data(index.column(), role);
265
245
    }
268
248
 
269
249
bool KDevelop::BreakpointModel::setData(const QModelIndex& index, const QVariant& value, int role)
270
250
{
271
 
    if (!index.parent().isValid() && index.row() == m_breakpoints.count()
272
 
        && role == Qt::EditRole
273
 
        && (index.column() == Breakpoint::LocationColumn || index.column() == Breakpoint::ConditionColumn)
274
 
        && !value.toString().isEmpty())
275
 
    {
276
 
        /* Helper breakpoint becomes a real breakpoint only if user types
277
 
        some real location.  */
278
 
        addCodeBreakpoint(); //setData below is called
279
 
    }
280
 
 
281
251
    if (!index.parent().isValid() && index.row() < m_breakpoints.count() && (role == Qt::EditRole || role == Qt::CheckStateRole)) {
282
252
        return m_breakpoints.at(index.row())->setData(index.column(), value);
283
253
    }
284
254
    return false;
285
 
 
286
255
}
287
256
 
288
257
void BreakpointModel::markChanged(
363
332
 
364
333
void BreakpointModel::reportChange(Breakpoint* breakpoint, Breakpoint::Column column)
365
334
{
366
 
    QModelIndex idx = breakpointIndex(breakpoint, column);
367
 
    emit dataChanged(idx, idx);
 
335
    // note: just a portion of Breakpoint::Column is displayed in this model!
 
336
    if (column >= 0 && column < columnCount()) {
 
337
        QModelIndex idx = breakpointIndex(breakpoint, column);
 
338
        Q_ASSERT(idx.isValid()); // make sure we don't pass invalid indices to dataChanged()
 
339
        emit dataChanged(idx, idx);
 
340
    }
368
341
    emit breakpointChanged(breakpoint, column);
369
342
}
370
343
 
456
429
{
457
430
    KConfigGroup breakpoints = KGlobal::config()->group("breakpoints");
458
431
    int count = breakpoints.readEntry("number", 0);
 
432
    if (count == 0)
 
433
        return;
 
434
 
 
435
    beginInsertRows(QModelIndex(), 0, count);
459
436
    for (int i = 0; i < count; ++i) {
460
437
        if (!breakpoints.group(QString::number(i)).readEntry("kind", "").isEmpty()) {
461
 
            Breakpoint *b = new Breakpoint(this, breakpoints.group(QString::number(i)));
462
 
            m_breakpoints << b;
 
438
            new Breakpoint(this, breakpoints.group(QString::number(i)));
463
439
        }
464
440
    }
465
 
    reset();
 
441
    endInsertRows();
466
442
}
467
443
 
468
444
void BreakpointModel::save()
475
451
        b->save(g);
476
452
        ++i;
477
453
    }
 
454
    breakpoints.sync();
478
455
}
479
456
 
480
457
QList<Breakpoint*> KDevelop::BreakpointModel::breakpoints() const
492
469
{
493
470
    beginInsertRows(QModelIndex(), m_breakpoints.count(), m_breakpoints.count());
494
471
    Breakpoint* n = new Breakpoint(this, Breakpoint::CodeBreakpoint);
495
 
    m_breakpoints << n;
496
472
    endInsertRows();
497
473
    return n;
498
474
}
515
491
{
516
492
    beginInsertRows(QModelIndex(), m_breakpoints.count(), m_breakpoints.count());
517
493
    Breakpoint* n = new Breakpoint(this, Breakpoint::WriteBreakpoint);
518
 
    m_breakpoints << n;
519
494
    endInsertRows();
520
495
    return n;
521
496
}
531
506
{
532
507
    beginInsertRows(QModelIndex(), m_breakpoints.count(), m_breakpoints.count());
533
508
    Breakpoint* n = new Breakpoint(this, Breakpoint::ReadBreakpoint);
534
 
    m_breakpoints << n;
535
509
    endInsertRows();
536
510
    return n;
537
511
}
547
521
{
548
522
    beginInsertRows(QModelIndex(), m_breakpoints.count(), m_breakpoints.count());
549
523
    Breakpoint* n = new Breakpoint(this, Breakpoint::AccessBreakpoint);
550
 
    m_breakpoints << n;
551
524
    endInsertRows();
552
525
    return n;
553
526
}
560
533
    return n;
561
534
}
562
535
 
 
536
void BreakpointModel::registerBreakpoint(Breakpoint* breakpoint)
 
537
{
 
538
    Q_ASSERT(!m_breakpoints.contains(breakpoint));
 
539
    m_breakpoints << breakpoint;
 
540
}
 
541
 
563
542
Breakpoint* BreakpointModel::breakpoint(const KUrl& url, int line) {
564
543
    foreach (Breakpoint *b, m_breakpoints) {
565
544
        if (b->url() == url && b->line() == line) {