X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fclient%2Fnetworkmodel.cpp;h=4f7935cf8820f64812528a883bdf97b3d4a7b427;hp=4c82418266dad2e2be95e423ee74b24e88510a0d;hb=a45c66ff2974e6599ac97884c60da9e29a402ddf;hpb=6cd95dbc8ac28ab7a22e640d9fe6e3a6aff8f8a9

diff --git a/src/client/networkmodel.cpp b/src/client/networkmodel.cpp
index 4c824182..4f7935cf 100644
--- a/src/client/networkmodel.cpp
+++ b/src/client/networkmodel.cpp
@@ -40,9 +40,9 @@ BufferItem::BufferItem(BufferInfo bufferInfo, AbstractTreeItem *parent)
     _activity(NoActivity)
 {
   // determine BufferType
-  if(bufferInfo.buffer().isEmpty())
+  if(bufferInfo.bufferName().isEmpty())
     _type = StatusType;
-  else if(isChannelName(bufferInfo.buffer()))
+  else if(isChannelName(bufferInfo.bufferName()))
     _type = ChannelType;
   else
     _type = QueryType;
@@ -51,15 +51,16 @@ BufferItem::BufferItem(BufferInfo bufferInfo, AbstractTreeItem *parent)
   if(bufferType() == QueryType)
     flags |= Qt::ItemIsDropEnabled;
   setFlags(flags);
-}
 
