rmx 0.6.0

data/lib/motion/RMXNavigationController.rb

@@ -0,0 +1,133 @@
+class RMXNavigationController < UINavigationController
+
+  include RMXCommonMethods
+  include RMXViewControllerPresentation
+
+  RMX.new(self).weak_attr_accessor :lastShownViewController
+
+  def animating?
+    if vc = viewControllers.last
+      vc != lastShownViewController
+    end
+  end
+
+  def navigationController(navigationController, didShowViewController:view_controller, animated:animated)
+    self.lastShownViewController = view_controller
+    Dispatch::Queue.main.async do
+      unless animating?
+        navigationBar.userInteractionEnabled = true
+        RMX.new(self).trigger(:done_animating)
+      end
+    end
+  end
+
+  def pushViewController(view_controller, animated:animated)
+    unless animating?
+      super
+    else
+      navigationBar.userInteractionEnabled = false
+      p "DELAYED pushViewController:animated:", view_controller, animated
+      RMX.new(self).once(:done_animating) do
+        p "RESUMED pushViewController:animated:", view_controller, animated
+        pushViewController(view_controller, animated:animated)
+      end
+      nil
+    end
+  end
+
+  def popViewControllerAnimated(animated)
+    unless animating?
+      super
+    else
+      navigationBar.userInteractionEnabled = false
+      p "DELAYED popViewControllerAnimated:", animated
+      RMX.new(self).once(:done_animating) do
+        p "RESUMED popViewControllerAnimated:", animated
+        popViewControllerAnimated(animated)
+      end
+      nil
+    end
+  end
+
+  def popToRootViewControllerAnimated(animated)
+    unless animating?
+      super
+    else
+      navigationBar.userInteractionEnabled = false
+      p "DELAYED popToRootViewControllerAnimated:", animated
+      RMX.new(self).once(:done_animating) do
+        p "RESUMED popToRootViewControllerAnimated:", animated
+        popToRootViewControllerAnimated(animated)
+      end
+      nil
+    end
+  end
+  def popToViewController(view_controller, animated:animated)
+    unless animating?
+      super
+    else
+      navigationBar.userInteractionEnabled = false
+      p "DELAYED popToViewController:animated:", view_controller, animated
+      RMX.new(self).once(:done_animating) do
+        p "RESUMED popToViewController:animated:", view_controller, animated
+        popToViewController(view_controller, animated:animated)
+      end
+      nil
+    end
+  end
+
+  def viewDidLoad
+    s = super
+    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
+    resignApplicationFirstResponder
+    rmx_viewWillDisappear(animated)
+    s
+  end
+
+  def viewDidDisappear(animated)
+    s = super
+    rmx_viewDidDisappear(animated)
+    s
+  end
+
+  def resignApplicationFirstResponder
+    windows = [] + UIApplication.sharedApplication.windows
+    while window = windows.pop
+      window.endEditing(true)
+    end
+  end
+
+  def didReceiveMemoryWarning
+    p "didReceiveMemoryWarning"
+    super
+  end
+
+  def rmx_dealloc
+    NSNotificationCenter.defaultCenter.removeObserver(self)
+    super
+  end
+
+  def self.create(rootViewController)
+    v = alloc.initWithNavigationBarClass(UINavigationBar, toolbarClass:nil)
+    v.delegate = v
+    v.pushViewController(rootViewController, animated: false) if rootViewController
+    v
+  end
+  
+end

data/lib/motion/RMXObjectExtensions.rb

@@ -0,0 +1,10 @@
+module RMXObjectExtensions
+    
+  def rmx_object_desc
+    cname = self.className.to_s
+    obj_id = '%x' % (self.object_id + 0)
+    res = "#<#{cname}:0x#{obj_id}>"
+  end
+
+end
+Object.send(:include, RMXObjectExtensions)

data/lib/motion/RMXSegmentedController.rb

