class SFML::Event

A window event. Holds a type symbol and a Hash of type-specific data. Pattern-match it directly; that’s the intended interface:

case event in {type: :closed} then … in {type: :key_pressed, code: :escape} then … in {type: :resized, size:} then … in {type: :mouse_moved, position: {x:, y:}} then … in {type: :mouse_wheel_scrolled, delta:} then … end

Type-specific fields are also reachable as plain methods (event.code, event.position) for the cases when pattern matching is overkill.

Constants

EMPTY: Frozen empty Hash — shared default for missing event payloads.
MOUSE_BUTTONS: Order matches sfMouseButton in CSFML 3: left, right, middle, extra1, extra2. (CSFML 2 called the last two x_button1/x_button2, but SFML 3 dropped the X-button terminology.)
MOUSE_WHEELS: Mouse wheel axes — :vertical / :horizontal.

Attributes

data [R]

The type, data components.

type [R]

The type, data components.

Public Class Methods

decode (type_sym, ptr)

Source

# File lib/sfml/window/event.rb, line 74
def self.decode(type_sym, ptr)
  case type_sym
  when :closed, :focus_lost, :focus_gained,
       :mouse_entered, :mouse_left
    EMPTY

  when :resized
    s = C::Window::SizeEvent.new(ptr)
    { size: Vector2.new(s[:size][:x], s[:size][:y]) }

  when :key_pressed, :key_released
    k = C::Window::KeyEvent.new(ptr)
    {
      code:    Keyboard.code_to_symbol(k[:code]),
      alt:     k[:alt],
      control: k[:control],
      shift:   k[:shift],
      system:  k[:system],
    }

  when :text_entered
    t = C::Window::TextEvent.new(ptr)
    { unicode: t[:unicode], char: [t[:unicode]].pack("U*") }

  when :mouse_moved
    m = C::Window::MouseMoveEvent.new(ptr)
    { position: Vector2.new(m[:position][:x], m[:position][:y]) }

  when :mouse_moved_raw
    m = C::Window::MouseMoveEvent.new(ptr)
    # Raw event re-uses the same struct shape but the field is a delta.
    { delta: Vector2.new(m[:position][:x], m[:position][:y]) }

  when :mouse_button_pressed, :mouse_button_released
    b = C::Window::MouseButtonEvent.new(ptr)
    {
      button:   MOUSE_BUTTONS[b[:button]] || :unknown,
      position: Vector2.new(b[:position][:x], b[:position][:y]),
    }

  when :mouse_wheel_scrolled
    w = C::Window::MouseWheelScrollEvent.new(ptr)
    {
      wheel:    MOUSE_WHEELS[w[:wheel]] || :unknown,
      delta:    w[:delta],
      position: Vector2.new(w[:position][:x], w[:position][:y]),
    }

  when :joystick_button_pressed, :joystick_button_released
    b = C::Window::JoystickButtonEvent.new(ptr)
    { joystick_id: b[:joystick_id], button: b[:button] }

  when :joystick_moved
    m = C::Window::JoystickMoveEvent.new(ptr)
    {
      joystick_id: m[:joystick_id],
      axis:        Joystick::AXES[m[:axis]] || :unknown,
      position:    m[:position],
    }

  when :joystick_connected, :joystick_disconnected
    c = C::Window::JoystickConnectEvent.new(ptr)
    { joystick_id: c[:joystick_id] }

  when :touch_began, :touch_moved, :touch_ended
    t = C::Window::TouchEvent.new(ptr)
    {
      finger:   t[:finger],
      position: Vector2.new(t[:position][:x], t[:position][:y]),
    }

  when :sensor_changed
    s = C::Window::SensorEvent.new(ptr)
    {
      sensor: Sensor::TYPES[s[:sensor]] || :unknown,
      value:  Vector3.new(s[:value][:x], s[:value][:y], s[:value][:z]),
    }

  else
    EMPTY
  end
end

Returns the self.

from_native (buffer)

Source

# File lib/sfml/window/event.rb, line 65
def self.from_native(buffer)
  type_index = buffer[:type]
  type_sym   = C::Window::EVENT_TYPES[type_index] || :unknown

  data = decode(type_sym, buffer.to_ptr)
  new(type_sym, data)
end

Reads the sfEvent union buffer, decodes the discriminator, and reads the type-specific variant. CSFML lays each variant out with the sfEventType as the first field, so we can re-interpret the same memory as the right struct.

new (type, data = {})

Source

