under-os 1.3.0 → 1.4.0

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

@@ -1,169 +0,0 @@
-#
-# 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/switch.rb

@@ -1,26 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,37 +0,0 @@
-#
-# 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

@@ -1,170 +0,0 @@
-#
-# 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)
-      event, r = find_recognizer_from(event.class)
-      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
-
-  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(view, event, params={})
-      @target = view
-
-      super event, params
-    end
-  end
-end