rmx 0.6.0

data/lib/motion/RMXUnsafeUnretainedHolder.rb

@@ -0,0 +1,30 @@
+class RMXUnsafeUnretainedHolder
+
+  def initialize(_value=nil)
+    @value_desc = _value.rmx_object_desc
+    self.value = _value
+    self
+  end
+
+  def value
+    @holder.nonretainedObjectValue
+  end
+
+  def value=(_value)
+    @holder = NSValue.valueWithNonretainedObject(_value)
+    _value
+  end
+
+  def hash
+    value.hash
+  end
+
+  def eql?(other)
+    other.hash == value.hash
+  end
+
+  def inspect
+    "(unsafe)#{@value_desc}"
+  end
+
+end

data/lib/motion/RMXView.rb

@@ -0,0 +1,84 @@
+class RMXView < UIView
+
+  include RMXCommonMethods
+  include RMXSetAttributes
+
+  attr_accessor :updatedSize, :reportSizeChanges
+
+  def rmx_dealloc
+    NSNotificationCenter.defaultCenter.removeObserver(self)
+    super
+  end
+
+  def prepare
+  end
+
+  def setup
+  end
+
+  def init
+    s = super
+    prepare
+    setUserInteractionEnabled(false)
+    setup
+    s
+  end
+
+  def setUserInteractionEnabled(bool)
+    @userInteractionEnabled = bool
+  end
+
+  def self.create(attributes={})
+    x = new
+    x.attributes = attributes
+    x
+  end
+
+  # normal userInteractionEnabled means the view and all subviews can't be clicked.  what we normally
+  # want is subviews to be clickable, but not the parent.  this custom hitTest allows that behavior.
+  def hitTest(point, withEvent:event)
+    s = super
+    if s == self && @userInteractionEnabled == false
+      return nil
+    end
+    s
+  end
+
+  def requiresConstraintBasedLayout
+    true
+  end
+
+  def layoutSubviews
+    s = super
+    if reportSizeChanges
+      Dispatch::Queue.main.async do
+        size = systemLayoutSizeFittingSize(UILayoutFittingCompressedSize)
+        unless updatedSize == size
+          self.updatedSize = size
+          RMX.new(self).trigger(:updatedSize, size)
+          
+          if tableView = is_or_within_a?(UITableView)
+            if tableView.delegate.respondsToSelector('tableView:viewDidUpdateSize:')
+              tableView.delegate.tableView(tableView, viewDidUpdateSize:self)
+            end
+            # p "unbounced reload"
+            RMX.new(self).debounce(:reloadTableUpdatedSize) do
+              # p "debounced reload"
+              if controller = tableView.lAncestorViewController
+                if controller.viewState == :viewDidAppear
+                  tableView.beginUpdates
+                  tableView.endUpdates
+                else
+                  tableView.reloadData
+                end
+              end
+            end
+          end
+
+        end
+      end
+    end
+    s
+  end
+
+end

data/lib/motion/RMXViewController.rb

@@ -0,0 +1,65 @@
+class RMXViewController < UIViewController
+
+  include RMXCommonMethods
+  include RMXViewControllerPresentation
+  include RMXKeyboardHelpers
+  include RMXSetAttributes
+
+  def init
+    s = super
+    NSNotificationCenter.defaultCenter.addObserver(self, selector:'refresh', name:UIApplicationWillEnterForegroundNotification, object:nil)
+    listenForKeyboardChanged
+    prepare
+    s
+  end
+
+  def prepare
+  end
+
+  def loaded
+  end
+
+  def refresh
+  end
+
+  def viewDidLoad
+    s = super
+    loaded
+    s
+  end
+
+  def viewWillAppear(animated)
+    s = super
+    rmx_viewWillAppear(animated)
+    s
+  end
+
+  def viewDidAppear(animated)
+    s = super
+    rmx_viewDidAppear(animated)
+    s
+  end
+
+  def viewWillDisappear(animated)
+    s = super
+    rmx_viewWillDisappear(animated)
+    s
+  end
+
+  def viewDidDisappear(animated)
+    s = super
+    rmx_viewDidDisappear(animated)
+    s
+  end
+
+  def didReceiveMemoryWarning
+    p "didReceiveMemoryWarning"
+    super
+  end
+
+  def rmx_dealloc
+    NSNotificationCenter.defaultCenter.removeObserver(self)
+    super
+  end
+
+end

data/lib/motion/RMXViewControllerPresentation.rb

