Add error message management module to the export plugin (#2878)

Co-authored-by: billyjin <[email protected]>

Author: jinwuwu001

exporter/src/aecommand/AECommand.cpp

@@ -19,7 +19,6 @@
 #include "AECommand.h"
 #include "utils/AEHelper.h"
 #include "utils/AEResource.h"
-
 namespace exporter {
 
 AEGP_Command AECommand::PAGExporterCMD = 0L;

exporter/src/ui/WindowManager.cpp

@@ -25,7 +25,7 @@
 
 namespace exporter {
 
-WindowManager& WindowManager::getInstance() {
+WindowManager& WindowManager::GetInstance() {
   static WindowManager instance;
   return instance;
 }
@@ -65,4 +65,14 @@ void WindowManager::initializeQtEnvironment() {
   QQuickWindow::setGraphicsApi(QSGRendererInterface::OpenGL);
 }
 
+bool WindowManager::showWarnings(std::vector<std::string>& /*infos*/) {
+
+  return true;
+}
+
+bool WindowManager::showErrors(std::vector<std::string>& /*infos*/) {
+
+  return true;
+}
+
 }  // namespace exporter

exporter/src/ui/WindowManager.h

@@ -18,10 +18,13 @@
 
 #pragma once
 
+#include <string>
+#include <vector>
+
 namespace exporter {
 class WindowManager {
  public:
-  static WindowManager& getInstance();
+  static WindowManager& GetInstance();
 
   void initializeQtEnvironment();
 
@@ -31,6 +34,10 @@ class WindowManager {
 
   void showExportPreviewWindow();
 
+  bool showWarnings(std::vector<std::string>& infos);
+
+  bool showErrors(std::vector<std::string>& infos);
+
   WindowManager(const WindowManager&) = delete;
   WindowManager& operator=(const WindowManager&) = delete;
 

exporter/src/utils/AEHelper.cpp

@@ -17,15 +17,18 @@
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "AEHelper.h"
+#include <iostream>
+#include "StringHelper.h"
 #include "platform/PlatformHelper.h"
-
 namespace AEHelper {
 
 AEGP_PluginID PluginID = 0L;
 std::shared_ptr<AEGP_SuiteHandler> Suites = nullptr;
 std::string DocumentsFolderPath = "";
 std::string AeVersion = "";
 
+int32_t MAJORVERSION = 23;
+
 void SetSuitesAndPluginID(SPBasicSuite* basicSuite, AEGP_PluginID id) {
   Suites = std::make_shared<AEGP_SuiteHandler>(basicSuite);
   PluginID = id;
@@ -114,4 +117,141 @@ void RunScriptPreWarm() {
   }
 }
 
+bool CheckAeVersion() {
+  int32_t majorVersion = 0;
+  if (AeVersion.empty()) {
+    return false;
+  }
+  try {
+    size_t dotPos = AeVersion.find('.');
+    if (dotPos == std::string::npos) {
+      std::cerr << "Invalid version format" << std::endl;
+      return false;
+    }
+    std::string versionStr = AeVersion.substr(0, dotPos);
+    majorVersion = std::stoi(versionStr);
+  } catch (const std::invalid_argument& e) {
+    std::cerr << "Invalid argument: " << e.what() << std::endl;
+    return false;
+  } catch (const std::out_of_range& e) {
+    std::cerr << "Out of range: " << e.what() << std::endl;
+    return false;
+  }
+  if (majorVersion >= MAJORVERSION) {
+    return true;
+  }
+  return false;
+}
+
+std::string GetItemName(const AEGP_ItemH& itemH) {
+  std::string itemName;
+  if (itemH == nullptr) {
+    return itemName;
+  }
+  const auto& suites = GetSuites();
+  auto pluginID = GetPluginID();
+  AEGP_MemHandle nameMemory = nullptr;
+  suites->ItemSuite8()->AEGP_GetItemName(pluginID, itemH, &nameMemory);
+  if (!nameMemory) {
+    return itemName;
+  }
+  itemName = StringHelper::AeMemoryHandleToString(nameMemory);
+  suites->MemorySuite1()->AEGP_FreeMemHandle(nameMemory);
+
+  itemName = StringHelper::DeleteLastSpace(itemName);
+  return itemName;
+}
+
+std::string GetLayerName(const AEGP_LayerH& layerH) {
+  std::string layerName;
+  if (layerH == nullptr) {
+    return layerName;
+  }
+  const auto& suites = GetSuites();
+  auto pluginID = GetPluginID();
+  AEGP_MemHandle layerNameHandle = nullptr;
+  AEGP_MemHandle sourceNameHandle = nullptr;
+  suites->LayerSuite6()->AEGP_GetLayerName(pluginID, layerH, &layerNameHandle, &sourceNameHandle);
+  if (!layerNameHandle || !sourceNameHandle) {
+    return layerName;
+  }
+  layerName = StringHelper::AeMemoryHandleToString(layerNameHandle);
+  if (layerName.empty()) {
+    layerName = StringHelper::AeMemoryHandleToString(sourceNameHandle);
+  }
+  suites->MemorySuite1()->AEGP_FreeMemHandle(layerNameHandle);
+  suites->MemorySuite1()->AEGP_FreeMemHandle(sourceNameHandle);
+
+  layerName = StringHelper::DeleteLastSpace(layerName);
+  return layerName;
+}
+
+AEGP_ItemH GetItemFromComp(const AEGP_CompH& compH) {
+  const auto& suites = GetSuites();
+  AEGP_ItemH itemH = nullptr;
+  if (compH != nullptr) {
+    suites->CompSuite6()->AEGP_GetItemFromComp(compH, &itemH);
+  }
+  return itemH;
+}
+
+std::string GetCompName(const AEGP_CompH& compH) {
+  if (compH == nullptr) {
+    return "";
+  }
+  auto itemH = GetItemFromComp(compH);
+  return GetItemName(itemH);
+}
+
+void SelectItem(const AEGP_ItemH& itemH) {
+  const auto& suites = GetSuites();
+  if (itemH != nullptr) {
+    suites->ItemSuite6()->AEGP_SelectItem(itemH, true, true);
+    suites->CommandSuite1()->AEGP_DoCommand(
+        3061);  // 3061: Open selection, ignoring any modifier keys.
+  }
+}
+
+void SelectItem(const AEGP_ItemH& itemH, const AEGP_LayerH& layerH) {
+  const auto& suites = GetSuites();
+  auto pluginID = GetPluginID();
+  if (itemH == nullptr) {
+    return;
+  }
+  bool hasLayer = (layerH != nullptr);
+  AEGP_CollectionItemV2 collectionItem;
+  AEGP_StreamRefH streamH;
+  if (hasLayer) {
+    suites->DynamicStreamSuite4()->AEGP_GetNewStreamRefForLayer(pluginID, layerH, &streamH);
+    collectionItem.type = AEGP_CollectionItemType_LAYER;
+    collectionItem.u.layer.layerH = layerH;
+    collectionItem.stream_refH = streamH;
+  }
+
+  suites->ItemSuite6()->AEGP_SelectItem(itemH, true, true);
+  if (!hasLayer) {
+    suites->CommandSuite1()->AEGP_DoCommand(
+        3061);  // 3061: Open selection, ignoring any modifier keys.
+    return;
+  }
+
+  auto compH = GetCompFromItem(itemH);
+  AEGP_Collection2H collectionH = nullptr;
+  suites->CollectionSuite2()->AEGP_NewCollection(pluginID, &collectionH);
+  suites->CollectionSuite2()->AEGP_CollectionPushBack(collectionH, &collectionItem);
+  suites->CompSuite6()->AEGP_SetSelection(compH, collectionH);
+  suites->CommandSuite1()->AEGP_DoCommand(
+      3061);  // 3061: Open selection, ignoring any modifier keys.
+  suites->CollectionSuite2()->AEGP_DisposeCollection(collectionH);
+}
+
+AEGP_CompH GetCompFromItem(const AEGP_ItemH& itemH) {
+  const auto& suites = GetSuites();
+  AEGP_CompH compH = nullptr;
+  if (itemH != nullptr) {
+    suites->CompSuite6()->AEGP_GetCompFromItem(itemH, &compH);
+  }
+  return compH;
+}
+
 }  // namespace AEHelper

exporter/src/utils/AEHelper.h

@@ -37,6 +37,20 @@ std::string RunScript(std::shared_ptr<AEGP_SuiteHandler> suites, AEGP_PluginID p
 
 void RunScriptPreWarm();
 
+bool CheckAeVersion();
+
+std::string GetItemName(const AEGP_ItemH& itemH);
+
+std::string GetCompName(const AEGP_CompH& compH);
+
+std::string GetLayerName(const AEGP_LayerH& layerH);
+
+AEGP_CompH GetCompFromItem(const AEGP_ItemH& itemH);
+
+void SelectItem(const AEGP_ItemH& itemH);
+
+void SelectItem(const AEGP_ItemH& itemH, const AEGP_LayerH& layerH);
+
 const std::string TextDocumentScript = R"(
 if (typeof PAG !== 'object') {
     PAG = {};