@@ -0,0 +1,71 @@
+class RMXSegmentedController < RMXViewController
+
+  def prepare
+    @controller_indexes = []
+    @control = UISegmentedControl.new
+    @control.addTarget(self, action:'control_change:', forControlEvents:UIControlEventValueChanged)
+  end
+
+  def loaded
+    navigationItem.titleView = @control
+    self.selectedIndex = 0
+  end
+
+  def segments=(segments)
+    @controller_indexes.clear
+    @control.removeAllSegments
+    if segments
+      segments.each_with_index do |segment, i|
+        if segment[:title]
+          @control.insertSegmentWithTitle(segment[:title], atIndex:i, animated:false)
+        elsif segment[:image]
+          @control.insertSegmentWithImage(segment[:image], atIndex:i, animated:false)
+        end
+        @controller_indexes[i] = segment[:controller]
+      end
+    end
+    @control.sizeToFit
+  end
+
+  def control_change(sender)
+    self.selectedIndex = sender.selectedSegmentIndex
+  end
+
+  def selectedIndex=(i)
+    cleanup_active
+    @control.selectedSegmentIndex = @control.numberOfSegments > i ? i : UISegmentedControlNoSegment
+    @active_controller = @controller_indexes[i]
+    if @active_controller
+      addChildViewController(@active_controller)
+      RMX::Layout.new do |layout|
+        layout.view = view
+        layout.subviews = {
+          "content" => @active_controller.view
+        }
+        layout.eqs %Q{
+          content.left == 0
+          content.right == 0
+          content.top == 0
+          content.bottom == 0
+        }
+      end
+      @active_controller.didMoveToParentViewController(self)
+    end
+  end
+
+  def cleanup_active
+    if @active_controller
+      @active_controller.willMoveToParentViewController(nil)
+      @active_controller.view.removeFromSuperview
+      @active_controller.removeFromParentViewController
+      @active_controller = nil
+    end
+  end
+
+  def rmx_dealloc
+    cleanup_active
+    @controller_indexes = nil
+  end
+
+end
+

data/lib/motion/RMXSetAttributes.rb

@@ -0,0 +1,34 @@
+module RMXSetAttributes
+
+  def self.included(klass)
+    klass.send(:include, InstanceMethods)
+    klass.send(:extend, ClassMethods)
+  end
+
+  module InstanceMethods
+
+    def after_attributes_set
+    end
+
+    def attributes=(attrs={})
+      keys = [] + attrs.keys
+      while key = keys.pop
+        value = attrs[key]
+        self.send("#{key}=", value)
+      end
+      after_attributes_set
+    end
+
+  end
+
+  module ClassMethods
+
+    def create(opts={})
+      x = new
+      x.attributes = opts
+      x
+    end
+
+  end
+
+end

data/lib/motion/RMXStrongToWeakHash.rb

@@ -0,0 +1,46 @@
+class RMXStrongToWeakHash < Hash
+
+  def [](key)
+    if weak = super
+      if val = weak.value
+        val
+      end
+    end
+  end
+
+  def []=(key, value)
+    super(key, value.nil? ? nil : RMXWeakHolder.new(value))
+    value
+  end
+
+  def delete(key)
+    if val = super
+      val.value
+    end
+  end
+
+  def keys
+    out = []
+    _keys = [] + super
+    while _keys.size > 0
+      key = _keys.shift
+      if val = self[key]
+        out << key
+      end
+    end
+    out
+  end
+
+  def values
+    out = []
+    values = [] + super
+    while values.size > 0
+      value = values.shift
+      if val = value.value
+        out << val
+      end
+    end
+    out
+  end
+
+end

data/lib/motion/RMXSynchronizedStrongToWeakHash.rb

@@ -0,0 +1,40 @@
+class RMXSynchronizedStrongToWeakHash < RMXStrongToWeakHash
+
+  def initialize
+    super
+    @queue = Dispatch::Queue.new("#{NSBundle.mainBundle.bundleIdentifier}.rmx.IdentityMap.queue.#{object_id}")
+  end
+
+  def [](key)
+    res = nil
+    @queue.sync do
+      res = super
+    end
+    res
+  end
+
+  def []=(key, value)
+    res = nil
+    @queue.sync do
+      res = super
+    end
+    res
+  end
+
+  def delete(key)
+    res = nil
+    @queue.sync do
+      res = super
+    end
+    res
+  end
+
+  def values
+    res = nil
+    @queue.sync do
+      res = super
+    end
+    res
+  end
+
+end

data/lib/motion/RMXTableHandler.rb

