workspace_manager.cc

Go to the documentation of this file.

#define IMGUI_DEFINE_MATH_OPERATORS
 
#include "app/editor/ui/workspace_manager.h"
 
#include "absl/strings/str_format.h"
#include "app/editor/layout/layout_manager.h"
#include "app/editor/system/editor_registry.h"
#include "app/editor/system/panel_manager.h"
#include "app/editor/ui/toast_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();
}
 
absl::Status WorkspaceManager::ResetWorkspaceLayout() {
  if (ImGui::GetCurrentContext()) {
    static const char kEmptyIni[] = "\n";
    ImGui::LoadIniSettingsFromMemory(kEmptyIni, sizeof(kEmptyIni) - 1);
  }
 
  if (auto ini_path = util::PlatformPaths::GetImGuiIniPath(); ini_path.ok()) {
    std::error_code ec;
    std::filesystem::remove(*ini_path, ec);
    if (ec) {
      LOG_WARN("WorkspaceManager", "Failed to remove ImGui ini: %s",
               ec.message().c_str());
    }
  }
 
  if (layout_manager_) {
    layout_manager_->ClearInitializationFlags();
 
    EditorType editor_type = EditorType::kSettings;
    if (panel_manager_) {
      editor_type =
          EditorRegistry::GetEditorTypeFromCategory(
              panel_manager_->GetActiveCategory());
    }
    layout_manager_->ResetToDefaultLayout(editor_type);
    layout_manager_->RequestRebuild();
  }
  if (toast_manager_) {
    toast_manager_->Show("Layout reset to default", ToastType::kInfo);
  }
  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 (panel_manager_) {
    panel_manager_->ShowAll();
  }
  if (toast_manager_) {
    toast_manager_->Show("All windows shown", ToastType::kInfo);
  }
}
 
void WorkspaceManager::HideAllWindows() {
  if (panel_manager_) {
    panel_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) {
    ImGuiID central_node_id =
        ImGui::DockBuilderGetCentralNode(ImGui::GetID("MainDockSpace"))->ID;
    ImGui::DockBuilderDockWindow(window->Name, central_node_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;
  }
}
 
// Command execution for WhichKey integration
void WorkspaceManager::ExecuteWorkspaceCommand(const std::string& command_id) {
  // Window commands (Space + w)
  if (command_id == "w.s") {
    ShowAllWindows();
  } else if (command_id == "w.h") {
    HideAllWindows();
  } else if (command_id == "w.m") {
    MaximizeCurrentWindow();
  } else if (command_id == "w.r") {
    RestoreAllWindows();
  } else if (command_id == "w.c") {
    CloseCurrentWindow();
  } else if (command_id == "w.f") {
    CloseAllFloatingWindows();
  } else if (command_id == "w.v") {
    SplitWindowVertical();
  } else if (command_id == "w.H") {
    SplitWindowHorizontal();
  }
 
  // Layout commands (Space + l)
  else if (command_id == "l.s") {
    SaveWorkspaceLayout();
  } else if (command_id == "l.l") {
    LoadWorkspaceLayout();
  } else if (command_id == "l.r") {
    ResetWorkspaceLayout();
  } else if (command_id == "l.d") {
    LoadDeveloperLayout();
  } else if (command_id == "l.g") {
    LoadDesignerLayout();
  } else if (command_id == "l.m") {
    LoadModderLayout();
  }
 
  // Unknown command
  else if (toast_manager_) {
    toast_manager_->Show(absl::StrFormat("Unknown command: %s", command_id),
                         ToastType::kWarning);
  }
}
 
}  // namespace editor
}  // namespace yaze