metaforce/Editor/Space.hpp

#pragma once

#include "athena/DNAYaml.hpp"
#include "specter/Space.hpp"
#include "specter/IMenuNode.hpp"
#include "specter/Button.hpp"
#include "specter/MultiLineTextView.hpp"
#include "specter/ViewResources.hpp"
#include "specter/RootView.hpp"
#include "ProjectManager.hpp"

namespace specter {
class View;
class SplitView;
class ViewResources;
class Toolbar;
struct Icon;
} // namespace specter
namespace metaforce {
class ViewManager;
class RootSpace;
class SplitSpace;

class Space : public specter::ISpaceController {
  friend class SplitSpace;

public:
  virtual ~Space() = default;
  Space(const Space& other) = delete;
  Space& operator=(const Space& other) = delete;

  /** Common encoded-enumeration for all space classes */
  enum class Class {
    None,
    RootSpace,
    SplitSpace,
    TestSpace,
    ResourceBrowser,
    ModelViewer,
    EffectEditor,
    InformationCenter,
    GameMode
  };

  struct State : athena::io::DNAVYaml<athena::Endian::Big> {
    Delete _d;
  };
  static Space* NewSpaceFromConfigStream(ViewManager& vm, Space* parent, ConfigReader& r);
  static RootSpace* NewRootSpaceFromConfigStream(ViewManager& vm, ConfigReader& r);

  struct SpaceMenuNode final : specter::IMenuNode {
    struct SubNodeData final : specter::IMenuNode {
      Class m_cls;
      std::string m_text;
      specter::Icon& m_icon;
      zeus::CColor m_color;
      const std::string* text() const override { return &m_text; }
      void activated(const boo::SWindowCoord& coord) override {}

      SubNodeData(Class cls, const char* text, specter::Icon& icon, const zeus::CColor& color)
      : m_cls(cls), m_text(text), m_icon(icon), m_color(color) {}
    };
    static std::vector<SubNodeData> s_subNodeDats;

    struct SubNode final : specter::IMenuNode {
      Space& m_space;
      const SubNodeData& m_data;
      const std::string* text() const override { return &m_data.m_text; }
      void activated(const boo::SWindowCoord& coord) override;

      SubNode(Space& space, const SubNodeData& data) : m_space(space), m_data(data) {}
    };
    std::vector<SubNode> m_subNodes;

    SpaceMenuNode(Space& space) {
      m_subNodes.reserve(s_subNodeDats.size());
      for (const SubNodeData& sn : s_subNodeDats)
        m_subNodes.emplace_back(space, sn);
    }

    static std::string s_text;
    const std::string* text() const override { return &s_text; }

    size_t subNodeCount() const override { return m_subNodes.size(); }
    IMenuNode* subNode(size_t idx) override { return &m_subNodes[idx]; }

    static void InitializeStrings(ViewManager& vm);
    static const std::string* LookupClassString(Class cls) {
      for (const SubNodeData& sn : s_subNodeDats)
        if (sn.m_cls == cls)
          return &sn.m_text;
      return nullptr;
    }
    static specter::Icon* LookupClassIcon(Class cls) {
      for (SubNodeData& sn : s_subNodeDats)
        if (sn.m_cls == cls)
          return &sn.m_icon;
      return nullptr;
    }
    static const zeus::CColor* LookupClassColor(Class cls) {
      for (SubNodeData& sn : s_subNodeDats)
        if (sn.m_cls == cls)
          return &sn.m_color;
      return nullptr;
    }
  } m_spaceMenuNode;

  struct SpaceSelectBind : specter::IButtonBinding {
    Space& m_space;
    std::string_view name(const specter::Control* control) const override { return SpaceMenuNode::s_text; }

    MenuStyle menuStyle(const specter::Button* button) const override { return MenuStyle::Primary; }
    std::unique_ptr<specter::View> buildMenu(const specter::Button* button) override;

    SpaceSelectBind(Space& space) : m_space(space) {}
  } m_spaceSelectBind;
  std::unique_ptr<specter::Button> m_spaceSelectButton;

protected:
  friend class ViewManager;
  friend class RootSpace;
  ViewManager& m_vm;
  Class m_class = Class::None;
  Space* m_parent;
  std::unique_ptr<specter::Space> m_spaceView;
  Space(ViewManager& vm, Class cls, Space* parent);

  /* Allows common Space code to access DNA-encoded state */
  virtual const Space::State& spaceState() const = 0;