@@ -0,0 +1,212 @@
+class RMXTableHandler
+
+  include RMXCommonMethods
+
+  RMX.new(self).weak_attr_accessor :tableView, :delegate
+
+  attr_accessor :registered_reuse_identifiers, :sections
+
+  def self.forTable(tableView)
+    x = new
+    x.tableView = tableView
+    tableView.dataSource = x
+    tableView.delegate = x
+    x
+  end
+
+  def rmx_dealloc
+    if tv = tableView
+      tv.dataSource = nil
+      tv.delegate = nil
+    end
+    RMX.new(self).nil_instance_variables!
+    super
+  end
+
+  def initialize
+    @sections = []
+    @heights = {}
+    @registered_reuse_identifiers = {}
+    self
+  end
+
+  def animateUpdates
+    if @isAnimatingUpdates
+      @animateUpdatesAgain = true
+      return
+    end
+    @isAnimatingUpdates = true
+    CATransaction.begin
+    CATransaction.setCompletionBlock(lambda do
+      p "animation has finished"
+      @isAnimatingUpdates = false
+      if @animateUpdatesAgain
+        p "animate again!"
+        @animateUpdatesAgain = false
+        animateUpdates
+      end
+    end)
+    tableView.beginUpdates
+    tableView.endUpdates
+    CATransaction.commit
+  end
+
+  def reloadData
+    if tv = tableView
+      tv.reloadData
+    end
+  end
+
+  def set_size_for_data(data, reuseIdentifier:reuseIdentifier)
+    reuseIdentifier = reuseIdentifier.to_s
+    sizerCell = registered_reuse_identifiers[reuseIdentifier]
+    sizerCell.data = data
+    height = sizerCell.contentView.systemLayoutSizeFittingSize(UILayoutFittingCompressedSize).height
+    updateHeight(height, data:data, reuseIdentifier:reuseIdentifier)
+  end
+
+  def registerClass(klass, forCellReuseIdentifier:reuseIdentifier)
+    reuseIdentifier = reuseIdentifier.to_s
+    registered_reuse_identifiers[reuseIdentifier] = klass.new
+    tableView.registerClass(klass, forCellReuseIdentifier:reuseIdentifier)
+  end
+
+  def tableView(tableView, cellForRowAtIndexPath:indexPath)
+    RMX.assert_main_thread!
+    context = {
+      :tableHandler => self,
+      :tableView => tableView,
+      :indexPath => indexPath,
+      :data => delegate.tableHandler(self, dataForSectionName:@sections[indexPath.section])[indexPath.row]
+    }
+    res = delegate.tableHandler(self, cellOptsForContext:context)
+    if res.is_a?(Hash)
+      context.update(res)
+      unless res[:reuseIdentifier]
+        raise ":reuseIdentifier is required"
+      end
+      reuseIdentifier = res[:reuseIdentifier].to_s
+      registered_reuse_identifiers[reuseIdentifier] || registerClass(RMXTableViewCell, forCellReuseIdentifier:reuseIdentifier)
+      res = tableView.dequeueReusableCellWithIdentifier(reuseIdentifier, forIndexPath:indexPath)
+      res.context = context
+    end
+    # p "cellForRowAtIndexPath", res, context
+    res
+  end
+
+  def tableView(tableView, heightForRowAtIndexPath:indexPath)
+    RMX.assert_main_thread!
+    context = {
+      :tableHandler => self,
+      :tableView => tableView,
+      :indexPath => indexPath,
+      :data => delegate.tableHandler(self, dataForSectionName:@sections[indexPath.section])[indexPath.row]
+    }
+    res = if @respondsToHeightForContext || delegate.respondsToSelector('tableHandler:heightForContext:')
+      @respondsToHeightForContext = true
+      delegate.tableHandler(self, heightForContext:context)
+    else
+      delegate.tableHandler(self, cellOptsForContext:context)
+    end
+    if res.is_a?(Hash)
+      context.update(res)
+      unless res[:reuseIdentifier]
+        raise ":reuseIdentifier is required"
+      end
+      reuseIdentifier = res[:reuseIdentifier].to_s
+      height = nil
+      if res[:data]
+        if heights = @heights[reuseIdentifier]
+          height = heights[res[:data]]
+        end
+      end
+      unless height
+        # p "using estimated"
+        height = res[:estimated]
+      # else
+      #   p "using real"
+      end
+      res = height
+    end
+    # p "heightForRowAtIndexPath", indexPath, res
+    res
+  end
+
+  def tableView(tableView, estimatedHeightForRowAtIndexPath:indexPath)
+    tableView(tableView, heightForRowAtIndexPath:indexPath)
+  end
+
+  def tableView(tableView, viewForHeaderInSection:section)
+    RMX.assert_main_thread!
+    if @respondsToHeaderForContext || delegate.respondsToSelector('tableHandler:headerForContext:')
+      @respondsToHeaderForContext = true
+      context = {
+        :tableHandler => self,
+        :tableView => tableView,
+        :section => section
+      }
+      res = delegate.tableHandler(self, headerForContext:context)
+      # p "viewForHeaderInSection", section, res
+      res
+    end
+  end
+
+  def tableView(tableView, heightForHeaderInSection:section)
+    RMX.assert_main_thread!
+    if @respondsToHeaderHeightForContext || delegate.respondsToSelector('tableHandler:headerHeightForContext:')
+      @respondsToHeaderHeightForContext = true
+      context = {
+        :tableHandler => self,
+        :tableView => tableView,
+        :section => section
+      }
+      res = delegate.tableHandler(self, headerHeightForContext:context)
+      # p "heightForHeaderInSection", section, res
+      res
+    else
+      0
+    end
+  end
+
+  def tableView(tableView, numberOfRowsInSection: section)
+    RMX.assert_main_thread!
+    res = delegate.tableHandler(self, dataForSectionName:@sections[section]).size
+    # p "numberOfRowsInSection", res
+    res
+  end
+
+  def numberOfSectionsInTableView(tableView)
+    RMX.assert_main_thread!
+    res = @sections.size
+    # p "numberOfSectionsInTableView", res
+    res
+  end
+
+  def tableView(tableView, didSelectRowAtIndexPath:indexPath)
+    RMX.assert_main_thread!
+    if @respondsToClickForContext || delegate.respondsToSelector('tableHandler:clickForContext:')
+      @respondsToClickForContext = true
+      context = {
+        :tableHandler => self,
+        :tableView => tableView,
+        :indexPath => indexPath,
+        :data => delegate.tableHandler(self, dataForSectionName:@sections[indexPath.section])[indexPath.row]
+      }
+      delegate.tableHandler(self, clickForContext:context)
+      tableView.deselectRowAtIndexPath(indexPath, animated:true)
+    end
+  end
+
+  def updateHeight(height, data:data, reuseIdentifier:reuseIdentifier)
+    reuseIdentifier = reuseIdentifier.to_s
+    @heights[reuseIdentifier] ||= {}
+    heights = @heights[reuseIdentifier]
+    current_height = heights[data]
+    if current_height != height
+      heights[data] = height
+      return true
+    end
+    false
+  end
+
+end

