1 files changed, 155 insertions, 29 deletions

diff --git a/src/Xpl2Client.cpp b/src/Xpl2Client.cpp
index 8ed032f..b29ac30 100644
--- a/src/Xpl2Client.cpp
+++ b/src/Xpl2Client.cpp
@@ -6,12 +6,32 @@
 
 Xpl2Client::Xpl2Client (QObject *parent) : QObject (parent)
 {
-  connect (&m_socket, &QTcpSocket::connected, this, &Xpl2Client::onConnected);
-  connect (&m_socket, &QTcpSocket::disconnected, this,
-           &Xpl2Client::onDisconnected);
-  connect (&m_socket, &QTcpSocket::readyRead, this, &Xpl2Client::onReadyRead);
-  connect (&m_socket, &QAbstractSocket::errorOccurred, this,
-           &Xpl2Client::onErrorOccurred);
+  connect (&m_commandSocket, &QTcpSocket::connected, this,
+           &Xpl2Client::onCommandSocketConnected);
+  connect (&m_commandSocket, &QTcpSocket::disconnected, this,
+           &Xpl2Client::onCommandSocketDisconnected);
+  connect (&m_commandSocket, &QTcpSocket::readyRead, this,
+           &Xpl2Client::onCommandSocketReadyRead);
+  connect (&m_commandSocket, &QAbstractSocket::errorOccurred, this,
+           &Xpl2Client::onCommandSocketError);
+
+  connect (&m_imagingSocket, &QTcpSocket::connected, this,
+           &Xpl2Client::onImagingSocketConnected);
+  connect (&m_imagingSocket, &QTcpSocket::disconnected, this,
+           &Xpl2Client::onImagingSocketDisconnected);
+  connect (&m_imagingSocket, &QTcpSocket::readyRead, this,
+           &Xpl2Client::onImagingSocketReadyRead);
+  connect (&m_imagingSocket, &QAbstractSocket::errorOccurred, this,
+           &Xpl2Client::onImagingSocketError);
+
+  connect (&m_statusSocket, &QTcpSocket::connected, this,
+           &Xpl2Client::onStatusSocketConnected);
+  connect (&m_statusSocket, &QTcpSocket::disconnected, this,
+           &Xpl2Client::onStatusSocketDisconnected);
+  connect (&m_statusSocket, &QTcpSocket::readyRead, this,
+           &Xpl2Client::onStatusSocketReadyRead);
+  connect (&m_statusSocket, &QAbstractSocket::errorOccurred, this,
+           &Xpl2Client::onStatusSocketError);
 }
 
 QString
@@ -77,69 +97,175 @@ Xpl2Client::setStatusPort (quint16 port)
 bool
 Xpl2Client::isConnected () const
 {
-  return m_socket.state () == QAbstractSocket::ConnectedState;
+  return m_connected;
 }
 
 void
 Xpl2Client::connectToServer ()
 {
-  if (isConnected ())
+  if (m_connected)
     {
       emit statusMessage (QStringLiteral ("Already connected"));
       return;
     }
-  emit statusMessage (QStringLiteral ("Connecting to %1:%2…")
+  emit statusMessage (QStringLiteral ("Connecting to %1 (ports %2/%3/%4)…")
                           .arg (m_host)
-                          .arg (m_commandPort));
-  m_socket.connectToHost (m_host, m_commandPort);
+                          .arg (m_commandPort)
+                          .arg (m_imagingPort)
+                          .arg (m_statusPort));
+  m_commandSocket.connectToHost (m_host, m_commandPort);
+  m_imagingSocket.connectToHost (m_host, m_imagingPort);
+  m_statusSocket.connectToHost (m_host, m_statusPort);
 }
 
 void
 Xpl2Client::disconnectFromServer ()
 {
-  if (!isConnected ())
-    return;
-  m_socket.disconnectFromHost ();
+  m_commandSocket.disconnectFromHost ();
+  m_imagingSocket.disconnectFromHost ();
+  m_statusSocket.disconnectFromHost ();
+}
+
+void
+Xpl2Client::sendToCommandSocket (const QString &message)
+{
+  sendToSocket (m_commandSocket, QStringLiteral ("Command"), message);
+}
+
+void
+Xpl2Client::sendToImagingSocket (const QString &message)
+{
+  sendToSocket (m_imagingSocket, QStringLiteral ("Imaging"), message);
+}
+
+void
+Xpl2Client::sendToStatusSocket (const QString &message)
+{
+  sendToSocket (m_statusSocket, QStringLiteral ("Status"), message);
 }
 
 void
