ruby_motion_query 0.1.1

data/motion/ruby_motion_query/event.rb

@@ -0,0 +1,125 @@
+module RubyMotionQuery
+  class Event
+    attr_accessor :block, :recognizer, :event, :sdk_event_or_recognizer, :gesture, :sender
+
+    def initialize(sender, event, block)
+      if @sdk_event_or_recognizer = VIEW_GESTURES[event]
+        @gesture = true
+      elsif sender.is_a?(UIControl)
+        @gesture = false
+        @sdk_event_or_recognizer = CONTROL_EVENTS[event]
+      end
+
+      if @sdk_event_or_recognizer
+        @sender = sender
+        @event = event
+        @block = block
+
+        if @gesture
+          @recognizer = @sdk_event_or_recognizer.alloc.initWithTarget(self, action: :handle_gesture_or_event)
+          @sender.addGestureRecognizer(@recognizer)
+        else
+          @sender.addTarget(self, action: :handle_gesture_or_event, forControlEvents: @sdk_event_or_recognizer)
+        end
+      else
+        raise "[RMQ Error]  Invalid event or gesture or invalid sender (#{event}). Example of use: button.on(:touch) { my_code }"
+      end
+    end
+
+    def handle_gesture_or_event
+      case @block.arity
+      when 2
+        @block.call(@sender, self)
+      when 1
+        @block.call(@sender)
+      else
+        @block.call
+      end
+    end
+
+    def set_options(opts)
+      if gesture?
+        @recognizer.tap do |o|
+          o.cancelsTouchesInView = opts[:cancels_touches_in_view] if opts.include?(:cancels_touches_in_view)
+          o.delegate = opts[:delegate] if opts.include?(:delegate)
+          o.numberOfTapsRequired = opts[:taps_required] if opts.include?(:taps_required)
+          o.numberOfTouchesRequired = opts[:fingers_required] if opts.include?(:fingers_required)
+          # TODO, add the rest
+        end
+      end
+    end
+
+    def gesture?
+      @gesture
+    end
+
+    def location
+      if gesture?
+        @recognizer.locationInView(@sender) 
+      else
+        @sender.convertRect(@sender.bounds, toView: nil).origin
+      end
+    end
+
+    def location_in(view)
+      if gesture?
+        @recognizer.locationInView(view) 
+      else
+        @sender.convertRect(@sender.bounds, toView: view).origin
+      end
+    end
+
+    def remove
+      if @sender
+        if self.gesture?
+          @sender.removeGestureRecognizer(@recognizer)
+        else
+          @sender.removeTarget(self, action: :handle_gesture_or_event, forControlEvents: @sdk_event_or_recognizer)
+        end
+      end
+    end
+
+    CONTROL_EVENTS = { 
+      touch: UIControlEventTouchUpInside,
+      touch_up: UIControlEventTouchUpInside,
+      touch_down: UIControlEventTouchDown,
+      touch_start: UIControlEventTouchDown | UIControlEventTouchDragEnter,
+      touch_stop: UIControlEventTouchUpInside | UIControlEventTouchCancel | UIControlEventTouchDragExit,
+      change:  UIControlEventValueChanged | UIControlEventEditingChanged,
+
+      touch_down_repeat: UIControlEventTouchDownRepeat,
+      touch_drag_inside: UIControlEventTouchDragInside,
+      touch_drag_outside: UIControlEventTouchDragOutside,
+      touch_drag_enter: UIControlEventTouchDragEnter,
+      touch_drag_exit: UIControlEventTouchDragExit,
+      touch_up_inside: UIControlEventTouchUpInside,
+      touch_up_outside: UIControlEventTouchUpOutside,
+      touch_cancel: UIControlEventTouchCancel,
+
+      value_changed: UIControlEventValueChanged,
+
+      editing_did_begin: UIControlEventEditingDidBegin,
+      editing_changed: UIControlEventEditingChanged,
+      editing_did_change: UIControlEventEditingChanged,
+      editing_did_end: UIControlEventEditingDidEnd,
+      editing_did_endonexit: UIControlEventEditingDidEndOnExit,
+
+      all_touch: UIControlEventAllTouchEvents,
+      all_editing: UIControlEventAllEditingEvents,
+
+      application: UIControlEventApplicationReserved,
+      system: UIControlEventSystemReserved,
+      all: UIControlEventAllEvents
+    }
+
+    VIEW_GESTURES = {
+      tap: UITapGestureRecognizer,
+      pinch: UIPinchGestureRecognizer,
+      rotate: UIRotationGestureRecognizer,
+      swipe: UISwipeGestureRecognizer,
+      pan: UIPanGestureRecognizer,
+      long_press: UILongPressGestureRecognizer
+    }
+
+  end
+end