  /* Structural control */
  virtual bool usesToolbar() const { return false; }
  virtual unsigned toolbarUnits() const { return 1; }
  virtual void buildToolbarView(specter::ViewResources& res, specter::Toolbar& tb) {}
  virtual specter::View* buildContentView(specter::ViewResources& res) = 0;
  virtual specter::View* buildSpaceView(specter::ViewResources& res);

public:
  virtual void saveState(athena::io::IStreamWriter& w) const;
  virtual void saveState(athena::io::YAMLDocWriter& w) const;
  virtual void reloadState() {}

  virtual void think() {}

  virtual Space* copy(Space* parent) const = 0;
  bool spaceSplitAllowed() const override { return true; }

  specter::ISplitSpaceController* spaceSplit(specter::SplitView::Axis axis, int thisSlot) override;
  virtual std::unique_ptr<Space> exchangeSpaceSplitJoin(Space* removeSpace, std::unique_ptr<Space>&& keepSpace) {
    return std::unique_ptr<Space>();
  }

  virtual specter::View* basisView() { return m_spaceView.get(); }
  Class cls() const { return m_class; }
  SplitSpace* castToSplitSpace();
};

class RootSpace : public Space {
  friend class ViewManager;
  std::unique_ptr<specter::RootView> m_rootView;
  std::unique_ptr<Space> m_spaceTree;

  struct State : Space::State{AT_DECL_DNA_YAMLV } m_state;
  const Space::State& spaceState() const override { return m_state; }

public:
  RootSpace(ViewManager& vm) : Space(vm, Class::RootSpace, nullptr) {}
  RootSpace(ViewManager& vm, ConfigReader& r) : RootSpace(vm) {
    m_state.read(r);
    if (auto rec = r.enterSubRecord("spaceTree"))
      m_spaceTree.reset(NewSpaceFromConfigStream(vm, this, r));
  }

  void think() override {
    if (m_spaceTree)
      m_spaceTree->think();
  }

  void saveState(athena::io::IStreamWriter& w) const override {
    w.writeUint32Big(atUint32(m_class));
    m_state.write(w);

    if (m_spaceTree)
      m_spaceTree->saveState(w);
    else
      w.writeUint32Big(0);
  }

  void saveState(athena::io::YAMLDocWriter& w) const override {
    w.writeUint32("class", atUint32(m_class));
    m_state.write(w);

    if (auto rec = w.enterSubRecord("spaceTree")) {
      if (m_spaceTree)
        m_spaceTree->saveState(w);
      else
        w.writeUint32("class", 0);
    }
  }

  void setChild(std::unique_ptr<Space>&& space) {
    m_spaceTree = std::move(space);
    m_spaceTree->m_parent = this;
  }

  Space* copy(Space* parent) const override { return nullptr; }
  bool spaceSplitAllowed() const override { return false; }

  specter::View* buildSpaceView(specter::ViewResources& res) override;
  specter::View* buildContentView(specter::ViewResources& res) override { return m_spaceTree->buildSpaceView(res); }

  std::unique_ptr<Space> exchangeSpaceSplitJoin(Space* removeSpace, std::unique_ptr<Space>&& keepSpace) override;

  specter::View* basisView() override;
};

class SplitSpace : public Space, public specter::ISplitSpaceController {
  friend class ViewManager;
  std::unique_ptr<Space> m_slots[2];
  std::unique_ptr<specter::SplitView> m_splitView;
  struct State : Space::State {
    AT_DECL_DNA_YAMLV
    Value<specter::SplitView::Axis> axis = specter::SplitView::Axis::Horizontal;
    Value<float> split = 0.5;
  } m_state;
  const Space::State& spaceState() const override { return m_state; }

public:
  SplitSpace(ViewManager& vm, Space* parent, specter::SplitView::Axis axis) : Space(vm, Class::SplitSpace, parent) {
    m_state.axis = axis;
    reloadState();
  }
  SplitSpace(ViewManager& vm, Space* parent, ConfigReader& r)
  : SplitSpace(vm, parent, specter::SplitView::Axis::Horizontal) {
    m_state.read(r);
    if (auto rec = r.enterSubRecord("slot0"))
      m_slots[0].reset(NewSpaceFromConfigStream(vm, this, r));
    if (auto rec = r.enterSubRecord("slot1"))
      m_slots[1].reset(NewSpaceFromConfigStream(vm, this, r));
    reloadState();
  }

  void reloadState() override {
    m_state.split = std::min(1.f, std::max(0.f, m_state.split));
    if (m_state.axis != specter::SplitView::Axis::Horizontal && m_state.axis != specter::SplitView::Axis::Vertical)
      m_state.axis = specter::SplitView::Axis::Horizontal;
    if (m_splitView) {
      m_splitView->setSplit(m_state.split);
      m_splitView->setAxis(m_state.axis);
    }
  }

