X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fclient%2Fnetworkmodel.cpp;h=4ccb5b5dd9fc7ea451b8e0d317044a220ab5ff07;hp=ff44942482eb47d9ea6ac54c2590a09169852593;hb=770b7ef54b03f3ebd1e29a58b4757505e1809b2d;hpb=e226a532d5f6cb4ff58edd30421386c6f8dc7d4d

diff --git a/src/client/networkmodel.cpp b/src/client/networkmodel.cpp
index ff449424..4ccb5b5d 100644
--- a/src/client/networkmodel.cpp
+++ b/src/client/networkmodel.cpp
@@ -59,7 +59,7 @@ const BufferInfo &BufferItem::bufferInfo() const {
 }
 
 quint64 BufferItem::id() const {
-  return bufferInfo().uid();
+  return bufferInfo().uid().toInt();
 }
 
 bool BufferItem::isStatusBuffer() const {
@@ -83,10 +83,12 @@ BufferItem::ActivityLevel BufferItem::activity() const {
 
 void BufferItem::setActivity(const ActivityLevel &level) {
   _activity = level;
+  emit dataChanged();
 }
 
-void BufferItem::addActivity(const ActivityLevel &level) {
+void BufferItem::updateActivity(const ActivityLevel &level) {
   _activity |= level;
+  emit dataChanged();
 }
 
 QVariant BufferItem::data(int column, int role) const {
@@ -94,18 +96,33 @@ QVariant BufferItem::data(int column, int role) const {
   case NetworkModel::ItemTypeRole:
     return NetworkModel::BufferItemType;
   case NetworkModel::BufferIdRole:
-    return bufferInfo().uid();
+    return qVariantFromValue(bufferInfo().uid());
   case NetworkModel::NetworkIdRole:
-    return bufferInfo().networkId();
+    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:
+    setActivity((ActivityLevel)value.toInt());
+  default:
+    return PropertyMapItem::setData(column, value, role);
+  }
+  return true;
+}
+
+
 void BufferItem::attachIrcChannel(IrcChannel *ircChannel) {
   if(!ircChannel)
     return;
@@ -120,16 +137,19 @@ void BufferItem::attachIrcChannel(IrcChannel *ircChannel) {
 	  this, SLOT(part(IrcUser *)));
   connect(ircChannel, SIGNAL(destroyed()),
 	  this, SLOT(ircChannelDestroyed()));
+  connect(ircChannel, SIGNAL(ircUserModesSet(IrcUser *, QString)),
+	  this, SLOT(userModeChanged(IrcUser *)));
+  connect(ircChannel, SIGNAL(ircUserModeAdded(IrcUser *, QString)),
+	  this, SLOT(userModeChanged(IrcUser *)));
+  connect(ircChannel, SIGNAL(ircUserModeRemoved(IrcUser *, QString)),
+	  this, SLOT(userModeChanged(IrcUser *)));
   
   emit dataChanged();
 }
 
 void BufferItem::ircChannelDestroyed() {
   emit dataChanged();
-  for(int i = 0; i < childCount(); i++) {
-    emit childDestroyed(i);
-    removeChild(i);
-  }
+  removeAllChilds();
 }
 
 QString BufferItem::bufferName() const {
@@ -159,22 +179,79 @@ void BufferItem::setTopic(const QString &topic) {
 }
 
 void BufferItem::join(IrcUser *ircUser) {
-  emit newChild(new IrcUserItem(ircUser, this));
+  if(!ircUser)
+    return;
+
+  addUserToCategory(ircUser);
   emit dataChanged(2);
 }
 
+void BufferItem::addUserToCategory(IrcUser *ircUser) {
+  Q_ASSERT(_ircChannel);
+
+  UserCategoryItem *categoryItem;
+  int categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
+  if(!(categoryItem = qobject_cast<UserCategoryItem *>(childById(qHash(categoryId))))) {
+    categoryItem = new UserCategoryItem(categoryId, this);
+    newChild(categoryItem);
+  }
+  categoryItem->addUser(ircUser);
+
+  int totalusers = 0;
+  for(int i = 0; i < childCount(); i++) {
+    totalusers += child(i)->childCount();
+  }
+}
+
 void BufferItem::part(IrcUser *ircUser) {
-  Q_UNUSED(ircUser);
+  if(!ircUser) {
+    qWarning() << bufferName() << "BufferItem::part(): unknown User" << ircUser;
+    return;
+  }
+
+  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));
+    if(success = categoryItem->removeChildById((quint64)ircUser)) {
+      if(categoryItem->childCount() == 0)
+	removeChild(i);
+      break;
+    }
+  }
+  Q_ASSERT(success);
+
+  int totalusers = 0;
+  for(int i = 0; i < childCount(); i++) {
+    totalusers += child(i)->childCount();
+  }
+}
+
+void BufferItem::userModeChanged(IrcUser *ircUser) {
+  Q_ASSERT(_ircChannel);
+
+  UserCategoryItem *categoryItem;
+  int categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
+  if((categoryItem = qobject_cast<UserCategoryItem *>(childById(qHash(categoryId)))) && categoryItem->childById((quint64)(ircUser)))
+    return; // already in the right category;
+  
+  removeUserFromCategory(ircUser);
+  addUserToCategory(ircUser);
+}
+
 /*****************************************
 *  Network Items
 *****************************************/
-NetworkItem::NetworkItem(const uint &netid, const QString &network, AbstractTreeItem *parent)
+NetworkItem::NetworkItem(const NetworkId &netid, AbstractTreeItem *parent)
   : PropertyMapItem(QList<QString>() << "networkName" << "currentServer" << "nickCount", parent),
-    _networkId(netid),
-    _networkName(network)
+    _networkId(netid)
 {
   setFlags(Qt::ItemIsEnabled);
 }
@@ -182,7 +259,7 @@ NetworkItem::NetworkItem(const uint &netid, const QString &network, AbstractTree
 QVariant NetworkItem::data(int column, int role) const {
   switch(role) {
   case NetworkModel::NetworkIdRole:
-    return _networkId;
+    return qVariantFromValue(_networkId);
   case NetworkModel::ItemTypeRole:
     return NetworkModel::NetworkItemType;
   case NetworkModel::ItemActiveRole:
@@ -193,7 +270,7 @@ QVariant NetworkItem::data(int column, int role) const {
 }
 
 quint64 NetworkItem::id() const {
-  return _networkId;
+  return _networkId.toInt();
 }
 
 bool NetworkItem::isActive() const {
@@ -204,7 +281,7 @@ QString NetworkItem::networkName() const {
   if(_network)
     return _network->networkName();
   else
-    return _networkName;
+    return QString();
 }
 
 QString NetworkItem::currentServer() const {
@@ -265,6 +342,64 @@ void NetworkItem::setCurrentServer(const QString &serverName) {
   emit dataChanged(1);
 }
 
+/*****************************************
+*  User Category Items (like @vh etc.)
+*****************************************/
+// 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");
+
+UserCategoryItem::UserCategoryItem(int category, AbstractTreeItem *parent)
+  : PropertyMapItem(QStringList() << "categoryId", parent),
+    _category(category)
+{
+}
+
+QString UserCategoryItem::categoryId() {
+  if(_category < categories.count())
+    return categories[_category].displayString;
+  else
+    return QString("Users");
+}
+
+quint64 UserCategoryItem::id() const {
+  return qHash(_category);
+}
+
+void UserCategoryItem::addUser(IrcUser *ircUser) {
+  newChild(new IrcUserItem(ircUser, this));
+}
+
+int UserCategoryItem::categoryFromModes(const QString &modes) {
+  for(int i = 0; i < categories.count(); i++) {
+    if(modes.contains(categories[i].mode))
+      return i;
+  }
+  return categories.count();
+}
+
+QVariant UserCategoryItem::data(int column, int role) const {
+  switch(role) {
+  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
 *****************************************/
@@ -272,25 +407,49 @@ IrcUserItem::IrcUserItem(IrcUser *ircUser, AbstractTreeItem *parent)
   : PropertyMapItem(QStringList() << "nickName", parent),
     _ircUser(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() {
+QString IrcUserItem::nickName() const {
   return _ircUser->nick();
 }
 
+IrcUser *IrcUserItem::ircUser() {
+  return _ircUser;
+}
+
+quint64 IrcUserItem::id() const {
+  return (quint64)_ircUser;
+}
+
+QVariant IrcUserItem::data(int column, int role) const {
+  switch(role) {
+  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);
+  return "<p><b>" + nickName() + "</b><br />" + _ircUser->hostmask() + "</p>";
+}
+
 void IrcUserItem::setNick(QString newNick) {
   Q_UNUSED(newNick);
   emit dataChanged(0);
 }
-void IrcUserItem::ircUserDestroyed() {
-  deleteLater();
-}
-
 
 /*****************************************
  * NetworkModel
@@ -310,45 +469,47 @@ bool NetworkModel::isBufferIndex(const QModelIndex &index) const {
   return index.data(NetworkModel::ItemTypeRole) == NetworkModel::BufferItemType;
 }
 
+/*
 Buffer *NetworkModel::getBufferByIndex(const QModelIndex &index) const {
   BufferItem *item = static_cast<BufferItem *>(index.internalPointer());
   return Client::instance()->buffer(item->id());
 }
+*/
 
 
 // experimental stuff :)
-QModelIndex NetworkModel::networkIndex(uint networkId) {
-  return indexById(networkId);
+QModelIndex NetworkModel::networkIndex(NetworkId networkId) {
+  return indexById(networkId.toInt());
 }
 
-NetworkItem *NetworkModel::network(uint networkId) {
-  return qobject_cast<NetworkItem *>(rootItem->childById(networkId));
+NetworkItem *NetworkModel::existsNetworkItem(NetworkId networkId) {
+  return qobject_cast<NetworkItem *>(rootItem->childById(networkId.toInt()));
 }
 
-NetworkItem *NetworkModel::newNetwork(uint networkId, const QString &networkName) {
-  NetworkItem *networkItem = network(networkId);
+NetworkItem *NetworkModel::networkItem(NetworkId networkId) {
+  NetworkItem *netItem = existsNetworkItem(networkId);
 
-  if(networkItem == 0) {
-    networkItem = new NetworkItem(networkId, networkName, rootItem);
-    appendChild(rootItem, networkItem);
+  if(netItem == 0) {
+    netItem = new NetworkItem(networkId, rootItem);
+    rootItem->newChild(netItem);
   }
 
-  Q_ASSERT(networkItem);
-  return networkItem;
+  Q_ASSERT(netItem);
+  return netItem;
 }
 
 QModelIndex NetworkModel::bufferIndex(BufferId bufferId) {
   AbstractTreeItem *netItem, *bufferItem;
   for(int i = 0; i < rootItem->childCount(); i++) {
     netItem = rootItem->child(i);
-    if((bufferItem = netItem->childById(bufferId))) {
+    if((bufferItem = netItem->childById(bufferId.toInt()))) {
       return indexById(bufferItem->id(), networkIndex(netItem->id()));
     }
   }
   return QModelIndex();
 }
 
-BufferItem *NetworkModel::buffer(BufferInfo bufferInfo) {
+BufferItem *NetworkModel::existsBufferItem(const BufferInfo &bufferInfo) {
   QModelIndex bufferIdx = bufferIndex(bufferInfo.uid());
   if(bufferIdx.isValid())
     return static_cast<BufferItem *>(bufferIdx.internalPointer());
@@ -356,16 +517,16 @@ BufferItem *NetworkModel::buffer(BufferInfo bufferInfo) {
     return 0;
 }
 
-BufferItem *NetworkModel::newBuffer(BufferInfo bufferInfo) {
-  BufferItem *bufferItem = buffer(bufferInfo);
-  if(bufferItem == 0) {
-    NetworkItem *networkItem = newNetwork(bufferInfo.networkId(), bufferInfo.network());
-    bufferItem = new BufferItem(bufferInfo, networkItem);
-    appendChild(networkItem, bufferItem);
+BufferItem *NetworkModel::bufferItem(const BufferInfo &bufferInfo) {
+  BufferItem *bufItem = existsBufferItem(bufferInfo);
+  if(bufItem == 0) {
+    NetworkItem *netItem = networkItem(bufferInfo.networkId());
+    bufItem = new BufferItem(bufferInfo, netItem);
+    netItem->newChild(bufItem);
   }
 
-  Q_ASSERT(bufferItem);
-  return bufferItem;
+  Q_ASSERT(bufItem);
+  return bufItem;
 }
 
 QStringList NetworkModel::mimeTypes() const {
@@ -381,19 +542,20 @@ bool NetworkModel::mimeContainsBufferList(const QMimeData *mimeData) {
   return mimeData->hasFormat("application/Quassel/BufferItemList");
 }
 
-QList< QPair<uint, uint> > NetworkModel::mimeDataToBufferList(const QMimeData *mimeData) {
-  QList< QPair<uint, uint> > bufferList;
+QList< QPair<NetworkId, BufferId> > NetworkModel::mimeDataToBufferList(const QMimeData *mimeData) {
+  QList< QPair<NetworkId, BufferId> > bufferList;
 
   if(!mimeContainsBufferList(mimeData))
     return bufferList;
 
   QStringList rawBufferList = QString::fromAscii(mimeData->data("application/Quassel/BufferItemList")).split(",");
-  uint networkId, bufferUid;
+  NetworkId networkId;
+  BufferId bufferUid;
   foreach(QString rawBuffer, rawBufferList) {
     if(!rawBuffer.contains(":"))
       continue;
-    networkId = rawBuffer.section(":", 0, 0).toUInt();
-    bufferUid = rawBuffer.section(":", 1, 1).toUInt();
+    networkId = rawBuffer.section(":", 0, 0).toInt();
+    bufferUid = rawBuffer.section(":", 1, 1).toInt();
     bufferList.append(qMakePair(networkId, bufferUid));
   }
   return bufferList;
@@ -406,8 +568,8 @@ QMimeData *NetworkModel::mimeData(const QModelIndexList &indexes) const {
   QStringList bufferlist;
   QString netid, uid, bufferid;
   foreach(QModelIndex index, indexes) {
-    netid = QString::number(index.data(NetworkIdRole).toUInt());
-    uid = QString::number(index.data(BufferIdRole).toUInt());
+    netid = QString::number(index.data(NetworkIdRole).value<NetworkId>().toInt());
+    uid = QString::number(index.data(BufferIdRole).value<BufferId>().toInt());
     bufferid = QString("%1:%2").arg(netid).arg(uid);
     if(!bufferlist.contains(bufferid))
       bufferlist << bufferid;
@@ -431,56 +593,53 @@ bool NetworkModel::dropMimeData(const QMimeData *data, Qt::DropAction action, in
   if(targetType != BufferItem::QueryType)
     return false;
 
-  QList< QPair<uint, uint> > bufferList = mimeDataToBufferList(data);
+  QList< QPair<NetworkId, BufferId> > bufferList = mimeDataToBufferList(data);
 
   // exactly one buffer has to be dropped
   if(bufferList.count() != 1)
     return false;
 
-  uint netId = bufferList.first().first;
-  uint bufferId = bufferList.first().second;
+  NetworkId netId = bufferList.first().first;
+  BufferId bufferId = bufferList.first().second;
 
   // no self merges (would kill us)
-  if(bufferId == parent.data(BufferIdRole).toUInt())
+  if(bufferId == parent.data(BufferIdRole).value<BufferId>())
     return false; 
   
-  Q_ASSERT(rootItem->childById(netId));
-  Q_ASSERT(rootItem->childById(netId)->childById(bufferId));
+  Q_ASSERT(rootItem->childById(netId.toInt()));
+  Q_ASSERT(rootItem->childById(netId.toInt())->childById(bufferId.toInt()));
 
   // source must be a query too
-  BufferItem::Type sourceType = (BufferItem::Type)rootItem->childById(netId)->childById(bufferId)->data(0, BufferTypeRole).toInt();
+  BufferItem::Type sourceType = (BufferItem::Type)rootItem->childById(netId.toInt())->childById(bufferId.toInt())->data(0, BufferTypeRole).toInt();
   if(sourceType != BufferItem::QueryType)
     return false;
     
   // TODO: warn user about buffermerge!
-  qDebug() << "merging" << bufferId << parent.data(BufferIdRole).toInt();
+  qDebug() << "merging" << bufferId << parent.data(BufferIdRole).value<BufferId>();
   removeRow(parent.row(), parent.parent());
   
   return true;
 }
 
 void NetworkModel::attachNetwork(Network *net) {
-  NetworkItem *networkItem = network(net->networkId());
-  if(!networkItem) {
-    qWarning() << "NetworkModel::attachNetwork(): network is unknown!";
-    return;
-  }
-  networkItem->attachNetwork(net);
+  NetworkItem *netItem = networkItem(net->networkId());
+  netItem->attachNetwork(net);
 }
 
 void NetworkModel::bufferUpdated(BufferInfo bufferInfo) {
-  BufferItem *bufferItem = newBuffer(bufferInfo);
-  QModelIndex itemindex = indexByItem(bufferItem);
+  BufferItem *bufItem = bufferItem(bufferInfo);
+  QModelIndex itemindex = indexByItem(bufItem);
   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::ActivityLevel level = BufferItem::OtherActivity;
+  if(msg.type() == Message::Plain || msg.type() == Message::Notice)
+    level |= BufferItem::NewMessage;
+
+  if(msg.flags() & Message::Highlight)
+    level |= BufferItem::Highlight;
+  
+  bufferItem(msg.buffer())->updateActivity(level);
 }