3 # timer event, something to do and when/how often to do it
6 # when this action is due next (updated by tick())
9 # is this action blocked? if so it won't be run
10 attr_accessor :blocked
12 # period:: how often (seconds) to run the action
13 # data:: optional data to pass to the proc
14 # once:: optional, if true, this action will be run once then removed
15 # func:: associate a block to be called to perform the action
18 def initialize(period, data=nil, once=false, &func)
29 diff = Time.new - @last_tick
35 "#<#{self.class}:#{@period}s:#{@once ? 'once' : 'repeat'}>"
42 # run the action by calling its proc
45 # really short duration timers can overrun and leave @in negative,
46 # for these we set @in to @period
47 @in = @period if @in <= 0
57 # timer handler, manage multiple Action objects, calling them when required.
58 # The timer must be ticked by whatever controls it, i.e. regular calls to
59 # tick() at whatever granularity suits your application's needs.
61 # Alternatively you can call run(), and the timer will spawn a thread and
62 # tick itself, intelligently shutting down the thread if there are no
65 def initialize(granularity = 0.1)
66 @granularity = granularity
70 @should_be_running = false
75 # period:: how often (seconds) to run the action
76 # data:: optional data to pass to the action's proc
77 # func:: associate a block with add() to perform the action
79 # add an action to the timer
80 def add(period, data=nil, &func)
82 @timers[@handle] = Action.new(period, data, &func)
87 # period:: how long (seconds) until the action is run
88 # data:: optional data to pass to the action's proc
89 # func:: associate a block with add() to perform the action
91 # add an action to the timer which will be run just once, after +period+
92 def add_once(period, data=nil, &func)
94 @timers[@handle] = Action.new(period, data, true, &func)
99 # remove action with handle +handle+ from the timer
101 @timers.delete(handle)
104 # block action with handle +handle+
106 @timers[handle].blocked = true
109 # unblock action with handle +handle+
111 @timers[handle].blocked = false
114 # you can call this when you know you're idle, or you can split off a
115 # thread and call the run() method to do it for you.
118 # don't do anything on the first tick
122 @next_action_time = 0
123 diff = (Time.now - @lasttime).to_f
125 @timers.each { |key,timer|
127 next if timer.blocked
134 if @next_action_time == 0 || timer.in < @next_action_time
135 @next_action_time = timer.in
140 # for backwards compat - this is a bit primitive
141 def run(granularity=0.1)
149 @thread && @thread.alive?
152 # return the number of seconds until the next action is due, or 0 if
153 # none are outstanding - will only be accurate immediately after a
159 # start the timer, it spawns a thread to tick the timer, intelligently
160 # shutting down if no events remain and starting again when needed.
163 @should_be_running = true
164 start_thread unless @timers.empty?
167 # stop the timer from ticking
169 @should_be_running = false
179 elsif @should_be_running
185 return unless running?
191 @thread = Thread.new do
194 exit if @timers.empty?
195 sleep(@next_action_time)