under-os 0.0.0 → 1.0.0

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

@@ -0,0 +1,169 @@
+#
+# 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 = [[left, top], [convert_size(width, :x), height]]
+      end
+
+      def height
+        @view.frame.size.height
+      end
+
+      def height=(height)
+        @view.frame = [[left, top], [width, convert_size(height, :y)]]
+      end
+
+      def top
+        @view.frame.origin.y
+      end
+
+      def top=(top)
+        @view.frame = [[left, convert_size(top, :y)], [width, height]]
+      end
+
+      def left
+        @view.frame.origin.x
+      end
+
+      def left=(left)
+        @view.frame = [[convert_size(left, :x), top], [width, height]]
+      end
+
+      def right
+        parent_size.x - left
+      end
+
+      def right=(right)
+        @view.frame = [[parent_size[:x] - convert_size(right, :x) - width, top], [width, height]]
+      end
+
+      def bottom
+        parent_size.y - top
+      end
+
+      def bottom=(bottom)
+        @view.frame = [[left, parent_size[:y] - convert_size(bottom, :y) - height], [width, height]]
+      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 'visible-hidden'  then :x
+        when 'hidden-visible'  then :y
+        else                   [overflowX, overflowY]
+        end
+      end
+
+      def overflow=(value)
+        x, y = case value.to_s
+        when 'x'       then ['visible', 'hidden']
+        when 'y'       then ['hidden', 'visible']
+        when 'hidden'  then ['hidden', 'hidden']
+        else                ['visible', 'visible']
+        end
+
+        self.overflowX = x
+        self.overflowY = y
+      end
+
+      def overflowX
+        @view.isScrollEnabled && @view.showsHorizontalScrollIndicator ? :visible : :hidden
+      end
+
+      def overflowX=(value)
+        return unless @view.is_a?(UIScrollView)
+        @view.showsHorizontalScrollIndicator = value.to_s == 'visible'
+        @view.directionalLockEnabled = overflowY == :hidden
+        @view.scrollEnabled = overflowX != :hidden || overflowY != :hidden
+      end
+
+      def overflowY
+        @view.isScrollEnabled && @view.showsVerticalScrollIndicator ? :visible : :hidden
+      end
+
+      def overflowY=(value)
+        return unless @view.is_a?(UIScrollView)
+        @view.showsVerticalScrollIndicator = value.to_s == 'visible'
+        @view.directionalLockEnabled = overflowX == :hidden
+        @view.scrollEnabled = overflowX != :hidden || overflowY != :hidden
+      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/style.rb

@@ -0,0 +1,21 @@
+#
+# The view styles handling wrapper
+#
+# The idea here is to provide a DOM like `style` object,
+# which can take similar to DOM properties and translate
+# them into iOS equivalents
+#
+class UnderOs::UI::Style
+  include Fonts
+  include Margins
+  include Outlining
+  include Positioning
+
+  attr_reader :view
+
+  def initialize(view, type)
+    @view = view
+    @type = type
+  end
+
+end

data/lib/under_os/ui/switch.rb

@@ -0,0 +1,29 @@
+class UnderOs::UI::Switch < UnderOs::UI::View
+  include UnderOs::UI::Editable
+
+  wraps UISwitch, tag: 'switch'
+
+  def initialize(options={})
+    super
+
+    self.value   = options[:value]   if options[:value]
+    self.checked = options[:checked] if options[:checked]
+  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,14 @@
+class UnderOs::UI::Textarea < UnderOs::UI::View
+  include UnderOs::UI::Editable
+
+  wraps UITextView, tag: 'textarea'
+
+  def initialize(options={})
+    super
+
+    self.value       = options[:value]       if options[:value]
+    self.keyboard    = options[:keyboard]    if options[:keyboard]
+  end
+
+  alias :text= :value= # to get values from the HTML layouts
+end

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

@@ -0,0 +1,99 @@
+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[: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/editable.rb

@@ -0,0 +1,43 @@
+#
+# A little trait to handle the common editable fields API
+#
+module UnderOs::UI::Editable
+  KEYBOARDS = {
+    default:   UIKeyboardTypeDefault,
+    ascii:     UIKeyboardTypeASCIICapable,
+    numeric:   UIKeyboardTypeNumbersAndPunctuation,
+    url:       UIKeyboardTypeURL,
+    numbers:   UIKeyboardTypeNumberPad,
+    phone:     UIKeyboardTypePhonePad,
+    name:      UIKeyboardTypeNamePhonePad,
+    email:     UIKeyboardTypeEmailAddress,
+    decimal:   UIKeyboardTypeDecimalPad,
+    twitter:   UIKeyboardTypeTwitter,
+    search:    UIKeyboardTypeWebSearch
+  }
+
+  def value
+    @_.text
+  end
+
+  def value=(value)
+    @_.text = value
+  end
+
+  def placeholder
+    @_.placeholder
+  end
+
+  def placeholder=(value)
+    @_.placeholder = value
+  end
+
+  def keyboard
+    KEYBOARDS.detect{|n,v| v == @_.keyboardType }[0]
+  end
+
+  def keyboard=(keyboard)
+    keyboard = keyboard.to_sym if keyboard.is_a?(String)
+    @_.keyboardType = KEYBOARDS[keyboard] || keyboard
+  end
+end

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

@@ -0,0 +1,75 @@
+#
+# 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)
+
+    event, recognizer = find_recognizer_from(event)
+
+    @_.addGestureRecognizer(recognizer.alloc.initWithTarget(self, action: :emit)) if recognizer
+    @_.userInteractionEnabled = true
+
+    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)
+      event = Event.new(self, event)
+    else
+      event = Event.new(self, *event)
+    end
+
+    UnderOs::Events::Listeners.kick(self, event, {})
+  end
+
+  def on=(hash)
+    on hash
+  end
+
+private
+
+  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)
+    event = event.to_sym if event.is_a?(String)
+
+    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(view, event, params={})
+      @target = view
+      event, r = view.__send__ :find_recognizer_from, event.class if event.is_a?(UIGestureRecognizer)
+      super event, params
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+#
+# The ui-views manipulation functionality
+#
+module UnderOs::UI::Manipulation
+
+  def insert(view, position=:end)
+    if view.is_a?(Array)
+      view.each{|v| insert(v, position)}
+    else
+      if position == :top
+        @_.insertSubview(view._, atIndex: 0)
+      else
+        @_.addSubview(view._)
+      end
+    end
+
+    self
+  end
+
+  def append(*views)
+    views.each{|v| insert(v)}
+    self
+  end
+
+  def prepend(*views)
+    views.each{|v| insert(v, :top) }
+    self
+  end
+
+  def insertTo(view, position=nil)
+    view.insert(self, position)
+    self
+  end
+
+  def remove
+    @_.removeFromSuperview
+    self
+  end
+
+  def clear
+    children.each(&:remove)
+    self
+  end
+end

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

@@ -0,0 +1,21 @@
+class UnderOs::UI::Position < UnderOs::Point
+  def initialize(view)
+    @view = view
+  end
+
+  def x
+    @view.style.left
+  end
+
+  def x=(position)
+    @view.style.left = position
+  end
+
+  def y
+    @view.style.top
+  end
+
+  def y=(position)
+    @view.style.top = position
+  end
+end

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

@@ -0,0 +1,21 @@
+class UnderOs::UI::Size < UnderOs::Point
+  def initialize(view)
+    @view = view
+  end
+
+  def x
+    @view.style.width
+  end
+
+  def x=(size)
+    @view.style.width = size
+  end
+
+  def y
+    @view.style.height
+  end
+
+  def y=(size)
+    @view.style.height = size
+  end
+end