Class: RMExtensions::EventsFromProxy

Inherits:
Object
  • Object
show all
Defined in:
lib/motion/events.rb

Overview

Proxy class used to hold the actual handlers and contexts of handlers. When the real class deallocates, all handlers are removed.

Instance Method Summary collapse

Constructor Details

#initialize(obj) ⇒ EventsFromProxy

Returns a new instance of EventsFromProxy.



124
125
126
127
128
129
130
 
# File 'lib/motion/events.rb', line 124

def initialize(obj)
  self.weak_object = obj
  @events = NSMapTable.weakToStrongObjectsMapTable
  if ::RMExtensions.debug?
    p "CREATED #{className}: #{weak_object.rmext_object_desc}"
  end
end

Instance Method Details

#dealloc ⇒ Object 



132
133
134
135
136
137
138
139
 
# File 'lib/motion/events.rb', line 132

def dealloc
  # @did_dealloc = true
  off
  if ::RMExtensions.debug?
    p "DEALLOC #{className}: #{weak_object.rmext_object_desc}"
  end
  super
end

#now_and_on(event, opts = {}, &block) ⇒ Object 



159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/motion/events.rb', line 159

def now_and_on(event, opts={}, &block)
  rmext_inline_or_on_main_q do
    res = EventResponse.new
    res.context = block.owner
    res.value = nil
    res.target = weak_object
    res.event = event
    block.call(res)
  end
  on(event, opts, &block)
end

#off(event = nil, context = nil, &block) ⇒ Object 



171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
 
# File 'lib/motion/events.rb', line 171

def off(event=nil, context=nil, &block)
  if event.is_a?(String) || event.is_a?(Symbol)
    event = event.to_s
    if block
      # remove the one block for the event in the blocks #owner
      context = block.owner
      if context_events = @events.objectForKey(context)
        if context_event_blocks = context_events.objectForKey(event)
          context_event_blocks.delete block
        end
      end
    elsif context
      # remove all handlers for the given event in the given context
      if context_events = @events.objectForKey(context)
        context_events.delete(event)
      end
    else
      # remove all handlers for the event in all contexts known
      keyEnumerator = @events.keyEnumerator
      contexts = []
      while context = keyEnumerator.nextObject
        contexts.push context
      end
      while context = contexts.pop
        if context_events = @events.objectForKey(context)
          context_events.delete event
        end
      end
    end
  elsif event
    # event is really a context. remove all events and handlers for the context
    context = event
    @events.removeObjectForKey(context)
  else
    # remove everything
    @events.removeAllObjects
  end
  nil
end

#on(event, opts = {}, &block) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/motion/events.rb', line 141

def on(event, opts={}, &block)
  return if event.nil? || block.nil?
  event = event.to_s
  context = block.owner
  unless context_events = @events.objectForKey(context)
    context_events = {}
    @events.setObject(context_events, forKey:context)
  end
  unless context_event_blocks = context_events.objectForKey(event)
    context_event_blocks = {}
    context_events.setObject(context_event_blocks, forKey:event)
  end
  block.weak!
  context_event_blocks[block] = opts[:limit] || -1
  # i.e.: controller/view has handlers for object
  context.rmext_events_to_proxy.has_handlers_for!(weak_object)
end

#trigger(event, value) ⇒ Object 



211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
 
# File 'lib/motion/events.rb', line 211

def trigger(event, value)
  rmext_inline_or_on_main_q do
    # next if @did_dealloc
    next if event.nil?
    event = event.to_s
    keyEnumerator = @events.keyEnumerator
    contexts = []
    while context = keyEnumerator.nextObject
      contexts.push context
    end
    while context = contexts.pop
      if context_events = @events.objectForKey(context)
        if event_blocks = context_events[event]
          blocks = event_blocks.keys
          if ::RMExtensions.debug?
            p "TRIGGER:", event, "OBJECT:", weak_object.rmext_object_desc, "CONTEXT:", context.rmext_object_desc, "BLOCKS SIZE:", blocks.size
          end
          while block = blocks.pop
            limit = event_blocks[block]
            res = EventResponse.new
            res.context = context
            res.value = value
            res.target = weak_object
            res.event = event
            block.call(res)
            if limit == 1
              # off
              if ::RMExtensions.debug?
                p "LIMIT REACHED:", event, "OBJECT:", weak_object.rmext_object_desc, "CONTEXT:", context.rmext_object_desc
              end
              off(event, context, &block)
            elsif limit > 1
              event_blocks[block] -= 1
            end
          end
        end
      end
    end
  end
  nil
end