under-os-ui 1.4.0

data/lib/under_os/ui.rb

@@ -0,0 +1,3 @@
+module UnderOs::UI
+  # Just a namespace for UI things
+end

data/lib/under_os/ui/alert.rb

@@ -0,0 +1,52 @@
+class UnderOs::UI::Alert
+  include UnderOs::Events
+
+  def initialize(options={})
+    options = {message: options}  if options.is_a?(String)
+    self.on = options.delete[:on] if options[:on]
+
+    @_ = CustomAlertView.alloc.initiWithOptions(self, options)
+    @_.show unless options[:show] == false
+  end
+
+  def show
+    @_.show
+    self
+  end
+
+  def hide(animated=true)
+    @_.dismissWithClickedButtonIndex(0, animated: animated)
+    self
+  end
+
+  def visible
+    @_.visible
+  end
+
+  def hidden
+    !visible
+  end
+
+  class CustomAlertView < UIAlertView
+    def initiWithOptions(wrapper, options)
+      @wrapper = wrapper
+
+      initWithTitle(     options[:title]   || "",
+                message: options[:message] || "No message given",
+               delegate: self,
+      cancelButtonTitle: options[:button]  || "Ok",
+      otherButtonTitles: nil )
+
+      (options[:buttons] || []).each do |title|
+        addButtonWithTitle title
+      end
+
+      self
+    end
+
+    def alertView(alertView, willDismissWithButtonIndex:buttonIndex)
+      @wrapper.emit(:tap, buttonIndex: buttonIndex, buttonTitle: buttonTitleAtIndex(buttonIndex))
+      @wrapper.emit(:close)
+    end
+  end
+end

data/lib/under_os/ui/button.rb

@@ -0,0 +1,42 @@
+class UnderOS::UI::Button < UnderOS::UI::View
+  wraps UIButton, tag: 'button'
+
+  def initialize(options={})
+    super
+
+    self.text = options.delete(:text) || ''
+    self.disable if options[:disabled]
+
+    @_.showsTouchWhenHighlighted = true
+    @_.setBackgroundImage(options.delete(:image), forState:UIControlStateNormal) if options[:image]
+    @_.sizeToFit
+  end
+
+  def text
+    @_.currentTitle
+  end
+
+  def text=(new_text, state=UIControlStateNormal)
+    @_.setTitle new_text, forState:state
+    repaint
+  end
+
+  def disabled
+    ! @_.isEnabled
+  end
+
+  alias :disabled? :disabled
+
+  def disabled=(value)
+    @_.enabled = ! value
+  end
+
+  def disable
+    self.disabled = true
+  end
+
+  def enable
+    self.disabled = false
+  end
+
+end

data/lib/under_os/ui/collection.rb

@@ -0,0 +1,65 @@
+class UnderOs::UI::Collection < UnderOs::UI::View
+  wraps UICollectionView, tag: :collection
+
+  def initialize(options={})
+    super
+
+    self.layout = Layout.new                          if ! options[:layout]
+    self.layout = options.delete(:layout)             if options[:layout].is_a?(Class)
+    self.layout = options.delete(:layout).constantize if options[:layout].is_a?(String)
+
+    @_.delegate = @_.dataSource = Delegate.new(self)
+    @_.registerClass(Cell, forCellWithReuseIdentifier:'UOSCollectionCell')
+  end
+
+  def on(*args, &block)
+    super *args do |event|
+      params = [event.item, event.index, event.section]
+      params = params.slice(0, block.arity) if block.arity > -1
+
+      block.call *params
+    end
+  end
+
+  def layout
+    @layout
+  end
+
+  def layout=(layout)
+    layout = Layout.new(layout) if layout.is_a?(UICollectionViewLayout)
+    @_.collectionViewLayout = (@layout = layout)._
+  end
+
+  def item_class
+    Cell.classes[self]
+  end
+
+  def item_class=(klass)
+    Cell.classes[self] = klass
+  end
+
+  def reload
+    @_.reloadData
+    self
+  end
+
+  def number_of_items(section=0)
+    (@number_of_items || [0])[section]
+  end
+
+  def number_of_items=(value)
+    @number_of_items = value.is_a?(Numeric) ? [value] : value
+    reload
+  end
+
+  def number_of_sections
+    (@number_of_items || [0]).size
+  end
+
+  def repaint(stylesheet=nil)
+    stylesheet ||= page && page.stylesheet
+
+    self.style = stylesheet.styles_for(self) if stylesheet
+    Styles.build(self, stylesheet)           if stylesheet
+  end
+end

data/lib/under_os/ui/collection/cell.rb

