X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fclient%2Fclient.cpp;h=d8dbcbf51ed94e9f56078b3be9255cf46e9eb464;hp=2b667e0cac363fd3b5250f18b30ea79fbfea479a;hb=7cd3ad607186b3a14989075968daa4f1e2ea265b;hpb=c0c8cea57282c56951562e427bc1acb3ee2028a3

diff --git a/src/client/client.cpp b/src/client/client.cpp
index 2b667e0c..d8dbcbf5 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-2015 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -15,490 +15,693 @@
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
 #include "client.h"
 
 #include "abstractmessageprocessor.h"
+#include "abstractui.h"
 #include "bufferinfo.h"
 #include "buffermodel.h"
 #include "buffersettings.h"
 #include "buffersyncer.h"
-#include "bufferviewmanager.h"
+#include "bufferviewconfig.h"
+#include "bufferviewoverlay.h"
+#include "clientaliasmanager.h"
 #include "clientbacklogmanager.h"
+#include "clientbufferviewmanager.h"
 #include "clientirclisthelper.h"
-#include "global.h"
-#include "identity.h"
+#include "clientidentity.h"
+#include "clientignorelistmanager.h"
+#include "clienttransfermanager.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 "quasselui.h"
+#include "quassel.h"
 #include "signalproxy.h"
 #include "util.h"
+#include "clientauthhandler.h"
+
+#include <stdio.h>
+#include <stdlib.h>
 
 QPointer<Client> Client::instanceptr = 0;
-AccountId Client::_currentCoreAccount = 0;
+Quassel::Features Client::_coreFeatures = 0;
 
 /*** Initialization/destruction ***/
 
-Client *Client::instance() {
-  if(!instanceptr)
-    instanceptr = new Client();
-  return instanceptr;
+bool Client::instanceExists()
+{
+    return instanceptr;
 }
 
-void Client::destroy() {
-  //delete instanceptr;
-  instanceptr->deleteLater();
+
+Client *Client::instance()
+{
+    if (!instanceptr)
+        instanceptr = new Client();
+    return instanceptr;
 }
 
-void Client::init(AbstractUi *ui) {
-  instance()->mainUi = ui;
-  instance()->init();
+
+void Client::destroy()
+{
+    if (instanceptr) {
+        delete instanceptr->mainUi();
+        instanceptr->deleteLater();
+        instanceptr = 0;
+    }
+}
+
+
+void Client::init(AbstractUi *ui)
+{
+    instance()->_mainUi = ui;
+    instance()->init();
 }
 
+
 Client::Client(QObject *parent)
-  : QObject(parent),
-    socket(0),
+    : QObject(parent),
     _signalProxy(new SignalProxy(SignalProxy::Client, this)),
-    mainUi(0),
+    _mainUi(0),
     _networkModel(0),
     _bufferModel(0),
     _bufferSyncer(0),
+    _aliasManager(0),
     _backlogManager(new ClientBacklogManager(this)),
     _bufferViewManager(0),
+    _bufferViewOverlay(new BufferViewOverlay(this)),
     _ircListHelper(new ClientIrcListHelper(this)),
+    _inputHandler(0),
+    _networkConfig(0),
+    _ignoreListManager(0),
+    _transferManager(0),
     _messageModel(0),
     _messageProcessor(0),
-    _connectedToCore(false),
-    _syncedToCore(false)
+    _coreAccountModel(new CoreAccountModel(this)),
+    _coreConnection(new CoreConnection(this)),
+    _connected(false),
+    _debugLog(&_debugLogBuffer)
 {
-  _signalProxy->synchronize(_ircListHelper);
-
-  connect(_backlogManager, SIGNAL(backlog(BufferId, const QVariantList &)),
-	  this, SLOT(receiveBacklog(BufferId, const QVariantList &)));
+    _signalProxy->synchronize(_ircListHelper);
 }
 
-Client::~Client() {
-  disconnectFromCore();
+
+Client::~Client()
+{
+    disconnectFromCore();
 }
 
-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)));
+void Client::init()
+{
+    _networkModel = new NetworkModel(this);
+
+    connect(this, SIGNAL(networkRemoved(NetworkId)),
+        _networkModel, SLOT(networkRemoved(NetworkId)));
+
+    _bufferModel = new BufferModel(_networkModel);
+    _messageModel = mainUi()->createMessageModel(this);
+    _messageProcessor = mainUi()->createMessageProcessor(this);
+    _inputHandler = new ClientUserInputHandler(this);
 
-  _bufferModel = new BufferModel(_networkModel);
-  _messageModel = mainUi->createMessageModel(this);
-  _messageProcessor = mainUi->createMessageProcessor(this);
+    SignalProxy *p = signalProxy();
 
-  SignalProxy *p = signalProxy();
+    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(bufferInfoUpdated(BufferInfo)), _networkModel, SLOT(bufferUpdated(BufferInfo)));
+    p->attachSignal(inputHandler(), SIGNAL(sendInput(BufferInfo, QString)));
+    p->attachSignal(this, SIGNAL(requestNetworkStates()));
 
-  p->attachSlot(SIGNAL(bufferInfoUpdated(BufferInfo)), this, SLOT(updateBufferInfo(BufferInfo)));
-  p->attachSignal(this, SIGNAL(sendInput(BufferInfo, QString)));
-  p->attachSignal(this, SIGNAL(requestNetworkStates()));
+    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)));
 