data/motion/ruby_motion_query/events.rb

@@ -0,0 +1,65 @@
+module RubyMotionQuery
+  class RMQ
+    def on(event, args = {}, &block)
+      selected.each do |view|
+        events(view).on(view, event, args, &block) 
+      end
+
+      self
+    end
+
+    def off(*events)
+      selected.each do |view|
+        events(view).off(events)
+      end
+
+      self
+    end
+
+    protected
+
+    def events(view)
+      view.rmq_data.events ||= Events.new
+    end
+  end
+
+  class Events
+    def initialize
+      @event_set = {}
+    end
+
+    def has_events?
+      !RMQ.is_blank?(@event_set)
+    end
+
+    def has_event?(event)
+      @event_set.include?(event)
+    end
+
+    def on(view, event, args = {}, &block)
+      raise "[RMQ Error]  Event already exists on this object: #{event}. Remove first, using .off" if @event_set[event]
+
+      if rmqe = RubyMotionQuery::Event.new(view, event, block)
+        rmqe.set_options(args)
+
+        @event_set[event] = rmqe
+      end
+
+      view
+    end
+
+    def off(*events)
+      events.flatten!
+      events = @event_set.keys if events.length == 0
+
+      events.each do |event| 
+        if rm_event = @event_set.delete(event)
+          rm_event.remove 
+        end
+      end
+
+      self
+    end
+
+  end
+end

data/motion/ruby_motion_query/factory.rb

@@ -0,0 +1,32 @@
+module RubyMotionQuery
+  class RMQ
+    # TODO question, should there be a rmq pool to reuse?
+
+    def create_blank_rmq
+      RMQ.create_with_array_and_selectors([], self.selectors, @context)
+    end
+
+    def create_rmq_in_context(*selectors)
+      RMQ.create_with_selectors(selectors, @context)
+    end
+
+    class << self
+
+      def create_with_selectors(selectors, context)
+        RMQ.new.tap do |o|
+          o.context = context
+          o.selectors = selectors
+        end
+      end
+
+      def create_with_array_and_selectors(array, selectors, context)
+        RMQ.new.tap do |o|
+          o.context = context
+          o.selectors = selectors
+          o.selected = array # Must be last
+        end
+      end
+
+    end
+  end
+end

data/motion/ruby_motion_query/font.rb

@@ -0,0 +1,66 @@
+# Add custome app-wide fonts here
+module RubyMotionQuery
+  class RMQ
+    def self.font
+      Font
+    end
+
+    def font
+      Font
+    end
+  end
+
+  class Font
+    class << self
+      # One way to add your own fonts it to open up the Font class and add your
+      # own message.
+      #
+      # STANDARD_FONT = 'Helvetica Neue'
+      # def standard_at_size(size);
+      #   UIFont.fontWithName(STANDARD_NAME, size: size)
+      # end
+      # def standard_large ; @standard_large ||= standard_at_size(18) ; end
+      # def standard_medium ; @standard_medium ||= standard_at_size(12) ; end
+
+      
+      # Another way is to add named fonts:
+      #
+      # Example
+      #   RubyMotionQuery::Font.add_named_font :large,  STANDARD_FONT, 44
+      #
+      #   # The use like so in your stylesheet:
+      #     font = font.large
+      def add_named(key, font_name_or_font, size = nil)
+        font = if font_name_or_font.is_a?(UIFont)
+          font_name_or_font
+        else
+          Font.font_with_name(font_name_or_font, size || 22)
+        end
+
+        Font.define_singleton_method(key) do
+          font
+        end
+      end
+
+      def font_with_name(name, size)
+        UIFont.fontWithName(name, size: size)
+      end
+      alias :with_name :font_with_name
+
+      # Use this in the console to get a list of font families
+      def family_list
+        UIFont.familyNames.sort
+      end
+
+      def for_family(family)
+        UIFont.fontNamesForFamilyName(family)
+      end
+
+      def system(size = nil)
+        UIFont.systemFontOfSize(size)
+      end
+
+    end
+  end
+
+end

