under-os-ui 1.4.0

data/lib/under_os/ui/style/positioning.rb

@@ -0,0 +1,183 @@
+#
+# This module contains things like positions and sizes of the elements
+#
+module UnderOs::UI
+  class Style
+    module Positioning
+      def width
+        @view.frame.size.width
+      end
+
+      def width=(width)
+        @view.frame = @view.frame.tap do |frame|
+          frame.size.width = convert_size(width, :x)
+        end
+      end
+
+      def height
+        @view.frame.size.height
+      end
+
+      def height=(height)
+        @view.frame = @view.frame.tap do |frame|
+          frame.size.height = convert_size(height, :y)
+        end
+      end
+
+      def top
+        @view.frame.origin.y
+      end
+
+      def top=(top)
+        @view.frame = @view.frame.tap do |frame|
+          frame.origin.y = convert_size(top, :y)
+        end
+      end
+
+      def left
+        @view.frame.origin.x
+      end
+
+      def left=(left)
+        @view.frame = @view.frame.tap do |frame|
+          frame.origin.x = convert_size(left, :x)
+        end
+      end
+
+      def right
+        parent_size.x - left
+      end
+
+      def right=(right)
+        @view.frame = @view.frame.tap do |frame|
+          frame.origin.x = parent_size[:x] - convert_size(right, :x) - frame.size.width
+        end
+      end
+
+      def bottom
+        parent_size.y - top
+      end
+
+      def bottom=(bottom)
+        @view.frame = @view.frame.tap do |frame|
+          frame.origin.y = parent_size[:y] - convert_size(bottom, :y) - frame.size.height
+        end
+      end
+
+      def contentWidth
+        @view.contentSize.width rescue 0
+      end
+
+      def contentWidth=(value)
+        return unless @view.is_a?(UIScrollView)
+
+        if value == 'auto'
+          value = 0
+          @view.subviews.each do |view|
+            x = view.origin.x + view.size.width
+            value = x if x > value
+          end
+        end
+
+        @view.contentSize = CGSizeMake(value, contentHeight)
+      end
+
+      def contentHeight
+        @view.contentSize.height rescue 0
+      end
+
+      def contentHeight=(value)
+        return unless @view.is_a?(UIScrollView)
+
+        if value == 'auto'
+          value = 0
+          @view.subviews.each do |view|
+            y = view.origin.y + view.size.height
+            value = y if y > value
+          end
+        end
+
+        @view.contentSize = CGSizeMake(contentWidth, value)
+      end
+
+      def zIndex
+        @view.layer.zPosition
+      end
+
+      def zIndex=(number)
+        @view.layer.zPosition = number
+      end
+
+      def overflow
+        case "#{overflowX}-#{overflowY}"
+        when 'visible-visible' then :visible
+        when 'hidden-hidden'   then :hidden
+        when 'scroll-scroll'   then :scroll
+        when 'scroll-visible'  then :x
+        when 'visible-scroll'  then :y
+        else                   [overflowX, overflowY]
+        end
+      end
+
+      def overflow=(value)
+        x, y = case value.to_s
+        when 'x'       then ['scroll',  'visible']
+        when 'y'       then ['visible', 'scroll']
+        when 'hidden'  then ['hidden',  'hidden']
+        when 'visible' then ['visible', 'visible']
+        else                ['scroll',  'scroll']
+        end
+
+        self.overflowX = x
+        self.overflowY = y
+      end
+
+      def overflowX
+        @view.isScrollEnabled ? @view.showsHorizontalScrollIndicator ? :scroll : :hidden : :visible
+      end
+
+      def overflowX=(value)
+        return unless @view.is_a?(UIScrollView)
+        @view.directionalLockEnabled = overflowY == :visible
+        @view.showsHorizontalScrollIndicator = value.to_s == 'scroll'
+        @view.scrollEnabled = value.to_s != 'visible' || overflowY != :visible
+      end
+
+      def overflowY
+        @view.isScrollEnabled ? @view.showsVerticalScrollIndicator ? :scroll : :hidden : :visible
+      end
+
+      def overflowY=(value)
+        return unless @view.is_a?(UIScrollView)
+        @view.directionalLockEnabled = overflowX == :visible
+        @view.showsVerticalScrollIndicator = value.to_s == 'scroll'
+        @view.scrollEnabled = overflowX != :visible || value.to_s != 'visible'
+      end
+
+    private
+
+      def convert_size(size, dim)
+        if size.is_a?(String)
+          if size.ends_with?('%')
+            size = size.slice(0, size.size-1).to_f
+            size = parent_size[dim] / 100.0 * size
+          end
+        end
+
+        size
+      end
+
+      def parent_size
+        parent = view.superview
+
+        if !parent.superview && parent == UnderOs::App.history.current_page.view._
+          parent = UIScreen.mainScreen.bounds.size
+        else
+          parent = parent.frame.size
+        end
+
+        {x: parent.width, y: parent.height}
+      end
+    end
+  end
+end