data/lib/motion/RMXTableViewCell.rb

@@ -0,0 +1,85 @@
+class RMXTableViewCell < UITableViewCell
+
+  include RMXCommonMethods
+
+  RMX.new(self).weak_attr_accessor :tableView
+  RMX.new(self).weak_attr_accessor :tableHandler
+  attr_accessor :indexPath, :innerContentView
+
+  def initWithStyle(style, reuseIdentifier:reuseIdentifier)
+    reuseIdentifier = reuseIdentifier.to_s
+    s = super(style, reuseIdentifier)
+    @innerContentView = RMXTableViewCellInnerContentView.new
+    @innerContentView.cell = self
+    RMX::Layout.new do |layout|
+      layout.view = contentView
+      layout.subviews = {
+        "innerContentView" => @innerContentView
+      }
+      layout.eqs %Q{
+        innerContentView.top == 0
+        innerContentView.left == 0
+        innerContentView.right == 0
+        innerContentView.bottom == 0 @ med
+      }
+    end
+    setup
+    s
+  end
+
+  def context=(context)
+    self.tableHandler = context[:tableHandler]
+    self.tableView = context[:tableView]
+    self.indexPath = context[:indexPath]
+    self.data = context[:data]
+    self.view = context[:view]
+    if context[:transform] && transform != context[:transform]
+      self.transform = context[:transform]
+    end
+  end
+
+  def setup
+  end
+
+  def data
+    @data
+  end
+
+  def data=(data)
+    @data = data
+  end
+
+  def view
+    @view
+  end
+
+  def view=(view)
+    @view.removeFromSuperview if @view
+    if @view = view
+      RMX::Layout.new do |layout|
+        layout.view = innerContentView
+        layout.subviews = {
+          "tile" => view
+        }
+        layout.eqs %Q{
+          tile.top == 0
+          tile.left == 0
+          tile.right == 0
+          tile.bottom == 0 @ 500
+        }
+      end
+    end
+    view
+  end
+
+  def updateHeight!
+    if (d = data) && (h = tableHandler)
+      height = contentView.systemLayoutSizeFittingSize(UILayoutFittingCompressedSize).height
+      # p "height", height
+      if h.updateHeight(height, data:d, reuseIdentifier:reuseIdentifier)
+        h.reloadData
+      end
+    end
+  end
+
+end

data/lib/motion/RMXTableViewCellInnerContentView.rb

@@ -0,0 +1,16 @@
+class RMXTableViewCellInnerContentView < RMXView
+  RMX.new(self).weak_attr_accessor :cell
+  attr_accessor :autoUpdateHeight
+
+  def layoutSubviews
+    s = super
+    updateHeight! if @autoUpdateHeight
+    s
+  end
+
+  def updateHeight!
+    if c = cell
+      c.updateHeight!
+    end
+  end
+end

data/lib/motion/RMXTableViewController.rb

@@ -0,0 +1,65 @@
+class RMXTableViewController < UITableViewController
+
+  include RMXCommonMethods
+  include RMXViewControllerPresentation
+  include RMXKeyboardHelpers
+  include RMXSetAttributes
+
+  def prepare
+  end
+
+  def loaded
+  end
+
+  def init
+    s = super
+    NSNotificationCenter.defaultCenter.addObserver(self, selector:'refresh', name:UIApplicationWillEnterForegroundNotification, object:nil)
+    listenForKeyboardChanged
+    prepare
+    s
+  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