data/motion/ruby_motion_query/format.rb

@@ -0,0 +1,54 @@
+module RubyMotionQuery
+  class RMQ
+    def format
+      Format
+    end
+    def self.format
+      Format
+    end
+  end
+
+  class Format
+    class << self
+
+      # rmq.format.number(1232, '#,##0.##')
+      def numeric(number, format)
+        RubyMotionQuery::Format.numeric_formatter(format).stringFromNumber(number)
+      end
+      alias :number :numeric
+
+      # rmq.format.date(Time.now, 'EEE, MMM d, ''yy')
+      #
+      # See <http://www.unicode.org/reports/tr35/tr35-19.html#Date_Format_Patterns>
+      # for more information about date format strings.
+      def date(date, format)
+        RubyMotionQuery::Format.date_formatter(format).stringFromDate(date)
+      end
+
+      def numeric_formatter(format)
+        @_numeric_formatter ||= {}
+
+        # Caching here is very important for performance
+        @_numeric_formatter[format] ||= begin
+          number_formater = NSNumberFormatter.alloc.init
+          number_formater.setPositiveFormat(format)
+          number_formater 
+        end
+      end
+
+      def date_formatter(format)
+        @_date_formatters ||= {}
+
+        # Caching here is very important for performance
+        @_date_formatters[format] ||= begin
+          format_template = NSDateFormatter.dateFormatFromTemplate(format, options:0,
+                                                            locale: NSLocale.currentLocale)
+          date_formatter = NSDateFormatter.alloc.init
+          date_formatter.setDateFormat(format_template)
+          date_formatter
+        end
+      end
+
+    end
+  end
+end

data/motion/ruby_motion_query/image.rb

@@ -0,0 +1,79 @@
+module RubyMotionQuery
+  class RMQ
+    def self.image
+      ImageUtils
+    end
+
+    def image
+      ImageUtils
+    end
+  end
+
+  class ImageUtils
+    class << self
+      DEFAULT_IMAGE_EXT = 'png'
+      def resource_for_device(file_base_name, opts = {})
+        resource( RMQ.device.four_inch? ? "#{file_base_name}-568h" : file_base_name, opts)
+      end
+
+      def resource(file_base_name, opts = {})
+        ext = opts[:ext] || DEFAULT_IMAGE_EXT
+        cached = opts[:cached]
+        cached = true if cached.nil?
+
+        if cached
+          UIImage.imageNamed("#{file_base_name}.#{ext}") 
+        else
+          file_base_name << '@2x' if RMQ.device.retina?
+          file = NSBundle.mainBundle.pathForResource(file_base_name, ofType: ext)
+          UIImage.imageWithContentsOfFile(file)
+        end
+      end
+
+      def resource_resizable(file_base_name, opts)
+        # TODO, also alloow short syntax, t: instead of top: etc
+        ext = opts[:ext] || DEFAULT_IMAGE_EXT
+        image = resource(file_base_name, opts)
+        image.resizableImageWithCapInsets([opts[:top], opts[:left], opts[:bottom], opts[:right]], resizingMode: UIImageResizingModeStretch) 
+      end
+
+      # [FROM Sugarcube, thanks Sugarcube]
+      #
+      # Easily take a snapshot of a `UIView`.
+      #
+      # Calling `from_view` with no arguments will return the image based on the
+      # `bounds` of the image.  In the case of container views (notably
+      # `UIScrollView` and its children) this does not include the entire contents,
+      # which is something you probably want.
+      #
+      # If you pass a truthy value to this method, it will use the `contentSize` of
+      # the view instead of the `bounds`, and it will draw all the child views, not
+      # just those that are visible in the viewport.
+      #
+      # It is guaranteed that `true` and `:all` will always have this behavior.  In
+      # the future, if this argument becomes something that accepts multiple values,
+      # those two are sacred.
+      def from_view(view, use_content_size = false)
+        scale = UIScreen.mainScreen.scale
+        if use_content_size
+          UIGraphicsBeginImageContextWithOptions(view.contentSize, false, scale)
+          context = UIGraphicsGetCurrentContext()
+          view.subviews.each do |subview|
+            CGContextSaveGState(context)
+            CGContextTranslateCTM(context, subview.frame.origin.x, subview.frame.origin.y)
+            subview.layer.renderInContext(context)
+            CGContextRestoreGState(context)
+          end
+          image = UIGraphicsGetImageFromCurrentImageContext()
+          UIGraphicsEndImageContext()
+        else
+          UIGraphicsBeginImageContextWithOptions(view.bounds.size, false, scale)
+          view.layer.renderInContext(UIGraphicsGetCurrentContext())
+          image = UIGraphicsGetImageFromCurrentImageContext()
+          UIGraphicsEndImageContext()
+        end
+        image
+      end
+    end
+  end
+end

