X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fclient%2Fclient.cpp;h=912623949449be7c784ed6d688f012e1b92d9c0e;hp=7b94d933074faed1f6faf0ad7352394c464f16ac;hb=6eefdfc697067d184a589fc8a231b16316c09106;hpb=5b686746c880e5cda6d5de3e08180ea4332ff222 diff --git a/src/client/client.cpp b/src/client/client.cpp index 7b94d933..91262394 100644 --- a/src/client/client.cpp +++ b/src/client/client.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-2012 by the Quassel Project * + * Copyright (C) 2005-2018 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -34,9 +34,11 @@ #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" @@ -46,90 +48,43 @@ #include "networkmodel.h" #include "quassel.h" #include "signalproxy.h" +#include "transfermodel.h" #include "util.h" +#include "clientauthhandler.h" -#include -#include +#include +#include -QPointer Client::instanceptr = 0; -Quassel::Features Client::_coreFeatures = 0; - -/*** Initialization/destruction ***/ - -bool Client::instanceExists() -{ - 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::init(AbstractUi *ui) -{ - instance()->_mainUi = ui; - instance()->init(); -} - - -Client::Client(QObject *parent) - : QObject(parent), +Client::Client(std::unique_ptr ui, QObject *parent) + : QObject(parent), Singleton(this), _signalProxy(new SignalProxy(SignalProxy::Client, this)), - _mainUi(0), - _networkModel(0), - _bufferModel(0), - _bufferSyncer(0), - _aliasManager(0), + _mainUi(std::move(ui)), + _networkModel(new NetworkModel(this)), + _bufferModel(new BufferModel(_networkModel)), _backlogManager(new ClientBacklogManager(this)), - _bufferViewManager(0), _bufferViewOverlay(new BufferViewOverlay(this)), + _coreInfo(new CoreInfo(this)), _ircListHelper(new ClientIrcListHelper(this)), - _inputHandler(0), - _networkConfig(0), - _ignoreListManager(0), - _messageModel(0), - _messageProcessor(0), + _inputHandler(new ClientUserInputHandler(this)), + _transferModel(new TransferModel(this)), + _messageModel(_mainUi->createMessageModel(this)), + _messageProcessor(_mainUi->createMessageProcessor(this)), _coreAccountModel(new CoreAccountModel(this)), - _coreConnection(new CoreConnection(_coreAccountModel, this)), - _connected(false), - _debugLog(&_debugLogBuffer) -{ - _signalProxy->synchronize(_ircListHelper); -} - - -Client::~Client() + _coreConnection(new CoreConnection(this)) { - disconnectFromCore(); -} - +#ifdef EMBED_DATA + Q_INIT_RESOURCE(data); +#endif -void Client::init() -{ - _networkModel = new NetworkModel(this); + connect(mainUi(), &AbstractUi::disconnectFromCore, this, &Client::disconnectFromCore); + connect(this, &Client::connected, mainUi(), &AbstractUi::connectedToCore); + connect(this, &Client::disconnected, mainUi(), &AbstractUi::disconnectedFromCore); - connect(this, SIGNAL(networkRemoved(NetworkId)), - _networkModel, SLOT(networkRemoved(NetworkId))); + connect(this, &Client::networkRemoved, _networkModel, &NetworkModel::networkRemoved); + connect(this, &Client::networkRemoved, _messageProcessor, &AbstractMessageProcessor::networkRemoved); - _bufferModel = new BufferModel(_networkModel); - _messageModel = mainUi()->createMessageModel(this); - _messageProcessor = mainUi()->createMessageProcessor(this); - _inputHandler = new ClientUserInputHandler(this); + connect(backlogManager(), &ClientBacklogManager::messagesReceived, _messageModel, &MessageModel::messagesReceived); + connect(coreConnection(), &CoreConnection::stateChanged, this, &Client::connectionStateChanged); SignalProxy *p = signalProxy(); @@ -150,33 +105,36 @@ void Client::init() 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())); + 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())); - // attach backlog manager p->synchronize(backlogManager()); - connect(backlogManager(), SIGNAL(messagesReceived(BufferId, int)), _messageModel, SLOT(messagesReceived(BufferId, int))); + p->synchronize(coreInfo()); + p->synchronize(_ircListHelper); coreAccountModel()->load(); - - connect(coreConnection(), SIGNAL(stateChanged(CoreConnection::ConnectionState)), SLOT(connectionStateChanged(CoreConnection::ConnectionState))); coreConnection()->init(); } -/*** public static methods ***/ +Client::~Client() +{ + disconnectFromCore(); +} + AbstractUi *Client::mainUi() { - return instance()->_mainUi; + return instance()->_mainUi.get(); } -void Client::setCoreFeatures(Quassel::Features features) +bool Client::isCoreFeatureEnabled(Quassel::Feature feature) { - _coreFeatures = features; + return coreConnection()->peer() ? coreConnection()->peer()->hasFeature(feature) : false; } @@ -192,6 +150,22 @@ bool Client::internalCore() } +void Client::onDbUpgradeInProgress(bool inProgress) +{ + emit dbUpgradeInProgress(inProgress); +} + + +void Client::onExitRequested(int exitCode, const QString &reason) +{ + if (!reason.isEmpty()) { + qCritical() << reason; + emit exitRequested(reason); + } + QCoreApplication::exit(exitCode); +} + + /*** Network handling ***/ QList Client::networkIds() @@ -203,7 +177,7 @@ QList Client::networkIds() const Network *Client::network(NetworkId networkid) { if (instance()->_networks.contains(networkid)) return instance()->_networks[networkid]; - else return 0; + else return nullptr; } @@ -235,7 +209,7 @@ void Client::addNetwork(Network *net) net->setProxy(signalProxy()); signalProxy()->synchronize(net); networkModel()->attachNetwork(net); - connect(net, SIGNAL(destroyed()), instance(), SLOT(networkDestroyed())); + connect(net, &QObject::destroyed, instance(), &Client::networkDestroyed); instance()->_networks[net->networkId()] = net; emit instance()->networkCreated(net->networkId()); } @@ -247,7 +221,7 @@ void Client::coreNetworkCreated(NetworkId id) qWarning() << "Creation of already existing network requested!"; return; } - Network *net = new Network(id, this); + auto *net = new Network(id, this); addNetwork(net); } @@ -273,7 +247,7 @@ QList Client::identityIds() const Identity *Client::identity(IdentityId id) { if (instance()->_identities.contains(id)) return instance()->_identities[id]; - else return 0; + else return nullptr; } @@ -308,7 +282,7 @@ void Client::removeIdentity(IdentityId id) void Client::coreIdentityCreated(const Identity &other) { if (!_identities.contains(other.id())) { - Identity *identity = new Identity(other, this); + auto *identity = new Identity(other, this); _identities[other.id()] = identity; identity->setInitialized(); signalProxy()->synchronize(identity); @@ -373,63 +347,118 @@ 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()->synchronize(bufferSyncer()); + connect(bufferSyncer(), &BufferSyncer::lastSeenMsgSet, _networkModel, &NetworkModel::setLastSeenMsgId); + connect(bufferSyncer(), &BufferSyncer::markerLineSet, _networkModel, &NetworkModel::setMarkerLineMsgId); + connect(bufferSyncer(), &BufferSyncer::bufferRemoved, this, &Client::bufferRemoved); + connect(bufferSyncer(), &BufferSyncer::bufferRenamed, this, &Client::bufferRenamed); + connect(bufferSyncer(), &BufferSyncer::buffersPermanentlyMerged, this, &Client::buffersPermanentlyMerged); + connect(bufferSyncer(), &BufferSyncer::buffersPermanentlyMerged, _messageModel, &MessageModel::buffersPermanentlyMerged); + connect(bufferSyncer(), &BufferSyncer::bufferMarkedAsRead, this, &Client::bufferMarkedAsRead); + connect(bufferSyncer(), &BufferSyncer::bufferActivityChanged, _networkModel, &NetworkModel::bufferActivityChanged); + connect(bufferSyncer(), &BufferSyncer::highlightCountChanged, _networkModel, &NetworkModel::highlightCountChanged); + connect(networkModel(), &NetworkModel::requestSetLastSeenMsg, bufferSyncer(), &BufferSyncer::requestSetLastSeenMsg); + + SignalProxy *p = signalProxy(); + p->synchronize(bufferSyncer()); // create a new BufferViewManager Q_ASSERT(!_bufferViewManager); - _bufferViewManager = new ClientBufferViewManager(signalProxy(), this); - connect(_bufferViewManager, SIGNAL(initDone()), _bufferViewOverlay, SLOT(restore())); + _bufferViewManager = new ClientBufferViewManager(p, this); + connect(_bufferViewManager, &SyncableObject::initDone, _bufferViewOverlay, &BufferViewOverlay::restore); // create AliasManager Q_ASSERT(!_aliasManager); _aliasManager = new ClientAliasManager(this); - connect(aliasManager(), SIGNAL(initDone()), SLOT(sendBufferedUserInput())); - signalProxy()->synchronize(aliasManager()); + connect(aliasManager(), &SyncableObject::initDone, this, &Client::sendBufferedUserInput); + p->synchronize(aliasManager()); // create NetworkConfig Q_ASSERT(!_networkConfig); _networkConfig = new NetworkConfig("GlobalNetworkConfig", this); - signalProxy()->synchronize(networkConfig()); + p->synchronize(networkConfig()); // create IgnoreListManager Q_ASSERT(!_ignoreListManager); _ignoreListManager = new ClientIgnoreListManager(this); - signalProxy()->synchronize(ignoreListManager()); + p->synchronize(ignoreListManager()); + + // create Core-Side HighlightRuleManager + Q_ASSERT(!_highlightRuleManager); + _highlightRuleManager = new HighlightRuleManager(this); + p->synchronize(highlightRuleManager()); + // Listen to network removed events + connect(this, &Client::networkRemoved, + _highlightRuleManager, &HighlightRuleManager::networkRemoved); + +/* 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(requestInitialBacklog())); + connect(bufferViewOverlay(), &BufferViewOverlay::initDone, this, &Client::finishConnectionInitialization); _connected = true; emit connected(); emit coreConnectionStateChanged(true); } - -void Client::requestInitialBacklog() +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(requestInitialBacklog())); - connect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog())); + disconnect(bufferViewOverlay(), &BufferViewOverlay::initDone, this, &Client::finishConnectionInitialization); + connect(bufferSyncer(), &SyncableObject::initDone, this, &Client::finishConnectionInitialization); return; } - disconnect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog())); - disconnect(bufferSyncer(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog())); + disconnect(bufferViewOverlay(), &BufferViewOverlay::initDone, this, &Client::finishConnectionInitialization); + disconnect(bufferSyncer(), &SyncableObject::initDone, this, &Client::finishConnectionInitialization); + + requestInitialBacklog(); + if (isCoreFeatureEnabled(Quassel::Feature::BufferActivitySync)) { + bufferSyncer()->markActivitiesChanged(); + bufferSyncer()->markHighlightCountsChanged(); + } +} + +void Client::requestInitialBacklog() +{ _backlogManager->requestInitialBacklog(); } +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::disconnectFromCore() { if (!coreConnection()->isConnected()) @@ -442,7 +471,6 @@ void Client::disconnectFromCore() void Client::setDisconnectedFromCore() { _connected = false; - _coreFeatures = 0; emit disconnected(); emit coreConnectionStateChanged(false); @@ -454,25 +482,44 @@ void Client::setDisconnectedFromCore() if (_bufferSyncer) { _bufferSyncer->deleteLater(); - _bufferSyncer = 0; + _bufferSyncer = nullptr; } + _coreInfo->reset(); + if (_bufferViewManager) { _bufferViewManager->deleteLater(); - _bufferViewManager = 0; + _bufferViewManager = nullptr; } _bufferViewOverlay->reset(); if (_aliasManager) { _aliasManager->deleteLater(); - _aliasManager = 0; + _aliasManager = nullptr; } if (_ignoreListManager) { _ignoreListManager->deleteLater(); - _ignoreListManager = 0; + _ignoreListManager = nullptr; + } + + 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(); @@ -483,7 +530,7 @@ void Client::setDisconnectedFromCore() while (netIter != _networks.end()) { Network *net = netIter.value(); emit networkRemoved(net->networkId()); - disconnect(net, SIGNAL(destroyed()), this, 0); + disconnect(net, &Network::destroyed, this, nullptr); netIter = _networks.erase(netIter); net->deleteLater(); } @@ -500,7 +547,7 @@ void Client::setDisconnectedFromCore() if (_networkConfig) { _networkConfig->deleteLater(); - _networkConfig = 0; + _networkConfig = nullptr; } } @@ -509,7 +556,7 @@ void Client::setDisconnectedFromCore() void Client::networkDestroyed() { - Network *net = static_cast(sender()); + auto *net = static_cast(sender()); QHash::iterator netIter = _networks.begin(); while (netIter != _networks.end()) { if (*netIter == net) { @@ -517,7 +564,7 @@ void Client::networkDestroyed() break; } else { - netIter++; + ++netIter; } } } @@ -555,7 +602,7 @@ MsgId Client::markerLine(BufferId id) { if (id.isValid() && networkModel()) return networkModel()->markerLineMsgId(id); - return MsgId(); + return {}; } @@ -634,22 +681,29 @@ void Client::markBufferAsRead(BufferId id) } -void Client::logMessage(QtMsgType type, const char *msg) +void Client::refreshLegacyCoreInfo() { - fprintf(stderr, "%s\n", msg); - fflush(stderr); - if (type == QtFatalMsg) { - Quassel::logFatalMessage(msg); - } - else { - QString msgString = QString("%1\n").arg(msg); + instance()->requestLegacyCoreInfo(); +} - //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); - } +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::kickClient(int peerId) +{ + emit instance()->requestKickClient(peerId); +} + + +void Client::corePasswordChanged(PeerPtr, bool success) +{ + if (success) + coreAccountModel()->save(); + emit passwordChanged(success); }