X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fclient%2Fclient.cpp;h=94119f5ea7e3591ab2ce50657061a63af9036fa3;hp=9a74119dc90bc9025c9823f3776b8eb585872804;hb=38db2f48a30f697ef8c0b61dfa6345e8a53336fd;hpb=42ff71aaa8d3cee9e348a45758c56c380a4f1b45

diff --git a/src/client/client.cpp b/src/client/client.cpp
index 9a74119d..94119f5e 100644
--- a/src/client/client.cpp
+++ b/src/client/client.cpp
@@ -30,10 +30,12 @@ Client * Client::instanceptr = 0;
 
 bool Client::connectedToCore = false;
 Client::ClientMode Client::clientMode;
+VarMap Client::coreConnectionInfo;
 QHash<BufferId, Buffer *> Client::buffers;
 QHash<uint, BufferId> Client::bufferIds;
 QHash<QString, QHash<QString, VarMap> > Client::nicks;
 QHash<QString, bool> Client::netConnected;
+QStringList Client::netsAwaitingInit;
 QHash<QString, QString> Client::ownNick;
 
 Client *Client::instance() {
@@ -71,16 +73,15 @@ void Client::init() {
   blockSize = 0;
 
   connect(&socket, SIGNAL(readyRead()), this, SLOT(serverHasData()));
-  connect(&socket, SIGNAL(connected()), this, SLOT(coreConnected()));
-  connect(&socket, SIGNAL(disconnected()), this, SLOT(coreDisconnected()));
+  connect(&socket, SIGNAL(connected()), this, SLOT(coreSocketConnected()));
+  connect(&socket, SIGNAL(disconnected()), this, SLOT(coreSocketDisconnected()));
   connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(serverError(QAbstractSocket::SocketError)));
 
-  connect(Global::instance(), SIGNAL(dataPutLocally(UserId, QString)), this, SLOT(updateCoreData(UserId, QString)));
-  connect(clientProxy, SIGNAL(csUpdateGlobalData(QString, QVariant)), this, SLOT(updateLocalData(QString, QVariant)));
   connect(this, SIGNAL(sendSessionData(const QString &, const QVariant &)), clientProxy, SLOT(gsSessionDataChanged(const QString &, const QVariant &)));
   connect(clientProxy, SIGNAL(csSessionDataChanged(const QString &, const QVariant &)), this, SLOT(recvSessionData(const QString &, const QVariant &)));
 
   connect(clientProxy, SIGNAL(send(ClientSignal, QVariant, QVariant, QVariant)), this, SLOT(recvProxySignal(ClientSignal, QVariant, QVariant, QVariant)));
+  connect(clientProxy, SIGNAL(csCoreState(QVariant)), this, SLOT(recvCoreState(const QVariant &)));
   connect(clientProxy, SIGNAL(csServerState(QString, QVariant)), this, SLOT(recvNetworkState(QString, QVariant)));
   connect(clientProxy, SIGNAL(csServerConnected(QString)), this, SLOT(networkConnected(QString)));
   connect(clientProxy, SIGNAL(csServerDisconnected(QString)), this, SLOT(networkDisconnected(QString)));
@@ -126,15 +127,18 @@ bool Client::isConnected() { return connectedToCore; }
 
 void Client::connectToCore(const VarMap &conn) {
   // TODO implement SSL
+  coreConnectionInfo = conn;
   if(isConnected()) {
-    qDebug() << "Already connected to core!";
+    emit coreConnectionError(tr("Already connected to Core!"));
     return;
   }
   if(conn["Host"].toString().isEmpty()) {
     clientMode = LocalCore;
-    syncToCore();  // TODO send user and pw from conn info
+    QVariant state = connectToLocalCore(coreConnectionInfo["User"].toString(), coreConnectionInfo["Password"].toString());
+    syncToCore(state);
   } else {
     clientMode = RemoteCore;
+    emit coreConnectionMsg(tr("Connecting..."));
     socket.connectToHost(conn["Host"].toString(), conn["Port"].toUInt());
   }
 }
@@ -144,38 +148,46 @@ void Client::disconnectFromCore() {
     socket.close();
   } else {
     disconnectFromLocalCore();
-    coreDisconnected();
+    coreSocketDisconnected();
   }
-  // TODO clear internal data
-}
-
-void Client::coreConnected() {
-  syncToCore();
-
-}
-
-void Client::coreDisconnected() {
+  /* Clear internal data. Hopefully nothing relies on it at this point. */
+  coreConnectionInfo.clear();
+  sessionData.clear();
+  //foreach(Buffer *buf, buffers.values()) delete buf;
+  qDebug() << "barfoo";
+  _bufferModel->clear();
+  //qDeleteAll(buffers);
+  qDebug() << "foobar";
+}
+
+void Client::coreSocketConnected() {
+  connect(this, SIGNAL(recvPartialItem(quint32, quint32)), this, SIGNAL(coreConnectionProgress(uint, uint)));
+  emit coreConnectionMsg(tr("Synchronizing to core..."));
+  VarMap clientInit;
+  clientInit["GuiProtocol"] = GUI_PROTOCOL;
+  clientInit["User"] = coreConnectionInfo["User"].toString();
+  clientInit["Password"] = coreConnectionInfo["Password"].toString();
+  writeDataToDevice(&socket, clientInit);
+}
+
+void Client::coreSocketDisconnected() {
   connectedToCore = false;
   emit disconnected();
 }
 