-Xpl2Client::sendCommand (const QString &command)
+Xpl2Client::sendToSocket (QTcpSocket &socket, const QString &label,
+                          const QString &message)
 {
-  if (!isConnected ())
+  if (socket.state () != QAbstractSocket::ConnectedState)
     {
-      emit errorOccurred (QStringLiteral ("Not connected"));
+      emit errorOccurred (
+          QStringLiteral ("%1 socket not connected").arg (label));
       return;
     }
-  QByteArray data = command.toUtf8 () + '\n';
-  m_socket.write (data);
-  emit statusMessage (QStringLiteral ("Sent: %1").arg (command));
+  QByteArray data = message.toUtf8 () + '\n';
+  socket.write (data);
+  emit statusMessage (QStringLiteral ("Sent [%1]: %2").arg (label, message));
 }
 
 void
-Xpl2Client::onConnected ()
+Xpl2Client::updateConnectedState ()
 {
+  bool allConnected
+      = m_commandSocket.state () == QAbstractSocket::ConnectedState
+        && m_imagingSocket.state () == QAbstractSocket::ConnectedState
+        && m_statusSocket.state () == QAbstractSocket::ConnectedState;
+  if (m_connected == allConnected)
+    return;
+  m_connected = allConnected;
   emit connectedChanged ();
 }
 
 void
-Xpl2Client::onDisconnected ()
+Xpl2Client::onCommandSocketConnected ()
 {
-  emit connectedChanged ();
+  emit statusMessage (QStringLiteral ("Command socket connected"));
+  updateConnectedState ();
+}
+
+void
+Xpl2Client::onCommandSocketDisconnected ()
+{
+  emit statusMessage (QStringLiteral ("Command socket disconnected"));
+  updateConnectedState ();
+}
+
+void
+Xpl2Client::onCommandSocketReadyRead ()
+{
+  while (m_commandSocket.canReadLine ())
+    {
+      QString line
+          = QString::fromUtf8 (m_commandSocket.readLine ()).trimmed ();
+      emit commandSocketResponseReceived (line);
+    }
+}
+
+void
+Xpl2Client::onCommandSocketError (QAbstractSocket::SocketError error)
+{
+  Q_UNUSED (error)
+  emit errorOccurred (
+      QStringLiteral ("Command: %1").arg (m_commandSocket.errorString ()));
+}
+
+void
+Xpl2Client::onImagingSocketConnected ()
+{
+  emit statusMessage (QStringLiteral ("Imaging socket connected"));
+  updateConnectedState ();
+}
+
+void
+Xpl2Client::onImagingSocketDisconnected ()
+{
+  emit statusMessage (QStringLiteral ("Imaging socket disconnected"));
+  updateConnectedState ();
+}
+
+void
+Xpl2Client::onImagingSocketReadyRead ()
+{
+  while (m_imagingSocket.canReadLine ())
+    {
+      QString line
+          = QString::fromUtf8 (m_imagingSocket.readLine ()).trimmed ();
+      emit imagingSocketResponseReceived (line);
+    }
+}
+
+void
+Xpl2Client::onImagingSocketError (QAbstractSocket::SocketError error)
+{
+  Q_UNUSED (error)
+  emit errorOccurred (
+      QStringLiteral ("Imaging: %1").arg (m_imagingSocket.errorString ()));
+}
+
+void
+Xpl2Client::onStatusSocketConnected ()
+{
+  emit statusMessage (QStringLiteral ("Status socket connected"));
+  updateConnectedState ();
+}
+
+void
+Xpl2Client::onStatusSocketDisconnected ()
+{
+  emit statusMessage (QStringLiteral ("Status socket disconnected"));
+  updateConnectedState ();
 }
 
 void
-Xpl2Client::onReadyRead ()
+Xpl2Client::onStatusSocketReadyRead ()
 {
-  while (m_socket.canReadLine ())
+  while (m_statusSocket.canReadLine ())
     {
-      QString line = QString::fromUtf8 (m_socket.readLine ()).trimmed ();
-      emit responseReceived (line);
+      QString line = QString::fromUtf8 (m_statusSocket.readLine ()).trimmed ();
+      emit statusSocketResponseReceived (line);
     }
 }
 
 void
-Xpl2Client::onErrorOccurred (QAbstractSocket::SocketError error)
+Xpl2Client::onStatusSocketError (QAbstractSocket::SocketError error)
 {
   Q_UNUSED (error)
-  emit errorOccurred (m_socket.errorString ());
+  emit errorOccurred (
+      QStringLiteral ("Status: %1").arg (m_statusSocket.errorString ()));
 }