X-Git-Url: https://git.quassel-irc.org/?a=blobdiff_plain;f=src%2Fclient%2Fclient.cpp;h=21beda08313606669f038501b51b98e98e486c03;hb=4ae8f86c1ce452582d6fe576956c7c1bc1460adf;hp=dd8bd21490c0ff80824c7b0e4e2998ce286ee959;hpb=d28b9ec38b6ea0bc473200fc2f1e65abd1b56bd6;p=quassel.git

diff --git a/src/client/client.cpp b/src/client/client.cpp
index dd8bd214..21beda08 100644
--- a/src/client/client.cpp
+++ b/src/client/client.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-08 by the Quassel Project                          *
+ *   Copyright (C) 2005-09 by the Quassel Project                          *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -20,24 +20,47 @@
 
 #include "client.h"
 
+#include "abstractmessageprocessor.h"
+#include "abstractui.h"
 #include "bufferinfo.h"
-#include "global.h"
-#include "identity.h"
+#include "buffermodel.h"
+#include "buffersettings.h"
+#include "buffersyncer.h"
+#include "bufferviewconfig.h"
+#include "bufferviewoverlay.h"
+#include "clientaliasmanager.h"
+#include "clientbacklogmanager.h"
+#include "clientbufferviewmanager.h"
+#include "clientirclisthelper.h"
+#include "clientidentity.h"
+#include "clientignorelistmanager.h"
+#include "clientuserinputhandler.h"
+#include "coreaccountmodel.h"
+#include "coreconnection.h"
 #include "ircchannel.h"
 #include "ircuser.h"
 #include "message.h"
+#include "messagemodel.h"
 #include "network.h"
+#include "networkconfig.h"
 #include "networkmodel.h"
-#include "buffermodel.h"
-#include "nickmodel.h"
-#include "quasselui.h"
+#include "quassel.h"
 #include "signalproxy.h"
 #include "util.h"
 
+#include <stdio.h>
+#include <stdlib.h>
+
 QPointer<Client> Client::instanceptr = 0;
+Quassel::Features Client::_coreFeatures = 0;
 
 /*** Initialization/destruction ***/
 