+  _lastSeen = BufferSettings(bufferInfo.bufferId()).lastSeen();
+}
 
 const BufferInfo &BufferItem::bufferInfo() const {
   return _bufferInfo;
 }
 
 quint64 BufferItem::id() const {
-  return bufferInfo().uid().toInt();
+  return qHash(bufferInfo().bufferId());
 }
 
 bool BufferItem::isStatusBuffer() const {
@@ -81,12 +82,17 @@ BufferItem::ActivityLevel BufferItem::activity() const {
   return _activity;
 }
 
-void BufferItem::setActivity(const ActivityLevel &level) {
+bool BufferItem::setActivity(const ActivityLevel &level) {
   _activity = level;
+  emit dataChanged();
+  return true;
 }
 
-void BufferItem::addActivity(const ActivityLevel &level) {
+void BufferItem::updateActivity(const ActivityLevel &level) {
+  ActivityLevel oldActivity = _activity;
   _activity |= level;
+  if(oldActivity != _activity)
+    emit dataChanged();
 }
 
 QVariant BufferItem::data(int column, int role) const {
@@ -94,18 +100,35 @@ QVariant BufferItem::data(int column, int role) const {
   case NetworkModel::ItemTypeRole:
     return NetworkModel::BufferItemType;
   case NetworkModel::BufferIdRole:
-    return qVariantFromValue(bufferInfo().uid());
+    return qVariantFromValue(bufferInfo().bufferId());
   case NetworkModel::NetworkIdRole:
     return qVariantFromValue(bufferInfo().networkId());
+  case NetworkModel::BufferInfoRole:
+    return qVariantFromValue(bufferInfo());
   case NetworkModel::BufferTypeRole:
     return int(bufferType());
   case NetworkModel::ItemActiveRole:
     return isActive();
+  case NetworkModel::BufferActivityRole:
+    return qVariantFromValue((int)activity());
   default:
     return PropertyMapItem::data(column, role);
   }
 }
 
+bool BufferItem::setData(int column, const QVariant &value, int role) {
+  switch(role) {
+  case NetworkModel::BufferActivityRole:
+    return setActivity((ActivityLevel)value.toInt());
+  case NetworkModel::LastSeenRole:
+    return setLastSeen();
+  default:
+    return PropertyMapItem::setData(column, value, role);
+  }
+  return true;
+}
+
+
 void BufferItem::attachIrcChannel(IrcChannel *ircChannel) {
   if(!ircChannel)
     return;
@@ -126,6 +149,13 @@ void BufferItem::attachIrcChannel(IrcChannel *ircChannel) {
 	  this, SLOT(userModeChanged(IrcUser *)));
   connect(ircChannel, SIGNAL(ircUserModeRemoved(IrcUser *, QString)),
 	  this, SLOT(userModeChanged(IrcUser *)));
+
+  if(!ircChannel->ircUsers().isEmpty()) {
+    qWarning() << "Channel" << ircChannel->name() << "has already users which is quite surprising :)";
+    foreach(IrcUser *ircUser, ircChannel->ircUsers()) {
+      join(ircUser);
+    }
+  }
   
   emit dataChanged();
 }
@@ -139,7 +169,7 @@ QString BufferItem::bufferName() const {
   if(bufferType() == StatusType)
     return tr("Status Buffer");
   else
-    return bufferInfo().buffer();
+    return bufferInfo().bufferName();
 }
 
 QString BufferItem::topic() const {
@@ -149,6 +179,13 @@ QString BufferItem::topic() const {
     return QString();
 }
 
+void BufferItem::ircUserDestroyed() {
+  // PRIVATE
+  IrcUser *ircUser = static_cast<IrcUser *>(sender());
+  removeUserFromCategory(ircUser);
+  emit dataChanged(2);
+}
+
 int BufferItem::nickCount() const {
   if(_ircChannel)
     return _ircChannel->ircUsers().count();
@@ -166,6 +203,8 @@ void BufferItem::join(IrcUser *ircUser) {
     return;
 
   addUserToCategory(ircUser);
+  connect(ircUser, SIGNAL(destroyed()),
+	  this, SLOT(ircUserDestroyed()));
   emit dataChanged(2);
 }
 
@@ -176,26 +215,55 @@ void BufferItem::addUserToCategory(IrcUser *ircUser) {
   int categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
   if(!(categoryItem = qobject_cast<UserCategoryItem *>(childById(qHash(categoryId))))) {
     categoryItem = new UserCategoryItem(categoryId, this);
-    emit newChild(categoryItem);
+    newChild(categoryItem);
   }
   categoryItem->addUser(ircUser);
+
+  int totalusers = 0;
+  for(int i = 0; i < childCount(); i++) {
+    totalusers += child(i)->childCount();
+  }
 }
 
 void BufferItem::part(IrcUser *ircUser) {
-  if(!ircUser)
+  if(!ircUser) {
+    qWarning() << bufferName() << "BufferItem::part(): unknown User" << ircUser;
     return;
+  }
 
+  disconnect(ircUser, 0, this, 0);
   removeUserFromCategory(ircUser);
   emit dataChanged(2);
 }
 
 void BufferItem::removeUserFromCategory(IrcUser *ircUser) {
+  Q_ASSERT(_ircChannel);
+
+  bool success = false;
   UserCategoryItem *categoryItem = 0;
   for(int i = 0; i < childCount(); i++) {
     categoryItem = qobject_cast<UserCategoryItem *>(child(i));
-    categoryItem->removeChildById((quint64)ircUser);
-    if(categoryItem->childCount() == 0)
-      removeChild(i);
+    if(success = categoryItem->removeUser(ircUser)) {
+      if(categoryItem->childCount() == 0)
+	removeChild(i);
+      break;
+    }
+  }
+
+  if(!success) {
+    qDebug() << "didn't find User:" << ircUser << (quint64)ircUser;
+    qDebug() << "==== Childlist for Item:" << this << id() << bufferName() << "====";
+    for(int i = 0; i < childCount(); i++) {
+      categoryItem = qobject_cast<UserCategoryItem *>(child(i));
+      categoryItem->dumpChildList();
+    }
+    qDebug() << "==== End Of Childlist for Item:" << this << id() << bufferName() << "====";
+  }
+  Q_ASSERT(success);
+
+  int totalusers = 0;
+  for(int i = 0; i < childCount(); i++) {
+    totalusers += child(i)->childCount();
   }
 }
 
@@ -211,6 +279,21 @@ void BufferItem::userModeChanged(IrcUser *ircUser) {
   addUserToCategory(ircUser);
 }
 
+void BufferItem::setLastMsgInsert(QDateTime msgDate) {
+  if(msgDate.isValid() && msgDate > _lastMsgInsert)
+    _lastMsgInsert = msgDate;
+}
+
+bool BufferItem::setLastSeen() {
+  _lastSeen = _lastMsgInsert;
+  BufferSettings(bufferInfo().bufferId()).setLastSeen(_lastSeen);
+  return true;
+}
+
+QDateTime BufferItem::lastSeen() {
+  return _lastSeen;
+}
+
 /*****************************************
 *  Network Items
 *****************************************/
@@ -235,11 +318,19 @@ QVariant NetworkItem::data(int column, int role) const {
 }
 
 quint64 NetworkItem::id() const {
-  return _networkId.toInt();
+  return qHash(_networkId);
+}
+
+void NetworkItem::setActive(bool connected) {
+  Q_UNUSED(connected);
+  emit dataChanged();
 }
 
 bool NetworkItem::isActive() const {
-  return _network;
+  if(_network)
+    return _network->isConnected();
+  else
+    return false;
 }
 
 QString NetworkItem::networkName() const {
@@ -275,6 +366,9 @@ void NetworkItem::attachNetwork(Network *network) {
 	  this, SLOT(setCurrentServer(QString)));
   connect(network, SIGNAL(ircChannelAdded(QString)),
 	  this, SLOT(attachIrcChannel(QString)));
+  connect(network, SIGNAL(connectedSet(bool)),
+	  this, SLOT(setActive(bool)));
+  
   // FIXME: connect this and that...
 
   emit dataChanged();
@@ -312,12 +406,13 @@ void NetworkItem::setCurrentServer(const QString &serverName) {
 *****************************************/
 // we hardcode this even though we have PREFIX in network... but that wouldn't help with mapping modes to
 // category strings anyway.
-const QList<UserCategoryItem::Category> UserCategoryItem::categories = QList<UserCategoryItem::Category>() << UserCategoryItem::Category('q', "Owners")
-													   << UserCategoryItem::Category('a', "Admins")
-													   << UserCategoryItem::Category('a', "Admins")
-													   << UserCategoryItem::Category('o', "Operators")
-													   << UserCategoryItem::Category('h', "Half-Ops")
-													   << UserCategoryItem::Category('v', "Voiced");
+const QList<UserCategoryItem::Category> UserCategoryItem::categories = QList<UserCategoryItem::Category>()
+  << UserCategoryItem::Category('q', "Owners")
+  << UserCategoryItem::Category('a', "Admins")
+  << UserCategoryItem::Category('a', "Admins")
+  << UserCategoryItem::Category('o', "Operators")
+  << UserCategoryItem::Category('h', "Half-Ops")
+  << UserCategoryItem::Category('v', "Voiced");
 
 UserCategoryItem::UserCategoryItem(int category, AbstractTreeItem *parent)
   : PropertyMapItem(QStringList() << "categoryId", parent),
@@ -337,7 +432,11 @@ quint64 UserCategoryItem::id() const {
 }
 
 void UserCategoryItem::addUser(IrcUser *ircUser) {
-  emit newChild(new IrcUserItem(ircUser, this));
+  newChild(new IrcUserItem(ircUser, this));
+}
+
+bool UserCategoryItem::removeUser(IrcUser *ircUser) {
+  return removeChildById((quint64)ircUser);
 }
 
 int UserCategoryItem::categoryFromModes(const QString &modes) {
@@ -347,23 +446,52 @@ int UserCategoryItem::categoryFromModes(const QString &modes) {
   }
   return categories.count();
 }
+
+QVariant UserCategoryItem::data(int column, int role) const {
+  switch(role) {
+  case NetworkModel::ItemActiveRole:
+    return true;
+  case NetworkModel::ItemTypeRole:
+    return NetworkModel::UserCategoryItemType;
+  case NetworkModel::BufferIdRole:
+    return parent()->data(column, role);
+  case NetworkModel::NetworkIdRole:
+    return parent()->data(column, role);
+  case NetworkModel::BufferInfoRole:
+    return parent()->data(column, role);
+  default:
+    return PropertyMapItem::data(column, role);
+  }
+}
+
      
 /*****************************************
 *  Irc User Items
 *****************************************/
 IrcUserItem::IrcUserItem(IrcUser *ircUser, AbstractTreeItem *parent)
   : PropertyMapItem(QStringList() << "nickName", parent),
-    _ircUser(ircUser)
+    _ircUser(ircUser),
+    _id(qHash(ircUser))
 {
-  connect(ircUser, SIGNAL(destroyed()),
-	  this, SLOT(ircUserDestroyed()));
+  // we don't need to handle the ircUser's destroyed signal since it's automatically removed
+  // by the IrcChannel::ircUserParted();
   
   connect(ircUser, SIGNAL(nickSet(QString)),
 	  this, SLOT(setNick(QString)));
 }
 
-QString IrcUserItem::nickName() {
-  return _ircUser->nick();
+QString IrcUserItem::nickName() const {
+  if(_ircUser)
+    return _ircUser->nick();
+  else
+    return QString();
+}
+
+bool IrcUserItem::isActive() const {
+  if(_ircUser)
+    return !_ircUser->isAway();
+  else
+    return false;
 }
 
 IrcUser *IrcUserItem::ircUser() {
@@ -371,17 +499,67 @@ IrcUser *IrcUserItem::ircUser() {
 }
 
 quint64 IrcUserItem::id() const {
-  return (quint64)_ircUser;
+  return _id;
+}
+
+QVariant IrcUserItem::data(int column, int role) const {
+  switch(role) {
+  case NetworkModel::ItemActiveRole:
+    return isActive();
+  case NetworkModel::ItemTypeRole:
+    return NetworkModel::IrcUserItemType;
+  case NetworkModel::BufferIdRole:
+    return parent()->data(column, role);
+  case NetworkModel::NetworkIdRole:
+    return parent()->data(column, role);
+  case NetworkModel::BufferInfoRole:
+    return parent()->data(column, role);
+  default:
+    return PropertyMapItem::data(column, role);
+  }
+}
+
+QString IrcUserItem::toolTip(int column) const {
+  Q_UNUSED(column);
+  QStringList toolTip(QString("<b>%1</b>").arg(nickName()));
+  if(_ircUser->isAway()) toolTip[0].append(" is away");
+  if(!_ircUser->awayMessage().isEmpty()) toolTip[0].append(QString(" (%1)").arg(_ircUser->awayMessage()));
+  if(!_ircUser->realName().isEmpty()) toolTip.append(_ircUser->realName());
+  if(!_ircUser->ircOperator().isEmpty()) toolTip.append(_ircUser->ircOperator());
+  toolTip.append(_ircUser->hostmask());
+
+  if(_ircUser->idleTime().isValid()) {
+    QDateTime now = QDateTime::currentDateTime();
+    QDateTime idle = _ircUser->idleTime();
+    int idleTime = idle.secsTo(now);
+
+    QList< QPair<int, QString> > timeUnit;
+    timeUnit.append(qMakePair(365*60*60, tr("year")));
+    timeUnit.append(qMakePair(24*60*60, tr("day")));
+    timeUnit.append(qMakePair(60*60, tr("h")));
+    timeUnit.append(qMakePair(60, tr("min")));
+    timeUnit.append(qMakePair(1, tr("sec")));
+
+    QString idleString(' ');
+    for(int i=0; i < timeUnit.size(); i++) {
+      int n = idleTime / timeUnit[i].first;
+      if(n > 0) {
+        idleString += QString("%1 %2 ").arg(QString::number(n), timeUnit[i].second);
+      }
+      idleTime = idleTime % timeUnit[i].first;
+    }
+    toolTip.append(QString("idling since %1").arg(idleString));
+  }
+
+  if(!_ircUser->server().isEmpty()) toolTip.append(QString("server: %1").arg(_ircUser->server()));
+
+  return QString("<p> %1 </p>").arg(toolTip.join("<br />"));
 }
 
 void IrcUserItem::setNick(QString newNick) {
   Q_UNUSED(newNick);
   emit dataChanged(0);
 }
-void IrcUserItem::ircUserDestroyed() {
-  parent()->removeChildById(id());
-  // deleteLater();
-}
 
 /*****************************************
  * NetworkModel
@@ -423,7 +601,7 @@ NetworkItem *NetworkModel::networkItem(NetworkId networkId) {
 
   if(netItem == 0) {
     netItem = new NetworkItem(networkId, rootItem);
-    appendChild(rootItem, netItem);
+    rootItem->newChild(netItem);
   }
 
   Q_ASSERT(netItem);
@@ -442,7 +620,7 @@ QModelIndex NetworkModel::bufferIndex(BufferId bufferId) {
 }
 
 BufferItem *NetworkModel::existsBufferItem(const BufferInfo &bufferInfo) {
-  QModelIndex bufferIdx = bufferIndex(bufferInfo.uid());
+  QModelIndex bufferIdx = bufferIndex(bufferInfo.bufferId());
   if(bufferIdx.isValid())
     return static_cast<BufferItem *>(bufferIdx.internalPointer());
   else
@@ -454,7 +632,7 @@ BufferItem *NetworkModel::bufferItem(const BufferInfo &bufferInfo) {
   if(bufItem == 0) {
     NetworkItem *netItem = networkItem(bufferInfo.networkId());
     bufItem = new BufferItem(bufferInfo, netItem);
-    appendChild(netItem, bufItem);
+    netItem->newChild(bufItem);
   }
 
   Q_ASSERT(bufItem);
@@ -564,13 +742,31 @@ void NetworkModel::bufferUpdated(BufferInfo bufferInfo) {
   emit dataChanged(itemindex, itemindex);
 }
 
-void NetworkModel::bufferActivity(BufferItem::ActivityLevel level, BufferInfo bufferInfo) {
-//   BufferItem *bufferItem = buffer(buf->bufferInfo());
-//   if(!bufferItem) {
-//     qWarning() << "NetworkModel::bufferActivity(): received Activity Info for uknown Buffer";
-//     return;
-//   }
-//   bufferItem->setActivity(level);
-//   bufferUpdated(buf);
+void NetworkModel::updateBufferActivity(const Message &msg) {
+  BufferItem *buff = bufferItem(msg.bufferInfo());
+  Q_ASSERT(buff);
+
+  buff->setLastMsgInsert(msg.timestamp());
+
+  if(buff->lastSeen() >= msg.timestamp())
+    return;
+
+  BufferItem::ActivityLevel level = BufferItem::OtherActivity;
+  if(msg.type() == Message::Plain || msg.type() == Message::Notice)
+    level |= BufferItem::NewMessage;
+
+  const Network *net = Client::network(msg.bufferInfo().networkId());
+  if(net && (msg.type() == Message::Plain || msg.type() == Message::Notice || msg.type() == Message::Action) && msg.text().contains(net->myNick()))
+    level |= BufferItem::Highlight;
+
+  bufferItem(msg.bufferInfo())->updateActivity(level);
 }
 
+const Network *NetworkModel::networkByIndex(const QModelIndex &index) const {
+  QVariant netVariant = index.data(NetworkIdRole);
+  if(!netVariant.isValid())
+    return 0;
+
+  NetworkId networkId = netVariant.value<NetworkId>();
+  return Client::network(networkId);
+}