data/motion/ruby_motion_query/position.rb

@@ -0,0 +1,45 @@
+module RubyMotionQuery
+  class RMQ
+
+    def move(opts) 
+      # TODO, add centered and from_bottom and from_top, and bottom and top
+      # TODO, add animate option
+      left = opts[:left] || opts[:l] || opts[:x]
+      top = opts[:top] || opts[:t] || opts[:y]
+      width = opts[:width] || opts[:w]
+      height = opts[:height] || opts[:h]
+
+      selected.each do |view|
+        view.frame = [
+          [left || view.origin.x, top || view.origin.y],
+          [width || view.size.width, height || view.size.height]
+        ]
+      end
+
+      self
+    end
+    alias :resize :move
+
+    def align(direction)
+      # TODO
+      # rmq(UILabel).align(:left)
+      # rmq(UILabel).align(:left, :top)
+    end
+
+    def nudge(opts) 
+      left = opts[:left] || opts[:l] || 0
+      right = opts[:right] || opts[:r] || 0
+      up = opts[:up] || opts[:u] || 0
+      down = opts[:down] || opts[:d] || 0
+
+      selected.each do |view|
+        f = view.frame
+        f.origin = [view.origin.x - left + right, view.origin.y + down - up]
+        view.frame = f
+      end
+
+      self
+    end
+
+  end
+end

data/motion/ruby_motion_query/selectors.rb

@@ -0,0 +1,56 @@
+module RubyMotionQuery
+  class RMQ
+
+    def selectors=(value)
+      @selected_dirty = true
+      normalize_selectors(value)
+      @_selectors = value
+    end
+    def selectors
+      @_selectors
+    end
+
+    def match_context(new_selectors)
+      match(context_or_context_view, new_selectors)
+    end
+
+    def match(view, new_selectors)
+      new_selectors.each do |selector|
+        if selector == :tagged
+          return true unless view.rmq_data.has_tag?
+        elsif selector.is_a?(Hash)
+          return true if match_hash(view, selector)
+        elsif selector.is_a?(Symbol)
+          # TODO, make this faster
+          return true if (view.rmq_data.style_name == selector) || view.rmq_data.has_tag?(selector)
+        elsif selector.is_a?(Integer)
+          # TODO, make this hugely faster
+          return true if view.object_id == selector
+        elsif RMQ.is_class?(selector)
+          return true if view.is_a?(selector)
+        else
+          return true if view == selector
+        end
+      end
+
+      false
+    end
+
+
+    private
+
+    def match_hash(view, hash)
+      # TODO, check speed, and do sub hashes for stuff like origin 
+      # it's probably pretty slow
+      hash.each do |k,v|
+        return true if view.respond_to?(k) && (view.send(k) == v)
+      end
+      false
+    end
+
+    def normalize_selectors(a = self.selectors)
+      a.flatten! if a
+      a
+    end
+  end
+end

data/motion/ruby_motion_query/stylers/ui_button_styler.rb

