add InteractivePathAnalysis code into FOEDAG

cmake/cmake_qt.txt

@@ -19,7 +19,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-find_package(Qt5 COMPONENTS Core Gui Widgets Xml REQUIRED)
+find_package(Qt5 COMPONENTS Core Gui Widgets Xml Network REQUIRED)
 if (NOT Qt5Widgets_FOUND)
     message(STATUS "Failed to find Qt5Widgets required (on debian/ubuntu try 'sudo apt install qt5-default')")
 elseif (NOT Qt5Gui_FOUND)
@@ -28,6 +28,8 @@ elseif (NOT Qt5Core_FOUND)
     message(STATUS "Failed to find Qt5Core required (on debian/ubuntu try 'sudo apt install qt5-default')")
 elseif (NOT Qt5Xml_FOUND)
     message(STATUS "Failed to find Qt5Xml required (on debian/ubuntu try 'sudo apt install qt5-default')")
+elseif (NOT Qt5Network_FOUND)
+    message(STATUS "Failed to find Qt5Network required (on debian/ubuntu try 'sudo apt install qt5-default')")
 else()
     set(CMAKE_AUTOMOC ON)
     set(CMAKE_AUTOUIC ON)

src/Compiler/CompilerDefines.cpp

@@ -56,6 +56,9 @@ QTableView *FOEDAG::prepareCompilerView(Compiler *compiler,
           FOEDAG::handleViewReportRequested(compiler, task, reportId,
                                             *reportManager);
       });