data/lib/under_os/ui/switch.rb

@@ -0,0 +1,26 @@
+class UnderOs::UI::Switch < UnderOs::UI::Input
+  wraps UISwitch, tag: 'switch'
+
+  def initialize(options={})
+    super
+    self.checked = options[:checked] if options[:checked]
+    @_.addTarget self, action: :handle_change, forControlEvents:UIControlEventValueChanged
+  end
+
+  def value
+    @_value
+  end
+
+  def value=(value)
+    @_value = value # just saving it on the instance
+  end
+
+  def checked
+    @_.on?
+  end
+
+  def checked=(flag)
+    @_.setOn flag, animated: true
+  end
+
+end

data/lib/under_os/ui/textarea.rb

@@ -0,0 +1,19 @@
+class UnderOs::UI::Textarea < UnderOs::UI::Input
+  wraps UITextView, tag: 'textarea'
+
+  alias :text= :value= # to get values from the HTML layouts
+
+# delegate
+
+  def textViewDidBeginEditing(textView)
+    handle_focus
+  end
+
+  def textViewDidChange(textView)
+    handle_change
+  end
+
+  def textViewDidEndEditing(textView)
+    handle_blur
+  end
+end

data/lib/under_os/ui/utils/animation.rb

@@ -0,0 +1,101 @@
+module UnderOs::UI::Animation
+
+  def animate(style, options={}, &block)
+    if block_given?
+      options = style
+      style   = nil
+    else
+      [:complete, :curve, :autoreverse, :repeat, :duration, :delay].each do |key|
+        options[key] = style.delete(key) if style.has_key?(key)
+      end
+
+      block   = Proc.new{ self.style = style }
+    end
+
+    Animation.new(self, options, &block)
+
+    self
+  end
+
+  def highlight(color=:yellow, options={})
+    old_color = style.background
+
+    animate({background: color},     {curve: :ease_out}.merge(options))
+    animate({background: old_color}, {curve: :ease_in}.merge(options))
+  end
+
+  def fade_in(options={})
+    animate({opacity: 1}, options)
+  end
+
+  def fade_out(options={})
+    animate({opacity: 0}, options)
+  end
+
+  class Animation
+    CURVES = {
+      ease_in_out: UIViewAnimationOptionCurveEaseInOut,
+          ease_in: UIViewAnimationOptionCurveEaseIn,
+         ease_out: UIViewAnimationOptionCurveEaseOut,
+           linear: UIViewAnimationOptionCurveLinear
+    }.freeze
+
+    FX_QUEUE = {}
+
+    def initialize(view, options, &block)
+      @view    = view
+      @options = options
+      @block   = block
+
+      @options = {duration: options} if options.is_a?(Numeric)
+
+      @options[:schedule] == false ? run : schedule
+    end
+
+    def queue
+      FX_QUEUE[@view] ||= []
+    end
+
+    def schedule
+      if queue.empty?
+        run
+      else
+        queue << self
+      end
+    end
+
+    def run
+      @view.emit('animation:start')
+
+      UIView.animateWithDuration duration,
+                          delay: delay,
+                        options: options,
+                     animations: ->{ @block.call },
+                     completion: ->(finished){ run_next }
+    end
+
+    def duration
+      @options[:duration] || 0.25
+    end
+
+    def delay
+      @options[:delay] || 0.0
+    end
+
+    def options
+      options = CURVES[@options[:curve]] || @options[:curve] || UIViewAnimationCurveEaseOut
+      options = options | UIViewAnimationOptionAutoreverse if @options[:autoreverse]
+      options = options | UIViewAnimationOptionRepeat      if @options[:repeat]
+      options | UIViewAnimationOptionAllowUserInteraction
+    end
+
+    def run_next
+      @view.emit('animation:finished')
+      @options[:complete].call if @options[:complete]
+
+      if next_fx = queue.shift
+        next_fx.run
+      end
+    end
+  end
+end

