window_events.hpp

/***
 *  @file window_events.hpp
 *  @author Xein
 *  @date 06 May 25
 *  @brief All the different events a window may have
 */
 
#pragma once
#include <toast/events/event.hpp>
 
namespace event {
 
constexpr int window_input_released = 0;
constexpr int window_input_pressed = 1;
constexpr int window_input_repeated = 2;
 
constexpr int window_input_device_disconnected = 0;
constexpr int window_input_device_connected = 1;

struct ExitApplication : Event<ExitApplication> { };

struct WindowClose : Event<WindowClose> {
  uint32_t window_id;
 
  explicit WindowClose(uint32_t window_id) : window_id(window_id) { }
};

struct WindowDrop : Event<WindowDrop> {
  std::vector<std::string> files;
 
  explicit WindowDrop(std::vector<std::string>&& input_files) : files(std::move(input_files)) { }
};

struct WindowKey : Event<WindowKey> {
  int key;         
  int scancode;    
  int action;      
  int mods;        
 
  WindowKey(int key, int scancode, int action, int mods) : key(key), scancode(scancode), action(action), mods(mods) { }
};

struct WindowChar : Event<WindowChar> {
  unsigned key;
 
  WindowChar(unsigned key) : key(key) { }
};

struct WindowMousePosition : Event<WindowMousePosition> {
  float x, y;
 
  WindowMousePosition(float x_pos, float y_pos) : x(x_pos), y(y_pos) { }
};

struct WindowMouseButton : Event<WindowMouseButton> {
  int button, action, mods;
 
  WindowMouseButton(int button, int action, int mods) : button(button), action(action), mods(mods) { }
};

struct WindowMouseScroll : Event<WindowMouseScroll> {
  float x, y;
 
  WindowMouseScroll(float x_offset, float y_offset) : x(x_offset), y(y_offset) { }
};

struct WindowResize : Event<WindowResize> {
  int width, height;
 
  WindowResize(int width, int height) : width(width), height(height) { }
};

struct WindowDisplayScale : Event<WindowDisplayScale> {
  float scale;
 
  explicit WindowDisplayScale(float scale) : scale(scale) { }
};
 
struct WindowMouseLock : Event<WindowMouseLock> {
  bool locked;
 
  explicit WindowMouseLock(bool locked) : locked(locked) { }
};

struct WindowFocus : Event<WindowFocus> {
  bool focused;
 
  explicit WindowFocus(bool focused) : focused(focused) { }
};
 
}