-void Client::syncToCore() {
-  VarMap state;
-  if(clientMode == LocalCore) {
-    state = connectToLocalCore("Default", "password").toMap(); // TODO make this configurable
-  } else {
+void Client::recvCoreState(const QVariant &state) {
+  disconnect(this, SIGNAL(recvPartialItem(quint32, quint32)), this, SIGNAL(coreConnectionProgress(uint, uint)));
+  syncToCore(state);
 
-  }
+}
 
-  VarMap data = state["CoreData"].toMap();
-  foreach(QString key, data.keys()) {
-    Global::updateData(key, data[key]);
-  }
-  //if(!Global::data("CoreReady").toBool()) {
-  //  qFatal("Something is wrong, getting invalid data from core!");
-  //}
+void Client::syncToCore(const QVariant &coreState) {
+  VarMap sessionState = coreState.toMap()["SessionState"].toMap();
+  VarMap sessData = sessionState["SessionData"].toMap();
 
-  VarMap sessionState = state["SessionState"].toMap();
+  foreach(QString key, sessData.keys()) {
+    recvSessionData(key, sessData[key]);
+  }
   QList<QVariant> coreBuffers = sessionState["Buffers"].toList();
   /* make lookups by id faster */
   foreach(QVariant vid, coreBuffers) {
@@ -183,26 +195,23 @@ void Client::syncToCore() {
     bufferIds[id.uid()] = id;  // make lookups by id faster
     buffer(id);                // create all buffers, so we see them in the network views
   }
+  netsAwaitingInit = sessionState["Networks"].toStringList();
   connectedToCore = true;
-  emit connected();
-  emit requestNetworkStates();
-}
-
-void Client::updateCoreData(UserId, QString key) {
-  if(clientMode == LocalCore) return;
-  QVariant data = Global::data(key);
-  recvProxySignal(GS_UPDATE_GLOBAL_DATA, key, data, QVariant());
-}
-
-void Client::updateLocalData(QString key, QVariant data) {
-  Global::updateData(key, data);
+  if(netsAwaitingInit.count()) {
+    emit coreConnectionMsg(tr("Requesting network states..."));
+    emit coreConnectionProgress(0, netsAwaitingInit.count());
+    emit requestNetworkStates();
+  }
+  else {
+    emit coreConnectionProgress(1, 1);
+    emit connected();
+  }
 }
 
 void Client::recvSessionData(const QString &key, const QVariant &data) {
   sessionData[key] = data;
   emit sessionDataChanged(key, data);
   emit sessionDataChanged(key);
-  qDebug() << "stored data in client:" << key;
 }
 
 void Client::storeSessionData(const QString &key, const QVariant &data) {
@@ -217,6 +226,10 @@ QVariant Client::retrieveSessionData(const QString &key, const QVariant &def) {
   else return def;
 }
 
+QStringList Client::sessionDataKeys() {
+  return instance()->sessionData.keys();
+}
+
 void Client::recvProxySignal(ClientSignal sig, QVariant arg1, QVariant arg2, QVariant arg3) {
   if(clientMode == LocalCore) return;
   QList<QVariant> sigdata;
@@ -244,6 +257,7 @@ void Client::serverHasData() {
 }
 
 void Client::networkConnected(QString net) {
+  Q_ASSERT(!netsAwaitingInit.contains(net));
   netConnected[net] = true;
   BufferId id = statusBufferId(net);
   Buffer *b = buffer(id);
@@ -260,6 +274,12 @@ void Client::networkDisconnected(QString net) {
     b->setActive(false);
   }
   netConnected[net] = false;
+  if(netsAwaitingInit.contains(net)) {
+    qDebug() << "Network" << net << "disconnected while not yet initialized!";
+    netsAwaitingInit.removeAll(net);
+    emit coreConnectionProgress(netConnected.count(), netConnected.count() + netsAwaitingInit.count());
+    if(!netsAwaitingInit.count()) emit connected();
+  }
 }
 
 void Client::updateBufferId(BufferId id) {
@@ -299,6 +319,7 @@ QList<BufferId> Client::allBufferIds() {
 }
 
 void Client::recvNetworkState(QString net, QVariant state) {
+  netsAwaitingInit.removeAll(net);
   netConnected[net] = true;
   setOwnNick(net, state.toMap()["OwnNick"].toString());
   buffer(statusBufferId(net))->setActive(true);
@@ -313,6 +334,8 @@ void Client::recvNetworkState(QString net, QVariant state) {
   foreach(QString nick, n.keys()) {
     addNick(net, nick, n[nick].toMap());
   }
+  emit coreConnectionProgress(netConnected.count(), netConnected.count() + netsAwaitingInit.count());
+  if(!netsAwaitingInit.count()) emit connected();
 }
 
 void Client::recvMessage(const Message &msg) {