content_registry.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_REGISTRY_CONTENT_REGISTRY_H_
#define YAZE_APP_EDITOR_REGISTRY_CONTENT_REGISTRY_H_
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
#include "app/editor/system/session/project_workflow_status.h"
 
namespace yaze {
class Rom;
class EventBus;
 
namespace project {
struct YazeProject;
}  // namespace project
 
namespace zelda3 {
class GameData;
}  // namespace zelda3
 
namespace editor {
class WindowContent;
class Editor;
class GlobalEditorContext;
struct EditorDependencies;
 
namespace workflow {
class HackWorkflowBackend;
class ValidationCapability;
class ProgressionCapability;
class PlanningCapability;
}  // namespace workflow
 
namespace ContentRegistry {
 
namespace Context {
 
void SetGlobalContext(::yaze::editor::GlobalEditorContext* ctx);
 
Rom* rom();
 
void SetRom(Rom* rom);
 
::yaze::EventBus* event_bus();
 
void SetEventBus(::yaze::EventBus* bus);
 
Editor* current_editor();
 
void SetCurrentEditor(Editor* editor);
 
Editor* editor_window_context(const std::string& category);
void SetEditorWindowContext(const std::string& category, Editor* editor);
 
::yaze::zelda3::GameData* game_data();
 
void SetGameData(::yaze::zelda3::GameData* data);
 
::yaze::project::YazeProject* current_project();
 
void SetCurrentProject(::yaze::project::YazeProject* project);
 
workflow::HackWorkflowBackend* hack_workflow_backend();
workflow::ValidationCapability* hack_validation_backend();
workflow::ProgressionCapability* hack_progression_backend();
workflow::PlanningCapability* hack_planning_backend();
void SetHackWorkflowBackend(workflow::HackWorkflowBackend* backend);
 
ProjectWorkflowStatus build_workflow_status();
void SetBuildWorkflowStatus(const ProjectWorkflowStatus& status);
ProjectWorkflowStatus run_workflow_status();
void SetRunWorkflowStatus(const ProjectWorkflowStatus& status);
std::string build_workflow_log();
void SetBuildWorkflowLog(const std::string& output);
std::vector<ProjectWorkflowHistoryEntry> workflow_history();
void AppendWorkflowHistory(const ProjectWorkflowHistoryEntry& entry);
void ClearWorkflowHistory();
std::function<void()> start_build_workflow_callback();
void SetStartBuildWorkflowCallback(std::function<void()> callback);
std::function<void()> run_project_workflow_callback();
void SetRunProjectWorkflowCallback(std::function<void()> callback);
std::function<void()> show_workflow_output_callback();
void SetShowWorkflowOutputCallback(std::function<void()> callback);
std::function<void()> cancel_build_workflow_callback();
void SetCancelBuildWorkflowCallback(std::function<void()> callback);
 
void Clear();
}  // namespace Context
 
namespace Panels {
using PanelFactory = std::function<std::unique_ptr<WindowContent>()>;
 
void RegisterFactory(PanelFactory factory);
 
template <typename T>
void add() {
  RegisterFactory([]() { return std::make_unique<T>(); });
}
 
std::vector<std::unique_ptr<WindowContent>> CreateAll();
 
void Register(std::unique_ptr<WindowContent> panel);
 
std::vector<WindowContent*> GetAll();
 
WindowContent* Get(const std::string& id);
 
void Clear();
}  // namespace Panels
 
namespace WindowContents = Panels;
 
namespace Editors {
using EditorFactory =
    std::function<std::unique_ptr<Editor>(const EditorDependencies&)>;
 
void RegisterFactory(EditorFactory factory);
 
template <typename T>
void add() {
  RegisterFactory([](const EditorDependencies& deps) {
    auto editor = std::make_unique<T>();
    editor->SetDependencies(deps);
    return editor;
  });
}
 
std::vector<std::unique_ptr<Editor>> CreateAll(const EditorDependencies& deps);
}  // namespace Editors
 
namespace Shortcuts {
struct ShortcutDef {
  std::string id;
  std::string default_key;
  std::string description;
};
 
void Register(const ShortcutDef& shortcut);
void add(const std::string& id, const std::string& key,
         const std::string& desc);
std::vector<ShortcutDef> GetAll();
}  // namespace Shortcuts
 
namespace WorkflowActions {
struct ActionDef {
  std::string id;
  std::string group;
  std::string label;
  std::string description;
  std::string shortcut;
  int priority = 50;
  std::function<void()> callback;
  std::function<bool()> enabled;
};
 
void Register(const ActionDef& action);
std::vector<ActionDef> GetAll();
void Clear();
}  // namespace WorkflowActions
 
namespace Settings {
struct SettingDef {
  std::string key;
  std::string section;
  std::string default_value;  // serialized
  std::string description;
};
 
void Register(const SettingDef& setting);
void add(const std::string& section, const std::string& key,
         const std::string& default_val, const std::string& desc);
std::vector<SettingDef> GetAll();
}  // namespace Settings
 
}  // namespace ContentRegistry
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_REGISTRY_CONTENT_REGISTRY_H_