ui_event.h

Go to the documentation of this file.

 
#pragma once
 
#include <climits>
#include <filesystem>
 
#include <rex/input_keys.h>
#include <rex/types.h>
 
namespace rex::ui {

class UIEvent {
 public:
  enum class Type : u8 {
    kOpened,        
    kDPIChanged,    
    kMonitorUpdate, 
    kMinimized,     
    kRestored,      
    kClosing,       
    kFileDrop,      
    kResize,        
    kClose,         
    kFocus,         
    kTouch,         
  };
 
  explicit UIEvent(Type type) : type_(type) {}
 
  virtual ~UIEvent() = default;
 
  Type GetType() const { return type_; }

  template <typename T>
  const T* As() const {
    return T::Carries(type_) ? static_cast<const T*>(this) : nullptr;
  }
 
 private:
  Type type_;
};

class UISetupEvent : public UIEvent {
 public:
  UISetupEvent(Type type, bool is_initial_setup = false)
      : UIEvent(type), is_initial_setup_(is_initial_setup) {}

  static constexpr bool Carries(Type type) {
    return type == Type::kOpened || type == Type::kDPIChanged || type == Type::kResize ||
           type == Type::kFocus || type == Type::kMonitorUpdate;
  }
 
  bool IsInitialSetup() const { return is_initial_setup_; }
 
 private:
  bool is_initial_setup_;
};
 
class MonitorUpdateEvent : public UISetupEvent {
 public:
  MonitorUpdateEvent(bool old_monitor_potentially_disconnected, bool is_initial_setup = false)
      : UISetupEvent(Type::kMonitorUpdate, is_initial_setup),
        old_monitor_potentially_disconnected_(old_monitor_potentially_disconnected) {}

  static constexpr bool Carries(Type type) { return type == Type::kMonitorUpdate; }
 
  bool IsOldMonitorPotentiallyDisconnected() const { return old_monitor_potentially_disconnected_; }
 
 private:
  bool old_monitor_potentially_disconnected_;
};
 
class FileDropEvent : public UIEvent {
 public:
  FileDropEvent(std::filesystem::path filename)
      : UIEvent(Type::kFileDrop), filename_(std::move(filename)) {}

  static constexpr bool Carries(Type type) { return type == Type::kFileDrop; }

  const std::filesystem::path& GetFilename() const { return filename_; }
 
 private:
  const std::filesystem::path filename_;
};
 
class TouchEvent : public UIEvent {
 public:
  enum class Action : u8 {
    kDown,
    kUp,
    kCancel, 
    kMove,
  };

  static constexpr u32 kPointerIDNone = UINT32_MAX;

  TouchEvent(Type type, u32 pointer_id, Action action, f32 x, f32 y)
      : UIEvent(type), pointer_id_(pointer_id), action_(action), x_(x), y_(y) {}

  static constexpr bool Carries(Type type) { return type == Type::kTouch; }

  bool IsHandled() const { return handled_; }

  void SetHandled(bool value) { handled_ = value; }
 
  u32 GetPointerID() const { return pointer_id_; }
 
  Action GetAction() const { return action_; }
 
  f32 GetX() const { return x_; }
 
  f32 GetY() const { return y_; }
 
 private:
  bool handled_ = false;
  u32 pointer_id_;
  Action action_;
  f32 x_;
  f32 y_;
};

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

  virtual void OnUIEvent(const ui::UIEvent& event) = 0;

  virtual void OnInputEvent(InputEvent& event) = 0;
};
 
}  // namespace rex::ui