+}
+
+
+void Client::init()
+{
+ _networkModel = new NetworkModel(this);
+
+ connect(this, SIGNAL(networkRemoved(NetworkId)),
+ _networkModel, SLOT(networkRemoved(NetworkId)));
+
+ _bufferModel = new BufferModel(_networkModel);
+ _messageModel = mainUi()->createMessageModel(this);
+ _messageProcessor = mainUi()->createMessageProcessor(this);
+ _inputHandler = new ClientUserInputHandler(this);
+
+ 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)));
+
+ //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)));
+
+ coreAccountModel()->load();
+
+ connect(coreConnection(), SIGNAL(stateChanged(CoreConnection::ConnectionState)), SLOT(connectionStateChanged(CoreConnection::ConnectionState)));
+ coreConnection()->init();
+}
+
+
+/*** public static methods ***/
+
+AbstractUi *Client::mainUi()
+{
+ return instance()->_mainUi;
+}
+
+
+void Client::setCoreFeatures(Quassel::Features features)
+{
+ _coreFeatures = features;
+}
+
+
+bool Client::isConnected()
+{
+ return instance()->_connected;
+}
+
+
+bool Client::internalCore()
+{
+ return currentCoreAccount().isInternal();
+}
+
+
+/*** Network handling ***/
+
+QList<NetworkId> Client::networkIds()
+{
+ return instance()->_networks.keys();
+}
+
+
+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::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::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::coreNetworkRemoved(NetworkId id)
+{
+ if (!_networks.contains(id))
+ return;
+ Network *net = _networks.take(id);
+ emit networkRemoved(net->networkId());
+ net->deleteLater();
+}
+
+
+/*** Identity handling ***/
+
+QList<IdentityId> Client::identityIds()
+{
+ return instance()->_identities.keys();
+}
+
+
+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;
+#ifdef HAVE_SSL
+ additional["KeyPem"] = id.sslKey().toPem();
+ additional["CertPem"] = id.sslCert().toPem();
+#endif
+ 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::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::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::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::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();
+ 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 TransferManager and DccConfig if core supports them
+ Q_ASSERT(!_dccConfig);
+ Q_ASSERT(!_transferManager);
+ if (coreFeatures() & Quassel::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()));
+
+ _connected = true;