+  QObject::connect(view, &TaskTableView::ViewInteractivePathAnalysisRequested, [compiler](){
+      FOEDAG::handleViewInteractivePathAnalysisRequested(compiler);
+  });
 
   QObject::connect(view, &TaskTableView::ViewWaveform, [compiler](Task *task) {
     auto simType = task->cusomData().data.value<Simulator::SimulationType>();

src/Compiler/CompilerOpenFPGA_ql.h

@@ -146,6 +146,7 @@ class CompilerOpenFPGA_ql : public Compiler {
   long double PowerEstimator_Dynamic();
   long double PowerEstimator_Leakage();
 
+  virtual std::string BaseVprCommand();
 
  protected:
   virtual bool IPGenerate();
@@ -217,7 +218,6 @@ class CompilerOpenFPGA_ql : public Compiler {
   std::string m_openFPGAScript;
   std::string m_pb_pin_fixup;
 
-  virtual std::string BaseVprCommand();
   virtual std::string BaseStaCommand();
   virtual std::string BaseStaScript(std::string libFileName,
                                     std::string netlistFileName,

src/Compiler/TaskTableView.cpp

@@ -216,6 +216,15 @@ void TaskTableView::addTaskLogAction(QMenu *menu, FOEDAG::Task *task) {
       menu->addAction(viewReport);
     }
   }
+
+  // create custom interactive path analysis action
+  if (task->title() == "Timing Analysis") {
+    QAction *interactivePathAnalysisAction = new QAction(tr("View Interactive Path Analysis"), this);
+    connect(interactivePathAnalysisAction, &QAction::triggered, this,
+            [this]() { emit ViewInteractivePathAnalysisRequested(); });
+    menu->addAction(interactivePathAnalysisAction);
+  }
+  //
 }
 
 void TaskTableView::addExpandCollapse(QMenu *menu) {

src/Compiler/TaskTableView.h

@@ -57,7 +57,8 @@ class TaskTableView : public QTableView {
   void ViewFileRequested(const QString &filePath);
   void ViewReportRequested(Task *task, const QString &reportId);
   void ViewWaveform(FOEDAG::Task *task);
-
+  void ViewInteractivePathAnalysisRequested();
+
  private:
   QRect expandArea(const QModelIndex &index) const;
   void addTaskLogAction(QMenu *menu, Task *task);

src/Compiler/compiler_resources.qrc

@@ -5,6 +5,7 @@
         <file>loading.png</file>
         <file>down-arrow.png</file>
         <file>next.png</file>
+        <file>search.png</file>
         <file>loading.gif</file>
     </qresource>
 </RCC>

src/InteractivePathAnalysis/client/client.cpp

@@ -0,0 +1,116 @@
+#include "client.h"
+#include "clienttoolswidget.h"
+#include "keys.h"
+
+#include "tcpsocket.h"
+#include "requestcreator.h"
+#include "ncriticalpathsettings.h"
+
+#include <QCoreApplication>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QJsonParseError>
+#include <QJsonDocument>
+#include <QJsonObject>
+
+Client::Client(
+#ifndef STANDALONE_APP
+    FOEDAG::Compiler* compiler
+#endif
+    )
+{
+    m_socket = std::make_unique<TcpSocket>();
+
+    /// UI
+    m_toolsWidget = new ClientToolsWidget(
+#ifndef STANDALONE_APP
+        compiler
+#endif
+        );
+
+    connect(m_toolsWidget, &ClientToolsWidget::getPathListRequested, this, &Client::runGetPathListScenario);
+
+    connect(m_toolsWidget, &ClientToolsWidget::highLightModeChanged, [this](){
+        onPathSelected(NCriticalPathSettings::instance().getLastSelectedPathId());
+    });
+    //
+
+    connect(m_socket.get(), &ISocket::connectedChanged, m_toolsWidget, &ClientToolsWidget::onConnectionStatusChanged);
+    connect(m_socket.get(), &ISocket::dataRecieved, this, &Client::handleResponse);
+    ///
+
+#ifdef ENABLE_AUTOMATIC_REQUEST
+    m_timer.setInterval(AUTOMATIC_CLIENT_REQUEST_INTERVAL_MS);
+    QObject::connect(&m_timer, &QTimer::timeout, this, &Client::runGetPathListScenario);
+    m_timer.start();
+#endif // ENABLE_AUTOMATIC_REQUEST
+}
+
+Client::~Client()
+{
+    if (!m_toolsWidget->parent()) {
+        delete m_toolsWidget;
+    }
+}
+
+bool Client::isConnected() const
+{
+    return m_socket->isConnected();
+}
+
+void Client::handleResponse(const QByteArray& bytes)
+{
+    qDebug() << "from server:" << bytes;
+
+    // Convert the QByteArray to a QJsonDocument
+    QJsonParseError parseError;
+    QJsonDocument jsonDoc = QJsonDocument::fromJson(bytes, &parseError);
+
+    if (parseError.error != QJsonParseError::NoError) {
+        qDebug() << "Error parsing JSON:" << parseError.errorString();
+        return;
+    }
+
+    // Extract the QJsonObject from the QJsonDocument
+    QJsonObject jsonObject = jsonDoc.object();
+
+    int cmd = jsonObject[KEY_CMD].toString().toInt();
+    bool status = jsonObject[KEY_STATUS].toString().toInt();
+    QString data = jsonObject[KEY_DATA].toString();
+
+    qInfo() << cmd << status << data;
+    if (status) {
+        switch(cmd) {
+        case CMD_GET_PATH_LIST_ID: emit critPathsDataReady(data); break;
+        }
+    } else {
+        qInfo() << "unable to perform cmd on server, error" << data;
+    }
+}
+
+void Client::sendRequest(const QByteArray& requestBytes)
+{
+    if (!m_socket->isConnected()) {
+        m_socket->connect();
+    }
+    qDebug() << "sending:" << requestBytes;
+    if (!m_socket->write(requestBytes)) {
+        qCritical() << "unable to send" << requestBytes;
+    }
+}
+
+void Client::runGetPathListScenario()
+{
+    QByteArray bytes = RequestCreator::instance().getPathListRequestTelegram(m_toolsWidget->nCriticalPathNum(),
+                                                                             m_toolsWidget->pathType(),
+                                                                             m_toolsWidget->detailesLevel(),
+                                                                             m_toolsWidget->isFlatRouting());
+    sendRequest(bytes);
+}
+
+void Client::onPathSelected(const QString& pathId)
+{
+    NCriticalPathSettings::instance().setLastSelectedPathId(pathId);
+    QByteArray bytes = RequestCreator::instance().getDrawPathIdTelegram(pathId, m_toolsWidget->highlightMode());
+    sendRequest(bytes);
+}

src/InteractivePathAnalysis/client/client.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <QWidget>
+#include <QObject>
+#include <QTimer>
+
+#include <memory>
+
+class ClientToolsWidget;
+class ISocket;
+
+#ifndef STANDALONE_APP
+#include "../../Compiler/Compiler.h"
+#endif
+
+class Client : public QObject
+{
+    Q_OBJECT
+public:
+    Client(
+#ifndef STANDALONE_APP
+        FOEDAG::Compiler*
+#endif
+        );
+    ~Client();
+
+    ClientToolsWidget* toolsWidget() const { return m_toolsWidget; }
+
+    bool isConnected() const;
+
+public slots:
+    void onPathSelected(const QString&);
+
+signals:
+    void critPathsDataReady(const QString&);
+
+private:
+    ClientToolsWidget* m_toolsWidget = nullptr;
+    std::unique_ptr<ISocket> m_socket;
+#ifdef ENABLE_AUTOMATIC_REQUEST
+    QTimer m_timer;
+#endif // ENABLE_AUTOMATIC_REQUEST
+
+    void sendRequest(const QByteArray&);
+    void handleResponse(const QByteArray&);
+
+private slots:
+    void runGetPathListScenario();
+};
+