X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fclient%2Fclient.cpp;h=3326b79d508bb74140b2c0bcdcffc47afdd38720;hp=4832549caaa85629163e941ba5873a0505457ac7;hb=1f7cffc751c022ddea816db471f7870a60dc0d1c;hpb=6623fd2d46dadd0168e4e28d1db6944c26c2a773

diff --git a/src/client/client.cpp b/src/client/client.cpp
index 4832549c..3326b79d 100644
--- a/src/client/client.cpp
+++ b/src/client/client.cpp
@@ -21,6 +21,7 @@
 #include "client.h"
 
 #include "bufferinfo.h"
+#include "buffersyncer.h"
 #include "global.h"
 #include "identity.h"
 #include "ircchannel.h"
@@ -32,8 +33,10 @@
 #include "quasselui.h"
 #include "signalproxy.h"
 #include "util.h"
+#include "buffersettings.h"
 
 QPointer<Client> Client::instanceptr = 0;
+AccountId Client::_currentCoreAccount = 0;
 
 /*** Initialization/destruction ***/
 
@@ -60,6 +63,7 @@ Client::Client(QObject *parent)
     mainUi(0),
     _networkModel(0),
     _bufferModel(0),
+    _bufferSyncer(0),
     _connectedToCore(false),
     _syncedToCore(false)
 {
@@ -71,27 +75,19 @@ Client::~Client() {
 }
 
 void Client::init() {
-
+  _currentCoreAccount = 0;
   _networkModel = new NetworkModel(this);
   connect(this, SIGNAL(bufferUpdated(BufferInfo)),
           _networkModel, SLOT(bufferUpdated(BufferInfo)));
+  connect(this, SIGNAL(networkRemoved(NetworkId)),
+	  _networkModel, SLOT(networkRemoved(NetworkId)));
 
   _bufferModel = new BufferModel(_networkModel);
 
   SignalProxy *p = signalProxy();
-  p->attachSignal(this, SIGNAL(sendSessionData(const QString &, const QVariant &)),
-                  SIGNAL(clientSessionDataChanged(const QString &, const QVariant &)));
-  p->attachSlot(SIGNAL(coreSessionDataChanged(const QString &, const QVariant &)),
-                this, SLOT(recvSessionData(const QString &, const QVariant &)));
-  //p->attachSlot(SIGNAL(networkConnected(uint)),
-  //FIXME              this, SLOT(networkConnected(uint)));
-  //p->attachSlot(SIGNAL(networkDisconnected(uint)),
-  //FIXME              this, SLOT(networkDisconnected(uint)));
-  p->attachSlot(SIGNAL(displayMsg(const Message &)),
-                this, SLOT(recvMessage(const Message &)));
-  p->attachSlot(SIGNAL(displayStatusMsg(QString, QString)),
-                this, SLOT(recvStatusMsg(QString, QString)));
 
+  p->attachSlot(SIGNAL(displayMsg(const Message &)), this, SLOT(recvMessage(const Message &)));
+  p->attachSlot(SIGNAL(displayStatusMsg(QString, QString)), this, SLOT(recvStatusMsg(QString, QString)));
 
   p->attachSlot(SIGNAL(backlogData(BufferInfo, const QVariantList &, bool)), this, SLOT(recvBacklogData(BufferInfo, const QVariantList &, bool)));
   p->attachSlot(SIGNAL(bufferInfoUpdated(BufferInfo)), this, SLOT(updateBufferInfo(BufferInfo)));
@@ -126,6 +122,14 @@ void Client::init() {
 
 /*** public static methods ***/
 
+AccountId Client::currentCoreAccount() {
+  return _currentCoreAccount;
+}
+
+void Client::setCurrentCoreAccount(AccountId id) {
+  _currentCoreAccount = id;
+}
+
 QList<BufferInfo> Client::allBufferInfos() {
   QList<BufferInfo> bufferids;
   foreach(Buffer *buffer, buffers()) {
@@ -139,47 +143,43 @@ QList<Buffer *> Client::buffers() {
 }
 
 
-// FIXME remove
-Buffer *Client::buffer(BufferId bufferUid) {
-  if(instance()->_buffers.contains(bufferUid))
-    return instance()->_buffers[bufferUid];
+Buffer *Client::statusBuffer(const NetworkId &networkId) const {
+  if(_statusBuffers.contains(networkId))
+    return _statusBuffers[networkId];
+  else
+    return 0;
+}
+
+Buffer *Client::buffer(BufferId bufferId) {
+  if(instance()->_buffers.contains(bufferId))
+    return instance()->_buffers[bufferId];
   else
     return 0;
 }
 
-// FIXME remove
-Buffer *Client::buffer(BufferInfo id) {
-  Buffer *buff = buffer(id.uid());
+Buffer *Client::buffer(BufferInfo bufferInfo) {
+  Buffer *buff = buffer(bufferInfo.bufferId());
 
   if(!buff) {
     Client *client = Client::instance();
-    buff = new Buffer(id, client);
-    connect(buff, SIGNAL(destroyed()),
-	    client, SLOT(bufferDestroyed()));
-    client->_buffers[id.uid()] = buff;
-    emit client->bufferUpdated(id);
+    buff = new Buffer(bufferInfo, client);
+    connect(buff, SIGNAL(destroyed()), client, SLOT(bufferDestroyed()));
+    client->_buffers[bufferInfo.bufferId()] = buff;
+    if(bufferInfo.type() == BufferInfo::StatusBuffer)
+      client->_statusBuffers[bufferInfo.networkId()] = buff;
+
+    emit client->bufferUpdated(bufferInfo);
+
+    // I don't like this: but currently there isn't really a prettier way:
+    if(isSynced()) {  // this slows down syncing a lot, so disable it during sync
+      QModelIndex bufferIdx = networkModel()->bufferIndex(bufferInfo.bufferId());
+      bufferModel()->setCurrentIndex(bufferModel()->mapFromSource(bufferIdx));
+    }
   }
   Q_ASSERT(buff);
   return buff;
 }
 
-Buffer *Client::monitorBuffer() {
-  return instance()->_monitorBuffer;
-}
-
-
-NetworkModel *Client::networkModel() {
-  return instance()->_networkModel;
-}
-
-BufferModel *Client::bufferModel() {
-  return instance()->_bufferModel;
-}
-
-SignalProxy *Client::signalProxy() {
-  return instance()->_signalProxy;
-}
-
 bool Client::isConnected() {
   return instance()->_connectedToCore;
 }
@@ -199,35 +199,6 @@ const Network * Client::network(NetworkId networkid) {
   else return 0;
 }
 
-/*
-void Client::networkConnected(uint netid) {
-  // TODO: create statusBuffer / switch to networkids
-  //BufferInfo id = statusBufferInfo(net);
-  //Buffer *b = buffer(id);
-  //b->setActive(true);
-
-  Network *netinfo = new Network(netid, this);
-  netinfo->setProxy(signalProxy());
-  networkModel()->attachNetwork(netinfo);
-  connect(netinfo, SIGNAL(destroyed()), this, SLOT(networkDestroyed()));
-  _networks[netid] = netinfo;
-}
-
-void Client::networkDisconnected(NetworkId networkid) {
-  if(!_networks.contains(networkid)) {
-    qWarning() << "Client::networkDisconnected(uint): unknown Network" << networkid;
-    return;
-}
-
-  Network *net = _networks.take(networkid);
-  if(!net->isInitialized()) {
-    qDebug() << "Network" << networkid << "disconnected while not yet initialized!";
-    updateCoreConnectionProgress();
-}
-  net->deleteLater();
-}
-*/
-
 void Client::createNetwork(const NetworkInfo &info) {
   emit instance()->requestCreateNetwork(info);
 }
@@ -315,39 +286,47 @@ void Client::userInput(BufferInfo bufferInfo, QString message) {
 
 /*** core connection stuff ***/
 
-void Client::setConnectedToCore(QIODevice *sock) {
+void Client::setConnectedToCore(QIODevice *sock, AccountId id) {
   socket = sock;
   signalProxy()->addPeer(socket);
   _connectedToCore = true;
+  setCurrentCoreAccount(id);
 }
 
 void Client::setSyncedToCore() {
+  // create buffersyncer
+  Q_ASSERT(!_bufferSyncer);
+  _bufferSyncer = new BufferSyncer(this);
+  connect(bufferSyncer(), SIGNAL(lastSeenSet(BufferId, const QDateTime &)), this, SLOT(updateLastSeen(BufferId, const QDateTime &)));
+  connect(bufferSyncer(), SIGNAL(bufferRemoved(BufferId)), this, SLOT(bufferRemoved(BufferId)));
+  connect(bufferSyncer(), SIGNAL(bufferRenamed(BufferId, QString)), this, SLOT(bufferRenamed(BufferId, QString)));
+  signalProxy()->synchronize(bufferSyncer());
+
   _syncedToCore = true;
   emit connected();
   emit coreConnectionStateChanged(true);
 }
 
 void Client::disconnectFromCore() {
+  if(!isConnected())
+    return;
+  
   if(socket) {
     socket->close();
     socket->deleteLater();
   }
   _connectedToCore = false;
   _syncedToCore = false;
+  setCurrentCoreAccount(0);
   emit disconnected();
   emit coreConnectionStateChanged(false);
 
   // Clear internal data. Hopefully nothing relies on it at this point.
-  _networkModel->clear();
-
-  QHash<NetworkId, Network*>::iterator netIter = _networks.begin();
-  while(netIter != _networks.end()) {
-    Network *net = netIter.value();
-    disconnect(net, SIGNAL(destroyed()), this, 0);
-    netIter = _networks.erase(netIter);
-    net->deleteLater();
+  if(_bufferSyncer) {
+    _bufferSyncer->deleteLater();
+    _bufferSyncer = 0;
   }
-  Q_ASSERT(_networks.isEmpty());
+  _networkModel->clear();
 
   QHash<BufferId, Buffer *>::iterator bufferIter =  _buffers.begin();
   while(bufferIter != _buffers.end()) {
@@ -358,6 +337,18 @@ void Client::disconnectFromCore() {
   }
   Q_ASSERT(_buffers.isEmpty());
 
+  _statusBuffers.clear();
+
+  QHash<NetworkId, Network*>::iterator netIter = _networks.begin();
+  while(netIter != _networks.end()) {
+    Network *net = netIter.value();
+    emit networkRemoved(net->networkId());
+    disconnect(net, SIGNAL(destroyed()), this, 0);
+    netIter = _networks.erase(netIter);
+    net->deleteLater();
+  }
+  Q_ASSERT(_networks.isEmpty());
+
   QHash<IdentityId, Identity*>::iterator idIter = _identities.begin();
   while(idIter != _identities.end()) {
     Identity *id = idIter.value();
@@ -367,7 +358,6 @@ void Client::disconnectFromCore() {
   }
   Q_ASSERT(_identities.isEmpty());
 
-  sessionData.clear();
   layoutQueue.clear();
   layoutTimer->stop();
 }
@@ -376,33 +366,6 @@ void Client::setCoreConfiguration(const QVariantMap &settings) {
   SignalProxy::writeDataToDevice(socket, settings);
 }
 
-/*** Session data ***/
-
-void Client::recvSessionData(const QString &key, const QVariant &data) {
-  sessionData[key] = data;
-  emit sessionDataChanged(key, data);
-  emit sessionDataChanged(key);
-}
-
-void Client::storeSessionData(const QString &key, const QVariant &data) {
-  // Not sure if this is a good idea, but we'll try it anyway:
-  // Calling this function only sends a signal to core. Data is stored upon reception of the update signal,
-  // rather than immediately.
-  emit instance()->sendSessionData(key, data);
-}
-
-QVariant Client::retrieveSessionData(const QString &key, const QVariant &def) {
-  if(instance()->sessionData.contains(key)) return instance()->sessionData[key];
-  else return def;
-}
-
-QStringList Client::sessionDataKeys() {
-  return instance()->sessionData.keys();
-}
-
-/*** ***/
-
-
 /*** ***/
 
 void Client::updateBufferInfo(BufferInfo id) {
@@ -419,27 +382,93 @@ void Client::bufferDestroyed() {
     }
     iter++;
   }
+
+  QHash<NetworkId, Buffer *>::iterator statusIter = _statusBuffers.begin();
+  while(statusIter != _statusBuffers.end()) {
+    if(statusIter.value() == buffer) {
+      statusIter = _statusBuffers.erase(statusIter);
+      break;
+    }
+    statusIter++;
+  }
 }
 
 void Client::networkDestroyed() {
-  // FIXME this is not gonna work, net is a QObject here already!
   Network *net = static_cast<Network *>(sender());
-  NetworkId networkId = net->networkId();
-  if(_networks.contains(networkId))
-    _networks.remove(networkId);
+  QHash<NetworkId, Network *>::iterator netIter = _networks.begin();
+  while(netIter != _networks.end()) {
+    if(*netIter == net) {
+      netIter = _networks.erase(netIter);
+      break;
+    } else {
+      netIter++;
+    }
+  }
 }
 
-void Client::recvMessage(const Message &msg) {
-  Buffer *b = buffer(msg.buffer());
-  b->appendMsg(msg);
-  networkModel()->updateBufferActivity(msg);
+void Client::recvMessage(const Message &message) {
+  Message msg = message;
+  Buffer *b;
+
+  checkForHighlight(msg);
+
+  if(msg.flags() & Message::Redirected) {
+    BufferSettings bufferSettings;
+    bool inStatus = bufferSettings.value("UserMessagesInStatusBuffer", QVariant(true)).toBool();
+    bool inQuery = bufferSettings.value("UserMessagesInQueryBuffer", QVariant(false)).toBool();
+    bool inCurrent = bufferSettings.value("UserMessagesInCurrentBuffer", QVariant(false)).toBool();
+
+    if(inStatus) {
+      b = statusBuffer(msg.bufferInfo().networkId());
+      if(b) {
+	b->appendMsg(msg);
+      } else if(!inQuery && !inCurrent) {	// make sure the message get's shown somewhere
+	b = buffer(msg.bufferInfo());
+	b->appendMsg(msg);
+      }
+    }
+
+    if(inQuery) {
+      b = buffer(msg.bufferInfo().bufferId());
+      if(b) {
+	b->appendMsg(msg);
+      } else if(!inStatus && !inCurrent) {	// make sure the message get's shown somewhere
+	b = statusBuffer(msg.bufferInfo().networkId());
+	if(!b)
+	  b = buffer(msg.bufferInfo()); // seems like we have to create the buffer anyways... 
+	b->appendMsg(msg);
+      }
+    }
+
+    if(inCurrent) {
+      BufferId currentId = bufferModel()->currentIndex().data(NetworkModel::BufferIdRole).value<BufferId>();
+      b = buffer(currentId);
+      if(b && currentId != msg.bufferInfo().bufferId() && !inQuery) {
+	b->appendMsg(msg);
+      } else if(!inStatus && !inQuery) {	// make sure the message get's shown somewhere
+	b = statusBuffer(msg.bufferInfo().networkId());
+	if(!b)
+	  b = buffer(msg.bufferInfo()); // seems like we have to create the buffer anyways... 
+	b->appendMsg(msg);
+      }
+    }
+  } else {
+    // the regular case: we can deliver where it was supposed to go
+    b = buffer(msg.bufferInfo());
+    b->appendMsg(msg);
+  }
+  
+  //bufferModel()->updateBufferActivity(msg);
 
   if(msg.type() == Message::Plain || msg.type() == Message::Notice || msg.type() == Message::Action) {
-    QString sender = msg.buffer().network() + ":" + msg.buffer().buffer() + ":" + msg.sender();
-    Message mmsg = Message(msg.timestamp(), msg.buffer(), msg.type(), msg.text(), sender, msg.flags());
+    const Network *net = network(msg.bufferInfo().networkId());
+    QString networkName = net != 0
+      ? net->networkName() + ":"
+      : QString();
+    QString sender = networkName + msg.bufferInfo().bufferName() + ":" + msg.sender();
+    Message mmsg = Message(msg.timestamp(), msg.bufferInfo(), msg.type(), msg.text(), sender, msg.flags());
     monitorBuffer()->appendMsg(mmsg);
   }
-
 }
 
 void Client::recvStatusMsg(QString /*net*/, QString /*msg*/) {
@@ -448,10 +477,16 @@ void Client::recvStatusMsg(QString /*net*/, QString /*msg*/) {
 
 void Client::recvBacklogData(BufferInfo id, QVariantList msgs, bool /*done*/) {
   Buffer *b = buffer(id);
+  if(!b) {
+    qWarning() << "Client::recvBacklogData(): received Backlog for unknown Buffer:" << id;
+    return;
+  }
+    
   foreach(QVariant v, msgs) {
     Message msg = v.value<Message>();
+    checkForHighlight(msg);
     b->prependMsg(msg);
-    // networkModel()->updateBufferActivity(msg);
+    //networkModel()->updateBufferActivity(msg);
     if(!layoutQueue.contains(b)) layoutQueue.append(b);
   }
   if(layoutQueue.count() && !layoutTimer->isActive()) layoutTimer->start();
@@ -472,3 +507,65 @@ AbstractUiMsg *Client::layoutMsg(const Message &msg) {
   return instance()->mainUi->layoutMsg(msg);
 }
 
+void Client::checkForHighlight(Message &msg) {
+  const Network *net = network(msg.bufferInfo().networkId());
+  if(net && !net->myNick().isEmpty()) {
+    QRegExp nickRegExp("^(.*\\W)?" + QRegExp::escape(net->myNick()) + "(\\W.*)?$");
+    if((msg.type() & (Message::Plain | Message::Notice | Message::Action)) && nickRegExp.exactMatch(msg.text()))
+      msg.setFlags(msg.flags() | Message::Highlight);
+  }
+}
+
+void Client::updateLastSeen(BufferId id, const QDateTime &lastSeen) {
+  Buffer *b = buffer(id);
+  if(!b) {
+    qWarning() << "Client::updateLastSeen(): Unknown buffer" << id;
+    return;
+  }
+  b->setLastSeen(lastSeen);
+}
+
+void Client::setBufferLastSeen(BufferId id, const QDateTime &lastSeen) {
+  if(!bufferSyncer()) return;
+  bufferSyncer()->requestSetLastSeen(id, lastSeen);
+}
+
+void Client::removeBuffer(BufferId id) {
+  if(!bufferSyncer()) return;
+  bufferSyncer()->requestRemoveBuffer(id);
+}
+
+void Client::bufferRemoved(BufferId bufferId) {
+  // first remove the buffer from has. this prohibits further lastSeenUpdates
+  Buffer *buff = 0;
+  if(_buffers.contains(bufferId)) {
+    buff = _buffers.take(bufferId);
+    disconnect(buff, 0, this, 0);
+  }
+
+  // then we select a sane buffer (status buffer)
+  /* we have to manually select a buffer because otherwise inconsitent changes
+   * to the model might occur:
+   * the result of a buffer removal triggers a change in the selection model.
+   * the newly selected buffer might be a channel that hasn't been selected yet
+   * and a new nickview would be created (which never heard of the "rowsAboutToBeRemoved").
+   * this new view (and/or) its sort filter will then only receive a "rowsRemoved" signal.
+   */
+  QModelIndex current = bufferModel()->currentIndex();
+  if(current.data(NetworkModel::BufferIdRole).value<BufferId>() == bufferId) {
+    bufferModel()->setCurrentIndex(current.sibling(0,0));
+  }
+
+  // and remove it from the model
+  networkModel()->removeBuffer(bufferId);
+
+  if(buff)
+    buff->deleteLater();
+}
+
+void Client::bufferRenamed(BufferId bufferId, const QString &newName) {
+  QModelIndex bufferIndex = networkModel()->bufferIndex(bufferId);
+  if(bufferIndex.isValid()) {
+    networkModel()->setData(bufferIndex, newName, Qt::DisplayRole);
+  }
+}