@@ -0,0 +1,127 @@
+module RMXViewControllerPresentation
+
+  def self.included(klass)
+    klass.send(:include, InstanceMethods)
+    klass.send(:attr_accessor, :viewState)
+  end
+
+  module FactoryMethods
+
+    # presentViewController should always be called on the next runloop to avoid quirks.
+    # this just wraps that behavior
+    def present(opts)
+      unless [ :origin, :view_controller, :animated, :completion ].all? { |x| opts.key?(x) }
+        raise "Missing RMXViewControllerPresentation.present opts: #{opts.inspect}"
+      end
+      Dispatch::Queue.main.async do
+        opts[:origin].presentViewController(opts[:view_controller], animated:opts[:animated], completion:opts[:completion])
+      end
+    end
+
+    # remove the controller from the display heirarchy, taking into account how it is
+    # currently presented.  avoid nesting animations and corrupting the UI by using
+    # whenOrIfViewState and executing on the main thread async to ensure it is not yanked out of the
+    # UI during existing animations
+    def dismiss(opts)
+      unless [ :view_controller, :animated, :completion ].all? { |x| opts.key?(x) }
+        raise "Missing RMXViewControllerPresentation.dismiss opts: #{opts.inspect}"
+      end
+      animated = opts[:animated]
+      block = opts[:completion]
+      view_controller = opts[:view_controller]
+      navigationController = view_controller.navigationController
+
+
+      if view_controller.presentingViewController
+        Dispatch::Queue.main.async do
+          view_controller.dismissViewControllerAnimated(animated, completion:block)
+        end
+      elsif navigationController
+        if index = navigationController.viewControllers.index(view_controller)
+          before_index = index - 1
+          before_index = 0 if index < 0
+          pop_to_controller = navigationController.viewControllers[before_index]
+          if pop_to_controller && pop_to_controller != navigationController.viewControllers.last
+            # p "pop_to_controller", pop_to_controller
+            # p "navigationController.popToViewController(pop_to_controller, animated:animated)"
+            Dispatch::Queue.main.async do
+              RMX.new(navigationController).once(:done_animating, &block) if block
+              navigationController.popToViewController(pop_to_controller, animated:animated)
+            end
+          end
+        end
+      end
+    end
+
+  end
+  extend FactoryMethods
+
+  module InstanceMethods
+
+    def triggerViewState!(animated)
+      # p "triggerViewState!", @viewState, animated
+      RMX.new(self).trigger(@viewState, animated)
+    end
+
+    def whenOrIfViewState(viewState, &block)
+      if viewState == @viewState
+        block.call
+      else
+        RMX.new(self).once(viewState, &block)
+      end
+    end
+
+    def appearing(animated)
+    end
+
+    def rmx_viewWillAppear(animated)
+      @viewState = :viewWillAppear
+      triggerViewState!(animated)
+      appearing(animated)
+    end
+
+    def appeared(animated)
+    end
+
+    def rmx_viewDidAppear(animated)
+      @viewState = :viewDidAppear
+      triggerViewState!(animated)
+      appeared(animated)
+    end
+
+    def disappearing(animated)
+    end
+
+    def rmx_viewWillDisappear(animated)
+      @viewState = :viewWillDisappear
+      triggerViewState!(animated)
+      disappearing(animated)
+    end
+
+    def disappeared(animated)
+    end
+
+    def rmx_viewDidDisappear(animated)
+      @viewState = :viewDidDisappear
+      triggerViewState!(animated)
+      disappeared(animated)
+    end
+
+    def present(vc, animated=false, &block)
+      RMXViewControllerPresentation.present({
+        :origin => self,
+        :view_controller => vc,
+        :animated => animated,
+        :completion => block
+      })
+    end
+    
+    def dismiss(animated=false, &block)
+      RMXViewControllerPresentation.dismiss({
+        :view_controller => self,
+        :animated => animated,
+        :completion => block
+      })
+    end
+  end
+end

data/lib/motion/RMXWeakHolder.rb

@@ -0,0 +1,36 @@
+class RMXWeakHolder
+
+  def initialize(_value=nil)
+    @value_desc = _value.rmx_object_desc
+    @holder = NSHashTable.weakObjectsHashTable
+    self.value = _value
+    self
+  end
+
+  def value
+    @holder.anyObject
+  end
+
+  def value=(_value)
+    @holder.removeAllObjects
+    @holder.addObject(_value) unless _value.nil?
+    _value
+  end
+
+  def hash
+    value.hash
+  end
+
+  def eql?(other)
+    other.hash == value.hash
+  end
+
+  def inspect
+    if val = value
+      "(weak)#{@value_desc}"
+    else
+      "(deallocated)#{@value_desc}"
+    end
+  end
+
+end