@@ -0,0 +1,21 @@
+#
+# This is a bridge to the iOS native functionality
+# please do not use it in your code
+#
+class UnderOs::UI::Collection::Cell < UICollectionViewCell
+
+  def self.classes
+    @classes ||= {}
+  end
+
+  def uos_view_for(collection)
+    @uos_view ||= self.class.classes[collection].for(collection).tap do |view|
+      contentView.addSubview(view._)
+    end
+  end
+
+  def prepareForReuse
+    super
+    @uos_view.cleanup if @uos_view
+  end
+end

data/lib/under_os/ui/collection/delegate.rb

@@ -0,0 +1,70 @@
+#
+# The iOS level events receiver, not for a public use
+#
+class UnderOs::UI::Collection::Delegate < UIViewController
+
+  def self.new(collection)
+    alloc.tap do |instance|
+      instance.instance_eval do
+        @collection = collection
+      end
+    end
+  end
+
+  ################################################################
+  # DataSource API
+  ################################################################
+
+  def numberOfSectionsInCollectionView(collection)
+    @collection.number_of_sections
+  end
+
+  def collectionView(collection, numberOfItemsInSection: section)
+    @collection.number_of_items(section)
+  end
+
+  def collectionView(collection, cellForItemAtIndexPath: indexPath)
+    collection.dequeueReusableCellWithReuseIdentifier('UOSCollectionCell', forIndexPath:indexPath).tap do |item|
+      @collection.emit(:item, item: item.uos_view_for(@collection), index: indexPath.row, section: indexPath.section)
+    end
+  end
+
+  # def collectionView(collection, viewForSupplementaryElementOfKind: kind, atIndexPath: indexPath)
+  #   # kind is a string
+  #   UICollectionReusableView.alloc.init
+    # UICollectionReusableView * reusableview = nil ;
+
+    # if ( kind == UICollectionElementKindSectionHeader ) {
+    #     RecipeCollectionHeaderView * headerView = [ collectionView dequeueReusableSupplementaryViewOfKind : UICollectionElementKindSectionHeader withReuseIdentifier : @ "HeaderView" forIndexPath : indexPath ] ;
+    #     NSString * title = [ [ NSString alloc ] initWithFormat : @ "Recipe Group #%i" , indexPath.section + 1 ] ;
+    #     headerView.title.text = title;
+    #     UIImage * headerImage = [ UIImage imageNamed : @ "header_banner.png" ] ;
+    #     headerView.backgroundImage.image = headerImage;
+
+    #     reusableview = headerView;
+    # }
+
+    # if ( kind == UICollectionElementKindSectionFooter ) {
+    #     UICollectionReusableView * footerview = [ collectionView dequeueReusableSupplementaryViewOfKind : UICollectionElementKindSectionFooter withReuseIdentifier : @ "FooterView" forIndexPath : indexPath ] ;
+
+    #     reusableview = footerview;
+    # }
+
+    # return reusableview;
+  # end
+
+
+  ################################################################
+  # DataSource API
+  ################################################################
+
+  def collectionView(collection, didSelectItemAtIndexPath: indexPath)
+    item = collection.cellForItemAtIndexPath(indexPath).uos_view_for(@collection)
+    @collection.emit(:select, item: item, index: indexPath.row, section: indexPath.section)
+  end
+
+  def collectionView(collection, didDeselectItemAtIndexPath: indexPath)
+    item = collection.cellForItemAtIndexPath(indexPath).uos_view_for(@collection)
+    @collection.emit(:unselect, item: item, index: indexPath.row, section: indexPath.section)
+  end
+end

data/lib/under_os/ui/collection/item.rb

@@ -0,0 +1,32 @@
+#
+# This is the collection item class that you supposed
+# to inherit (well, if you need to)
+#
+class UnderOs::UI::Collection::Item < UnderOs::UI::View
+
+  tag :item
+
+  def self.build(collection, &builder)
+    @builders           ||= {}
+    @builders[collection] = builder
+    collection.item_class = self
+  end
+
+  def self.for(collection, stylesheet=nil)
+    new.tap do |view|
+      def view.parent; @_parent; end
+      view.instance_variable_set('@_parent', collection)
+
+      @builders[collection] && @builders[collection].call.each do |child|
+        view.insert child
+      end
+
+      view.repaint(stylesheet || UnderOs::App.history.current_page.stylesheet)
+    end
+  end
+
+  def cleanup
+    # implement me if you need to clean cells between reuse
+  end
+
+end

data/lib/under_os/ui/collection/layout.rb

