editor_panel.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_SYSTEM_EDITOR_PANEL_H_
#define YAZE_APP_EDITOR_SYSTEM_EDITOR_PANEL_H_
 
#include <any>
#include <cstdint>
#include <functional>
#include <string>
#include <unordered_map>
#include <utility>
 
namespace yaze {
namespace editor {
 
enum class WindowLifecycle {
  EditorBound,  
  CrossEditor   
};
 
enum class WindowContextScope : uint8_t {
  kNone = 0,
  kRoom,
  kSelection,
};
 
enum class WindowScope { kSession, kGlobal };
 
enum class WindowPresentationRole : uint8_t {
  kCoreWorkspace,
  kEmbeddedTool,
  kOptionalPopOut,
  kDiagnostic,
};
 
enum class WindowDefaultHost : uint8_t {
  kWorkspace,
  kEmbedded,
};
 
inline const char* WindowPresentationRoleName(WindowPresentationRole role) {
  switch (role) {
    case WindowPresentationRole::kCoreWorkspace:
      return "CoreWorkspace";
    case WindowPresentationRole::kEmbeddedTool:
      return "EmbeddedTool";
    case WindowPresentationRole::kOptionalPopOut:
      return "OptionalPopOut";
    case WindowPresentationRole::kDiagnostic:
      return "Diagnostic";
  }
  return "Unknown";
}
 
struct WindowPresentationPolicy {
  WindowPresentationRole role = WindowPresentationRole::kOptionalPopOut;
  WindowDefaultHost default_host = WindowDefaultHost::kWorkspace;
  bool list_in_window_browser = true;
  bool allow_popout = true;
  std::string required_capability;
  std::function<bool()> capability_condition;
 
  bool declared = false;
 
  std::string host;
 
  bool IsAdmitted() const {
    return !capability_condition || capability_condition();
  }
 
  [[nodiscard]] WindowPresentationPolicy WithHost(std::string host_name) const {
    WindowPresentationPolicy copy = *this;
    copy.host = std::move(host_name);
    return copy;
  }
 
  static WindowPresentationPolicy CoreWorkspace() {
    return {.role = WindowPresentationRole::kCoreWorkspace, .declared = true};
  }
 
  static WindowPresentationPolicy EmbeddedTool(
      std::string capability = std::string()) {
    return {
        .role = WindowPresentationRole::kEmbeddedTool,
        .default_host = WindowDefaultHost::kEmbedded,
        .list_in_window_browser = false,
        .allow_popout = true,
        .required_capability = std::move(capability),
        .declared = true,
    };
  }
 
  static WindowPresentationPolicy OptionalPopOut() {
    return {.role = WindowPresentationRole::kOptionalPopOut, .declared = true};
  }
 
  static WindowPresentationPolicy Diagnostic() {
    return {
        .role = WindowPresentationRole::kDiagnostic,
        .default_host = WindowDefaultHost::kEmbedded,
        .list_in_window_browser = false,
        .allow_popout = true,
        .declared = true,
    };
  }
};
 
class WindowContent {
 public:
  virtual ~WindowContent() = default;
 
  // ==========================================================================
  // Identity (Required)
  // ==========================================================================
 
  virtual std::string GetId() const = 0;
 
  virtual std::string GetDisplayName() const = 0;
 
  virtual std::string GetIcon() const = 0;
 
  virtual std::string GetEditorCategory() const = 0;
 
  // ==========================================================================
  // Drawing (Required)
  // ==========================================================================
 
  virtual void Draw(bool* p_open) = 0;
 
  // ==========================================================================
  // Lifecycle Hooks (Optional)
  // ==========================================================================
 
  virtual void OnFirstDraw() {}
 
  virtual bool RequiresLazyInit() const { return false; }
 
  void InvalidateLazyInit();  // Implementation below private member
 
  virtual void OnOpen() {}
 
  virtual void OnClose() {}
 
  virtual void OnFocus() {}
 
  // ==========================================================================
  // Behavior (Optional)
  // ==========================================================================
 
  virtual WindowLifecycle GetWindowLifecycle() const {
    return WindowLifecycle::EditorBound;
  }
 
  virtual WindowContextScope GetContextScope() const {
    return WindowContextScope::kNone;
  }
 
  virtual WindowScope GetScope() const { return WindowScope::kSession; }
 
  virtual WindowPresentationPolicy GetPresentationPolicy() const {
    return WindowPresentationPolicy();
  }
 
  virtual bool IsEnabled() const { return true; }
 
  virtual std::string GetDisabledTooltip() const { return ""; }
 
  virtual std::string GetShortcutHint() const { return ""; }
 
  virtual int GetPriority() const { return 50; }
 
  virtual std::string GetWorkflowGroup() const { return ""; }
 
  virtual std::string GetWorkflowLabel() const { return GetDisplayName(); }
 
  virtual std::string GetWorkflowDescription() const { return ""; }
 
  virtual int GetWorkflowPriority() const { return GetPriority(); }
 
  virtual float GetPreferredWidth() const { return 0.0f; }
 
  virtual bool HasExactPreferredWidth() const { return false; }
 
  virtual float GetPreferredHeight() const { return 0.0f; }
 
  virtual bool PrefersFloating() const { return false; }
 
  virtual bool PreferAutoHideTabBar() const { return false; }
 
  virtual bool IsVisibleByDefault() const { return false; }
 
  // ==========================================================================
  // Relationships (Optional)
  // ==========================================================================
 
  virtual std::string GetParentPanelId() const { return ""; }
 
  virtual bool CascadeCloseChildren() const { return false; }
 
  // ==========================================================================
  // Internal State (Managed by WorkspaceWindowManager)
  // ==========================================================================
 
  void DrawWithLazyInit(bool* p_open) {
    if (RequiresLazyInit() && !lazy_init_done_) {
      OnFirstDraw();
      lazy_init_done_ = true;
    }
    Draw(p_open);
  }
 
 protected:
  // ==========================================================================
  // Caching Infrastructure (For Derived Panels)
  // ==========================================================================
 
  void InvalidateCache() { cache_valid_ = false; }
 
  template <typename T>
  T& GetCached(const std::string& key, std::function<T()> compute) {
    if (!cache_valid_ || cache_.find(key) == cache_.end()) {
      cache_[key] = compute();
      cache_valid_ = true;  // Mark valid after first successful computation
    }
    return std::any_cast<T&>(cache_[key]);
  }
 
  bool IsCacheValid() const { return cache_valid_; }
 
  void ClearCache() {
    cache_.clear();
    cache_valid_ = false;
  }
 
 private:
  bool lazy_init_done_ = false;
 
  // Cache infrastructure
  bool cache_valid_ = false;
  std::unordered_map<std::string, std::any> cache_;
};
 
// Inline implementation (requires private member to be declared first)
inline void WindowContent::InvalidateLazyInit() {
  lazy_init_done_ = false;
}
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_SYSTEM_EDITOR_PANEL_H_