data/lib/motion/RMXWeakToStrongHash.rb

@@ -0,0 +1,39 @@
+class RMXWeakToStrongHash < Hash
+
+  def [](key)
+    super(RMXWeakHolder.new(key))
+  end
+
+  def []=(key, value)
+    super(RMXWeakHolder.new(key), value)
+  end
+
+  def delete(key)
+    super(RMXWeakHolder.new(key))
+  end
+
+  def keys
+    out = []
+    keys = [] + super
+    while keys.size > 0
+      key = keys.shift
+      if val = key.value
+        out << val
+      end
+    end
+    out
+  end
+
+  def values
+    out = []
+    keys = [] + self.keys
+    while keys.size > 0
+      key = keys.shift
+      if val = key.value
+        out << self[key]
+      end
+    end
+    out
+  end
+
+end

data/lib/motion/accessors.rb

@@ -0,0 +1,29 @@
+class RMX
+
+  CREATE_WEAK_HOLDER = proc do
+    RMXWeakHolder.new
+  end
+
+  # creates an +attr_accessor+ like behavior, but the object is
+  # stored within an NSHashTable.weakObjectsHashTable and retrieved
+  # from the NSHashTable on demand.
+  # does not conform to KVO like a normal attr_accessor.
+  def weak_attr_accessor(*attrs)
+    if object = unsafe_unretained_object
+      attrs.each do |attr|
+        attr_holder = "#{attr}_holder"
+        object.send(:define_method, attr) do
+          if holder = RMX.new(self).ivar(attr_holder)
+            holder.value
+          end
+        end
+        object.send(:define_method, "#{attr}=") do |val|
+          holder = RMX.new(self).ivar(attr_holder, &CREATE_WEAK_HOLDER)
+          holder.value = val
+          val
+        end
+      end
+    end
+  end
+
+end

data/lib/motion/base.rb

@@ -0,0 +1,12 @@
+class RMX
+
+  def initialize(_object)
+    @unsafe_unretained_object_holder = RMXUnsafeUnretainedHolder.new(_object)
+    self
+  end
+
+  def unsafe_unretained_object
+    @unsafe_unretained_object_holder.value
+  end
+
+end

data/lib/motion/env.rb

@@ -0,0 +1,9 @@
+class RMX
+
+  DEBUG_LONGTASK = Env['rmx_debug_longtask'] == '1'
+  DEBUG_DEALLOC = Env['rmx_debug_dealloc'] == '1'
+  DEBUG_EVENTS = Env['rmx_debug_events'] == '1'
+  DEBUG_QUEUES = Env['rmx_debug_queues'] == '1'
+  DEBUG = Env['rmx_debug'] == '1'
+
+end

data/lib/motion/events.rb

@@ -0,0 +1,61 @@
+class RMX
+
+  CREATE_EVENT_PROXY = proc do
+    RMXEventsFromProxy.new
+  end
+
+  def events_from_proxy
+    res = nil
+    RMXEventsFromProxy::QUEUE.sync do
+      res = ivar(:_rmx_events_from_proxy, &CREATE_EVENT_PROXY)
+    end
+    res
+  end
+
+  def _events_from_proxy
+    res = nil
+    RMXEventsFromProxy::QUEUE.sync do
+      res = ivar(:_rmx_events_from_proxy)
+    end
+    res
+  end
+
+  # register a callback when an event is triggered on this object.
+  def on(event, opts={}, &block)
+    if object = unsafe_unretained_object
+      _opts = opts.dup
+      if _opts[:strong]
+        _opts[:strong] = [ object, block.owner ]
+      end
+      events_from_proxy.on(event, _opts, &block)
+    end
+  end
+
+  def now_and_on(event, opts={}, &block)
+    events_from_proxy.now_and_on(event, opts.dup, &block)
+  end
+
+  # register a callback when an event is triggered on this object and remove it after it fires once
+  def once(event, opts={}, &block)
+    _opts = opts.dup
+    _opts[:limit] = 1
+    on(event, _opts, &block)
+  end
+
+  # RMX(@model).off(:fire, &block)    # remove :fire for specific handler
+  # RMX(@model).off(:fire)            # remove all :fire in all knowns contexts
+  # RMX(@model).off                   # remove all events in all known contexts
+  def off(event=nil, execution_block=nil)
+    if proxy = _events_from_proxy
+      proxy.off(event, execution_block)
+    end
+  end
+
+  # trigger an event with value on this object
+  def trigger(event, *values)
+    if proxy = _events_from_proxy
+      proxy.trigger(event, *values)
+    end
+  end
+
+end