data/lib/under_os/ui/utils/commons.rb

@@ -0,0 +1,70 @@
+module UnderOs::UI::Commons
+  def id
+    @_id
+  end
+
+  def id=(id)
+    @_id = id
+  end
+
+  def tagName
+    @_tag_name ||= begin
+      wraps = UnderOs::UI::Wrap::WRAPS_TAGS_MAP
+      klass = self.class; tag = 'VIEW'
+
+      while klass
+        if wrap = wraps.detect{|t,k| k == klass}
+          tag = wrap[0].upcase
+          break
+        else
+          klass = klass.superclass
+        end
+      end
+
+      tag
+    end
+  end
+
+  def data(key=nil)
+    key && @_data ? @_data[key.to_sym] : @_data
+  end
+
+  def data=(hash)
+    @_data = hash
+  end
+
+  def page
+    resp = @_
+
+    while resp = resp.nextResponder
+      if resp.is_a?(UIViewController)
+        return resp.wrapper
+      end
+    end
+
+    nil
+  end
+
+  def hide
+    style.display = :none
+  end
+
+  def show
+    style.display = :block
+  end
+
+  def toggle
+    hidden ? show : hide
+  end
+
+  def hidden
+    @_.isHidden
+  end
+
+  def visible
+    !hidden
+  end
+
+  alias :hidden?  :hidden
+  alias :visible? :visible
+end

data/lib/under_os/ui/utils/dimensions.rb

@@ -0,0 +1,37 @@
+#
+# This module handles generic ui dimensions and positions of views
+#
+module UnderOs::UI::Dimensions
+  def size(size=nil)
+    if size
+      self.size = size
+      self
+    else
+      @size ||= UnderOs::UI::Size.new(self)
+    end
+  end
+
+  def size=(size)
+    size = UnderOs::Point.new(size) # cleaning up
+
+    self.size.x = size.x if size.x
+    self.size.y = size.y if size.y
+  end
+
+  def position(position=nil)
+    if position
+      self.position = position
+      self
+    else
+      @position ||= UnderOs::UI::Position.new(self)
+    end
+  end
+
+  def position=(position)
+    position = UnderOs::Point.new(position) # cleaning up
+
+    self.position.x = position.x if position.x
+    self.position.y = position.y if position.y
+  end
+
+end

data/lib/under_os/ui/utils/events.rb

