OK Folks, my first commit after quite a while, and while Quassel looks the same as...

[quassel.git] / src / client / client.cpp

diff --git a/src/client/client.cpp b/src/client/client.cpp
index 30eeb51..b591f2c 100644 (file)
--- 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;
@@ -77,6 +79,8 @@ void Client::init() {
 
   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(csServerState(QString, QVariant)), this, SLOT(recvNetworkState(QString, QVariant)));
@@ -124,15 +128,17 @@ 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
+    syncToCore();
   } else {
     clientMode = RemoteCore;
+    emit coreConnectionMsg(tr("Connecting..."));
     socket.connectToHost(conn["Host"].toString(), conn["Port"].toUInt());
   }
 }
@@ -144,7 +150,14 @@ void Client::disconnectFromCore() {
     disconnectFromLocalCore();
     coreDisconnected();
   }
-  // TODO clear internal data
+  /* 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::coreConnected() {
@@ -160,9 +173,9 @@ void Client::coreDisconnected() {
 void Client::syncToCore() {
   VarMap state;
   if(clientMode == LocalCore) {
-    state = connectToLocalCore("Default", "password").toMap(); // TODO make this configurable
+    state = connectToLocalCore(coreConnectionInfo["User"].toString(), coreConnectionInfo["Password"].toString()).toMap();
   } else {
-
+    // TODO connect to remote cores
   }
 
   VarMap data = state["CoreData"].toMap();
@@ -174,17 +187,28 @@ void Client::syncToCore() {
   //}
 
   VarMap sessionState = state["SessionState"].toMap();
+  VarMap sessData = sessionState["SessionData"].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) {
@@ -197,6 +221,28 @@ void Client::updateLocalData(QString key, QVariant data) {
   Global::updateData(key, data);
 }
 
+void Client::recvSessionData(const QString &key, const QVariant &data) {
+  sessionData[key] = data;
+  emit sessionDataChanged(key, data);
+  emit sessionDataChanged(key);
+}
+
+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) {
   if(clientMode == LocalCore) return;
   QList<QVariant> sigdata;
@@ -224,6 +270,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 +287,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 +332,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 +347,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 +460,3 @@ void Client::setOwnNick(QString net, QString nick) {
   }
 }
 
-