Class: Deftones::Draw

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Defined in:
lib/deftones/draw.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Draw

Returns a new instance of Draw.



22
23
24
25
 
# File 'lib/deftones/draw.rb', line 22

def initialize
  @timeline = {}
  @next_id = 0
end

Class Method Details

.instance ⇒ Object 



12
13
14
 
# File 'lib/deftones/draw.rb', line 12

def instance
  @instance ||= new
end

.reset! ⇒ Object 



16
17
18
19
 
# File 'lib/deftones/draw.rb', line 16

def reset!
  @instance = nil
  self
end

Instance Method Details

#advance_to(time) ⇒ Object 



58
59
60
61
 
# File 'lib/deftones/draw.rb', line 58

def advance_to(time)
  flush_until(time)
  self
end

#cancel(after_time = 0, event_id: nil) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/deftones/draw.rb', line 35

def cancel(after_time = 0, event_id: nil)
  if event_id.nil? && after_time.is_a?(Integer) && @timeline.key?(after_time)
    return @timeline.delete(after_time)
  end

  return @timeline.delete(event_id) if event_id

  threshold = resolve_time(after_time)
  @timeline.delete_if { |_id, event| event[:time] >= threshold }
  self
end

#dispose ⇒ Object 



47
48
49
50
51
 
# File 'lib/deftones/draw.rb', line 47

def dispose
  @timeline.clear
  @next_id = 0
  self
end

#due_events(limit) ⇒ Object (private) 



79
80
81
82
 
# File 'lib/deftones/draw.rb', line 79

def due_events(limit)
  events = @timeline.values.select { |event| event[:time] <= limit }
  events.sort_by { |event| event[:time] }
end

#flush_until(time) ⇒ Object (private) 



84
85
86
87
88
89
90
 
# File 'lib/deftones/draw.rb', line 84

def flush_until(time)
  limit = resolve_time(time)
  due_events(limit).each do |event|
    invoke(event[:callback], event[:time])
  end
  @timeline.delete_if { |_id, event| event[:time] <= limit }
end

#invoke(callback, time) ⇒ Object (private) 



92
93
94
 
# File 'lib/deftones/draw.rb', line 92

def invoke(callback, time)
  callback.arity.zero? ? callback.call : callback.call(time)
end

#prepare_render(duration) ⇒ Object 



53
54
55
56
 
# File 'lib/deftones/draw.rb', line 53

def prepare_render(duration)
  flush_until(duration)
  self
end

#resolve_schedule_arguments(callback_or_time, maybe_time, block) ⇒ Object (private) 



65
66
67
68
69
70
71
72
73
 
# File 'lib/deftones/draw.rb', line 65

def resolve_schedule_arguments(callback_or_time, maybe_time, block)
  if callback_or_time.respond_to?(:call)
    [callback_or_time, maybe_time]
  else
    [block, callback_or_time]
  end.tap do |callback, _time|
    raise ArgumentError, "callback is required" unless callback
  end
end

#resolve_time(value) ⇒ Object (private) 



75
76
77
 
# File 'lib/deftones/draw.rb', line 75

def resolve_time(value)
  Deftones::Music::Time.parse(value || 0)
end

#schedule(callback_or_time = nil, maybe_time = nil, &block) ⇒ Object 



27
28
29
30
31
32
33
 
# File 'lib/deftones/draw.rb', line 27

def schedule(callback_or_time = nil, maybe_time = nil, &block)
  callback, time = resolve_schedule_arguments(callback_or_time, maybe_time, block)
  event_id = @next_id
  @timeline[event_id] = { time: resolve_time(time), callback: callback }
  @next_id += 1
  event_id
end