# File lib/sfml/window/event.rb, line 27
def initialize(type, data = {})
  @type = type
  @data = data.freeze
  freeze
end

Build directly (rare — Event.from_native is the usual path).

Public Instance Methods

[] (key)

Source

# File lib/sfml/window/event.rb, line 34
  def [](key)        = @data[key]
  # Hash-style fetch with the standard fallback / block behaviour.
  def fetch(*args, &) = @data.fetch(*args, &)

  # Pattern-match hook — flattens `{type:, ...payload}` into one
  # hash so callers can write `in {type: :key_pressed, code:}`.
  def deconstruct_keys(_keys)
    { type: @type, **@data }
  end

  # `respond_to?` answer for payload keys — keeps `#method_missing`
  # safe under introspection.
  def respond_to_missing?(name, _private = false)
    @data.key?(name) || super
  end

  # Payload keys are exposed as method calls so `event.code` works
  # alongside `event[:code]`.
  def method_missing(name, *args)
    return @data[name] if args.empty? && @data.key?(name)
    super
  end

  # String representation for debugging.
  def to_s = "#<SFML::Event #{@type} #{@data.inspect}>"
  alias inspect to_s

  # Reads the sfEvent union buffer, decodes the discriminator, and reads
  # the type-specific variant. CSFML lays each variant out with the
  # sfEventType as the first field, so we can re-interpret the same memory
  # as the right struct.
  def self.from_native(buffer)
    type_index = buffer[:type]
    type_sym   = C::Window::EVENT_TYPES[type_index] || :unknown

    data = decode(type_sym, buffer.to_ptr)
    new(type_sym, data)
  end

  # Returns the self.
  def self.decode(type_sym, ptr)
    case type_sym
    when :closed, :focus_lost, :focus_gained,
         :mouse_entered, :mouse_left
      EMPTY

    when :resized
      s = C::Window::SizeEvent.new(ptr)
      { size: Vector2.new(s[:size][:x], s[:size][:y]) }

    when :key_pressed, :key_released
      k = C::Window::KeyEvent.new(ptr)
      {
        code:    Keyboard.code_to_symbol(k[:code]),
        alt:     k[:alt],
        control: k[:control],
        shift:   k[:shift],
        system:  k[:system],
      }

    when :text_entered
      t = C::Window::TextEvent.new(ptr)
      { unicode: t[:unicode], char: [t[:unicode]].pack("U*") }

    when :mouse_moved
      m = C::Window::MouseMoveEvent.new(ptr)
      { position: Vector2.new(m[:position][:x], m[:position][:y]) }

    when :mouse_moved_raw
      m = C::Window::MouseMoveEvent.new(ptr)
      # Raw event re-uses the same struct shape but the field is a delta.
      { delta: Vector2.new(m[:position][:x], m[:position][:y]) }

    when :mouse_button_pressed, :mouse_button_released
      b = C::Window::MouseButtonEvent.new(ptr)
      {
        button:   MOUSE_BUTTONS[b[:button]] || :unknown,
        position: Vector2.new(b[:position][:x], b[:position][:y]),
      }

    when :mouse_wheel_scrolled
      w = C::Window::MouseWheelScrollEvent.new(ptr)
      {
        wheel:    MOUSE_WHEELS[w[:wheel]] || :unknown,
        delta:    w[:delta],
        position: Vector2.new(w[:position][:x], w[:position][:y]),
      }

    when :joystick_button_pressed, :joystick_button_released
      b = C::Window::JoystickButtonEvent.new(ptr)
      { joystick_id: b[:joystick_id], button: b[:button] }

    when :joystick_moved
      m = C::Window::JoystickMoveEvent.new(ptr)
      {
        joystick_id: m[:joystick_id],
        axis:        Joystick::AXES[m[:axis]] || :unknown,
        position:    m[:position],
      }

    when :joystick_connected, :joystick_disconnected
      c = C::Window::JoystickConnectEvent.new(ptr)
      { joystick_id: c[:joystick_id] }

    when :touch_began, :touch_moved, :touch_ended
      t = C::Window::TouchEvent.new(ptr)
      {
        finger:   t[:finger],
        position: Vector2.new(t[:position][:x], t[:position][:y]),
      }

    when :sensor_changed
      s = C::Window::SensorEvent.new(ptr)
      {
        sensor: Sensor::TYPES[s[:sensor]] || :unknown,
        value:  Vector3.new(s[:value][:x], s[:value][:y], s[:value][:z]),
      }

    else
      EMPTY
    end
  end

  # Frozen empty Hash — shared default for missing event payloads.
  EMPTY = {}.freeze
  private_constant :EMPTY
