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 <functional>
#include <string>
#include <unordered_map>
 
namespace yaze {
namespace editor {
 
enum class WindowLifecycle {
  EditorBound,  
  CrossEditor   
};
 
enum class WindowContextScope : uint8_t {
  kNone = 0,
  kRoom,
  kSelection,
};
 
enum class WindowScope { kSession, kGlobal };
 
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 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 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_