ui_system.h

Go to the documentation of this file.

 
#pragma once
 
#include <filesystem>
#include <memory>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
#include <rex/platform.h>
#include <rex/input_keys.h>
#include <rex/module.h>
#include <rex/ui/dialog.h>
#include <rex/platform/native_window.h>
#include <rex/ui/window.h>
#include <rex/ui/ui_event.h>
#include <rex/utility.h>
#include <rex/result.h>
#include <rex/setting.h>
#include <rex/settings_registry.h>
#include <rex/title.h>
#include <rex/types.h>
#include <rex/overlay_renderer.h>
 
struct ImGuiIO;
 
namespace rex::ui {

class IDialog {
 public:
  virtual ~IDialog() = default;

  virtual bool Draw(ImGuiIO& io) = 0;

  virtual void OnClose() = 0;

  virtual bool NeedsContinuousPaint() const = 0;

  virtual bool WantsExclusiveInput() const = 0;
 
  virtual void OnShow() = 0;

  virtual bool OnToggle() = 0;
};

class DialogBase : public IDialog {
 public:
  void OnClose() override {}
 
  bool NeedsContinuousPaint() const override { return true; }
 
  bool WantsExclusiveInput() const override { return false; }
 
  void OnShow() override {}
 
  bool OnToggle() override { return false; }
};
 
}  // namespace rex::ui
 
struct ImDrawData;
struct ImFontAtlas;
struct ImGuiIO;
struct ImGuiStyle;
 
namespace rex::ui {
 
class IUISystem;
struct Style;

struct OverlayConfig {
  std::string_view name; 
  KeyChord default_key;  
  std::unique_ptr<ui::IDialog> (*create)(IUISystem& ui);
};
 
class REX_UI_API UISettings final : public SettingOwner {
 public:
  UISettings();
 
  REX_SETTING(std::string, driver, "sdl3",
              "UI driver, none for headless in an app that does not require a UI", kStartupOnly);
  REX_SETTING(std::string, title, "", "Window title, the app name when empty");
  REX_SETTING(i32, window_width, 0, "Window width, 0 for the video mode width", Range{0, 16384});
  REX_SETTING(i32, window_height, 0, "Window height, 0 for the video mode height", Range{0, 16384});
  REX_SETTING(bool, fullscreen, true, "Fullscreen");
  REX_SETTING(bool, fullscreen_exclusive, false, "Exclusive fullscreen");
  REX_SETTING(i32, monitor, 0, "Display to open on", Range{0, 16});
  REX_SETTING(i32, min_width, 0, "Smallest window width", Range{0, 16384});
  REX_SETTING(i32, min_height, 0, "Smallest window height", Range{0, 16384});
  REX_SETTING(std::string, aspect_ratio, "stretch", "Window shape",
              Allowed("stretch", "4:3", "5:4", "3:2", "16:10", "16:9", "21:9", "32:9"));
  REX_SETTING(std::string, resolution, "",
              "Video mode preset or WxH, empty to use the ui.video_mode_* settings");
  REX_SETTING(i32, video_mode_width, 1280, "Video mode width the title sees", Range{640, 4095},
              kRestart);
  REX_SETTING(i32, video_mode_height, 720, "Video mode height the title sees", Range{480, 4095},
              kRestart);
  REX_SETTING(f64, video_mode_refresh_rate, 60.0, "Refresh rate the title sees", Range{24.0, 240.0},
              kRestart);
  REX_SETTING(f64, cursor_timeout, 0.0, "Seconds before an idle cursor hides, 0 never hides",
              Range{0.0, 3600.0});
};

REX_DECLARE_INTERFACE(IUISystem, 2)
  virtual UISettings& GetSettings() = 0;

  virtual bool IsHeadless() const = 0;

  virtual bool HasWindow() const = 0;

  virtual bool IsFocused() const = 0;

  virtual VideoMode GetVideoMode() const = 0;

  [[nodiscard]] virtual Result<NativeWindow> GetNativeWindow() const = 0;
 
  virtual void RaiseWindow() = 0;

  virtual bool IsUIThread() const = 0;

  virtual void PostTask(MoveOnlyFunction<void()> fn) = 0;

  [[nodiscard]] virtual bool RunSynchronous(MoveOnlyFunction<void()> fn) = 0;

  [[nodiscard]] virtual ScopeGuard AddEventListener(IUIEventListener& listener) = 0;

  virtual ImFontAtlas& GetFonts() = 0;

  virtual ImGuiStyle& GetImGuiStyle() = 0;

  virtual ImGuiIO& GetImGuiIO() = 0;

  virtual ui::Style& GetStyle() = 0;

  [[nodiscard]] virtual Result<void> AddOverlays(std::span<const OverlayConfig> overlays) = 0;
 
  virtual void ShowOverlay(std::string_view name, bool visible) = 0;
 
  virtual void ToggleOverlay(std::string_view name) = 0;

  [[nodiscard]] virtual Result<ui::IDialog*> GetOverlay(std::string_view name) = 0;

  virtual bool IsAnyOverlayVisible() const = 0;

  [[nodiscard]] virtual ScopeGuard AddDialog(ui::IDialog& dialog) = 0;

  virtual void AddDialog(std::unique_ptr<ui::IDialog> dialog) = 0;

  virtual bool HasDialogs() const = 0;

  virtual void DrawOverlays(IOverlayRenderer& renderer) = 0;

  virtual void ShowMessage(MessageType type, std::string_view heading, std::string_view body) = 0;

  [[nodiscard]] virtual Result<u32> ShowChoice(const ui::ChoiceConfig& config) = 0;

  [[nodiscard]] virtual Result<std::vector<std::filesystem::path>> ShowFileDialog(
      const ui::FileDialogConfig& config) = 0;

  virtual void ShowPrompt(ui::PromptConfig config,
                          MoveOnlyFunction<void(ui::PromptResult)> done) = 0;

  virtual void CancelPrompts() = 0;

  virtual std::vector<ui::Monitor> GetDisplays() = 0;

  virtual std::vector<ui::HostLocale> GetPreferredLocales() = 0;
};
 
}  // namespace rex::ui