  void think() override {
    if (m_slots[0])
      m_slots[0]->think();
    if (m_slots[1])
      m_slots[1]->think();
  }

  void saveState(athena::io::IStreamWriter& w) const override {
    w.writeUint32Big(atUint32(m_class));
    m_state.write(w);

    if (m_slots[0])
      m_slots[0]->saveState(w);
    else
      w.writeUint32Big(0);

    if (m_slots[1])
      m_slots[1]->saveState(w);
    else
      w.writeUint32Big(0);
  }

  void saveState(athena::io::YAMLDocWriter& w) const override {
    w.writeUint32("class", atUint32(m_class));
    m_state.write(w);

    if (auto rec = w.enterSubRecord("slot0")) {
      if (m_slots[0])
        m_slots[0]->saveState(w);
      else
        w.writeUint32("class", 0);
    }

    if (auto rec = w.enterSubRecord("slot1")) {
      if (m_slots[1])
        m_slots[1]->saveState(w);
      else
        w.writeUint32("class", 0);
    }
  }

  void setChildSlot(unsigned slot, std::unique_ptr<Space>&& space);

  specter::View* buildSpaceView(specter::ViewResources& res) override { return buildContentView(res); }
  specter::View* buildContentView(specter::ViewResources& res) override;

  Space* copy(Space* parent) const override { return nullptr; }
  bool spaceSplitAllowed() const override { return false; }

  ISpaceController* spaceJoin(int keepSlot) {
    if (m_parent) {
      ISpaceController* ret = m_slots[keepSlot].get();
      m_parent->exchangeSpaceSplitJoin(this, std::move(m_slots[keepSlot]));
      return ret;
    }
    return nullptr;
  }

  std::unique_ptr<Space> exchangeSpaceSplitJoin(Space* removeSpace, std::unique_ptr<Space>&& keepSpace) override;

  specter::SplitView* splitView() override { return m_splitView.get(); }
  void updateSplit(float split) override { m_state.split = split; }
  void joinViews(specter::SplitView* thisSplit, int thisSlot, specter::SplitView* otherSplit, int otherSlot) override;

  void setAxis(specter::SplitView::Axis axis) {
    m_state.axis = axis;
    reloadState();
  }

  specter::SplitView::Axis axis() const { return m_state.axis; }
  float split() const { return m_state.split; }

  specter::View* basisView() override { return m_splitView.get(); }
};
inline SplitSpace* Space::castToSplitSpace() {
  return cls() == Class::SplitSpace ? static_cast<SplitSpace*>(this) : nullptr;
}

class ViewerSpace : public Space {
public:
  ViewerSpace(ViewManager& vm, Class cls, Space* parent) : Space(vm, cls, parent) {}
};

class EditorSpace : public Space {
public:
  EditorSpace(ViewManager& vm, Class cls, Space* parent) : Space(vm, cls, parent) {}
};

class GameSpace : public Space {
public:
  GameSpace(ViewManager& vm, Class cls, Space* parent) : Space(vm, cls, parent) {}
};

class TestSpace : public Space {
  std::unique_ptr<specter::Button> m_button;
  std::unique_ptr<specter::MultiLineTextView> m_textView;

  std::string m_contentStr;
  std::string m_buttonStr;

  specter::IButtonBinding* m_binding;

public:
  TestSpace(ViewManager& vm, Space* parent, std::string_view content, std::string_view button,
            specter::IButtonBinding* binding)
  : Space(vm, Class::TestSpace, parent), m_contentStr(content), m_buttonStr(button), m_binding(binding) {}

  struct State : Space::State{AT_DECL_DNA_YAMLV} m_state;
  const Space::State& spaceState() const override { return m_state; }

  bool usesToolbar() const override { return true; }
  void buildToolbarView(specter::ViewResources& res, specter::Toolbar& tb) override {
    m_button.reset(new specter::Button(res, tb, m_binding, m_buttonStr));
    tb.push_back(m_button.get(), 0);
  }

  specter::View* buildContentView(specter::ViewResources& res) override {
    m_textView.reset(new specter::MultiLineTextView(res, *m_spaceView, res.m_heading14));
    m_textView->setBackground(res.themeData().viewportBackground());
    m_textView->typesetGlyphs(m_contentStr, res.themeData().uiText());
    return m_textView.get();
  }
};

} // namespace metaforce