+bool Client::instanceExists()
+{
+  return instanceptr;
+}
+
 Client *Client::instance() {
   if(!instanceptr)
     instanceptr = new Client();
@@ -45,26 +68,41 @@ Client *Client::instance() {
 }
 
 void Client::destroy() {
-  //delete instanceptr;
-  instanceptr->deleteLater();
+  if(instanceptr) {
+    delete instanceptr->mainUi();
+    instanceptr->deleteLater();
+    instanceptr = 0;
+  }
 }
 
 void Client::init(AbstractUi *ui) {
-  instance()->mainUi = ui;
+  instance()->_mainUi = ui;
   instance()->init();
 }
 
 Client::Client(QObject *parent)
   : QObject(parent),
-    socket(0),
     _signalProxy(new SignalProxy(SignalProxy::Client, this)),
-    mainUi(0),
+    _mainUi(0),
     _networkModel(0),
     _bufferModel(0),
-    _nickModel(0),
-    _connectedToCore(false),
-    _syncedToCore(false)
+    _bufferSyncer(0),
+    _aliasManager(0),
+    _backlogManager(new ClientBacklogManager(this)),
+    _bufferViewManager(0),
+    _bufferViewOverlay(new BufferViewOverlay(this)),
+    _ircListHelper(new ClientIrcListHelper(this)),
+    _inputHandler(0),
+    _networkConfig(0),
+    _ignoreListManager(0),
+    _messageModel(0),
+    _messageProcessor(0),
+    _coreAccountModel(new CoreAccountModel(this)),
+    _coreConnection(new CoreConnection(_coreAccountModel, this)),
+    _connected(false),
+    _debugLog(&_debugLogBuffer)
 {
+  _signalProxy->synchronize(_ircListHelper);
 }
 
 Client::~Client() {
@@ -72,132 +110,120 @@ Client::~Client() {
 }
 
 void Client::init() {
-
   _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);
-  _nickModel = new NickModel(_networkModel);
+  _messageModel = mainUi()->createMessageModel(this);
+  _messageProcessor = mainUi()->createMessageProcessor(this);
+  _inputHandler = new ClientUserInputHandler(this);
 
   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(backlogData(BufferInfo, const QVariantList &, bool)), this, SLOT(recvBacklogData(BufferInfo, const QVariantList &, bool)));
-  p->attachSlot(SIGNAL(bufferInfoUpdated(BufferInfo)), this, SLOT(updateBufferInfo(BufferInfo)));
-  p->attachSignal(this, SIGNAL(sendInput(BufferInfo, 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(bufferInfoUpdated(BufferInfo)), _networkModel, SLOT(bufferUpdated(BufferInfo)));
+  p->attachSignal(inputHandler(), SIGNAL(sendInput(BufferInfo, QString)));
   p->attachSignal(this, SIGNAL(requestNetworkStates()));
 
-  p->attachSignal(this, SIGNAL(requestCreateIdentity(const Identity &)), SIGNAL(createIdentity(const Identity &)));
-  p->attachSignal(this, SIGNAL(requestUpdateIdentity(const Identity &)), SIGNAL(updateIdentity(const Identity &)));
+  p->attachSignal(this, SIGNAL(requestCreateIdentity(const Identity &, const QVariantMap &)), SIGNAL(createIdentity(const Identity &, const QVariantMap &)));
   p->attachSignal(this, SIGNAL(requestRemoveIdentity(IdentityId)), SIGNAL(removeIdentity(IdentityId)));
   p->attachSlot(SIGNAL(identityCreated(const Identity &)), this, SLOT(coreIdentityCreated(const Identity &)));
   p->attachSlot(SIGNAL(identityRemoved(IdentityId)), this, SLOT(coreIdentityRemoved(IdentityId)));
 
-  connect(p, SIGNAL(disconnected()), this, SLOT(disconnectFromCore()));
+  p->attachSignal(this, SIGNAL(requestCreateNetwork(const NetworkInfo &, const QStringList &)), SIGNAL(createNetwork(const NetworkInfo &, const QStringList &)));
+  p->attachSignal(this, SIGNAL(requestRemoveNetwork(NetworkId)), SIGNAL(removeNetwork(NetworkId)));
+  p->attachSlot(SIGNAL(networkCreated(NetworkId)), this, SLOT(coreNetworkCreated(NetworkId)));
+  p->attachSlot(SIGNAL(networkRemoved(NetworkId)), this, SLOT(coreNetworkRemoved(NetworkId)));
+
+  //connect(mainUi(), SIGNAL(connectToCore(const QVariantMap &)), this, SLOT(connectToCore(const QVariantMap &)));
+  connect(mainUi(), SIGNAL(disconnectFromCore()), this, SLOT(disconnectFromCore()));
+  connect(this, SIGNAL(connected()), mainUi(), SLOT(connectedToCore()));
+  connect(this, SIGNAL(disconnected()), mainUi(), SLOT(disconnectedFromCore()));
 
-  //connect(mainUi, SIGNAL(connectToCore(const QVariantMap &)), this, SLOT(connectToCore(const QVariantMap &)));
-  connect(mainUi, SIGNAL(disconnectFromCore()), this, SLOT(disconnectFromCore()));
-  connect(this, SIGNAL(connected()), mainUi, SLOT(connectedToCore()));
-  connect(this, SIGNAL(disconnected()), mainUi, SLOT(disconnectedFromCore()));
+  // attach backlog manager
+  p->synchronize(backlogManager());
+  connect(backlogManager(), SIGNAL(messagesReceived(BufferId, int)), _messageModel, SLOT(messagesReceived(BufferId, int)));
 
-  layoutTimer = new QTimer(this);
-  layoutTimer->setInterval(0);
-  layoutTimer->setSingleShot(false);
-  connect(layoutTimer, SIGNAL(timeout()), this, SLOT(layoutMsg()));
+  coreAccountModel()->load();
 
+  connect(coreConnection(), SIGNAL(stateChanged(CoreConnection::ConnectionState)), SLOT(connectionStateChanged(CoreConnection::ConnectionState)));
+  coreConnection()->init();
 }
 
 /*** public static methods ***/
 
-
-QList<Network *> Client::networks() {
-  return instance()->_networks.values();
+AbstractUi *Client::mainUi() {
+  return instance()->_mainUi;
 }
 
-Network *Client::network(NetworkId networkid) {
-  if(instance()->_networks.contains(networkid))
-    return instance()->_networks[networkid];
-  else
-    return 0;
+void Client::setCoreFeatures(Quassel::Features features) {
+  _coreFeatures = features;
 }
 
-QList<BufferInfo> Client::allBufferInfos() {
-  QList<BufferInfo> bufferids;
-  foreach(Buffer *buffer, buffers()) {
-    bufferids << buffer->bufferInfo();
-  }
-  return bufferids;
+bool Client::isConnected() {
+  return instance()->_connected;
 }
 
-QList<Buffer *> Client::buffers() {
-  return instance()->_buffers.values();
+bool Client::internalCore() {
+  return currentCoreAccount().isInternal();
 }
 
+/*** Network handling ***/
 
-// FIXME remove
-Buffer *Client::buffer(BufferId bufferUid) {
-  if(instance()->_buffers.contains(bufferUid))
-    return instance()->_buffers[bufferUid];
-  else
-    return 0;
+QList<NetworkId> Client::networkIds() {
+  return instance()->_networks.keys();
 }
 
-// FIXME remove
-Buffer *Client::buffer(BufferInfo id) {
-  Buffer *buff = buffer(id.uid());
-
-  if(!buff) {
-    Client *client = Client::instance();
-    buff = new Buffer(id, client);
-
-    connect(buff, SIGNAL(userInput(BufferInfo, QString)),
-	    client, SLOT(userInput(BufferInfo, QString)));
-    connect(buff, SIGNAL(destroyed()),
-	    client, SLOT(bufferDestroyed()));
-    client->_buffers[id.uid()] = buff;
-    emit client->bufferUpdated(id);
-  }
-  Q_ASSERT(buff);
-  return buff;
+const Network * Client::network(NetworkId networkid) {
+  if(instance()->_networks.contains(networkid)) return instance()->_networks[networkid];
+  else return 0;
 }
 
-
-NetworkModel *Client::networkModel() {
-  return instance()->_networkModel;
+void Client::createNetwork(const NetworkInfo &info, const QStringList &persistentChannels) {
+  emit instance()->requestCreateNetwork(info, persistentChannels);
 }
 
-BufferModel *Client::bufferModel() {
-  return instance()->_bufferModel;
+void Client::removeNetwork(NetworkId id) {
+  emit instance()->requestRemoveNetwork(id);
 }
 
-NickModel *Client::nickModel() {
-  return instance()->_nickModel;
+void Client::updateNetwork(const NetworkInfo &info) {
+  Network *netptr = instance()->_networks.value(info.networkId, 0);
+  if(!netptr) {
+    qWarning() << "Update for unknown network requested:" << info;
+    return;
+  }
+  netptr->requestSetNetworkInfo(info);
 }
 
-
-SignalProxy *Client::signalProxy() {
-  return instance()->_signalProxy;
+void Client::addNetwork(Network *net) {
+  net->setProxy(signalProxy());
+  signalProxy()->synchronize(net);
+  networkModel()->attachNetwork(net);
+  connect(net, SIGNAL(destroyed()), instance(), SLOT(networkDestroyed()));
+  instance()->_networks[net->networkId()] = net;
+  emit instance()->networkCreated(net->networkId());
 }
 
-bool Client::isConnected() {
-  return instance()->_connectedToCore;
+void Client::coreNetworkCreated(NetworkId id) {
+  if(_networks.contains(id)) {
+    qWarning() << "Creation of already existing network requested!";
+    return;
+  }
+  Network *net = new Network(id, this);
+  addNetwork(net);
 }
 
-bool Client::isSynced() {
-  return instance()->_syncedToCore;
+void Client::coreNetworkRemoved(NetworkId id) {
+  if(!_networks.contains(id))
+    return;
+  Network *net = _networks.take(id);
+  emit networkRemoved(net->networkId());
+  net->deleteLater();
 }
 
 /*** Identity handling ***/
@@ -206,17 +232,27 @@ QList<IdentityId> Client::identityIds() {
   return instance()->_identities.keys();
 }
 
-const Identity * Client::identity(IdentityId id) {
+const Identity *Client::identity(IdentityId id) {
   if(instance()->_identities.contains(id)) return instance()->_identities[id];
   else return 0;
 }
 
-void Client::createIdentity(const Identity &id) {
-  emit instance()->requestCreateIdentity(id);
+void Client::createIdentity(const CertIdentity &id) {
+  QVariantMap additional;
+#ifdef HAVE_SSL
+  additional["KeyPem"] = id.sslKey().toPem();
+  additional["CertPem"] = id.sslCert().toPem();
+#endif
+  emit instance()->requestCreateIdentity(id, additional);
 }
 
-void Client::updateIdentity(const Identity &id) {
-  emit instance()->requestUpdateIdentity(id);
+void Client::updateIdentity(IdentityId id, const QVariantMap &ser) {
+  Identity *idptr = instance()->_identities.value(id, 0);
+  if(!idptr) {
+    qWarning() << "Update for unknown identity requested:" << id;
+    return;
+  }
+  idptr->requestUpdate(ser);
 }
 
 void Client::removeIdentity(IdentityId id) {
@@ -243,223 +279,281 @@ void Client::coreIdentityRemoved(IdentityId id) {
   }
 }
 
-/***  ***/
+/*** User input handling ***/
 
-void Client::fakeInput(BufferId bufferUid, QString message) {
-  Buffer *buff = buffer(bufferUid);
-  if(!buff)
-    qWarning() << "No Buffer with uid" << bufferUid << "can't send Input" << message;
+void Client::userInput(const BufferInfo &bufferInfo, const QString &message) {
+  // we need to make sure that AliasManager is ready before processing input
+  if(aliasManager() && aliasManager()->isInitialized())
+    inputHandler()->handleUserInput(bufferInfo, message);
   else
-    emit instance()->sendInput(buff->bufferInfo(), message);
+   instance()-> _userInputBuffer.append(qMakePair(bufferInfo, message));
 }
 
-void Client::fakeInput(BufferInfo bufferInfo, QString message) {
-  fakeInput(bufferInfo, message);
+void Client::sendBufferedUserInput() {
+  for(int i = 0; i < _userInputBuffer.count(); i++)
+    userInput(_userInputBuffer.at(i).first, _userInputBuffer.at(i).second);
+
+  _userInputBuffer.clear();
 }
 
 /*** core connection stuff ***/
 
-void Client::setConnectedToCore(QIODevice *sock) {
-  socket = sock;
-  signalProxy()->addPeer(socket);
-  _connectedToCore = true;
+void Client::connectionStateChanged(CoreConnection::ConnectionState state) {
+  switch(state) {
+  case CoreConnection::Disconnected:
+    setDisconnectedFromCore();
+    break;
+  case CoreConnection::Synchronized:
+    setSyncedToCore();
+    break;
+  default:
+    break;
+  }
 }
 
 void Client::setSyncedToCore() {
-  _syncedToCore = true;
+  // create buffersyncer
+  Q_ASSERT(!_bufferSyncer);
+  _bufferSyncer = new BufferSyncer(this);
+  connect(bufferSyncer(), SIGNAL(lastSeenMsgSet(BufferId, MsgId)), _networkModel, SLOT(setLastSeenMsgId(BufferId, MsgId)));
+  connect(bufferSyncer(), SIGNAL(markerLineSet(BufferId,MsgId)), _networkModel, SLOT(setMarkerLineMsgId(BufferId,MsgId)));
+  connect(bufferSyncer(), SIGNAL(bufferRemoved(BufferId)), this, SLOT(bufferRemoved(BufferId)));
+  connect(bufferSyncer(), SIGNAL(bufferRenamed(BufferId, QString)), this, SLOT(bufferRenamed(BufferId, QString)));
+  connect(bufferSyncer(), SIGNAL(buffersPermanentlyMerged(BufferId, BufferId)), this, SLOT(buffersPermanentlyMerged(BufferId, BufferId)));
+  connect(bufferSyncer(), SIGNAL(buffersPermanentlyMerged(BufferId, BufferId)), _messageModel, SLOT(buffersPermanentlyMerged(BufferId, BufferId)));
+  connect(bufferSyncer(), SIGNAL(bufferMarkedAsRead(BufferId)), SIGNAL(bufferMarkedAsRead(BufferId)));
+  connect(networkModel(), SIGNAL(requestSetLastSeenMsg(BufferId, MsgId)), bufferSyncer(), SLOT(requestSetLastSeenMsg(BufferId, const MsgId &)));
+  signalProxy()->synchronize(bufferSyncer());
+
+  // create a new BufferViewManager
+  Q_ASSERT(!_bufferViewManager);
+  _bufferViewManager = new ClientBufferViewManager(signalProxy(), this);
+  connect(_bufferViewManager, SIGNAL(initDone()), _bufferViewOverlay, SLOT(restore()));
+
+  // create AliasManager
+  Q_ASSERT(!_aliasManager);
+  _aliasManager = new ClientAliasManager(this);
+  connect(aliasManager(), SIGNAL(initDone()), SLOT(sendBufferedUserInput()));
+  signalProxy()->synchronize(aliasManager());
+
+  // create NetworkConfig
+  Q_ASSERT(!_networkConfig);
+  _networkConfig = new NetworkConfig("GlobalNetworkConfig", this);
+  signalProxy()->synchronize(networkConfig());
+
+  // create IgnoreListManager
+  Q_ASSERT(!_ignoreListManager);
+  _ignoreListManager = new ClientIgnoreListManager(this);
+  signalProxy()->synchronize(ignoreListManager());
+
+  // trigger backlog request once all active bufferviews are initialized
+  connect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
+
+  _connected = true;
   emit connected();
   emit coreConnectionStateChanged(true);
 }
 
-void Client::disconnectFromCore() {
-  if(socket) {
-    socket->close();
-    socket->deleteLater();
+void Client::requestInitialBacklog() {
+  // usually it _should_ take longer until the bufferViews are initialized, so that's what
+  // triggers this slot. But we have to make sure that we know all buffers yet.
+  // so we check the BufferSyncer and in case it wasn't initialized we wait for that instead
+  if(!bufferSyncer()->isInitialized()) {
+    disconnect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
+    connect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
+    return;
   }
-  _connectedToCore = false;
-  _syncedToCore = false;
+  disconnect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
+  disconnect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
+
+  _backlogManager->requestInitialBacklog();
+}
+
+void Client::disconnectFromCore() {
+  if(!coreConnection()->isConnected())
+    return;
+
+  coreConnection()->disconnectFromCore();
+}
+
+void Client::setDisconnectedFromCore() {
+  _connected = false;
+  _coreFeatures = 0;
+
   emit disconnected();
   emit coreConnectionStateChanged(false);
 
+  backlogManager()->reset();
+  messageProcessor()->reset();
+
   // Clear internal data. Hopefully nothing relies on it at this point.
-  _networkModel->clear();
 
-  QHash<BufferId, Buffer *>::iterator bufferIter =  _buffers.begin();
-  while(bufferIter != _buffers.end()) {
-    Buffer *buffer = bufferIter.value();
-    disconnect(buffer, SIGNAL(destroyed()), this, 0);
-    bufferIter = _buffers.erase(bufferIter);
-    buffer->deleteLater();
+  if(_bufferSyncer) {
+    _bufferSyncer->deleteLater();
+    _bufferSyncer = 0;
+  }
+
+  if(_bufferViewManager) {
+    _bufferViewManager->deleteLater();
+    _bufferViewManager = 0;
+  }
+
+  _bufferViewOverlay->reset();
+
+  if(_aliasManager) {
+    _aliasManager->deleteLater();
+    _aliasManager = 0;
   }
-  Q_ASSERT(_buffers.isEmpty());
 
+  if(_ignoreListManager) {
+    _ignoreListManager->deleteLater();
+    _ignoreListManager = 0;
+  }
+  // we probably don't want to save pending input for reconnect
+  _userInputBuffer.clear();
+
+  _messageModel->clear();
+  _networkModel->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();
+  QHash<IdentityId, Identity *>::iterator idIter = _identities.begin();
   while(idIter != _identities.end()) {
+    emit identityRemoved(idIter.key());
     Identity *id = idIter.value();
-    emit identityRemoved(id->id());
     idIter = _identities.erase(idIter);
     id->deleteLater();
   }
   Q_ASSERT(_identities.isEmpty());
 
-  sessionData.clear();
-  layoutQueue.clear();
-  layoutTimer->stop();
-}
-
-void Client::setCoreConfiguration(const QVariantMap &settings) {
-  SignalProxy::writeDataToDevice(socket, settings);
+  if(_networkConfig) {
+    _networkConfig->deleteLater();
+    _networkConfig = 0;
+  }
 }
 
-/*** Session data ***/
+/*** ***/
 
-void Client::recvSessionData(const QString &key, const QVariant &data) {
-  sessionData[key] = data;
-  emit sessionDataChanged(key, data);
-  emit sessionDataChanged(key);
+void Client::networkDestroyed() {
+  Network *net = static_cast<Network *>(sender());
+  QHash<NetworkId, Network *>::iterator netIter = _networks.begin();
+  while(netIter != _networks.end()) {
+    if(*netIter == net) {
+      netIter = _networks.erase(netIter);
+      break;
+    } else {
+      netIter++;
+    }
+  }
 }
 
-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);
+// Hmm... we never used this...
+void Client::recvStatusMsg(QString /*net*/, QString /*msg*/) {
+  //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg)));
 }
 
-QVariant Client::retrieveSessionData(const QString &key, const QVariant &def) {
-  if(instance()->sessionData.contains(key)) return instance()->sessionData[key];
-  else return def;
+void Client::recvMessage(const Message &msg) {
+  Message msg_ = msg;
+  messageProcessor()->process(msg_);
 }
 
-QStringList Client::sessionDataKeys() {
-  return instance()->sessionData.keys();
+void Client::setBufferLastSeenMsg(BufferId id, const MsgId &msgId) {
+  if(bufferSyncer())
+    bufferSyncer()->requestSetLastSeenMsg(id, msgId);
 }
 
-/*** ***/
-
-/*
-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::setMarkerLine(BufferId id, const MsgId &msgId) {
+  if(bufferSyncer())
+    bufferSyncer()->requestSetMarkerLine(id, msgId);
 }
 
-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();
+MsgId Client::markerLine(BufferId id) {
+  if(id.isValid() && networkModel())
+    return networkModel()->markerLineMsgId(id);
+  return MsgId();
 }
-*/
 
-void Client::addNetwork(NetworkId netid) {
-  Network *net = new Network(netid, instance());
-  addNetwork(net);
+void Client::removeBuffer(BufferId id) {
+  if(!bufferSyncer()) return;
+  bufferSyncer()->requestRemoveBuffer(id);
 }
 
-void Client::addNetwork(Network *net) {
-  net->setProxy(signalProxy());
-  signalProxy()->synchronize(net);
-  networkModel()->attachNetwork(net);
-  connect(net, SIGNAL(destroyed()), instance(), SLOT(networkDestroyed()));
-  instance()->_networks[net->networkId()] = net;
-  //if(net->networkId() == 1) net->requestConnect(); // FIXME
+void Client::renameBuffer(BufferId bufferId, const QString &newName) {
+  if(!bufferSyncer())
+    return;
+  bufferSyncer()->requestRenameBuffer(bufferId, newName);
 }
 
-/*** ***/
-
-void Client::updateBufferInfo(BufferInfo id) {
-  emit bufferUpdated(id);
+void Client::mergeBuffersPermanently(BufferId bufferId1, BufferId bufferId2) {
+  if(!bufferSyncer())
+    return;
+  bufferSyncer()->requestMergeBuffersPermanently(bufferId1, bufferId2);
 }
 
-void Client::bufferDestroyed() {
-  Buffer *buffer = static_cast<Buffer *>(sender());
-  QHash<BufferId, Buffer *>::iterator iter = _buffers.begin();
-  while(iter != _buffers.end()) {
-    if(iter.value() == buffer) {
-      iter = _buffers.erase(iter);
-      break;
-    }
-    iter++;
+void Client::purgeKnownBufferIds() {
+  if(!bufferSyncer())
+    return;
+  bufferSyncer()->requestPurgeBufferIds();
+}
+
+void Client::bufferRemoved(BufferId bufferId) {
+  // 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));
   }
-}
 
-void Client::networkDestroyed() {
-  Network *netinfo = static_cast<Network *>(sender());
-  NetworkId networkId = netinfo->networkId();
-  if(_networks.contains(networkId))
-    _networks.remove(networkId);
+  // and remove it from the model
+  networkModel()->removeBuffer(bufferId);
 }
 
-void Client::recvMessage(const Message &msg) {
-  Buffer *b = buffer(msg.buffer());
-
-//   Buffer::ActivityLevel level = Buffer::OtherActivity;
-//   if(msg.type() == Message::Plain || msg.type() == Message::Notice){
-//     level |= Buffer::NewMessage;
-//   }
-//   if(msg.flags() & Message::Highlight){
-//     level |= Buffer::Highlight;
-//   }
-//   emit bufferActivity(level, b);
-
-  b->appendMsg(msg);
+void Client::bufferRenamed(BufferId bufferId, const QString &newName) {
+  QModelIndex bufferIndex = networkModel()->bufferIndex(bufferId);
+  if(bufferIndex.isValid()) {
+    networkModel()->setData(bufferIndex, newName, Qt::DisplayRole);
+  }
 }
 
-void Client::recvStatusMsg(QString /*net*/, QString /*msg*/) {
-  //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg)));
+void Client::buffersPermanentlyMerged(BufferId bufferId1, BufferId bufferId2) {
+  QModelIndex idx = networkModel()->bufferIndex(bufferId1);
+  bufferModel()->setCurrentIndex(bufferModel()->mapFromSource(idx));
+  networkModel()->removeBuffer(bufferId2);
 }
 
-void Client::recvBacklogData(BufferInfo id, QVariantList msgs, bool /*done*/) {
-  Buffer *b = buffer(id);
-  foreach(QVariant v, msgs) {
-    Message msg = v.value<Message>();
-    b->prependMsg(msg);
-    if(!layoutQueue.contains(b)) layoutQueue.append(b);
-  }
-  if(layoutQueue.count() && !layoutTimer->isActive()) layoutTimer->start();
+void Client::markBufferAsRead(BufferId id) {
+  if(bufferSyncer() && id.isValid())
+    bufferSyncer()->requestMarkBufferAsRead(id);
 }
 
-void Client::layoutMsg() {
-  if(layoutQueue.count()) {
-    Buffer *b = layoutQueue.takeFirst();  // TODO make this the current buffer
-    if(b->layoutMsg())
-      layoutQueue.append(b);  // Buffer has more messages in its queue --> Round Robin
-  }
-  
-  if(!layoutQueue.count())
-    layoutTimer->stop();
-}
+void Client::logMessage(QtMsgType type, const char *msg) {
+  fprintf(stderr, "%s\n", msg);
+  fflush(stderr);
+  if(type == QtFatalMsg) {
+    Quassel::logFatalMessage(msg);
+  } else {
+    QString msgString = QString("%1\n").arg(msg);
 
-AbstractUiMsg *Client::layoutMsg(const Message &msg) {
-  return instance()->mainUi->layoutMsg(msg);
-}
+    //Check to see if there is an instance around, else we risk recursions
+    //when calling instance() and creating new ones.
+    if (!instanceExists())
+      return;
 
-void Client::userInput(BufferInfo id, QString msg) {
-  emit sendInput(id, msg);
+    instance()->_debugLog << msgString;
+    emit instance()->logUpdated(msgString);
+  }
 }
-