+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();
+ }
+}
+
+
+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())
+ 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<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;
+ }
+}
+
+