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

diff --git a/src/client/client.cpp b/src/client/client.cpp
index b61ebd7e..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,408 +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 "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 "quassel.h"
-#include "quasselui.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() {
-  if(instanceptr) {
-    delete instanceptr->mainUi;
-    instanceptr->deleteLater();
-    instanceptr = 0;
-  }
+
+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),
+    : 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);
+    _signalProxy->synchronize(_ircListHelper);
 }
 
-Client::~Client() {
-  disconnectFromCore();
+
+Client::~Client()
+{
+    disconnectFromCore();
 }
 
-void Client::init() {
-  _currentCoreAccount = 0;
-  _networkModel = new NetworkModel(this);
 
-  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)), _networkModel, SLOT(bufferUpdated(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(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(disconnectedFromCore()));
+    // 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();
 
-  // attach backlog manager
-  p->synchronize(backlogManager());
-  connect(backlogManager(), SIGNAL(messagesReceived(BufferId, int)), _messageModel, SLOT(messagesReceived(BufferId, int)));
+    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;
+
+void Client::setCoreFeatures(Quassel::Features features)
+{
+    _coreFeatures = features;
 }
 
-bool Client::isConnected() {
-  return instance()->_connectedToCore;
+
+bool Client::isConnected()
+{
+    return instance()->_connected;
 }
 
-bool Client::isSynced() {
-  return instance()->_syncedToCore;
+
+bool Client::internalCore()
+{
+    return currentCoreAccount().isInternal();
 }
 
+
 /*** Network handling ***/
 
-QList<NetworkId> Client::networkIds() {
-  return instance()->_networks.keys();
+QList<NetworkId> Client::networkIds()
+{
+    return instance()->_networks.keys();
 }
 
-const Network * Client::network(NetworkId networkid) {
-  if(instance()->_networks.contains(networkid)) return instance()->_networks[networkid];
-  else return 0;
+
+const Network *Client::network(NetworkId networkid)
+{
+    if (instance()->_networks.contains(networkid)) return instance()->_networks[networkid];
+    else return 0;
 }
 
-void Client::createNetwork(const NetworkInfo &info) {
-  emit instance()->requestCreateNetwork(info);
+
+void Client::createNetwork(const NetworkInfo &info, const QStringList &persistentChannels)
+{
+    emit instance()->requestCreateNetwork(info, persistentChannels);
 }
 
-void Client::removeNetwork(NetworkId id) {
-  emit instance()->requestRemoveNetwork(id);
+
+void Client::removeNetwork(NetworkId id)
+{
+    emit instance()->requestRemoveNetwork(id);
 }
 
-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);
+
+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);
 }
 
-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::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::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::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::coreNetworkRemoved(NetworkId id) {
-  if(!_networks.contains(id))
-    return;
-  Network *net = _networks.take(id);
-  emit networkRemoved(net->networkId());
-  net->deleteLater();
+
+void Client::coreNetworkRemoved(NetworkId id)
+{
+    if (!_networks.contains(id))
+        return;
+    Network *net = _networks.take(id);
+    emit networkRemoved(net->networkId());
+    net->deleteLater();
 }
 
+
 /*** Identity handling ***/
 
-QList<IdentityId> Client::identityIds() {
-  return instance()->_identities.keys();
+QList<IdentityId> Client::identityIds()
+{
+    return instance()->_identities.keys();
 }
 
-const Identity * Client::identity(IdentityId id) {
-  if(instance()->_identities.contains(id)) return instance()->_identities[id];
-  else return 0;
+
+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(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::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) {
-  emit instance()->requestRemoveIdentity(id);
+
+void Client::removeIdentity(IdentityId id)
+{
+    emit instance()->requestRemoveIdentity(id);
 }
 
-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::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::coreIdentityRemoved(IdentityId id) {
-  if(_identities.contains(id)) {
-    emit identityRemoved(id);
-    Identity *i = _identities.take(id);
-    i->deleteLater();
-  }
+
+void Client::coreIdentityRemoved(IdentityId id)
+{
+    if (_identities.contains(id)) {
+        emit identityRemoved(id);
+        Identity *i = _identities.take(id);
+        i->deleteLater();
+    }
 }
 
-/***  ***/
-void Client::userInput(BufferInfo bufferInfo, QString message) {
-  emit instance()->sendInput(bufferInfo, message);
+
+/*** 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));
 }
 
-/*** core connection stuff ***/
 
-void Client::setConnectedToCore(QIODevice *socket, AccountId id) {
-  // if the socket is an orphan, the signalProxy adopts it.
-  // -> we don't need to care about it anymore
-  socket->setParent(0);
-  signalProxy()->addPeer(socket);
-  _connectedToCore = true;
-  setCurrentCoreAccount(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::setConnectedToInternalCore() {
-  _connectedToCore = true;
-  setCurrentCoreAccount(AccountId());
+
+/*** 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::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());
 
-  // create a new BufferViewManager
-  _bufferViewManager = new BufferViewManager(signalProxy(), this);
+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()));
 
-  _syncedToCore = true;
-  emit connected();
-  emit coreConnectionStateChanged(true);
+    _connected = true;
+    emit connected();
+    emit coreConnectionStateChanged(true);
 }
 
-void Client::setSecuredConnection() {
-  emit securedConnection();
+
+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();
 }
 
-void Client::disconnectFromCore() {
-  if(!isConnected())
-    return;
 
-  signalProxy()->removeAllPeers();
+void Client::disconnectFromCore()
+{
+    if (!coreConnection()->isConnected())
+        return;
+
+    coreConnection()->disconnectFromCore();
 }
 
-void Client::disconnectedFromCore() {
-  _connectedToCore = false;
-  _syncedToCore = false;
-  emit disconnected();
-  emit coreConnectionStateChanged(false);
 
-  backlogManager()->reset();
-  messageProcessor()->reset();
+void Client::setDisconnectedFromCore()
+{
+    _connected = false;
+    _coreFeatures = 0;
 
-  // Clear internal data. Hopefully nothing relies on it at this point.
-  setCurrentCoreAccount(0);
+    emit disconnected();
+    emit coreConnectionStateChanged(false);
 
-  if(_bufferSyncer) {
-    _bufferSyncer->deleteLater();
-    _bufferSyncer = 0;
-  }
+    backlogManager()->reset();
+    messageProcessor()->reset();
 
-  if(_bufferViewManager) {
-    _bufferViewManager->deleteLater();
-    _bufferViewManager = 0;
-  }
+    // Clear internal data. Hopefully nothing relies on it at this point.
 
-  _messageModel->clear();
-  _networkModel->clear();
+    if (_bufferSyncer) {
+        _bufferSyncer->deleteLater();
+        _bufferSyncer = 0;
+    }
 
-  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());
+    if (_bufferViewManager) {
+        _bufferViewManager->deleteLater();
+        _bufferViewManager = 0;
+    }
 
-  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());
+    _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::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++;
+        }
     }
-  }
 }
 
+
 // Hmm... we never used this...
-void Client::recvStatusMsg(QString /*net*/, QString /*msg*/) {
-  //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg)));
+void Client::recvStatusMsg(QString /*net*/, QString /*msg*/)
+{
+    //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg)));
 }
 
-void Client::recvMessage(const Message &msg) {
-  Message msg_ = msg;
-  messageProcessor()->process(msg_);
+
+void Client::recvMessage(const Message &msg)
+{
+    Message msg_ = msg;
+    messageProcessor()->process(msg_);
 }
 
-void Client::setBufferLastSeenMsg(BufferId id, const MsgId &msgId) {
-  if(!bufferSyncer())
-    return;
-  bufferSyncer()->requestSetLastSeenMsg(id, msgId);
+
+void Client::setBufferLastSeenMsg(BufferId id, const MsgId &msgId)
+{
+    if (bufferSyncer())
+        bufferSyncer()->requestSetLastSeenMsg(id, msgId);
 }
 
-void Client::removeBuffer(BufferId id) {
-  if(!bufferSyncer()) return;
-  bufferSyncer()->requestRemoveBuffer(id);
+
+void Client::setMarkerLine(BufferId id, const MsgId &msgId)
+{
+    if (bufferSyncer())
+        bufferSyncer()->requestSetMarkerLine(id, msgId);
 }
 
-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));
-  }
 
-  // and remove it from the model
-  networkModel()->removeBuffer(bufferId);
+MsgId Client::markerLine(BufferId id)
+{
+    if (id.isValid() && networkModel())
+        return networkModel()->markerLineMsgId(id);
+    return MsgId();
 }
 
-void Client::bufferRenamed(BufferId bufferId, const QString &newName) {
-  QModelIndex bufferIndex = networkModel()->bufferIndex(bufferId);
-  if(bufferIndex.isValid()) {
-    networkModel()->setData(bufferIndex, newName, Qt::DisplayRole);
-  }
+
+void Client::removeBuffer(BufferId id)
+{
+    if (!bufferSyncer()) return;
+    bufferSyncer()->requestRemoveBuffer(id);
 }
 
-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);
-    instance()->_debugLog << msgString;
-    emit instance()->logUpdated(msgString);
-  }
+
+void Client::renameBuffer(BufferId bufferId, const QString &newName)
+{
+    if (!bufferSyncer())
+        return;
+    bufferSyncer()->requestRenameBuffer(bufferId, newName);
 }
 
+
+void Client::mergeBuffersPermanently(BufferId bufferId1, BufferId bufferId2)
+{
+    if (!bufferSyncer())
+        return;
+    bufferSyncer()->requestMergeBuffersPermanently(bufferId1, bufferId2);
+}
+
+
+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));
+    }
+
+    // and remove it from the model
+    networkModel()->removeBuffer(bufferId);
+}
+
+
+void Client::bufferRenamed(BufferId bufferId, const QString &newName)
+{
+    QModelIndex bufferIndex = networkModel()->bufferIndex(bufferId);
+    if (bufferIndex.isValid()) {
+        networkModel()->setData(bufferIndex, newName, Qt::DisplayRole);
+    }
+}
+
+
+void Client::buffersPermanentlyMerged(BufferId bufferId1, BufferId bufferId2)
+{
+    QModelIndex idx = networkModel()->bufferIndex(bufferId1);
+    bufferModel()->setCurrentIndex(bufferModel()->mapFromSource(idx));
+    networkModel()->removeBuffer(bufferId2);
+}
+
+
+void Client::markBufferAsRead(BufferId id)
+{
+    if (bufferSyncer() && id.isValid())
+        bufferSyncer()->requestMarkBufferAsRead(id);
+}
+
+void Client::changePassword(QString newPassword) {
+    CoreAccount account = currentCoreAccount();
+    account.setPassword(newPassword);
+    coreAccountModel()->createOrUpdateAccount(account);
+    coreAccountModel()->save();
+    emit clientChangePassword(newPassword);
+}
+
+
+#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);
+
+        //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);
+    }
+}
+#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);
+
+        //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