end

Hash-style lookup into the event payload.

deconstruct_keys (_keys)

Source

# File lib/sfml/window/event.rb, line 40
def deconstruct_keys(_keys)
  { type: @type, **@data }
end

Pattern-match hook — flattens {type:, ...payload} into one hash so callers can write in {type: :key_pressed, code:}.

fetch (*args, &)

Source

# File lib/sfml/window/event.rb, line 36
    def fetch(*args, &) = @data.fetch(*args, &)

    # Pattern-match hook — flattens `{type:, ...payload}` into one
    # hash so callers can write `in {type: :key_pressed, code:}`.
    def deconstruct_keys(_keys)
      { type: @type, **@data }
    end

    # `respond_to?` answer for payload keys — keeps `#method_missing`
    # safe under introspection.
    def respond_to_missing?(name, _private = false)
      @data.key?(name) || super
    end

    # Payload keys are exposed as method calls so `event.code` works
    # alongside `event[:code]`.
    def method_missing(name, *args)
      return @data[name] if args.empty? && @data.key?(name)
      super
    end

    # String representation for debugging.
    def to_s = "#<SFML::Event #{@type} #{@data.inspect}>"
    alias inspect to_s

    # Reads the sfEvent union buffer, decodes the discriminator, and reads
    # the type-specific variant. CSFML lays each variant out with the
    # sfEventType as the first field, so we can re-interpret the same memory
    # as the right struct.
    def self.from_native(buffer)
      type_index = buffer[:type]
      type_sym   = C::Window::EVENT_TYPES[type_index] || :unknown

      data = decode(type_sym, buffer.to_ptr)
      new(type_sym, data)
    end

    # Returns the self.
    def self.decode(type_sym, ptr)
      case type_sym
      when :closed, :focus_lost, :focus_gained,
           :mouse_entered, :mouse_left
        EMPTY

      when :resized
        s = C::Window::SizeEvent.new(ptr)
        { size: Vector2.new(s[:size][:x], s[:size][:y]) }

      when :key_pressed, :key_released
        k = C::Window::KeyEvent.new(ptr)
        {
          code:    Keyboard.code_to_symbol(k[:code]),
          alt:     k[:alt],
          control: k[:control],
          shift:   k[:shift],
          system:  k[:system],
        }

      when :text_entered
        t = C::Window::TextEvent.new(ptr)
        { unicode: t[:unicode], char: [t[:unicode]].pack("U*") }

      when :mouse_moved
        m = C::Window::MouseMoveEvent.new(ptr)
        { position: Vector2.new(m[:position][:x], m[:position][:y]) }

      when :mouse_moved_raw
        m = C::Window::MouseMoveEvent.new(ptr)
        # Raw event re-uses the same struct shape but the field is a delta.
        { delta: Vector2.new(m[:position][:x], m[:position][:y]) }

      when :mouse_button_pressed, :mouse_button_released
        b = C::Window::MouseButtonEvent.new(ptr)
        {
          button:   MOUSE_BUTTONS[b[:button]] || :unknown,
          position: Vector2.new(b[:position][:x], b[:position][:y]),
        }

      when :mouse_wheel_scrolled
        w = C::Window::MouseWheelScrollEvent.new(ptr)
        {
          wheel:    MOUSE_WHEELS[w[:wheel]] || :unknown,
          delta:    w[:delta],
          position: Vector2.new(w[:position][:x], w[:position][:y]),
        }

      when :joystick_button_pressed, :joystick_button_released
        b = C::Window::JoystickButtonEvent.new(ptr)
        { joystick_id: b[:joystick_id], button: b[:button] }

      when :joystick_moved
        m = C::Window::JoystickMoveEvent.new(ptr)
        {
          joystick_id: m[:joystick_id],
          axis:        Joystick::AXES[m[:axis]] || :unknown,
          position:    m[:position],
        }

      when :joystick_connected, :joystick_disconnected
        c = C::Window::JoystickConnectEvent.new(ptr)
        { joystick_id: c[:joystick_id] }

      when :touch_began, :touch_moved, :touch_ended
        t = C::Window::TouchEvent.new(ptr)
        {
          finger:   t[:finger],
          position: Vector2.new(t[:position][:x], t[:position][:y]),
        }

      when :sensor_changed
        s = C::Window::SensorEvent.new(ptr)
        {
          sensor: Sensor::TYPES[s[:sensor]] || :unknown,
          value:  Vector3.new(s[:value][:x], s[:value][:y], s[:value][:z]),
        }

      else
        EMPTY
      end
    end

    # Frozen empty Hash — shared default for missing event payloads.
    EMPTY = {}.freeze
    private_constant :EMPTY
  end
