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

diff --git a/src/client/client.cpp b/src/client/client.cpp
index 30eeb51d..94119f5e 100644
--- a/src/client/client.cpp
+++ b/src/client/client.cpp
@@ -19,22 +19,24 @@
  ***************************************************************************/
 
 #include "client.h"
-#include "clientproxy.h"
+
 #include "buffer.h"
 #include "buffertreemodel.h"
+#include "clientproxy.h"
+#include "quasselui.h"
 #include "util.h"
 
 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;
-//QList<BufferId> Client::coreBuffers;
-
 
 Client *Client::instance() {
   if(instanceptr) return instanceptr;
@@ -71,14 +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)));
@@ -124,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());
   }
 }
@@ -142,59 +148,86 @@ 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) {
     BufferId id = vid.value<BufferId>();
     bufferIds[id.uid()] = id;  // make lookups by id faster
     buffer(id);                // create all buffers, so we see them in the network views
-    //emit requestBacklog(id, -1, -1);  // TODO: use custom settings for backlog request
   }
+  netsAwaitingInit = sessionState["Networks"].toStringList();
   connectedToCore = true;
-  emit connected();
-  emit requestNetworkStates();
+  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::updateCoreData(UserId, QString key) {
-  if(clientMode == LocalCore) return;
-  QVariant data = Global::data(key);
-  recvProxySignal(GS_UPDATE_GLOBAL_DATA, key, data, QVariant());
+void Client::recvSessionData(const QString &key, const QVariant &data) {
+  sessionData[key] = data;
+  emit sessionDataChanged(key, data);
+  emit sessionDataChanged(key);
 }
 
-void Client::updateLocalData(QString key, QVariant data) {
-  Global::updateData(key, data);
+void Client::storeSessionData(const QString &key, const QVariant &data) {
+  // Not sure if this is a good idea, but we'll try it anyway:
+  // Calling this function only sends a signal to core. Data is stored upon reception of the update signal,
+  // rather than immediately.
+  emit instance()->sendSessionData(key, data);
+}
+
+QVariant Client::retrieveSessionData(const QString &key, const QVariant &def) {
+  if(instance()->sessionData.contains(key)) return instance()->sessionData[key];
+  else return def;
+}
+
+QStringList Client::sessionDataKeys() {
+  return instance()->sessionData.keys();
 }
 
 void Client::recvProxySignal(ClientSignal sig, QVariant arg1, QVariant arg2, QVariant arg3) {
@@ -224,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);
@@ -240,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) {
@@ -279,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);
@@ -293,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) {
@@ -404,4 +447,3 @@ void Client::setOwnNick(QString net, QString nick) {
   }
 }
 
-