~ubuntu-branches/ubuntu/jaunty/quassel/jaunty-backports

« back to all changes in this revision

Viewing changes to src/client/messagemodel.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2009-01-14 01:28:49 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20090114012849-38celzez3y3wpai9
Tags: 0.4.0~git090113-0ubuntu1
* New upstream git snapshot
  - Use networks.ini to provide default network/channel
  - Provide presets for common IRC networks
* Add kubuntu_01_default_network_channel.patch to set Freenode, port
  8001, and #kubuntu as defaults
* Add build-dep on quilt

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
/***************************************************************************
2
 
 *   Copyright (C) 2005-08 by the Quassel IRC Team                         *
 
2
 *   Copyright (C) 2005-09 by the Quassel Project                          *
3
3
 *   devel@quassel-irc.org                                                 *
4
4
 *                                                                         *
5
5
 *   This program is free software; you can redistribute it and/or modify  *
48
48
 
49
49
QVariant MessageModel::data(const QModelIndex &index, int role) const {
50
50
  int row = index.row(); int column = index.column();
51
 
  if(row < 0 || row >= _messageList.count() || column < 0)
 
51
  if(row < 0 || row >= messageCount() || column < 0)
52
52
    return QVariant();
53
53
 
54
54
  if(role == ColumnTypeRole)
55
55
    return column;
56
56
 
57
 
  return _messageList[row]->data(index.column(), role);
 
57
  return messageItemAt(row)->data(index.column(), role);
 
58
  // return _messageList[row]->data(index.column(), role);
58
59
}
59
60
 
60
61
bool MessageModel::setData(const QModelIndex &index, const QVariant &value, int role) {
61
62
  int row = index.row();
62
 
  if(row < 0 || row >= _messageList.count())
 
63
  if(row < 0 || row >= messageCount())
63
64
    return false;
64
65
 
65
 
  if(_messageList[row]->setData(index.column(), value, role)) {
 
66
  if(messageItemAt(row)->setData(index.column(), value, role)) {
66
67
    emit dataChanged(index, index);
67
68
    return true;
68
69
  }
69
 
 
70
70
  return false;
71
71
}
72
72
 
73
73
bool MessageModel::insertMessage(const Message &msg, bool fakeMsg) {
74
74
  MsgId id = msg.msgId();
75
75
  int idx = indexForId(id);
76
 
  if(!fakeMsg && idx < _messageList.count()) { // check for duplicate
77
 
    if(_messageList[idx]->msgId() == id)
 
76
  if(!fakeMsg && idx < messageCount()) { // check for duplicate
 
77
    if(messageItemAt(idx)->msgId() == id)
78
78
      return false;
79
79
  }
80
80
 
111
111
//   Q_ASSERT(0 == last || msglist.at(0).msgId() != msglist.at(last).msgId() || msglist.at(last).type() == Message::DayChange);
112
112
  int start = indexForId(msglist.first().msgId());
113
113
  int end = start + msglist.count() - 1;
114
 
  MessageModelItem *dayChangeItem = 0;
 
114
  Message dayChangeMsg;
 
115
//   MessageModelItem *dayChangeItem = 0;
115
116
  bool relocatedMsg = false;
116
117
  if(start > 0) {
117
118
    // check if the preceeding msg is a daychange message and if so if
118
119
    // we have to drop or relocate it at the end of this chunk
119
120
    int prevIdx = start - 1;
120
 
    if(_messageList.at(prevIdx)->msgType() == Message::DayChange
121
 
       && _messageList.at(prevIdx)->timeStamp() > msglist.at(0).timestamp()) {
 
121
    if(messageItemAt(prevIdx)->msgType() == Message::DayChange
 
122
       && messageItemAt(prevIdx)->timestamp() > msglist.at(0).timestamp()) {
122
123
      beginRemoveRows(QModelIndex(), prevIdx, prevIdx);
123
 
      MessageModelItem *oldItem = _messageList.takeAt(prevIdx);
124
 
      if(msglist.last().timestamp() < oldItem->timeStamp()) {
125
 
        // we have to reinsert it (with changed msgId -> thus we need to recreate it)
126
 
        Message dayChangeMsg = Message::ChangeOfDay(oldItem->timeStamp());
 
124
//       MessageModelItem *oldItem = _messageList.takeAt(prevIdx);
 
125
//       if(msglist.last().timestamp() < oldItem->timestamp()) {
 
126
//      // we have to reinsert it (with changed msgId -> thus we need to recreate it)
 
127
//      Message dayChangeMsg = Message::ChangeOfDay(oldItem->timestamp());
 
128
//      dayChangeMsg.setMsgId(msglist.last().msgId());
 
129
//      dayChangeItem = createMessageModelItem(dayChangeMsg);
 
130
//       }
 
131
//       delete oldItem;
 
132
 
 
133
 
 
134
      dayChangeMsg = takeMessageAt(prevIdx);
 
135
      if(msglist.last().timestamp() < dayChangeMsg.timestamp()) {
 
136
        // we have to reinsert it with a changed msgId
127
137
        dayChangeMsg.setMsgId(msglist.last().msgId());
128
 
        dayChangeItem = createMessageModelItem(dayChangeMsg);
129
138
      }
130
 
      delete oldItem;
131
139
      endRemoveRows();
132
140
      start--;
133
141
      end--;
135
143
    }
136
144
  }
137
145
 
138
 
  if(!dayChangeItem && start < _messageList.count()) {
 
146
  if(!dayChangeMsg.isValid() && start < messageCount()) {
 
147
    // if(!dayChangeItem && start < _messageList.count()) {
139
148
    // check if we need to insert a daychange message at the end of the this group
140
149
 
141
150
    // if this assert triggers then indexForId() would have found a spot right before a DayChangeMsg
142
151
    // this should never happen as daychange messages share the msgId with the preceeding message
143
 
    Q_ASSERT(_messageList[start]->msgType() != Message::DayChange);
144
 
    QDateTime nextTs = _messageList[start]->timeStamp();
 
152
    Q_ASSERT(messageItemAt(start)->msgType() != Message::DayChange);
 
153
    QDateTime nextTs = messageItemAt(start)->timestamp();
145
154
    QDateTime prevTs = msglist.last().timestamp();
146
155
    nextTs.setTimeSpec(Qt::UTC);
147
156
    prevTs.setTimeSpec(Qt::UTC);
150
159
    if(nextDay != prevDay) {
151
160
      nextTs.setTime_t(nextDay * 86400);
152
161
      nextTs.setTimeSpec(Qt::LocalTime);
153
 
      Message dayChangeMsg = Message::ChangeOfDay(nextTs);
 
162
      dayChangeMsg = Message::ChangeOfDay(nextTs);
154
163
      dayChangeMsg.setMsgId(msglist.last().msgId());
155
 
      dayChangeItem = createMessageModelItem(dayChangeMsg);
156
164
    }
157
165
  }
158
166
 
159
 
  if(dayChangeItem)
 
167
  if(dayChangeMsg.isValid())
160
168
    end++;
161
169
 
162
 
  Q_ASSERT(start == 0 || _messageList[start - 1]->msgId() < msglist.first().msgId());
163
 
  Q_ASSERT(start == _messageList.count() || _messageList[start]->msgId() > msglist.last().msgId());
 
170
  Q_ASSERT(start == 0 || messageItemAt(start - 1)->msgId() < msglist.first().msgId());
 
171
  Q_ASSERT(start == messageCount() || messageItemAt(start)->msgId() > msglist.last().msgId());
164
172
  beginInsertRows(QModelIndex(), start, end);
165
 
  int pos = start;
166
 
  foreach(Message msg, msglist) {
167
 
    _messageList.insert(pos, createMessageModelItem(msg));
168
 
    pos++;
169
 
  }
170
 
  if(dayChangeItem) {
171
 
    _messageList.insert(pos, dayChangeItem);
172
 
    pos++; // needed for the following assert
173
 
  }
 
173
//   int pos = start;
 
174
//   foreach(Message msg, msglist) {
 
175
//     _messageList.insert(pos, createMessageModelItem(msg));
 
176
//     pos++;
 
177
//   }
 
178
//   if(dayChangeItem) {
 
179
//     _messageList.insert(pos, dayChangeItem);
 
180
//     pos++; // needed for the following assert
 
181
//   }
 
182
  insertMessages__(start, msglist);
 
183
  if(dayChangeMsg.isValid())
 
184
    insertMessage__(start + msglist.count(), dayChangeMsg);
174
185
  endInsertRows();
175
186
 
176
187
//   Q_ASSERT(start == end || _messageList.at(start)->msgId() != _messageList.at(end)->msgId() || _messageList.at(end)->msgType() == Message::DayChange);
177
 
  Q_ASSERT(start == 0 || _messageList[start - 1]->msgId() < _messageList[start]->msgId());
178
 
  Q_ASSERT(end + 1 == _messageList.count() || _messageList[end]->msgId() < _messageList[end + 1]->msgId());
179
 
  Q_ASSERT(pos - 1 == end);
 
188
  Q_ASSERT(start == 0 || messageItemAt(start - 1)->msgId() < messageItemAt(start)->msgId());
 
189
  Q_ASSERT(end + 1 == messageCount() || messageItemAt(end)->msgId() < messageItemAt(end + 1)->msgId());
 
190
//   Q_ASSERT(pos - 1 == end);
180
191
}
181
192
 
182
193
int MessageModel::insertMessagesGracefully(const QList<Message> &msglist) {
205
216
  }
206
217
 
207
218
  idx = indexForId((*iter).msgId());
208
 
  if(idx < _messageList.count())
209
 
    dupeId = _messageList[idx]->msgId();
 
219
  if(idx < messageCount())
 
220
    dupeId = messageItemAt(idx)->msgId();
210
221
 
211
222
  // we always compare to the previous entry...
212
223
  // if there isn't, we can fastforward to the top
213
224
  if(idx - 1 >= 0)
214
 
    minId = _messageList[idx - 1]->msgId();
 
225
    minId = messageItemAt(idx - 1)->msgId();
215
226
  else
216
227
    fastForward = true;
217
228
 
233
244
 
234
245
      if(grouplist.isEmpty()) { // as long as we don't have a starting point, we have to update the dupeId
235
246
        idx = indexForId((*iter).msgId());
236
 
        if(idx >= 0 && !_messageList.isEmpty())
237
 
          dupeId = _messageList[idx]->msgId();
 
247
        if(idx >= 0 && !messagesIsEmpty())
 
248
          dupeId = messageItemAt(idx)->msgId();
238
249
      }
239
250
      if((*iter).msgId() != dupeId) {
240
251
        if(!grouplist.isEmpty()) {
264
275
 
265
276
      if(grouplist.isEmpty()) { // as long as we don't have a starting point, we have to update the dupeId
266
277
        idx = indexForId((*iter).msgId());
267
 
        if(idx >= 0 && !_messageList.isEmpty())
268
 
          dupeId = _messageList[idx]->msgId();
 
278
        if(idx >= 0 && !messagesIsEmpty())
 
279
          dupeId = messageItemAt(idx)->msgId();
269
280
      }
270
281
      if((*iter).msgId() != dupeId) {
271
282
        if(!grouplist.isEmpty()) {
316
327
 
317
328
void MessageModel::clear() {
318
329
  beginRemoveRows(QModelIndex(), 0, rowCount() - 1);
319
 
  qDeleteAll(_messageList);
320
 
  _messageList.clear();
 
330
  removeAllMessages();
321
331
  endRemoveRows();
322
332
  _messagesWaiting.clear();
323
333
}
324
334
 
325
335
// returns index of msg with given Id or of the next message after that (i.e., the index where we'd insert this msg)
326
336
int MessageModel::indexForId(MsgId id) {
327
 
  if(_messageList.isEmpty() || id <= _messageList.value(0)->msgId())
 
337
  if(messagesIsEmpty() || id <= messageItemAt(0)->msgId())
328
338
    return 0;
329
 
  if(id > _messageList.last()->msgId())
330
 
    return _messageList.count();
 
339
 
 
340
  if(id > lastMessageItem()->msgId())
 
341
    return messageCount();
331
342
 
332
343
  // binary search
333
 
  int start = 0; int end = _messageList.count()-1;
 
344
  int start = 0; int end = messageCount() - 1;
334
345
  while(1) {
335
346
    if(end - start == 1)
336
347
      return end;
337
348
    int pivot = (end + start) / 2;
338
 
    if(id <= _messageList.value(pivot)->msgId()) end = pivot;
 
349
    if(id <= messageItemAt(pivot)->msgId()) end = pivot;
339
350
    else start = pivot;
340
351
  }
341
352
}
342
353
 
343
354
void MessageModel::changeOfDay() {
344
355
  _dayChangeTimer.setInterval(86400000);
345
 
  if(!_messageList.isEmpty()) {
346
 
    int idx = _messageList.count();
347
 
    while(idx > 0 && _messageList[idx - 1]->timeStamp() > _nextDayChange) {
 
356
  if(!messagesIsEmpty()) {
 
357
    int idx = messageCount();
 
358
    while(idx > 0 && messageItemAt(idx - 1)->timestamp() > _nextDayChange) {
348
359
      idx--;
349
360
    }
350
361
    beginInsertRows(QModelIndex(), idx, idx);
351
362
    Message dayChangeMsg = Message::ChangeOfDay(_nextDayChange);
352
 
    dayChangeMsg.setMsgId(_messageList[idx - 1]->msgId());
353
 
    _messageList.insert(idx, createMessageModelItem(dayChangeMsg));
 
363
    dayChangeMsg.setMsgId(messageItemAt(idx - 1)->msgId());
 
364
    insertMessage__(idx, dayChangeMsg);
354
365
    endInsertRows();
355
366
  }
356
367
  _nextDayChange = _nextDayChange.addSecs(86400);
363
374
  BacklogSettings backlogSettings;
364
375
  int requestCount = backlogSettings.dynamicBacklogAmount();
365
376
 
366
 
  for(int i = 0; i < _messageList.count(); i++) {
367
 
    if(_messageList.at(i)->bufferId() == bufferId) {
 
377
  for(int i = 0; i < messageCount(); i++) {
 
378
    if(messageItemAt(i)->bufferId() == bufferId) {
368
379
      _messagesWaiting[bufferId] = requestCount;
369
380
      Client::backlogManager()->emitMessagesRequested(tr("Requesting %1 messages from backlog for buffer %2:%3")
370
381
                                                      .arg(requestCount)
371
382
                                                      .arg(Client::networkModel()->networkName(bufferId))
372
383
                                                      .arg(Client::networkModel()->bufferName(bufferId)));
373
 
      Client::backlogManager()->requestBacklog(bufferId, -1, _messageList.at(i)->msgId(), requestCount);
 
384
      Client::backlogManager()->requestBacklog(bufferId, -1, messageItemAt(i)->msgId(), requestCount);
374
385
      return;
375
386
    }
376
387
  }
386
397
}
387
398
 
388
399
void MessageModel::buffersPermanentlyMerged(BufferId bufferId1, BufferId bufferId2) {
389
 
  for(int i = 0; i < _messageList.count(); i++) {
390
 
    if(_messageList[i]->bufferId() == bufferId2) {
391
 
      _messageList[i]->setBufferId(bufferId1);
 
400
  for(int i = 0; i < messageCount(); i++) {
 
401
    if(messageItemAt(i)->bufferId() == bufferId2) {
 
402
      messageItemAt(i)->setBufferId(bufferId1);
392
403
      QModelIndex idx = index(i, 0);
393
404
      emit dataChanged(idx, idx);
394
405
    }
398
409
// ========================================
399
410
//  MessageModelItem
400
411
// ========================================
401
 
MessageModelItem::MessageModelItem(const Message &msg) :
402
 
  _timestamp(msg.timestamp()),
403
 
  _msgId(msg.msgId()),
404
 
  _bufferId(msg.bufferInfo().bufferId()),
405
 
  _type(msg.type()),
406
 
  _flags(msg.flags())
407
 
{
408
 
  if(!msg.sender().contains('!'))
409
 
    _flags |= Message::ServerMsg;
410
 
}
411
 
 
412
412
QVariant MessageModelItem::data(int column, int role) const {
413
413
  if(column < MessageModel::TimestampColumn || column > MessageModel::ContentsColumn)
414
414
    return QVariant();
415
415
 
416
416
  switch(role) {
417
 
  case MessageModel::MsgIdRole: return QVariant::fromValue<MsgId>(_msgId);
418
 
  case MessageModel::BufferIdRole: return QVariant::fromValue<BufferId>(_bufferId);
419
 
  case MessageModel::TypeRole: return _type;
420
 
  case MessageModel::FlagsRole: return (int)_flags;
421
 
  case MessageModel::TimestampRole: return _timestamp;
 
417
  case MessageModel::MsgIdRole: return QVariant::fromValue<MsgId>(msgId());
 
418
  case MessageModel::BufferIdRole: return QVariant::fromValue<BufferId>(bufferId());
 
419
  case MessageModel::TypeRole: return msgType();
 
420
  case MessageModel::FlagsRole: return (int)msgFlags();
 
421
  case MessageModel::TimestampRole: return timestamp();
422
422
  case MessageModel::RedirectedToRole: return qVariantFromValue<BufferId>(_redirectedTo);
423
423
  default: return QVariant();
424
424
  }
442
442
}
443
443
 
444
444
bool MessageModelItem::operator<(const MessageModelItem &other) const {
445
 
  return _msgId < other._msgId;
 
445
  return msgId() < other.msgId();
446
446
}
447
447
 
448
448
bool MessageModelItem::operator==(const MessageModelItem &other) const {
449
 
  return _msgId == other._msgId;
 
449
  return msgId() == other.msgId();
450
450
}
451
451
 
452
452
bool MessageModelItem::operator>(const MessageModelItem &other) const {
453
 
  return _msgId > other._msgId;
 
453
  return msgId() > other.msgId();
454
454
}
455
455
 
456
456
QDebug operator<<(QDebug dbg, const MessageModelItem &msgItem) {
457
457
  dbg.nospace() << qPrintable(QString("MessageModelItem(MsgId:")) << msgItem.msgId()
458
 
                << qPrintable(QString(",")) << msgItem.timeStamp()
 
458
                << qPrintable(QString(",")) << msgItem.timestamp()
459
459
                << qPrintable(QString(", Type:")) << msgItem.msgType()
460
460
                << qPrintable(QString(", Flags:")) << msgItem.msgFlags() << qPrintable(QString(")"))
461
461
                << msgItem.data(1, Qt::DisplayRole).toString() << ":" << msgItem.data(2, Qt::DisplayRole).toString();