end

Hash-style fetch with the standard fallback / block behaviour.

method_missing (name, *args)

Source

# File lib/sfml/window/event.rb, line 52
def method_missing(name, *args)
  return @data[name] if args.empty? && @data.key?(name)
  super
end

Payload keys are exposed as method calls so event.code works alongside event[:code].

Calls superclass method

respond_to_missing? (name, _private = false)

Source

# File lib/sfml/window/event.rb, line 46
def respond_to_missing?(name, _private = false)
  @data.key?(name) || super
end

respond_to? answer for payload keys — keeps method_missing safe under introspection.

Calls superclass method

to_s (= "

Source

# File lib/sfml/window/event.rb, line 58
  def to_s = "#<SFML::Event #{@type} #{@data.inspect}>"
  alias inspect to_s

  # Reads the sfEvent union buffer, decodes the discriminator, and reads
  # the type-specific variant. CSFML lays each variant out with the
  # sfEventType as the first field, so we can re-interpret the same memory
  # as the right struct.
  def self.from_native(buffer)
    type_index = buffer[:type]
    type_sym   = C::Window::EVENT_TYPES[type_index] || :unknown

    data = decode(type_sym, buffer.to_ptr)
    new(type_sym, data)
  end

  # Returns the self.
  def self.decode(type_sym, ptr)
    case type_sym
    when :closed, :focus_lost, :focus_gained,
         :mouse_entered, :mouse_left
      EMPTY

    when :resized
      s = C::Window::SizeEvent.new(ptr)
      { size: Vector2.new(s[:size][:x], s[:size][:y]) }

    when :key_pressed, :key_released
      k = C::Window::KeyEvent.new(ptr)
      {
        code:    Keyboard.code_to_symbol(k[:code]),
        alt:     k[:alt],
        control: k[:control],
        shift:   k[:shift],
        system:  k[:system],
      }

    when :text_entered
      t = C::Window::TextEvent.new(ptr)
      { unicode: t[:unicode], char: [t[:unicode]].pack("U*") }

    when :mouse_moved
      m = C::Window::MouseMoveEvent.new(ptr)
      { position: Vector2.new(m[:position][:x], m[:position][:y]) }

    when :mouse_moved_raw
      m = C::Window::MouseMoveEvent.new(ptr)
      # Raw event re-uses the same struct shape but the field is a delta.
      { delta: Vector2.new(m[:position][:x], m[:position][:y]) }

    when :mouse_button_pressed, :mouse_button_released
      b = C::Window::MouseButtonEvent.new(ptr)
      {
        button:   MOUSE_BUTTONS[b[:button]] || :unknown,
        position: Vector2.new(b[:position][:x], b[:position][:y]),
      }

    when :mouse_wheel_scrolled
      w = C::Window::MouseWheelScrollEvent.new(ptr)
      {
        wheel:    MOUSE_WHEELS[w[:wheel]] || :unknown,
        delta:    w[:delta],
        position: Vector2.new(w[:position][:x], w[:position][:y]),
      }

    when :joystick_button_pressed, :joystick_button_released
      b = C::Window::JoystickButtonEvent.new(ptr)
      { joystick_id: b[:joystick_id], button: b[:button] }

    when :joystick_moved
      m = C::Window::JoystickMoveEvent.new(ptr)
      {
        joystick_id: m[:joystick_id],
        axis:        Joystick::AXES[m[:axis]] || :unknown,
        position:    m[:position],
      }

    when :joystick_connected, :joystick_disconnected
      c = C::Window::JoystickConnectEvent.new(ptr)
      { joystick_id: c[:joystick_id] }

    when :touch_began, :touch_moved, :touch_ended
      t = C::Window::TouchEvent.new(ptr)
      {
        finger:   t[:finger],
        position: Vector2.new(t[:position][:x], t[:position][:y]),
      }

    when :sensor_changed
      s = C::Window::SensorEvent.new(ptr)
      {
        sensor: Sensor::TYPES[s[:sensor]] || :unknown,
        value:  Vector3.new(s[:value][:x], s[:value][:y], s[:value][:z]),
      }

    else
      EMPTY
    end
  end

  # Frozen empty Hash — shared default for missing event payloads.
  EMPTY = {}.freeze
  private_constant :EMPTY
end

String representation for debugging.