-  p->attachSignal(this, SIGNAL(requestCreateIdentity(const Identity &)), SIGNAL(createIdentity(const Identity &)));
-  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)));
+    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)));
 
-  p->attachSignal(this, SIGNAL(requestCreateNetwork(const NetworkInfo &)), SIGNAL(createNetwork(const NetworkInfo &)));
-  p->attachSignal(this, SIGNAL(requestUpdateNetwork(const NetworkInfo &)), SIGNAL(updateNetwork(const NetworkInfo &)));
-  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(p, SIGNAL(disconnected()), this, SLOT(disconnectFromCore()));
+    // attach backlog manager
+    p->synchronize(backlogManager());
+    connect(backlogManager(), SIGNAL(messagesReceived(BufferId, int)), _messageModel, SLOT(messagesReceived(BufferId, int)));
 
-  //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()));
+    coreAccountModel()->load();
 
+    connect(coreConnection(), SIGNAL(stateChanged(CoreConnection::ConnectionState)), SLOT(connectionStateChanged(CoreConnection::ConnectionState)));
+    coreConnection()->init();
 }
 
+
 /*** public static methods ***/
 
-AccountId Client::currentCoreAccount() {
-  return _currentCoreAccount;
+AbstractUi *Client::mainUi()
+{
+    return instance()->_mainUi;
 }
 
-void Client::setCurrentCoreAccount(AccountId id) {
-  _currentCoreAccount = id;
-}
 
-QList<BufferInfo> Client::allBufferInfos() {
-  QList<BufferInfo> bufferids;
-  foreach(Buffer *buffer, buffers()) {
-    bufferids << buffer->bufferInfo();
-  }
-  return bufferids;
+void Client::setCoreFeatures(Quassel::Features features)
+{
+    _coreFeatures = features;
 }
 
-QList<Buffer *> Client::buffers() {
-  return instance()->_buffers.values();
+
+bool Client::isConnected()
+{
+    return instance()->_connected;
 }
 
 
-Buffer *Client::statusBuffer(const NetworkId &networkId) const {
-  if(_statusBuffers.contains(networkId))
-    return _statusBuffers[networkId];
-  else
-    return 0;
+bool Client::internalCore()
+{
+    return currentCoreAccount().isInternal();
 }
 
-Buffer *Client::buffer(BufferInfo bufferInfo) {
-  Buffer *buff = 0;
-  if(instance()->_buffers.contains(bufferInfo.bufferId()))
-    buff = instance()->_buffers[bufferInfo.bufferId()];
 
-  if(!buff) {
-    Client *client = Client::instance();
-    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;
+/*** Network handling ***/
+
+QList<NetworkId> Client::networkIds()
+{
+    return instance()->_networks.keys();
+}
 
-    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;
+const Network *Client::network(NetworkId networkid)
+{
+    if (instance()->_networks.contains(networkid)) return instance()->_networks[networkid];
+    else return 0;
 }
 
-bool Client::isConnected() {
-  return instance()->_connectedToCore;
+
+void Client::createNetwork(const NetworkInfo &info, const QStringList &persistentChannels)
+{
+    emit instance()->requestCreateNetwork(info, persistentChannels);
 }
 
-bool Client::isSynced() {
-  return instance()->_syncedToCore;
+
+void Client::removeNetwork(NetworkId id)
+{
+    emit instance()->requestRemoveNetwork(id);
 }
 
-/*** Network handling ***/
 
-QList<NetworkId> Client::networkIds() {
-  return instance()->_networks.keys();
+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);
 }
 
-const Network * Client::network(NetworkId networkid) {
-  if(instance()->_networks.contains(networkid)) return instance()->_networks[networkid];
-  else return 0;
+
+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());
 }
 
-void Client::createNetwork(const NetworkInfo &info) {
-  emit instance()->requestCreateNetwork(info);
+
+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);
 }
 
-void Client::updateNetwork(const NetworkInfo &info) {
-  emit instance()->requestUpdateNetwork(info);
+
+void Client::coreNetworkRemoved(NetworkId id)
+{
+    if (!_networks.contains(id))
+        return;
+    Network *net = _networks.take(id);
+    emit networkRemoved(net->networkId());
+    net->deleteLater();
 }
 
-void Client::removeNetwork(NetworkId id) {
-  emit instance()->requestRemoveNetwork(id);
+
+/*** Identity handling ***/
+
+QList<IdentityId> Client::identityIds()
+{
+    return instance()->_identities.keys();
 }
 
-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());
+
+const Identity *Client::identity(IdentityId id)
+{
+    if (instance()->_identities.contains(id)) return instance()->_identities[id];
+    else return 0;
 }
 
-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);
+
+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::coreNetworkRemoved(NetworkId id) {
-  if(!_networks.contains(id))
-    return;
-  Network *net = _networks.take(id);
-  emit networkRemoved(net->networkId());
-  net->deleteLater();
+
+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);
 }
 
-/*** Identity handling ***/
 
-QList<IdentityId> Client::identityIds() {
-  return instance()->_identities.keys();
+void Client::removeIdentity(IdentityId id)
+{
+    emit instance()->requestRemoveIdentity(id);
 }
 
-const Identity * Client::identity(IdentityId id) {
-  if(instance()->_identities.contains(id)) return instance()->_identities[id];
-  else return 0;
+
+void Client::coreIdentityCreated(const Identity &other)
+{
+    if (!_identities.contains(other.id())) {
+        Identity *identity = new Identity(other, this);
+        _identities[other.id()] = identity;
+        identity->setInitialized();
+        signalProxy()->synchronize(identity);
+        emit identityCreated(other.id());
+    }
+    else {
+        qWarning() << tr("Identity already exists in client!");
+    }
 }
 
-void Client::createIdentity(const Identity &id) {
-  emit instance()->requestCreateIdentity(id);
+
+void Client::coreIdentityRemoved(IdentityId id)
+{
+    if (_identities.contains(id)) {
+        emit identityRemoved(id);
+        Identity *i = _identities.take(id);
+        i->deleteLater();
+    }
 }
 
-void Client::updateIdentity(IdentityId id, const QVariantMap &ser) {
-  //emit instance()->requestUpdateIdentity(id);
-  Identity *idptr = instance()->_identities.value(id, 0);
-  if(!idptr) {
-    qWarning() << "Update for unknown identity requested:" << id;
-    return;
-  }
-  idptr->requestUpdate(ser);
+
+/*** User input handling ***/
+
+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
+        instance()->_userInputBuffer.append(qMakePair(bufferInfo, message));
 }
 
-void Client::removeIdentity(IdentityId id) {
-  emit instance()->requestRemoveIdentity(id);
+
+void Client::sendBufferedUserInput()
+{
+    for (int i = 0; i < _userInputBuffer.count(); i++)
+        userInput(_userInputBuffer.at(i).first, _userInputBuffer.at(i).second);
+
+    _userInputBuffer.clear();
 }
 
-void Client::coreIdentityCreated(const Identity &other) {
-  if(!_identities.contains(other.id())) {
-    Identity *identity = new Identity(other, this);
-    _identities[other.id()] = identity;
-    identity->setInitialized();
-    signalProxy()->synchronize(identity);
-    emit identityCreated(other.id());
-  } else {
-    qWarning() << tr("Identity already exists in client!");
-  }
+
+/*** core connection stuff ***/
+
+void Client::connectionStateChanged(CoreConnection::ConnectionState state)
+{
+    switch (state) {
+    case CoreConnection::Disconnected:
+        setDisconnectedFromCore();
+        break;
+    case CoreConnection::Synchronized:
+        setSyncedToCore();
+        break;
+    default:
+        break;
+    }
 }
 
-void Client::coreIdentityRemoved(IdentityId id) {
-  if(_identities.contains(id)) {
-    emit identityRemoved(id);
-    Identity *i = _identities.take(id);
-    i->deleteLater();
-  }
+
+void Client::setSyncedToCore()
+{
+    // 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 *p = signalProxy();
+
+    if ((Client::coreFeatures() & Quassel::PasswordChange)) {
+        p->attachSignal(this, SIGNAL(clientChangePassword(QString)));
+    }
+
+    p->synchronize(bufferSyncer());
+
+    // create a new BufferViewManager
+    Q_ASSERT(!_bufferViewManager);
+    _bufferViewManager = new ClientBufferViewManager(p, this);
+    connect(_bufferViewManager, SIGNAL(initDone()), _bufferViewOverlay, SLOT(restore()));
+
+    // create AliasManager
+    Q_ASSERT(!_aliasManager);
+    _aliasManager = new ClientAliasManager(this);
+    connect(aliasManager(), SIGNAL(initDone()), SLOT(sendBufferedUserInput()));
+    p->synchronize(aliasManager());
+
+    // create NetworkConfig
+    Q_ASSERT(!_networkConfig);
+    _networkConfig = new NetworkConfig("GlobalNetworkConfig", this);
+    p->synchronize(networkConfig());
+
+    // create IgnoreListManager
+    Q_ASSERT(!_ignoreListManager);
+    _ignoreListManager = new ClientIgnoreListManager(this);
+    p->synchronize(ignoreListManager());
+
+    Q_ASSERT(!_transferManager);
+    _transferManager = new ClientTransferManager(this);
+    p->synchronize(transferManager());
+
+    // 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::userInput(BufferInfo bufferInfo, QString message) {
-  emit instance()->sendInput(bufferInfo, message);
+
+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;
+    }
+    disconnect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
+    disconnect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
+
+    _backlogManager->requestInitialBacklog();
 }
 
-/*** core connection stuff ***/
 
-void Client::setConnectedToCore(QIODevice *sock, AccountId id) {
-  socket = sock;
-  signalProxy()->addPeer(socket);
-  _connectedToCore = true;
-  setCurrentCoreAccount(id);
+void Client::disconnectFromCore()
+{
+    if (!coreConnection()->isConnected())
+        return;
+
+    coreConnection()->disconnectFromCore();
 }
 
-void Client::setSyncedToCore() {
-  // create buffersyncer
-  Q_ASSERT(!_bufferSyncer);
-  _bufferSyncer = new BufferSyncer(this);
-  connect(bufferSyncer(), SIGNAL(lastSeenMsgSet(BufferId, MsgId)), _networkModel, SLOT(setLastSeenMsgId(BufferId, MsgId)));
-  connect(bufferSyncer(), SIGNAL(bufferRemoved(BufferId)), this, SLOT(bufferRemoved(BufferId)));
-  connect(bufferSyncer(), SIGNAL(bufferRenamed(BufferId, QString)), this, SLOT(bufferRenamed(BufferId, QString)));
-  signalProxy()->synchronize(bufferSyncer());
 
-  // attach backlog manager
-  signalProxy()->synchronize(backlogManager());
+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.
 
-  // create a new BufferViewManager
-  _bufferViewManager = new BufferViewManager(signalProxy(), this);
+    if (_bufferSyncer) {
+        _bufferSyncer->deleteLater();
+        _bufferSyncer = 0;
+    }
+
+    if (_bufferViewManager) {
+        _bufferViewManager->deleteLater();
+        _bufferViewManager = 0;
+    }
 
-  _syncedToCore = true;
-  emit connected();
-  emit coreConnectionStateChanged(true);
+    _bufferViewOverlay->reset();
+
+    if (_aliasManager) {
+        _aliasManager->deleteLater();
+        _aliasManager = 0;
+    }
+
+    if (_ignoreListManager) {
+        _ignoreListManager->deleteLater();
+        _ignoreListManager = 0;
+    }
+
+    if (_transferManager) {
+        _transferManager->deleteLater();
+        _transferManager = 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();
+    while (idIter != _identities.end()) {
+        emit identityRemoved(idIter.key());
+        Identity *id = idIter.value();
+        idIter = _identities.erase(idIter);
+        id->deleteLater();
+    }
+    Q_ASSERT(_identities.isEmpty());
+
+    if (_networkConfig) {
+        _networkConfig->deleteLater();
+        _networkConfig = 0;
+    }
+}
+
+
+/*** ***/
+
+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::setSecuredConnection() {
-  emit securedConnection();
+
+// Hmm... we never used this...
+void Client::recvStatusMsg(QString /*net*/, QString /*msg*/)
+{
+    //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg)));
 }
 
-void Client::disconnectFromCore() {
-  if(!isConnected())
-    return;
-  _connectedToCore = false;
 
-  if(socket) {
-    socket->close();
-    socket->deleteLater();
-  }
-  _syncedToCore = false;
-  emit disconnected();
-  emit coreConnectionStateChanged(false);
+void Client::recvMessage(const Message &msg)
+{
+    Message msg_ = msg;
+    messageProcessor()->process(msg_);
+}
 
-  messageProcessor()->reset();
 
-  // Clear internal data. Hopefully nothing relies on it at this point.
-  setCurrentCoreAccount(0);
+void Client::setBufferLastSeenMsg(BufferId id, const MsgId &msgId)
+{
+    if (bufferSyncer())
+        bufferSyncer()->requestSetLastSeenMsg(id, msgId);
+}
 
-  if(_bufferSyncer) {
-    _bufferSyncer->deleteLater();
-    _bufferSyncer = 0;
-  }
 
-  if(_bufferViewManager) {
-    _bufferViewManager->deleteLater();
-    _bufferViewManager = 0;
-  }
+void Client::setMarkerLine(BufferId id, const MsgId &msgId)
+{
+    if (bufferSyncer())
+        bufferSyncer()->requestSetMarkerLine(id, msgId);
+}
 
-  _messageModel->clear();
-  _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();
-  }
-  Q_ASSERT(_buffers.isEmpty());
+MsgId Client::markerLine(BufferId id)
+{
+    if (id.isValid() && networkModel())
+        return networkModel()->markerLineMsgId(id);
+    return MsgId();
+}
 
-  _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());
+void Client::removeBuffer(BufferId id)
+{
+    if (!bufferSyncer()) return;
+    bufferSyncer()->requestRemoveBuffer(id);
+}
 
-  QHash<IdentityId, Identity*>::iterator idIter = _identities.begin();
-  while(idIter != _identities.end()) {
-    Identity *id = idIter.value();
-    emit identityRemoved(id->id());
-    idIter = _identities.erase(idIter);
-    id->deleteLater();
-  }
-  Q_ASSERT(_identities.isEmpty());
 
+void Client::renameBuffer(BufferId bufferId, const QString &newName)
+{
+    if (!bufferSyncer())
+        return;
+    bufferSyncer()->requestRenameBuffer(bufferId, newName);
 }
 
-void Client::setCoreConfiguration(const QVariantMap &settings) {
-  SignalProxy::writeDataToDevice(socket, settings);
+
+void Client::mergeBuffersPermanently(BufferId bufferId1, BufferId bufferId2)
+{
+    if (!bufferSyncer())
+        return;
+    bufferSyncer()->requestMergeBuffersPermanently(bufferId1, bufferId2);
 }
 
-/*** ***/
 
-void Client::updateBufferInfo(BufferInfo id) {
-  emit bufferUpdated(id);
+void Client::purgeKnownBufferIds()
+{
+    if (!bufferSyncer())
+        return;
+    bufferSyncer()->requestPurgeBufferIds();
 }
 
-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++;
-  }
-
-  QHash<NetworkId, Buffer *>::iterator statusIter = _statusBuffers.begin();
-  while(statusIter != _statusBuffers.end()) {
-    if(statusIter.value() == buffer) {
-      statusIter = _statusBuffers.erase(statusIter);
-      break;
-    }
-    statusIter++;
-  }
-}
-
-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::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));
     }
-  }
-}
 
-// Hmm... we never used this...
-void Client::recvStatusMsg(QString /*net*/, QString /*msg*/) {
-  //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg)));
+    // and remove it from the model
+    networkModel()->removeBuffer(bufferId);
 }
 
-void Client::recvMessage(const Message &msg_) {
-  Message msg = msg_;
-  messageProcessor()->process(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::receiveBacklog(BufferId bufferId, const QVariantList &msgs) {
-  //QTime start = QTime::currentTime();
-  QList<Message> msglist;
-  foreach(QVariant v, msgs) {
-    Message msg = v.value<Message>();
-    msg.setFlags(msg.flags() | Message::Backlog);
-    msglist << msg;
-  }
-  messageProcessor()->process(msglist);
-  //qDebug() << "processed" << msgs.count() << "backlog lines in" << start.msecsTo(QTime::currentTime());
+
+void Client::buffersPermanentlyMerged(BufferId bufferId1, BufferId bufferId2)
+{
+    QModelIndex idx = networkModel()->bufferIndex(bufferId1);
+    bufferModel()->setCurrentIndex(bufferModel()->mapFromSource(idx));
+    networkModel()->removeBuffer(bufferId2);
 }
 
-void Client::setBufferLastSeenMsg(BufferId id, const MsgId &msgId) {
-  if(!bufferSyncer())
-    return;
-  bufferSyncer()->requestSetLastSeenMsg(id, msgId);
+
+void Client::markBufferAsRead(BufferId id)
+{
+    if (bufferSyncer() && id.isValid())
+        bufferSyncer()->requestMarkBufferAsRead(id);
 }
 
-void Client::removeBuffer(BufferId id) {
-  if(!bufferSyncer()) return;
-  bufferSyncer()->requestRemoveBuffer(id);
+void Client::changePassword(QString newPassword) {
+    CoreAccount account = currentCoreAccount();
+    account.setPassword(newPassword);
+    coreAccountModel()->createOrUpdateAccount(account);
+    coreAccountModel()->save();
+    emit clientChangePassword(newPassword);
 }
 
-void Client::bufferRemoved(BufferId bufferId) {
-  // first remove the buffer from hash. 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));
-  }
+#if QT_VERSION < 0x050000
+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);
 
-  // and remove it from the model
-  networkModel()->removeBuffer(bufferId);
+        //Check to see if there is an instance around, else we risk recursions
+        //when calling instance() and creating new ones.
+        if (!instanceExists())
+            return;
 
-  if(buff)
-    buff->deleteLater();
+        instance()->_debugLog << msgString;
+        emit instance()->logUpdated(msgString);
+    }
 }
+#else
+void Client::logMessage(QtMsgType type, const QMessageLogContext &context, const QString &msg)
+{
+    Q_UNUSED(context);
+
+    fprintf(stderr, "%s\n", msg.toLocal8Bit().constData());
+    fflush(stderr);
+    if (type == QtFatalMsg) {
+        Quassel::logFatalMessage(msg.toLocal8Bit().constData());
+    }
+    else {
+        QString msgString = QString("%1\n").arg(msg);
 
-void Client::bufferRenamed(BufferId bufferId, const QString &newName) {
-  QModelIndex bufferIndex = networkModel()->bufferIndex(bufferId);
-  if(bufferIndex.isValid()) {
-    networkModel()->setData(bufferIndex, newName, Qt::DisplayRole);
-  }
+        //Check to see if there is an instance around, else we risk recursions
+        //when calling instance() and creating new ones.
+        if (!instanceExists())
+            return;
+
+        instance()->_debugLog << msgString;
+        emit instance()->logUpdated(msgString);
+    }
 }
+#endif