X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fclient%2Fclient.cpp;h=d8dbcbf51ed94e9f56078b3be9255cf46e9eb464;hp=741388c192e87505e60abb11cd5bcae23e19c783;hb=7cd3ad607186b3a14989075968daa4f1e2ea265b;hpb=7fc418e5841a1633f651e08a34ccd2123ba6e0db diff --git a/src/client/client.cpp b/src/client/client.cpp index 741388c1..d8dbcbf5 100644 --- a/src/client/client.cpp +++ b/src/client/client.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-09 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,7 +15,7 @@ * 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" @@ -33,51 +33,64 @@ #include "clientbufferviewmanager.h" #include "clientirclisthelper.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 "signalproxy.h" #include "util.h" +#include "clientauthhandler.h" #include #include QPointer Client::instanceptr = 0; -AccountId Client::_currentCoreAccount = 0; +Quassel::Features Client::_coreFeatures = 0; /*** Initialization/destruction ***/ bool Client::instanceExists() { - return instanceptr; + return instanceptr; } -Client *Client::instance() { - if(!instanceptr) - instanceptr = new Client(); - return instanceptr; + +Client *Client::instance() +{ + if (!instanceptr) + instanceptr = new Client(); + return instanceptr; } -void Client::destroy() { - if(instanceptr) { - delete instanceptr->mainUi(); - instanceptr->deleteLater(); - instanceptr = 0; - } + +void Client::destroy() +{ + if (instanceptr) { + delete instanceptr->mainUi(); + instanceptr->deleteLater(); + instanceptr = 0; + } } -void Client::init(AbstractUi *ui) { - instance()->_mainUi = ui; - instance()->init(); + +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), _networkModel(0), @@ -89,434 +102,606 @@ Client::Client(QObject *parent) _bufferViewOverlay(new BufferViewOverlay(this)), _ircListHelper(new ClientIrcListHelper(this)), _inputHandler(0), + _networkConfig(0), + _ignoreListManager(0), + _transferManager(0), _messageModel(0), _messageProcessor(0), - _connectedToCore(false), - _syncedToCore(false), - _internalCore(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); - _bufferModel = new BufferModel(_networkModel); - _messageModel = mainUi()->createMessageModel(this); - _messageProcessor = mainUi()->createMessageProcessor(this); - _inputHandler = new ClientUserInputHandler(this); + connect(this, SIGNAL(networkRemoved(NetworkId)), + _networkModel, SLOT(networkRemoved(NetworkId))); - SignalProxy *p = signalProxy(); + _bufferModel = new BufferModel(_networkModel); + _messageModel = mainUi()->createMessageModel(this); + _messageProcessor = mainUi()->createMessageProcessor(this); + _inputHandler = new ClientUserInputHandler(this); - p->attachSlot(SIGNAL(displayMsg(const Message &)), this, SLOT(recvMessage(const Message &))); - p->attachSlot(SIGNAL(displayStatusMsg(QString, QString)), this, SLOT(recvStatusMsg(QString, QString))); + SignalProxy *p = signalProxy(); - p->attachSlot(SIGNAL(bufferInfoUpdated(BufferInfo)), _networkModel, SLOT(bufferUpdated(BufferInfo))); - p->attachSignal(inputHandler(), SIGNAL(sendInput(BufferInfo, QString))); - p->attachSignal(this, SIGNAL(requestNetworkStates())); + p->attachSlot(SIGNAL(displayMsg(const Message &)), this, SLOT(recvMessage(const Message &))); + p->attachSlot(SIGNAL(displayStatusMsg(QString, QString)), this, SLOT(recvStatusMsg(QString, QString))); - 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->attachSlot(SIGNAL(bufferInfoUpdated(BufferInfo)), _networkModel, SLOT(bufferUpdated(BufferInfo))); + p->attachSignal(inputHandler(), SIGNAL(sendInput(BufferInfo, QString))); + p->attachSignal(this, SIGNAL(requestNetworkStates())); - 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(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(disconnectedFromCore())); + 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))); + // attach backlog manager + p->synchronize(backlogManager()); + connect(backlogManager(), SIGNAL(messagesReceived(BufferId, int)), _messageModel, SLOT(messagesReceived(BufferId, int))); + + coreAccountModel()->load(); + + connect(coreConnection(), SIGNAL(stateChanged(CoreConnection::ConnectionState)), SLOT(connectionStateChanged(CoreConnection::ConnectionState))); + coreConnection()->init(); } + /*** public static methods ***/ -AbstractUi *Client::mainUi() { - return instance()->_mainUi; +AbstractUi *Client::mainUi() +{ + return instance()->_mainUi; } -AccountId Client::currentCoreAccount() { - return _currentCoreAccount; -} -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 Client::networkIds() { - return instance()->_networks.keys(); +QList 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, const QStringList &persistentChannels) { - emit instance()->requestCreateNetwork(info, persistentChannels); + +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 Client::identityIds() { - return instance()->_identities.keys(); +QList 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 CertIdentity &id) { - QVariantMap additional; + +void Client::createIdentity(const CertIdentity &id) +{ + QVariantMap additional; #ifdef HAVE_SSL - additional["KeyPem"] = id.sslKey().toPem(); - additional["CertPem"] = id.sslCert().toPem(); + additional["KeyPem"] = id.sslKey().toPem(); + additional["CertPem"] = id.sslCert().toPem(); #endif - emit instance()->requestCreateIdentity(id, additional); + 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(); + } } + /*** 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::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::sendBufferedUserInput() { - for(int i = 0; i < _userInputBuffer.count(); i++) - userInput(_userInputBuffer.at(i).first, _userInputBuffer.at(i).second); - _userInputBuffer.clear(); +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(AccountId id, QIODevice *socket) { - if(socket) { // external core - // 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); - } - _internalCore = !socket; - _connectedToCore = true; - setCurrentCoreAccount(id); -} - -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))); - connect(bufferSyncer(), SIGNAL(buffersPermanentlyMerged(BufferId, BufferId)), this, SLOT(buffersPermanentlyMerged(BufferId, BufferId))); - connect(bufferSyncer(), SIGNAL(buffersPermanentlyMerged(BufferId, BufferId)), _messageModel, SLOT(buffersPermanentlyMerged(BufferId, BufferId))); - connect(networkModel(), SIGNAL(setLastSeenMsg(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()), this, SLOT(createDefaultBufferView())); - connect(bufferViewManager(), SIGNAL(viewsInitialized()), this, SLOT(requestInitialBacklog())); - - // create AliasManager - Q_ASSERT(!_aliasManager); - _aliasManager = new ClientAliasManager(this); - connect(aliasManager(), SIGNAL(initDone()), SLOT(sendBufferedUserInput())); - signalProxy()->synchronize(aliasManager()); - - _syncedToCore = true; - emit connected(); - emit coreConnectionStateChanged(true); -} - -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(bufferViewManager(), SIGNAL(viewsInitialized()), this, SLOT(requestInitialBacklog())); - connect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog())); - return; - } - _backlogManager->requestInitialBacklog(); -} - -void Client::createDefaultBufferView() { - if(bufferViewManager()->bufferViewConfigs().isEmpty()) { - BufferViewConfig config(-1); - config.setBufferViewName(tr("All Buffers")); - config.initSetBufferList(networkModel()->allBufferIdsSorted()); - bufferViewManager()->requestCreateBufferView(config.toVariantMap()); - } -} - -void Client::disconnectFromCore() { - if(!isConnected()) - return; - - signalProxy()->removeAllPeers(); -} - -void Client::disconnectedFromCore() { - _connectedToCore = false; - _syncedToCore = false; - emit disconnected(); - emit coreConnectionStateChanged(false); - - backlogManager()->reset(); - messageProcessor()->reset(); - - // Clear internal data. Hopefully nothing relies on it at this point. - setCurrentCoreAccount(0); - - if(_bufferSyncer) { - _bufferSyncer->deleteLater(); - _bufferSyncer = 0; - } - - if(_bufferViewManager) { - _bufferViewManager->deleteLater(); - _bufferViewManager = 0; - } - - if(_aliasManager) { - _aliasManager->deleteLater(); - _aliasManager = 0; - } - - // we probably don't want to save pending input for reconnect - _userInputBuffer.clear(); - - _messageModel->clear(); - _networkModel->clear(); - - QHash::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::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(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); +} - QHash::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()); +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 (!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. + + if (_bufferSyncer) { + _bufferSyncer->deleteLater(); + _bufferSyncer = 0; + } + + if (_bufferViewManager) { + _bufferViewManager->deleteLater(); + _bufferViewManager = 0; + } + + _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::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::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(sender()); - QHash::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(sender()); + QHash::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()) + bufferSyncer()->requestSetLastSeenMsg(id, msgId); } -void Client::setBufferLastSeenMsg(BufferId id, const MsgId &msgId) { - if(!bufferSyncer()) - return; - bufferSyncer()->requestSetLastSeenMsg(id, msgId); + +void Client::setMarkerLine(BufferId id, const MsgId &msgId) +{ + if (bufferSyncer()) + bufferSyncer()->requestSetMarkerLine(id, msgId); } -void Client::removeBuffer(BufferId id) { - if(!bufferSyncer()) return; - bufferSyncer()->requestRemoveBuffer(id); + +MsgId Client::markerLine(BufferId id) +{ + if (id.isValid() && networkModel()) + return networkModel()->markerLineMsgId(id); + return MsgId(); } -void Client::renameBuffer(BufferId bufferId, const QString &newName) { - if(!bufferSyncer()) - return; - bufferSyncer()->requestRenameBuffer(bufferId, newName); + +void Client::removeBuffer(BufferId id) +{ + if (!bufferSyncer()) return; + bufferSyncer()->requestRemoveBuffer(id); } -void Client::mergeBuffersPermanently(BufferId bufferId1, BufferId bufferId2) { - if(!bufferSyncer()) - return; - bufferSyncer()->requestMergeBuffersPermanently(bufferId1, bufferId2); + +void Client::renameBuffer(BufferId bufferId, const QString &newName) +{ + if (!bufferSyncer()) + return; + bufferSyncer()->requestRenameBuffer(bufferId, newName); } -void Client::purgeKnownBufferIds() { - if(!bufferSyncer()) - return; - bufferSyncer()->requestPurgeBufferIds(); + +void Client::mergeBuffersPermanently(BufferId bufferId1, BufferId bufferId2) +{ + if (!bufferSyncer()) + return; + bufferSyncer()->requestMergeBuffersPermanently(bufferId1, bufferId2); } -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) { - bufferModel()->setCurrentIndex(current.sibling(0,0)); - } - // and remove it from the model - networkModel()->removeBuffer(bufferId); +void Client::purgeKnownBufferIds() +{ + if (!bufferSyncer()) + return; + bufferSyncer()->requestPurgeBufferIds(); } -void Client::bufferRenamed(BufferId bufferId, const QString &newName) { - QModelIndex bufferIndex = networkModel()->bufferIndex(bufferId); - if(bufferIndex.isValid()) { - networkModel()->setData(bufferIndex, newName, Qt::DisplayRole); - } + +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) { + bufferModel()->setCurrentIndex(current.sibling(0, 0)); + } + + // and remove it from the model + networkModel()->removeBuffer(bufferId); } -void Client::buffersPermanentlyMerged(BufferId bufferId1, BufferId bufferId2) { - QModelIndex idx = networkModel()->bufferIndex(bufferId1); - bufferModel()->setCurrentIndex(bufferModel()->mapFromSource(idx)); - networkModel()->removeBuffer(bufferId2); + +void Client::bufferRenamed(BufferId bufferId, const QString &newName) +{ + QModelIndex bufferIndex = networkModel()->bufferIndex(bufferId); + if (bufferIndex.isValid()) { + networkModel()->setData(bufferIndex, newName, Qt::DisplayRole); + } } -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; +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); - } + 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