@@ -0,0 +1,210 @@
+#
+# Special, UI avare events API
+#
+module UnderOs::UI::Events
+
+  def on(event, *args, &block)
+    return event.map{|e,b| self.on(e,&b)}[0] || self if event.is_a?(Hash)
+
+    @_.userInteractionEnabled = true
+
+    event = add_ui_event_listener(event)
+
+    UnderOs::Events::Listeners.add(self, event, *args, block)
+  end
+
+  def off(event)
+    UnderOs::Events::Listeners.remove(self, event)
+  end
+
+  def emit(*event)
+    if event.is_a?(UIGestureRecognizer)
+      name, r = find_recognizer_from(event.class)
+      event = Event.new(event, self, name)
+    else # emits by a name
+      event = Event.new(nil, self, *event)
+    end
+
+    UnderOs::Events::Listeners.kick(self, event, {})
+  end
+
+  def on=(hash)
+    on hash
+  end
+
+  class TouchListeners
+    def self.listeners
+      @listeners ||= Hash.new{ |h,k| h[k] = [] }
+    end
+
+    def self.add(eventname, view)
+      listeners[eventname] << view
+    end
+
+    def self.notify(eventname, event)
+      listeners[eventname].each do |view|
+        if eventname == :touchmove # being nice and throttling the touchmove events
+          return if @__working
+          @__working = true
+        end
+
+        touches = touches_for_view(view, event)
+
+        view.emit(eventname, touches: touches) if touches.size > 0
+
+        @__working = false
+      end
+    end
+
+    def self.touches_for_view(view, event)
+      frame   = view._.frame
+      touches = []
+
+      event.allTouches.each do |touch|
+        if point = touch_inside_of(frame, touch)
+          touches << Touch.new(view, point)
+        end
+      end
+
+      touches
+    end
+
+    def self.touch_inside_of(frame, touch)
+      point = touch.locationInView(nil)
+      point = nil if point.x < frame.origin.x ||
+           point.y < frame.origin.y ||
+           point.x > frame.origin.x + frame.size.width ||
+           point.y > frame.origin.y + frame.size.height
+
+      point
+    end
+
+    class Touch
+      attr_reader :view, :position
+
+      def initialize(view, position)
+        @view     = view
+        @position = position
+      end
+
+      def pageX
+        position.x
+      end
+
+      def pageY
+        position.y
+      end
+
+      def viewX
+        @position.x - view._.frame.origin.x
+      end
+
+      def viewY
+        @position.y - view._.frame.origin.y
+      end
+
+      def inspect
+        "#<Touch x=#{pageX} y=#{pageY}"
+      end
+    end
+  end
+
+private
+
+  def add_ui_event_listener(event)
+    event = event.to_sym if event.is_a?(String)
+    event = try_add_touch_event_listener(event)
+    event, recognizer = find_recognizer_from(event)
+
+    @_.addGestureRecognizer(recognizer.alloc.initWithTarget(self, action: :emit)) if recognizer
+
+    event
+  end
+
+  TOUCH_EVENTS = [:touchstart, :touchmove, :touchend, :touchcancel]
+
+  def try_add_touch_event_listener(event)
+    if TOUCH_EVENTS.include?(event)
+      UnderOs::UI::Events::TouchListeners.add(event, self)
+    end
+
+    event
+  end
+
+  RECOGNIZERS = {
+    tap:    UITapGestureRecognizer,
+    pinch:  UIPinchGestureRecognizer,
+    rotate: UIRotationGestureRecognizer,
+    swipe:  UISwipeGestureRecognizer,
+    pan:    UIPanGestureRecognizer,
+    press:  UILongPressGestureRecognizer
+  }
+
+  # tries to figure event name and gesture recognizer
+  def find_recognizer_from(event)
+    if event.is_a?(Class) && event < UIGestureRecognizer
+      recognizer = event
+
+      if recognizer.respond_to?(:event_name)
+        event = recognizer.event_name
+      else
+        RECOGNIZERS.each{ |e,r| event = e if r == recognizer }
+      end
+
+    elsif RECOGNIZERS[event]
+      recognizer = RECOGNIZERS[event]
+    end
+
+    [event, recognizer]
+  end
+
+  class Event < UnderOs::Events::Event
+    attr_reader :_, :target
+
+    def initialize(original, target, event, params={})
+      @_      = original
+      @target = target
+
+      super event, params
+    end
+
+    def scale
+      @_.scale
+    end
+
+    def scale=(value)
+      @_.scale = value
+    end
+
+    def angle
+      @_.rotation
+    end
+
+    def angle=(value)
+      @_.rotation = value
+    end
+
+    def translation(view)
+      view = view._ if view.is_a?(UnderOs::UI::View)
+      @_.translationInView(view)
+    end
+
+    def translation=(params)
+      point = params[0]; view = params[1]
+      view = view._ if view.is_a?(UnderOs::UI::View)
+      @_.setTranslation(point, inView:view)
+    end
+
+    RECOGNIZER_STATES = {
+      UIGestureRecognizerStateBegan     => :began,
+      UIGestureRecognizerStateChanged   => :changed,
+      UIGestureRecognizerStateEnded     => :ended,
+      UIGestureRecognizerStateCancelled => :canceled,
+      UIGestureRecognizerStateFailed    => :failed
+    }.freeze
+
+    def state
+      RECOGNIZER_STATES[@_.state]
+    end
+  end
+end