X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fclient%2Fclient.cpp;h=b1e2f119e12c02ee2dcdd94efd2221d61098ebc9;hp=7f464c409f8f4f031794e9adf405aef7305293b2;hb=1a45f16a9734820fba42fe1db3f38dd1eee49df6;hpb=a18660ee87e81b6f4072537be3aa10c93a243b2a diff --git a/src/client/client.cpp b/src/client/client.cpp index 7f464c40..b1e2f119 100644 --- a/src/client/client.cpp +++ b/src/client/client.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-07 by the Quassel IRC Team * + * Copyright (C) 2005-2018 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -15,535 +15,701 @@ * 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 "global.h" +#include "buffermodel.h" +#include "buffersettings.h" +#include "buffersyncer.h" +#include "bufferviewconfig.h" +#include "bufferviewoverlay.h" +#include "clientaliasmanager.h" +#include "clientbacklogmanager.h" +#include "clientbufferviewmanager.h" +#include "clientirclisthelper.h" +#include "clientidentity.h" +#include "clientignorelistmanager.h" +#include "clienttransfermanager.h" +#include "clientuserinputhandler.h" +#include "coreaccountmodel.h" +#include "coreconnection.h" +#include "dccconfig.h" #include "ircchannel.h" #include "ircuser.h" #include "message.h" -#include "networkinfo.h" +#include "messagemodel.h" +#include "network.h" +#include "networkconfig.h" #include "networkmodel.h" -#include "quasselui.h" +#include "quassel.h" #include "signalproxy.h" +#include "transfermodel.h" #include "util.h" +#include "clientauthhandler.h" -QPointer Client::instanceptr = 0; +#include +#include -// ============================== -// public Static Methods -// ============================== -Client *Client::instance() { - if(!instanceptr) - instanceptr = new Client(); - return instanceptr; +Client::Client(std::unique_ptr ui, QObject *parent) + : QObject(parent), Singleton(this), + _signalProxy(new SignalProxy(SignalProxy::Client, this)), + _mainUi(std::move(ui)), + _networkModel(new NetworkModel(this)), + _bufferModel(new BufferModel(_networkModel)), + _bufferSyncer(0), + _aliasManager(0), + _backlogManager(new ClientBacklogManager(this)), + _bufferViewManager(0), + _bufferViewOverlay(new BufferViewOverlay(this)), + _coreInfo(new CoreInfo(this)), + _dccConfig(0), + _ircListHelper(new ClientIrcListHelper(this)), + _inputHandler(new ClientUserInputHandler(this)), + _networkConfig(0), + _ignoreListManager(0), + _highlightRuleManager(0), + _transferManager(0), + _transferModel(new TransferModel(this)), + _messageModel(_mainUi->createMessageModel(this)), + _messageProcessor(_mainUi->createMessageProcessor(this)), + _coreAccountModel(new CoreAccountModel(this)), + _coreConnection(new CoreConnection(this)), + _connected(false) +{ + //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(this, SIGNAL(networkRemoved(NetworkId)), _networkModel, SLOT(networkRemoved(NetworkId))); + connect(this, SIGNAL(networkRemoved(NetworkId)), _messageProcessor, SLOT(networkRemoved(NetworkId))); + + connect(backlogManager(), SIGNAL(messagesReceived(BufferId, int)), _messageModel, SLOT(messagesReceived(BufferId, int))); + connect(coreConnection(), SIGNAL(stateChanged(CoreConnection::ConnectionState)), SLOT(connectionStateChanged(CoreConnection::ConnectionState))); + + 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(bufferInfoUpdated(BufferInfo)), _networkModel, SLOT(bufferUpdated(BufferInfo))); + p->attachSignal(inputHandler(), SIGNAL(sendInput(BufferInfo, QString))); + p->attachSignal(this, SIGNAL(requestNetworkStates())); + + p->attachSignal(this, SIGNAL(requestCreateIdentity(const Identity &, 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(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(requestPasswordChange(PeerPtr,QString,QString,QString)), SIGNAL(changePassword(PeerPtr,QString,QString,QString))); + p->attachSlot(SIGNAL(passwordChanged(PeerPtr,bool)), this, SLOT(corePasswordChanged(PeerPtr,bool))); + + p->attachSignal(this, SIGNAL(requestKickClient(int)), SIGNAL(kickClient(int))); + p->attachSlot(SIGNAL(disconnectFromCore()), this, SLOT(disconnectFromCore())); + + p->synchronize(backlogManager()); + p->synchronize(coreInfo()); + p->synchronize(_ircListHelper); + + coreAccountModel()->load(); + coreConnection()->init(); } -void Client::destroy() { - delete instanceptr; + +Client::~Client() +{ + disconnectFromCore(); } -void Client::init(AbstractUi *ui) { - instance()->mainUi = ui; - instance()->init(); + +AbstractUi *Client::mainUi() +{ + return instance()->_mainUi.get(); } -QList Client::networkInfos() { - return instance()->_networkInfo.values(); + +bool Client::isCoreFeatureEnabled(Quassel::Feature feature) +{ + return coreConnection()->peer() ? coreConnection()->peer()->hasFeature(feature) : false; } -NetworkInfo *Client::networkInfo(uint networkid) { - if(instance()->_networkInfo.contains(networkid)) - return instance()->_networkInfo[networkid]; - else - return 0; + +bool Client::isConnected() +{ + return instance()->_connected; } -QList Client::allBufferInfos() { - QList bufferids; - foreach(Buffer *buffer, buffers()) { - bufferids << buffer->bufferInfo(); - } - return bufferids; + +bool Client::internalCore() +{ + return currentCoreAccount().isInternal(); } -QList Client::buffers() { - return instance()->_buffers.values(); + +void Client::onDbUpgradeInProgress(bool inProgress) +{ + emit dbUpgradeInProgress(inProgress); } -Buffer *Client::buffer(uint bufferUid) { - if(instance()->_buffers.contains(bufferUid)) - return instance()->_buffers[bufferUid]; - else - return 0; + +void Client::onExitRequested(int exitCode, const QString &reason) +{ + if (!reason.isEmpty()) { + qCritical() << reason; + emit exitRequested(reason); + } + QCoreApplication::exit(exitCode); } -Buffer *Client::buffer(BufferInfo id) { - Buffer *buff = buffer(id.uid()); - if(!buff) { - Client *client = Client::instance(); - buff = new Buffer(id, client); +/*** Network handling ***/ - connect(buff, SIGNAL(userInput(BufferInfo, QString)), - client, SLOT(userInput(BufferInfo, QString))); - connect(buff, SIGNAL(bufferUpdated(Buffer *)), - client, SIGNAL(bufferUpdated(Buffer *))); - connect(buff, SIGNAL(destroyed()), - client, SLOT(bufferDestroyed())); - client->_buffers[id.uid()] = buff; - emit client->bufferUpdated(buff); - } - Q_ASSERT(buff); - return buff; +QList Client::networkIds() +{ + return instance()->_networks.keys(); } -// FIXME switch to netids! -// WHEN IS THIS NEEDED ANYHOW!? -// ...only for finding the Buffer for a channel, I guess... -BufferInfo Client::bufferInfo(QString net, QString buf) { - foreach(Buffer *buffer_, buffers()) { - BufferInfo bufferInfo = buffer_->bufferInfo(); - if(!bufferInfo.network().compare(net, Qt::CaseInsensitive) && !bufferInfo.buffer().compare(buf, Qt::CaseInsensitive)) - return bufferInfo; - } - Q_ASSERT(false); // should never happen! - return BufferInfo(); + +const Network *Client::network(NetworkId networkid) +{ + if (instance()->_networks.contains(networkid)) return instance()->_networks[networkid]; + else return 0; } -BufferInfo Client::statusBufferInfo(QString net) { - return bufferInfo(net, ""); + +void Client::createNetwork(const NetworkInfo &info, const QStringList &persistentChannels) +{ + emit instance()->requestCreateNetwork(info, persistentChannels); } -NetworkModel *Client::networkModel() { - return instance()->_networkModel; + +void Client::removeNetwork(NetworkId id) +{ + emit instance()->requestRemoveNetwork(id); } -SignalProxy *Client::signalProxy() { - return instance()->_signalProxy; + +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()); } -// ============================== -// Constructor / Decon -// ============================== -Client::Client(QObject *parent) - : QObject(parent), - socket(0), - _signalProxy(new SignalProxy(SignalProxy::Client, this)), - mainUi(0), - _networkModel(0), - connectedToCore(false) -{ -} - -Client::~Client() { - -} - -void Client::init() { - blockSize = 0; - - _networkModel = new NetworkModel(this); - - connect(this, SIGNAL(bufferSelected(Buffer *)), - _networkModel, SLOT(selectBuffer(Buffer *))); - connect(this, SIGNAL(bufferUpdated(Buffer *)), - _networkModel, SLOT(bufferUpdated(Buffer *))); - connect(this, SIGNAL(bufferActivity(Buffer::ActivityLevel, Buffer *)), - _networkModel, SLOT(bufferActivity(Buffer::ActivityLevel, Buffer *))); - - SignalProxy *p = signalProxy(); - p->attachSignal(this, SIGNAL(sendSessionData(const QString &, const QVariant &)), - SIGNAL(clientSessionDataChanged(const QString &, const QVariant &))); - p->attachSlot(SIGNAL(coreSessionDataChanged(const QString &, const QVariant &)), - this, SLOT(recvSessionData(const QString &, const QVariant &))); - p->attachSlot(SIGNAL(coreState(const QVariant &)), - this, SLOT(recvCoreState(const QVariant &))); - p->attachSlot(SIGNAL(networkConnected(uint)), - this, SLOT(networkConnected(uint))); - p->attachSlot(SIGNAL(networkDisconnected(uint)), - this, SLOT(networkDisconnected(uint))); - p->attachSlot(SIGNAL(displayMsg(const Message &)), - this, SLOT(recvMessage(const Message &))); - p->attachSlot(SIGNAL(displayStatusMsg(QString, QString)), - this, SLOT(recvStatusMsg(QString, QString))); - - - p->attachSlot(SIGNAL(backlogData(BufferInfo, const QVariantList &, bool)), this, SLOT(recvBacklogData(BufferInfo, const QVariantList &, bool))); - p->attachSlot(SIGNAL(bufferInfoUpdated(BufferInfo)), this, SLOT(updateBufferInfo(BufferInfo))); - p->attachSignal(this, SIGNAL(sendInput(BufferInfo, QString))); - p->attachSignal(this, SIGNAL(requestNetworkStates())); - - 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())); - - layoutTimer = new QTimer(this); - layoutTimer->setInterval(0); - layoutTimer->setSingleShot(false); - connect(layoutTimer, SIGNAL(timeout()), this, SLOT(layoutMsg())); - -} - -bool Client::isConnected() { - return instance()->connectedToCore; -} - -void Client::fakeInput(uint bufferUid, QString message) { - Buffer *buff = buffer(bufferUid); - if(!buff) - qWarning() << "No Buffer with uid" << bufferUid << "can't send Input" << message; - else - emit instance()->sendInput(buff->bufferInfo(), message); -} - -void Client::fakeInput(BufferInfo bufferInfo, QString message) { - fakeInput(bufferInfo, message); -} - -void Client::connectToCore(const QVariantMap &conn) { - // TODO implement SSL - coreConnectionInfo = conn; - if(isConnected()) { - emit coreConnectionError(tr("Already connected to Core!")); - return; - } - - if(socket != 0) - socket->deleteLater(); - - if(conn["Host"].toString().isEmpty()) { - clientMode = LocalCore; - socket = new QBuffer(this); - connect(socket, SIGNAL(readyRead()), this, SLOT(coreHasData())); - socket->open(QIODevice::ReadWrite); - //QVariant state = connectToLocalCore(coreConnectionInfo["User"].toString(), coreConnectionInfo["Password"].toString()); - //syncToCore(state); - coreSocketConnected(); - } else { - clientMode = RemoteCore; - emit coreConnectionMsg(tr("Connecting...")); - Q_ASSERT(!socket); - QTcpSocket *sock = new QTcpSocket(this); - socket = sock; - connect(sock, SIGNAL(readyRead()), this, SLOT(coreHasData())); - connect(sock, SIGNAL(connected()), this, SLOT(coreSocketConnected())); - connect(signalProxy(), SIGNAL(disconnected()), this, SLOT(coreSocketDisconnected())); - connect(sock, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(coreSocketError(QAbstractSocket::SocketError))); - sock->connectToHost(conn["Host"].toString(), conn["Port"].toUInt()); - } -} - -void Client::disconnectFromCore() { - socket->close(); -} - -void Client::setCoreConfiguration(const QVariantMap &settings) { - SignalProxy::writeDataToDevice(socket, settings); -} - -void Client::coreSocketConnected() { - connect(this, SIGNAL(recvPartialItem(uint, uint)), this, SIGNAL(coreConnectionProgress(uint, uint))); - emit coreConnectionMsg(tr("Synchronizing to core...")); - QVariantMap clientInit; - clientInit["GuiProtocol"] = GUI_PROTOCOL; - clientInit["User"] = coreConnectionInfo["User"].toString(); - clientInit["Password"] = coreConnectionInfo["Password"].toString(); - SignalProxy::writeDataToDevice(socket, clientInit); -} - -void Client::coreSocketDisconnected() { - instance()->connectedToCore = false; - emit disconnected(); - socket->deleteLater(); - blockSize = 0; - - /* Clear internal data. Hopefully nothing relies on it at this point. */ - _networkModel->clear(); - - QHash::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()); - - - QHash::iterator netIter = _networkInfo.begin(); - while(netIter != _networkInfo.end()) { - NetworkInfo *net = netIter.value(); - disconnect(net, SIGNAL(destroyed()), this, 0); - netIter = _networkInfo.erase(netIter); - net->deleteLater(); - } - Q_ASSERT(_networkInfo.isEmpty()); - coreConnectionInfo.clear(); - sessionData.clear(); - layoutQueue.clear(); - layoutTimer->stop(); +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::recvCoreState(const QVariant &state) { - disconnect(this, SIGNAL(recvPartialItem(uint, uint)), this, SIGNAL(coreConnectionProgress(uint, uint))); - disconnect(socket, 0, this, 0); // rest of communication happens through SignalProxy - signalProxy()->addPeer(socket); - syncToCore(state); + +void Client::coreNetworkRemoved(NetworkId id) +{ + if (!_networks.contains(id)) + return; + Network *net = _networks.take(id); + emit networkRemoved(net->networkId()); + net->deleteLater(); } -// TODO: auth errors -void Client::syncToCore(const QVariant &coreState) { - if(!coreState.toMap().contains("SessionState")) { - emit coreConnectionError(tr("Invalid data received from core!")); - disconnectFromCore(); - return; - } - QVariantMap sessionState = coreState.toMap()["SessionState"].toMap(); +/*** Identity handling ***/ - // store sessionData - QVariantMap sessData = sessionState["SessionData"].toMap(); - foreach(QString key, sessData.keys()) - recvSessionData(key, sessData[key]); +QList Client::identityIds() +{ + return instance()->_identities.keys(); +} - // store Buffer details - QVariantList coreBuffers = sessionState["Buffers"].toList(); - /* make lookups by id faster */ - foreach(QVariant vid, coreBuffers) { - buffer(vid.value()); // create all buffers, so we see them in the network views - } - // create networkInfo objects - QVariantList networkids = sessionState["Networks"].toList(); - foreach(QVariant networkid, networkids) { - networkConnected(networkid.toUInt()); - } +const Identity *Client::identity(IdentityId id) +{ + if (instance()->_identities.contains(id)) return instance()->_identities[id]; + else return 0; +} - instance()->connectedToCore = true; - updateCoreConnectionProgress(); +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::updateCoreConnectionProgress() { - // we'll do this in three steps: - // 1.) networks - // 2.) channels - // 3.) ircusers - int numNets = networkInfos().count(); - int numNetsWaiting = 0; +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); +} - int numIrcUsers = 0; - int numIrcUsersWaiting = 0; - int numChannels = 0; - int numChannelsWaiting = 0; +void Client::removeIdentity(IdentityId id) +{ + emit instance()->requestRemoveIdentity(id); +} - foreach(NetworkInfo *net, networkInfos()) { - if(! net->initialized()) - numNetsWaiting++; - numIrcUsers += net->ircUsers().count(); - foreach(IrcUser *user, net->ircUsers()) { - if(! user->initialized()) - numIrcUsersWaiting++; +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!"); } +} + - numChannels += net->ircChannels().count(); - foreach(IrcChannel *channel, net->ircChannels()) { - if(! channel->initialized()) - numChannelsWaiting++; +void Client::coreIdentityRemoved(IdentityId id) +{ + if (_identities.contains(id)) { + emit identityRemoved(id); + Identity *i = _identities.take(id); + i->deleteLater(); } - } +} - if(numNetsWaiting > 0) { - emit coreConnectionMsg(tr("Requesting network states...")); - emit coreConnectionProgress(numNets - numNetsWaiting, numNets); - return; - } - if(numIrcUsersWaiting > 0) { - emit coreConnectionMsg(tr("Requesting User states...")); - emit coreConnectionProgress(numIrcUsers - numIrcUsersWaiting, numIrcUsers); - return; - } +/*** User input handling ***/ - if(numChannelsWaiting > 0) { - emit coreConnectionMsg(tr("Requesting Channel states...")); - emit coreConnectionProgress(numChannels - numChannelsWaiting, numChannels); - return; - } +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)); +} - emit coreConnectionProgress(1,1); - emit connected(); - foreach(NetworkInfo *net, networkInfos()) { - disconnect(net, 0, this, SLOT(updateCoreConnectionProgress())); - } - // signalProxy()->dumpProxyStats(); +void Client::sendBufferedUserInput() +{ + for (int i = 0; i < _userInputBuffer.count(); i++) + userInput(_userInputBuffer.at(i).first, _userInputBuffer.at(i).second); + + _userInputBuffer.clear(); } -void Client::recvSessionData(const QString &key, const QVariant &data) { - sessionData[key] = data; - emit sessionDataChanged(key, data); - emit sessionDataChanged(key); + +/*** 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::storeSessionData(const QString &key, const QVariant &data) { - // Not sure if this is a good idea, but we'll try it anyway: - // Calling this function only sends a signal to core. Data is stored upon reception of the update signal, - // rather than immediately. - emit instance()->sendSessionData(key, data); + +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(bufferSyncer(), SIGNAL(bufferActivityChanged(BufferId, const Message::Types)), _networkModel, SLOT(bufferActivityChanged(BufferId, const Message::Types))); + connect(bufferSyncer(), SIGNAL(highlightCountChanged(BufferId, int)), _networkModel, SLOT(highlightCountChanged(BufferId, int))); + connect(networkModel(), SIGNAL(requestSetLastSeenMsg(BufferId, MsgId)), bufferSyncer(), SLOT(requestSetLastSeenMsg(BufferId, const MsgId &))); + + SignalProxy *p = signalProxy(); + 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()); + + // create Core-Side HighlightRuleManager + Q_ASSERT(!_highlightRuleManager); + _highlightRuleManager = new HighlightRuleManager(this); + p->synchronize(highlightRuleManager()); + // Listen to network removed events + connect(this, SIGNAL(networkRemoved(NetworkId)), + _highlightRuleManager, SLOT(networkRemoved(NetworkId))); + +/* not ready yet + // create TransferManager and DccConfig if core supports them + Q_ASSERT(!_dccConfig); + Q_ASSERT(!_transferManager); + if (isCoreFeatureEnabled(Quassel::Feature::DccFileTransfer)) { + _dccConfig = new DccConfig(this); + p->synchronize(dccConfig()); + _transferManager = new ClientTransferManager(this); + _transferModel->setManager(_transferManager); + p->synchronize(transferManager()); + } +*/ + + // trigger backlog request once all active bufferviews are initialized + connect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization())); + + _connected = true; + emit connected(); + emit coreConnectionStateChanged(true); } -QVariant Client::retrieveSessionData(const QString &key, const QVariant &def) { - if(instance()->sessionData.contains(key)) return instance()->sessionData[key]; - else return def; +void Client::finishConnectionInitialization() +{ + // 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(finishConnectionInitialization())); + connect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization())); + return; + } + disconnect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization())); + disconnect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(finishConnectionInitialization())); + + requestInitialBacklog(); + if (isCoreFeatureEnabled(Quassel::Feature::BufferActivitySync)) { + bufferSyncer()->markActivitiesChanged(); + bufferSyncer()->markHighlightCountsChanged(); + } } -QStringList Client::sessionDataKeys() { - return instance()->sessionData.keys(); + +void Client::requestInitialBacklog() +{ + _backlogManager->requestInitialBacklog(); } -void Client::coreSocketError(QAbstractSocket::SocketError) { - emit coreConnectionError(socket->errorString()); - socket->deleteLater(); + +void Client::requestLegacyCoreInfo() +{ + // On older cores, the CoreInfo object was only synchronized on demand. Synchronize now if + // needed. + if (isConnected() && !isCoreFeatureEnabled(Quassel::Feature::SyncedCoreInfo)) { + // Delete the existing core info object (it will always exist as client is single-threaded) + _coreInfo->deleteLater(); + // No need to set to null when creating new one immediately after + + // Create a fresh, unsynchronized CoreInfo object, emulating legacy behavior of CoreInfo not + // persisting + _coreInfo = new CoreInfo(this); + // Synchronize the new object + signalProxy()->synchronize(_coreInfo); + + // Let others know signal handlers have been reset + emit coreInfoResynchronized(); + } } -void Client::coreHasData() { - QVariant item; - if(SignalProxy::readDataFromDevice(socket, blockSize, item)) { - emit recvPartialItem(1,1); - QVariantMap msg = item.toMap(); - if (!msg["StartWizard"].toBool()) { - recvCoreState(msg["Reply"]); - } else { - qWarning("Core not configured!"); - qDebug() << "Available storage providers: " << msg["StorageProviders"].toStringList(); - emit showConfigWizard(msg); + +void Client::disconnectFromCore() +{ + if (!coreConnection()->isConnected()) + return; + + coreConnection()->disconnectFromCore(); +} + + +void Client::setDisconnectedFromCore() +{ + _connected = false; + + 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; + } + + _coreInfo->reset(); + + if (_bufferViewManager) { + _bufferViewManager->deleteLater(); + _bufferViewManager = 0; + } + + _bufferViewOverlay->reset(); + + if (_aliasManager) { + _aliasManager->deleteLater(); + _aliasManager = 0; + } + + if (_ignoreListManager) { + _ignoreListManager->deleteLater(); + _ignoreListManager = 0; + } + + if (_highlightRuleManager) { + _highlightRuleManager->deleteLater(); + _highlightRuleManager = nullptr; + } + + if (_transferManager) { + _transferModel->setManager(nullptr); + _transferManager->deleteLater(); + _transferManager = nullptr; + } + + if (_dccConfig) { + _dccConfig->deleteLater(); + _dccConfig = nullptr; + } + + // 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; } - blockSize = 0; - return; - } - if(blockSize > 0) { - emit recvPartialItem(socket->bytesAvailable(), blockSize); - } } -void Client::networkConnected(uint netid) { - // TODO: create statusBuffer / switch to networkids - //BufferInfo id = statusBufferInfo(net); - //Buffer *b = buffer(id); - //b->setActive(true); - - NetworkInfo *netinfo = new NetworkInfo(netid, this); - netinfo->setProxy(signalProxy()); - networkModel()->attachNetworkInfo(netinfo); - - if(!isConnected()) { - connect(netinfo, SIGNAL(initDone()), this, SLOT(updateCoreConnectionProgress())); - connect(netinfo, SIGNAL(ircUserInitDone()), this, SLOT(updateCoreConnectionProgress())); - connect(netinfo, SIGNAL(ircChannelInitDone()), this, SLOT(updateCoreConnectionProgress())); - } - connect(netinfo, SIGNAL(ircChannelAdded(QString)), this, SLOT(ircChannelAdded(QString))); - connect(netinfo, SIGNAL(destroyed()), this, SLOT(networkInfoDestroyed())); - _networkInfo[netid] = netinfo; + +/*** ***/ + +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::networkDisconnected(uint networkid) { - foreach(Buffer *buffer, buffers()) { - if(buffer->bufferInfo().networkId() != networkid) - continue; - //buffer->displayMsg(Message(bufferid, Message::Server, tr("Server disconnected."))); FIXME - buffer->setActive(false); - } +// Hmm... we never used this... +void Client::recvStatusMsg(QString /*net*/, QString /*msg*/) +{ + //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg))); +} + - Q_ASSERT(networkInfo(networkid)); - if(!networkInfo(networkid)->initialized()) { - qDebug() << "Network" << networkid << "disconnected while not yet initialized!"; - updateCoreConnectionProgress(); - } +void Client::recvMessage(const Message &msg) +{ + Message msg_ = msg; + messageProcessor()->process(msg_); } -void Client::ircChannelAdded(QString chanName) { - NetworkInfo *netInfo = qobject_cast(sender()); - Q_ASSERT(netInfo); - Buffer *buf = buffer(bufferInfo(netInfo->networkName(), chanName)); - Q_ASSERT(buf); - buf->setIrcChannel(netInfo->ircChannel(chanName)); +void Client::setBufferLastSeenMsg(BufferId id, const MsgId &msgId) +{ + if (bufferSyncer()) + bufferSyncer()->requestSetLastSeenMsg(id, msgId); } -void Client::updateBufferInfo(BufferInfo id) { - buffer(id)->updateBufferInfo(id); + +void Client::setMarkerLine(BufferId id, const MsgId &msgId) +{ + if (bufferSyncer()) + bufferSyncer()->requestSetMarkerLine(id, msgId); } -void Client::bufferDestroyed() { - Buffer *buffer = static_cast(sender()); - uint bufferUid = buffer->uid(); - if(_buffers.contains(bufferUid)) - _buffers.remove(bufferUid); + +MsgId Client::markerLine(BufferId id) +{ + if (id.isValid() && networkModel()) + return networkModel()->markerLineMsgId(id); + return MsgId(); } -void Client::networkInfoDestroyed() { - NetworkInfo *netinfo = static_cast(sender()); - uint networkId = netinfo->networkId(); - if(_networkInfo.contains(networkId)) - _networkInfo.remove(networkId); + +void Client::removeBuffer(BufferId id) +{ + if (!bufferSyncer()) return; + bufferSyncer()->requestRemoveBuffer(id); } -void Client::recvMessage(const Message &msg) { - Buffer *b = buffer(msg.buffer()); - Buffer::ActivityLevel level = Buffer::OtherActivity; - if(msg.type() == Message::Plain || msg.type() == Message::Notice){ - level |= Buffer::NewMessage; - } - if(msg.flags() & Message::Highlight){ - level |= Buffer::Highlight; - } - emit bufferActivity(level, b); +void Client::renameBuffer(BufferId bufferId, const QString &newName) +{ + if (!bufferSyncer()) + return; + bufferSyncer()->requestRenameBuffer(bufferId, newName); +} + - b->appendMsg(msg); +void Client::mergeBuffersPermanently(BufferId bufferId1, BufferId bufferId2) +{ + if (!bufferSyncer()) + return; + bufferSyncer()->requestMergeBuffersPermanently(bufferId1, bufferId2); } -void Client::recvStatusMsg(QString /*net*/, QString /*msg*/) { - //recvMessage(net, Message::server("", QString("[STATUS] %1").arg(msg))); + +void Client::purgeKnownBufferIds() +{ + if (!bufferSyncer()) + return; + bufferSyncer()->requestPurgeBufferIds(); } -void Client::recvBacklogData(BufferInfo id, QVariantList msgs, bool /*done*/) { - Buffer *b = buffer(id); - foreach(QVariant v, msgs) { - Message msg = v.value(); - b->prependMsg(msg); - if(!layoutQueue.contains(b)) layoutQueue.append(b); - } - if(layoutQueue.count() && !layoutTimer->isActive()) layoutTimer->start(); + +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::layoutMsg() { - if(layoutQueue.count()) { - Buffer *b = layoutQueue.takeFirst(); // TODO make this the current buffer - if(b->layoutMsg()) - layoutQueue.append(b); // Buffer has more messages in its queue --> Round Robin - } - - if(!layoutQueue.count()) - layoutTimer->stop(); + +void Client::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); } -AbstractUiMsg *Client::layoutMsg(const Message &msg) { - return instance()->mainUi->layoutMsg(msg); + +void Client::refreshLegacyCoreInfo() +{ + instance()->requestLegacyCoreInfo(); +} + + +void Client::changePassword(const QString &oldPassword, const QString &newPassword) { + CoreAccount account = currentCoreAccount(); + account.setPassword(newPassword); + coreAccountModel()->createOrUpdateAccount(account); + emit instance()->requestPasswordChange(nullptr, account.user(), oldPassword, newPassword); } -void Client::userInput(BufferInfo id, QString msg) { - emit sendInput(id, msg); + +void Client::kickClient(int peerId) +{ + emit instance()->requestKickClient(peerId); } + +void Client::corePasswordChanged(PeerPtr, bool success) +{ + if (success) + coreAccountModel()->save(); + emit passwordChanged(success); +}