+
+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());
+
+ // create a new BufferViewManager
+ Q_ASSERT(!_bufferViewManager);
+ _bufferViewManager = new ClientBufferViewManager(signalProxy(), this);
+ connect(_bufferViewManager, SIGNAL(initDone()), _bufferViewOverlay, SLOT(restore()));
+
+ // create AliasManager
+ Q_ASSERT(!_aliasManager);
+ _aliasManager = new ClientAliasManager(this);
+ connect(aliasManager(), SIGNAL(initDone()), SLOT(sendBufferedUserInput()));
+ signalProxy()->synchronize(aliasManager());
+
+ // create NetworkConfig
+ Q_ASSERT(!_networkConfig);
+ _networkConfig = new NetworkConfig("GlobalNetworkConfig", this);
+ signalProxy()->synchronize(networkConfig());
+
+ // create IgnoreListManager
+ Q_ASSERT(!_ignoreListManager);
+ _ignoreListManager = new ClientIgnoreListManager(this);
+ signalProxy()->synchronize(ignoreListManager());
+
+ Q_ASSERT(!_transferManager);
+ _transferManager = new ClientTransferManager(this);
+ signalProxy()->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);
+}
+
+
+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<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++;
+ }
+ }
+}
+
+
+// Hmm... we never used this...
+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::setBufferLastSeenMsg(BufferId id, const MsgId &msgId)
+{
+ if (bufferSyncer())
+ bufferSyncer()->requestSetLastSeenMsg(id, msgId);
+}
+
+
+void Client::setMarkerLine(BufferId id, const MsgId &msgId)
+{
+ if (bufferSyncer())
+ bufferSyncer()->requestSetMarkerLine(id, msgId);
+}
+
+
+MsgId Client::markerLine(BufferId id)
+{
+ if (id.isValid() && networkModel())
+ return networkModel()->markerLineMsgId(id);
+ return MsgId();
+}
+
+
+void Client::removeBuffer(BufferId id)
+{
+ if (!bufferSyncer()) return;
+ bufferSyncer()->requestRemoveBuffer(id);
+}
+
+
+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::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);
+ }
+}