@@ -0,0 +1,32 @@
+module RubyMotionQuery
+  module Stylers
+    class UIButtonStyler < UIControlStyler 
+
+      def text=(value)
+        @view.setTitle(value, forState: UIControlStateNormal)
+      end
+      def text
+        @view.title
+      end
+
+      def font=(value) ; @view.titleLabel.font = value ; end
+      def font ; @view.titleLabel.font ; end
+
+      def color=(value)
+        @view.setTitleColor(value, forState: UIControlStateNormal)
+      end
+      def color
+        @view.titleColor
+      end
+
+      def image_normal=(value)
+        @view.setImage value, forState: UIControlStateNormal
+      end
+
+      def image_highlighted=(value)
+        @view.setImage value, forState: UIControlStateHighlighted
+      end
+
+    end
+  end
+end

data/motion/ruby_motion_query/stylers/ui_control_styler.rb

@@ -0,0 +1,8 @@
+module RubyMotionQuery
+  module Stylers
+
+    class UIControlStyler < UIViewStyler 
+    end
+
+  end
+end

data/motion/ruby_motion_query/stylers/ui_date_picker_styler.rb

@@ -0,0 +1,8 @@
+module RubyMotionQuery
+  module Stylers
+
+    class UIDatePickerStyler < UIControlStyler 
+    end
+
+  end
+end

data/motion/ruby_motion_query/stylers/ui_image_view_styler.rb

@@ -0,0 +1,14 @@
+module RubyMotionQuery
+  module Stylers
+
+    class UIImageViewStyler < UIViewStyler 
+      def image=(value)
+        @view.image = value
+      end
+      def image
+        @view.image
+      end
+    end
+
+  end
+end

data/motion/ruby_motion_query/stylers/ui_label_styler.rb

@@ -0,0 +1,36 @@
+module RubyMotionQuery
+  module Stylers
+
+    class UILabelStyler < UIViewStyler 
+      def text=(value) ; @view.text = value ; end
+      def text ; @view.text ; end
+
+      def font=(value) ; @view.font = value ; end
+      def font ; @view.font ; end
+
+      def color=(value) ; @view.textColor = value ; end
+      def color ; @view.textColor ; end
+
+      def text_alignment=(value) 
+        @view.textAlignment = TEXT_ALIGNMENTS[value] || value
+      end
+      def text_alignment 
+        @view.textAlignment
+      end
+
+      def resize_to_fit_text
+        @view.sizeToFit
+      end
+      alias :size_to_fit :resize_to_fit_text
+
+      TEXT_ALIGNMENTS = {
+        left: NSTextAlignmentLeft,
+        center: NSTextAlignmentCenter,
+        right: NSTextAlignmentRight,
+        justified: NSTextAlignmentJustified,
+        natural: NSTextAlignmentNatural
+      }
+    end
+
+  end
+end

data/motion/ruby_motion_query/stylers/ui_navigation_bar_styler.rb

@@ -0,0 +1,8 @@
+module RubyMotionQuery
+  module Stylers
+
+    class UINavigationBarStyler < UIViewStyler 
+    end
+
+  end
+end

data/motion/ruby_motion_query/stylers/ui_page_control_styler.rb

@@ -0,0 +1,8 @@
+module RubyMotionQuery
+  module Stylers
+
+    class UIPageControlStyler < UIControlStyler 
+    end
+
+  end
+end

data/motion/ruby_motion_query/stylers/ui_refresh_control_styler.rb

@@ -0,0 +1,8 @@
+module RubyMotionQuery
+  module Stylers
+
+    class UIRefreshControlStyler < UIControlStyler 
+    end
+
+  end
+end

data/motion/ruby_motion_query/stylers/ui_scroll_view_styler.rb

@@ -0,0 +1,10 @@
+module RubyMotionQuery
+  module Stylers
+
+    class UIScrollViewStyler < UIViewStyler 
+      def paging=(value) ; @view.pagingEnabled = value ; end
+      def paging ; @view.isPagingEnabled ; end
+    end
+
+  end
+end

data/motion/ruby_motion_query/stylers/ui_segmented_control_styler.rb

@@ -0,0 +1,8 @@
+module RubyMotionQuery
+  module Stylers
+
+    class UISegmentedControlStyler < UIControlStyler 
+    end
+
+  end
+end

data/motion/ruby_motion_query/stylers/ui_slider_styler.rb

@@ -0,0 +1,8 @@
+module RubyMotionQuery
+  module Stylers
+
+    class UISliderStyler < UIControlStyler 
+    end
+
+  end
+end