@@ -0,0 +1,43 @@
+#
+# The basic, grid (flow) layout. inheritable.
+#
+class Layout
+  attr_reader :_
+
+  def initialize(layout=nil)
+    @_ = layout || UICollectionViewFlowLayout.alloc.init
+
+    self.items_spacing = 0
+    self.rows_spacing  = 1
+  end
+
+  def item_size
+  end
+
+  def item_size=(*size)
+    size = UnderOs::Point.new(*size)
+    @_.itemSize = CGSizeMake(size.x, size.y)
+  end
+
+  def items_spacing
+    @_.minimumInteritemSpacing
+  end
+
+  def items_spacing=(value)
+    @_.minimumInteritemSpacing = value
+  end
+
+  def rows_spacing
+    @_.minimumLineSpacing
+  end
+
+  def rows_spacing=(value)
+    @_.minimumLineSpacing = value
+  end
+
+  def section_inset
+  end
+
+  def section_inset=(value)
+  end
+end

data/lib/under_os/ui/collection/styles.rb

@@ -0,0 +1,15 @@
+#
+# This thing catches styles from the collection element
+# and adjusts the layout settings for them
+#
+class UnderOs::UI::Collection::Styles
+  def self.build(collection, stylesheet)
+    item = UnderOs::UI::Collection::Item.for(collection, stylesheet)
+
+    collection.layout.item_size     = item.size
+    collection.layout.items_spacing = item.style.marginLeft + item.style.marginRight
+    collection.layout.rows_spacing  = item.style.marginTop  + item.style.marginBottom
+
+    # TODO header/footer
+  end
+end

data/lib/under_os/ui/div.rb

@@ -0,0 +1,3 @@
+class UnderOs::UI::Div < UnderOs::UI::View
+  tag :div
+end

data/lib/under_os/ui/form.rb

@@ -0,0 +1,60 @@
+class UnderOs::UI::Form < UnderOs::UI::View
+  tag :form
+
+  def elements
+    find('*').select do |view|
+      view.is_a?(UnderOs::UI::Input) || view._.is_a?(UIButton)
+    end
+  end
+
+  def inputs
+    find('*').select do |view|
+      view.is_a?(UnderOs::UI::Input)
+    end
+  end
+
+  def values
+    {}.tap do |values|
+      inputs.each do |input|
+        next if input.disabled || ! input.name || (input.is_a?(UnderOs::UI::Switch) && !input.checked)
+
+        hash = values; key = nil
+        keys = input.name.scan(/[^\[]+/)
+
+        # getting throught the smth[smth][smth][] in the name
+        while keys.size > 1
+          key = keys.shift
+          key = key.slice(0, key.size-1) if key.ends_with?(']')
+
+          hash[key] = keys[0] == ']' ? [] : {} if ! hash[key]
+          hash = hash[key]
+        end
+
+        key = keys.shift
+        key = key.slice(0, key.size-1) if key.ends_with?(']')
+
+        if hash.is_a?(Array)
+          hash << input.value
+        else
+          hash[key] = input.value
+        end
+      end
+    end
+  end
+
+  def disable
+    elements.each(&:disable)
+    self
+  end
+
+  def enable
+    elements.each(&:enable)
+    self
+  end
+
+  def focus
+    if input = inputs.first
+      input.focus
+    end
+  end
+end

data/lib/under_os/ui/icon.rb

@@ -0,0 +1,61 @@
+class UnderOs::UI::Icon < UnderOs::UI::View
+  include UnderOs::UI::IconEngine
+  engine UnderOs::UI::IconEngineAwesome
+
+  wraps  UIButton, tag: 'icon'
+
+  def initialize(options)
+    options = {type: options} if ! options.is_a?(Hash)
+
+    super(options)
+
+    self.type = options.delete(:type) || :bug
+    self.size = options.delete(:size) || 20
+    self.disable if options[:disabled]
+
+    @_.sizeToFit
+    @_.showsTouchWhenHighlighted = true
+  end
+
+  def type
+    @type
+  end
+
+  def type=(type)
+    @type = type
+    @_.setTitle self.class.engine.text(type), forState:UIControlStateNormal
+  end
+
+  def size(size=nil)
+    if size
+      self.size = size
+      self
+    else
+      @size
+    end
+  end
+
+  def size=(size)
+    @size = size
+    @_.setFont self.class.engine.font(size)
+    @_.sizeToFit
+  end
+
+  def disabled
+    ! @_.isEnabled
+  end
+
+  alias :disabled? :disabled
+
+  def disabled=(value)
+    @_.enabled = ! value
+  end
+
+  def disable
+    self.disabled = true
+  end
+
+  def enable
+    self.disabled = false
+  end
+end