workspace_manager.cc

Go to the documentation of this file.

#define IMGUI_DEFINE_MATH_OPERATORS
 
#include "app/editor/shell/coordinator/workspace_manager.h"
 
#include "absl/strings/str_format.h"
#include "app/editor/layout/layout_manager.h"
#include "app/editor/shell/feedback/toast_manager.h"
#include "app/editor/system/editor_registry.h"
#include "app/editor/system/workspace/workspace_window_manager.h"
#include "imgui/imgui.h"
#include "imgui/imgui_internal.h"
#include "rom/rom.h"
#include "util/file_util.h"
#include "util/log.h"
#include "util/platform_paths.h"
 
namespace yaze {
namespace editor {
 
absl::Status WorkspaceManager::SaveWorkspaceLayout(const std::string& name) {
  if (layout_manager_) {
    const std::string layout_name = name.empty() ? "workspace" : name;
    layout_manager_->SaveCurrentLayout(layout_name);
  }
  if (toast_manager_) {
    toast_manager_->Show("Layout saved", ToastType::kSuccess);
  }
  return absl::OkStatus();
}
 
absl::Status WorkspaceManager::LoadWorkspaceLayout(const std::string& name) {
  bool loaded = false;
  if (layout_manager_) {
    const std::string layout_name = name.empty() ? "workspace" : name;
    if (layout_manager_->HasLayout(layout_name)) {
      layout_manager_->LoadLayout(layout_name);
      loaded = true;
    } else if (toast_manager_) {
      toast_manager_->Show("Layout not found", ToastType::kWarning);
    }
  }
  if (toast_manager_ && loaded) {
    toast_manager_->Show("Layout loaded", ToastType::kSuccess);
  }
  return absl::OkStatus();
}
 
void WorkspaceManager::SaveWorkspacePreset(const std::string& name) {
  if (name.empty())
    return;
 
  std::filesystem::path workspace_dir = std::filesystem::current_path();
  auto workspace_dir_status =
      util::PlatformPaths::GetAppDataSubdirectory("workspaces");
  if (workspace_dir_status.ok()) {
    workspace_dir = *workspace_dir_status;
  }
 
  if (layout_manager_) {
    layout_manager_->SaveCurrentLayout(name);
  } else {
    std::filesystem::path ini_path =
        workspace_dir / absl::StrFormat("workspace_%s.ini", name.c_str());
    ImGui::SaveIniSettingsToDisk(ini_path.string().c_str());
  }
 
  if (!workspace_presets_loaded_) {
    // RefreshWorkspacePresets(); // This will be implemented next
  }
 
  if (std::find(workspace_presets_.begin(), workspace_presets_.end(), name) ==
      workspace_presets_.end()) {
    workspace_presets_.emplace_back(name);
    try {
      std::ostringstream ss;
      for (const auto& n : workspace_presets_)
        ss << n << "\n";
      std::filesystem::path presets_path =
          workspace_dir / "workspace_presets.txt";
      util::SaveFile(presets_path.string(), ss.str());
    } catch (const std::exception& e) {
      // LOG_WARN("WorkspaceManager", "Failed to save presets: %s", e.what());
    }
  }
  last_workspace_preset_ = name;
  if (toast_manager_) {
    toast_manager_->Show(absl::StrFormat("Preset '%s' saved", name),
                         ToastType::kSuccess);
  }
}
 
void WorkspaceManager::LoadWorkspacePreset(const std::string& name) {
  if (name.empty())
    return;
 
  if (layout_manager_) {
    if (layout_manager_->HasLayout(name)) {
      layout_manager_->LoadLayout(name);
      last_workspace_preset_ = name;
      if (toast_manager_) {
        toast_manager_->Show(absl::StrFormat("Preset '%s' loaded", name),
                             ToastType::kSuccess);
      }
      return;
    }
  }
  std::filesystem::path workspace_dir = std::filesystem::current_path();
  auto workspace_dir_status =
      util::PlatformPaths::GetAppDataSubdirectory("workspaces");
  if (workspace_dir_status.ok()) {
    workspace_dir = *workspace_dir_status;
  }
  std::filesystem::path ini_path =
      workspace_dir / absl::StrFormat("workspace_%s.ini", name.c_str());
  ImGui::LoadIniSettingsFromDisk(ini_path.string().c_str());
  last_workspace_preset_ = name;
  if (toast_manager_) {
    toast_manager_->Show(absl::StrFormat("Preset '%s' loaded", name),
                         ToastType::kSuccess);
  }
}
 
void WorkspaceManager::RefreshPresets() {
  try {
    std::vector<std::string> new_presets;
    auto workspace_dir =
        util::PlatformPaths::GetAppDataSubdirectory("workspaces");
    if (workspace_dir.ok()) {
      std::filesystem::path presets_path =
          *workspace_dir / "workspace_presets.txt";
      auto data = util::LoadFile(presets_path.string());
      if (!data.empty()) {
        std::istringstream ss(data);
        std::string name;
        while (std::getline(ss, name)) {
          name.erase(0, name.find_first_not_of(" \t\r\n"));
          name.erase(name.find_last_not_of(" \t\r\n") + 1);
          if (!name.empty() && name.length() < 256) {
            new_presets.emplace_back(std::move(name));
          }
        }
      }
    }
    workspace_presets_ = std::move(new_presets);
    workspace_presets_loaded_ = true;
  } catch (const std::exception& e) {
    // LOG_ERROR("WorkspaceManager", "Error refreshing presets: %s", e.what());
    workspace_presets_.clear();
    workspace_presets_loaded_ = true;
  }
}
 
void WorkspaceManager::LoadDeveloperLayout() {
  if (apply_preset_callback_) {
    apply_preset_callback_("Developer");
  } else if (toast_manager_) {
    toast_manager_->Show("Layout presets not available", ToastType::kWarning);
  }
}
 
void WorkspaceManager::LoadDesignerLayout() {
  if (apply_preset_callback_) {
    apply_preset_callback_("Designer");
  } else if (toast_manager_) {
    toast_manager_->Show("Layout presets not available", ToastType::kWarning);
  }
}
 
void WorkspaceManager::LoadModderLayout() {
  if (apply_preset_callback_) {
    apply_preset_callback_("Modder");
  } else if (toast_manager_) {
    toast_manager_->Show("Layout presets not available", ToastType::kWarning);
  }
}
 
void WorkspaceManager::ShowAllWindows() {
  if (window_manager_) {
    window_manager_->ShowAll();
  }
  if (toast_manager_) {
    toast_manager_->Show("All windows shown", ToastType::kInfo);
  }
}
 
void WorkspaceManager::HideAllWindows() {
  if (window_manager_) {
    window_manager_->HideAll();
  }
  if (toast_manager_) {
    toast_manager_->Show("All windows hidden", ToastType::kInfo);
  }
}
 
void WorkspaceManager::MaximizeCurrentWindow() {
  // Use ImGui internal API to maximize current window
  ImGuiWindow* window = ImGui::GetCurrentWindowRead();
  if (window && window->DockNode && layout_manager_) {
    if (ImGuiDockNode* central = ImGui::DockBuilderGetCentralNode(
            layout_manager_->GetMainDockspaceId())) {
      ImGui::DockBuilderDockWindow(window->Name, central->ID);
    }
  }
  if (toast_manager_) {
    toast_manager_->Show("Window maximized", ToastType::kInfo);
  }
}
 
void WorkspaceManager::RestoreAllWindows() {
  // Reset all window sizes - ImGui will auto-restore based on docking
  ImGuiContext* ctx = ImGui::GetCurrentContext();
  if (ctx) {
    for (ImGuiWindow* window : ctx->Windows) {
      if (window && !window->Collapsed) {
        ImGui::SetWindowSize(window->Name, ImVec2(0, 0));  // Auto-size
      }
    }
  }
  if (toast_manager_) {
    toast_manager_->Show("All windows restored", ToastType::kInfo);
  }
}
 
void WorkspaceManager::CloseAllFloatingWindows() {
  // Close all windows that are not docked
  ImGuiContext* ctx = ImGui::GetCurrentContext();
  if (ctx) {
    for (ImGuiWindow* window : ctx->Windows) {
      if (window && !window->DockNode && !window->Collapsed) {
        window->Hidden = true;
      }
    }
  }
  if (toast_manager_) {
    toast_manager_->Show("Floating windows closed", ToastType::kInfo);
  }
}
 
size_t WorkspaceManager::GetActiveSessionCount() const {
  if (!sessions_)
    return 0;
 
  size_t count = 0;
  for (const auto& session : *sessions_) {
    if (session.rom && session.rom->is_loaded()) {
      count++;
    }
  }
  return count;
}
 
bool WorkspaceManager::HasDuplicateSession(const std::string& filepath) const {
  if (!sessions_)
    return false;
 
  for (const auto& session : *sessions_) {
    if (session.filepath == filepath && session.rom &&
        session.rom->is_loaded()) {
      return true;
    }
  }
  return false;
}
 
// Window navigation operations
void WorkspaceManager::FocusNextWindow() {
  ImGuiContext* ctx = ImGui::GetCurrentContext();
  if (ctx && ctx->NavWindow) {
    ImGui::FocusWindow(ImGui::FindWindowByName(ctx->NavWindow->Name));
  }
  // TODO: Implement proper window cycling
}
 
void WorkspaceManager::FocusPreviousWindow() {
  // TODO: Implement window cycling backward
}
 
void WorkspaceManager::SplitWindowHorizontal() {
  ImGuiWindow* window = ImGui::GetCurrentWindowRead();
  if (window && window->DockNode) {
    ImGuiID node_id = window->DockNode->ID;
    ImGuiID out_id_at_dir = 0;
    ImGuiID out_id_at_opposite_dir = 0;
    ImGui::DockBuilderSplitNode(node_id, ImGuiDir_Down, 0.5f, &out_id_at_dir,
                                &out_id_at_opposite_dir);
  }
}
 
void WorkspaceManager::SplitWindowVertical() {
  ImGuiWindow* window = ImGui::GetCurrentWindowRead();
  if (window && window->DockNode) {
    ImGuiID node_id = window->DockNode->ID;
    ImGuiID out_id_at_dir = 0;
    ImGuiID out_id_at_opposite_dir = 0;
    ImGui::DockBuilderSplitNode(node_id, ImGuiDir_Right, 0.5f, &out_id_at_dir,
                                &out_id_at_opposite_dir);
  }
}
 
void WorkspaceManager::CloseCurrentWindow() {
  ImGuiWindow* window = ImGui::GetCurrentWindowRead();
  if (window) {
    window->Hidden = true;
  }
}
 
}  // namespace editor
}  // namespace yaze