class SDL2::Event

Object oriented representation of SDL_Event union

## Event Enumerations/Constants:

Sub-Structures

Union Layout

Public Class Methods

add(*events) click to toggle source

Add a bunch of events, expects them as arguments so make sure you add that astrik/star: ‘SDL2::Event.add(*array)`

# File lib/sdl2/event.rb, line 164
def self.add(*events)
  self.peep(events, nil, :ADD, f, l)
end
cast(something) click to toggle source

Coerce some value into an Event

# File lib/sdl2/event.rb, line 187
def self.cast(something)
  SDL2::Debug.log(self){"Casting Something: #{something.inspect}"}
  if something.kind_of? Abstract
    return something.to_event
  elsif something.kind_of? Hash
    raise "Must have type : #{something.inspect}" unless something.has_key? :type
    tmp = self.new
    fields = members & something.keys
    SDL2::Debug.log(self){"Using fields: #{fields.inspect}"}
    fields.each do |field|
      if tmp[field].kind_of? Struct and something[field].kind_of? Hash
        tmp[field].update_members(something[field])
      else
        tmp[field] = something[field]
      end
    end
    return tmp
  else
    raise "Is not an Abstract!: #{something.inspect}"
  end
end
filter(user_data = nil, &event_filter) click to toggle source

Use this function to filter events on current event Que removing any events for which this filter returns 0 (Zero) If called without arguments, it will check and return any currently defined global filters and associated user data as: [filter, data]

# File lib/sdl2/event.rb, line 100
def self.filter(user_data = nil, &event_filter)
  if event_filter
    SDL2.filter_events(event_filter, user_data)
  else
    event_filter = SDL2::TypedPointer::EventFilter.new
    user_data = SDL2::TypedPointer::Pointer.new
    if SDL2.get_event_filter?(event_filter, user_data)
      [event_filter.value, user_data.value]
    else
      false
    end
  end
end
filter=(filter_lambda, user_data_pointer = nil) click to toggle source

This routine sets the global event filter, it expects either a single lambda parameter or an array with or paired with a user_data_pointer

# File lib/sdl2/event.rb, line 117
def self.filter=(filter_lambda, user_data_pointer = nil)
  SDL2.set_event_filter(filter_lambda, user_data_pointer)    
end
flush(type, type_end = nil) click to toggle source

Flush this kind of event (or this range of event types) from the que

# File lib/sdl2/event.rb, line 131
def self.flush(type, type_end = nil)
  unless type_end
    SDL2.flush_event(type)
  else
    SDL2.flush_events(type, type_end)
  end
end
get(count = 10, f = :FIRSTEVENT, l = :LASTEVENT) click to toggle source

Get a bunch of events, defaults to 10 at once

# File lib/sdl2/event.rb, line 169
def self.get(count = 10, f = :FIRSTEVENT, l = :LASTEVENT)
  self.peep(nil, count, :GET, f, l)
end
has?(type, type_end = nil) click to toggle source

Check if this event type, or a range of event types exist

# File lib/sdl2/event.rb, line 122
def self.has?(type, type_end = nil)
  unless type_end
    SDL2.has_event?(type)
  else
    SDL2.has_events?(type, type_end)
  end
end
peek(count = 10, f = :FIRSTEVENT, l = :LASTEVENT) click to toggle source

Peek at events, default maximum to return at once is 10

# File lib/sdl2/event.rb, line 158
def self.peek(count = 10, f = :FIRSTEVENT, l = :LASTEVENT)
  self.peep(nil, count, :PEEK, f, l)
end
peep(events = nil, num_events = nil, action = :PEEK, first_event = :FIRSTEVENT, last_event = :LASTEVENT) click to toggle source

General Utility for Peek/Get/Del/Add many events

# File lib/sdl2/event.rb, line 146
def self.peep(events = nil, num_events = nil, action = :PEEK, first_event = :FIRSTEVENT, last_event = :LASTEVENT)
  if events.is_a?(Array)
    events = SDL2::StructArray.clone_from(events, SDL2::Event)
  end
  num_events ||= events.try(:count)
  raise 'num_events must be specified unless events responds to count' if num_events.nil?
  events ||= SDL2::StructArray.new(SDL2::Event, num_events) unless num_events == 0     
  returned = SDL2.peep_events!(events.nil? ? nil : events.first, num_events, action, first_event, last_event)
  events.nil? ? Array.new(returned, nil) : events.first(returned)      
end
poll() click to toggle source

Polls for currently pending events. @returns SDL2::Event or nil if there are no events.

# File lib/sdl2/event.rb, line 86
def self.poll()
  tmp_event = SDL2::Event.new
  unless SDL2.poll_event?(tmp_event)
    tmp_event.pointer.free
    tmp_event = nil
  end
  return tmp_event # May be nil if SDL2.poll_event fails.
end
pump() click to toggle source

Pump the events.

# File lib/sdl2/event.rb, line 174
def self.pump
  SDL2.pump_events()
end
push(event) click to toggle source

Add an event to the que

# File lib/sdl2/event.rb, line 140
def self.push(event)
  event = Event.cast(event) unless event.kind_of? Event
  SDL2.push_event!(event)
end
quit_requested?() click to toggle source

Indicates if a Quit event is waiting in the que.

# File lib/sdl2/event.rb, line 179
def self.quit_requested?
  self.pump()
  # Peek into the event que and return the count of quit events.
  # Return true if that is greater than zero.
  self.peep(nil,0,:PEEK,:QUIT,:QUIT).count > 0
end
state(type,state=:QUERY) click to toggle source

Set the state of processing event types:

# File lib/sdl2/event.rb, line 80
def self.state(type,state=:QUERY)
  SDL2.event_state(type,state)
end

Public Instance Methods

==(other) click to toggle source
Calls superclass method
# File lib/sdl2/event.rb, line 209
def ==(other)
  if other.kind_of?(Hash)
    # False if there are fields that do not exist
    return false unless (other.keys - members).empty?

    (other.keys & members).each do |field|
      return false unless self[field] == other[field]
    end

    return true #if we get this far

  else

    return super(other)

  end
end