ProMotion 0.3.0 → 0.4.0

data/lib/ProMotion/_modules/ScreenNavigation.rb

@@ -1,149 +0,0 @@
-module ProMotion
-  module ScreenNavigation
-    def open_screen(screen, args = {})
-      # Instantiate screen if given a class instead
-      screen = screen.new if screen.respond_to?(:new)
-
-      screen.parent_screen = self
-      screen.view_controller.title = args[:title] if args[:title]
-
-      screen.add_nav_bar if args[:nav_bar]
-      
-      unless args[:close_all] || args[:modal]
-        screen.navigation_controller ||= self.navigation_controller
-        screen.tab_bar ||= self.tab_bar
-      end
-
-      screen.modal = args[:modal] if args[:modal]
-      screen.send(:on_load) if screen.respond_to?(:on_load)
-      screen.view_controller.hidesBottomBarWhenPushed = args[:hide_tab_bar] if args[:hide_tab_bar]
-
-      if args[:close_all]
-        fresh_start(screen)
-      elsif args[:modal]
-        self.view_controller.presentModalViewController(screen.main_controller, animated:true)
-      elsif args[:in_tab] && self.tab_bar
-        vc = open_tab(args[:in_tab])
-        # $stderr.puts "Found a #{vc.to_s}"
-        if vc
-          if vc.is_a?(UINavigationController)
-            screen.navigation_controller = vc
-            push_view_controller(screen.view_controller, vc)
-          else
-            self.tab_bar.selectedIndex = vc.tabBarItem.tag
-            $stderr.puts "#{self.tab_bar.selectedIndex} is selected and should be #{vc.tabBarItem.tag}"
-            # PM::TabBar.replace_current_item(self.tab_bar, view_controller: screen.view_controller)
-            # TODO: This doesn't work yet.
-          end
-        else
-          $stderr.puts "No tab bar item '#{args[:in_tab]}'"
-        end
-      elsif self.navigation_controller
-        push_view_controller screen.view_controller
-      else
-        open_view_controller screen.main_controller
-      end
-
-      if screen.respond_to?(:on_opened)
-        screen.send(:on_opened)
-      end
-    end
-
-    def fresh_start(screen)
-      app_delegate.fresh_start(screen)
-    end
-
-    def app_delegate
-      UIApplication.sharedApplication.delegate
-    end
-
-    def close_screen(args = {})
-      args ||= {}
-      
-      # Pop current view, maybe with arguments, if in navigation controller
-      previous_screen = self.parent_screen
-      if self.is_modal?
-        self.parent_screen.view_controller.dismissModalViewControllerAnimated(true)
-      elsif self.navigation_controller
-        if args[:to_screen]
-          self.navigation_controller.popToViewController(args[:to_screen].view_controller, animated: true)
-          previous_screen = args[:to_screen]
-        else
-          self.navigation_controller.popViewControllerAnimated(true)
-        end
-      else
-        Console.log("Tried to close #{self.to_s}; however, this screen isn't modal or in a nav bar.", withColor: Console::PURPLE_COLOR)
-      end
-      
-      if previous_screen && previous_screen.respond_to?(:on_return)
-        if args
-          previous_screen.send(:on_return, args)
-        else
-          previous_screen.send(:on_return)
-        end          
-      end
-    end
-
-    def tab_bar_controller(*screens)
-      tab_bar_controller = UITabBarController.alloc.init
-
-      view_controllers = []
-      tag_index = 0
-      screens.each do |s|
-        if s.is_a? Screen
-          s = s.new if s.respond_to?(:new)
-          s.view_controller.tabBarItem.tag = tag_index
-          view_controllers << s.main_controller
-          tag_index += 1
-        else
-          Console.log("Non-Screen passed into tab_bar_controller: #{s.to_s}", withColor: Console::RED_COLOR)
-        end
-      end
-
-      tab_bar_controller.viewControllers = view_controllers
-      tab_bar_controller
-    end
-    
-    # Open a UITabBarController with the specified screens as the
-    # root view controller of the current app.
-    # @param [Array] A comma-delimited list of screen classes or instances.
-    # @return [UITabBarController] (this may change in the future; please
-    #   do not rely on it right now)
-    def open_tab_bar(*screens)
-      tab_bar = tab_bar_controller(*screens)
-
-      screens.each do |s|
-        s.parent_screen = self if s.respond_to?("parent_screen=")
-        s.tab_bar = tab_bar
-        s.on_load if s.respond_to?(:on_load)
-      end
-      
-      open_view_controller(tab_bar)
-
-      screens.each do |s|
-        s.on_opened if s.respond_to?(:on_opened)
-      end
-
-      tab_bar
-    end
-
-    def open_tab(tab)
-      if tab.is_a? String
-        return PM::TabBar.select(self.tab_bar, title: tab)
-      else
-        $stderr.puts "Unable to open tab #{tab.to_s} because it isn't a string."
-      end
-    end
-
-    def open_view_controller(vc)
-      UIApplication.sharedApplication.delegate.load_root_view vc
-    end
-
-    def push_view_controller(vc, nav_controller=nil)
-      # vc.hidesBottomBarWhenPushed = true if args[:hide_tab_bar]
-      Console.log(" You need a nav_bar if you are going to push #{vc.to_s} onto it.", withColor: Console::RED_COLOR) unless self.navigation_controller
-      nav_controller ||= self.navigation_controller
-      nav_controller.pushViewController(vc, animated: true)
-    end
-  end
-end

data/lib/ProMotion/classes/Element.rb

@@ -1,14 +0,0 @@
-module ProMotion
-  class Element
-    attr_accessor :view
-
-    def initialize(with_view)
-      self.view = with_view
-      self
-    end
-
-    def remove
-      self.view.removeFromSuperview
-    end
-  end
-end

data/lib/ProMotion/classes/Screen.rb

@@ -1,206 +0,0 @@
-module ProMotion
-  # Instance methods
-  class Screen
-    include ProMotion::ScreenNavigation
-    include ProMotion::ScreenElements
-    include ProMotion::SystemHelper
-
-    attr_accessor :view_controller, :navigation_controller, :parent_screen, :first_screen, :tab_bar_item, :tab_bar, :modal
-
-    def initialize(args = {})
-      args.each do |k, v|
-        self.send("#{k}=", v) if self.respond_to?("#{k}=")
-      end
-      self.load_view_controller
-      self.view_controller.title = self.title
-
-      self.add_nav_bar if args[:nav_bar]
-      self.on_init if self.respond_to?(:on_init)
-      self
-    end
-
-    def is_modal?
-      self.modal == true
-    end
-
-    def has_nav_bar?
-      self.navigation_controller.nil? != true
-    end
-
-    # Note: this is overridden in TableScreen
-    def load_view_controller
-      self.view_controller ||= ViewController
-    end
-
-    def set_tab_bar_item(args = {})
-      self.tab_bar_item = args
-      refresh_tab_bar_item
-    end
-
-    def refresh_tab_bar_item
-      self.main_controller.tabBarItem = ProMotion::TabBar.tab_bar_item(self.tab_bar_item) if self.tab_bar_item
-    end
-
-    def add_nav_bar
-      self.navigation_controller = NavigationController.alloc.initWithRootViewController(self.view_controller)
-      self.first_screen = true
-    end
-
-    def set_nav_bar_right_button(title, args={})
-      args[:style]  ||= UIBarButtonItemStyleBordered
-      args[:target] ||= self
-      args[:action] ||= nil
-
-      right_button = UIBarButtonItem.alloc.initWithTitle(title, style: args[:style], target: args[:target], action: args[:action])
-      self.view_controller.navigationItem.rightBarButtonItem = right_button
-      right_button
-    end
-
-    def set_nav_bar_left_button(title, args={})
-      args[:style]  ||= UIBarButtonItemStyleBordered
-      args[:target] ||= self
-      args[:action] ||= nil
-
-      left_button = UIBarButtonItem.alloc.initWithTitle(title, style: args[:style], target: args[:target], action: args[:action])
-      self.view_controller.navigationItem.leftBarButtonItem = left_button
-      left_button
-    end
-
-    def view_controller=(vc)
-      vc = vc.alloc.initWithNibName(nil, bundle:nil) if vc.respond_to?(:alloc)
-      if self.navigation_controller && self.first_screen?
-        @view_controller = vc
-        self.navigation_controller = NavigationController.alloc.initWithRootViewController(self.view_controller)
-      else
-        @view_controller = vc
-      end
-      @view_controller.screen = self if @view_controller.respond_to?("screen=")
-
-      refresh_tab_bar_item
-    end
-
-    def first_screen?
-      self.first_screen == true
-    end
-
-    def set_view_controller(vc)
-      self.view_controller = vc
-    end
-
-    def view_did_load; end
-    def on_opened; end
-
-    def view_will_appear(animated)
-      ProMotion::Screen.current_screen = self
-      self.will_appear
-    end
-    def will_appear; end
-
-    def view_did_appear(animated)
-      ProMotion::Screen.current_screen = self
-      self.on_appear
-    end
-    def on_appear; end
-
-    def view_will_disappear(animated)
-      self.will_disappear
-    end
-    def will_disappear; end
-
-    def view_did_disappear(animated)
-      self.on_disappear
-    end
-    def on_disappear; end
-
-    def title
-      self.class.send(:get_title)
-    end
-
-    def title=(new_title)
-      self.class.title = new_title
-      self.view_controller.title = new_title if self.view_controller
-    end
-
-    def main_controller
-      return self.navigation_controller if self.navigation_controller
-      self.view_controller
-    end
-
-    def should_rotate(orientation)
-      case orientation
-      when UIInterfaceOrientationPortrait
-        return supported_orientation?("UIInterfaceOrientationPortrait")
-      when UIInterfaceOrientationLandscapeLeft
-        return supported_orientation?("UIInterfaceOrientationLandscapeLeft")
-      when UIInterfaceOrientationLandscapeRight
-        return supported_orientation?("UIInterfaceOrientationLandscapeRight")
-      when UIInterfaceOrientationPortraitUpsideDown
-        return supported_orientation?("UIInterfaceOrientationPortraitUpsideDown")
-      else
-        false
-      end
-    end
-
-    def will_rotate(orientation, duration)
-    end
-
-    def should_autorotate
-      false
-    end
-
-    def on_rotate
-    end
-
-    def supported_orientation?(orientation)
-      NSBundle.mainBundle.infoDictionary["UISupportedInterfaceOrientations"].include?(orientation)
-    end
-
-    def supported_orientations
-      ors = 0
-      NSBundle.mainBundle.infoDictionary["UISupportedInterfaceOrientations"].each do |ori|
-        case ori
-        when "UIInterfaceOrientationPortrait"
-          ors |= UIInterfaceOrientationMaskPortrait
-        when "UIInterfaceOrientationLandscapeLeft"
-          ors |= UIInterfaceOrientationMaskLandscapeLeft
-        when "UIInterfaceOrientationLandscapeRight"
-          ors |= UIInterfaceOrientationMaskLandscapeRight
-        when "UIInterfaceOrientationPortraitUpsideDown"
-          ors |= UIInterfaceOrientationMaskPortraitUpsideDown
-        end
-      end
-      ors
-    end
-  end
-
-  # Class methods
-  class Screen
-    class << self
-      def debug_mode
-        @debug_mode
-      end
-
-      def debug_mode=(v)
-        @debug_mode = v
-      end
-
-      def current_screen=(s)
-        @current_screen = s
-      end
-
-      def current_screen
-        @current_screen
-      end
-
-      def title(t)
-        @title = t
-      end
-      def title=(t)
-        @title = t
-      end
-      def get_title
-        @title ||= self.to_s
-      end
-    end
-  end
-end

data/lib/ProMotion/classes/TableScreen.rb

@@ -1,52 +0,0 @@
-module ProMotion
-  # Instance methods
-  class TableScreen < Screen
-    include MotionTable::PlainTable
-    include MotionTable::SearchableTable
-
-    def view
-      self.view_controller.view
-    end
-
-    def load_view_controller
-      check_table_data_method
-
-      self.view_controller ||= TableViewController
-      self.view_controller.view = self.createTableViewFromData(self.table_data)
-      if self.class.get_searchable
-        self.makeSearchable(contentController: self.view_controller, searchBar: self.class.get_searchable_params)
-      end
-    end
-
-    def check_table_data_method
-      Console.log("- table_data method needed in table view screen.", withColor: Console::RED_COLOR) unless self.respond_to?(:table_data)
-    end
-
-    def update_table_data
-      self.updateTableViewData(table_data)
-    end
-
-    class << self
-      def searchable(params={})
-        @searchable_params = params
-        @searchable = true
-      end
-
-      def get_searchable_params
-        @searchable_params ||= nil
-      end
-
-      def get_searchable
-        @searchable ||= false
-      end
-    end
-  end
-
-  class GroupedTableScreen < TableScreen
-    include MotionTable::GroupedTable
-  end
-
-  class SectionedTableScreen < TableScreen
-    include MotionTable::SectionedTable
-  end
-end

data/lib/ProMotion/helpers/MeasureHelper.rb

@@ -1,18 +0,0 @@
-module ProMotion
-  class MeasureHelper
-    class << self
-      def content_height(view)
-        height = 0
-        view.subviews.each do |sub_view|
-          next if sub_view.isHidden
-          y = sub_view.frame.origin.y
-          h = sub_view.frame.size.height
-          if (y + h) > height
-            height = y + h
-          end
-        end
-        height
-      end
-    end
-  end
-end

data/lib/ProMotion/helpers/TabBar.rb

@@ -1,99 +0,0 @@
-module ProMotion
-  class TabBar
-    class << self
-      def create_tab_bar_controller_from_data(data)
-        data = self.setTags(data)
-
-        tabBarController = UITabBarController.alloc.init
-        tabBarController.viewControllers = self.tab_controllers_from_data(data)
-
-        return tabBarController
-      end
-
-      def set_tags(data)
-        tag_number = 0
-        
-        data.each do |d|
-          d[:tag] = tag_number
-          tag_number += 1
-        end
-
-        return data
-      end
-
-      def tab_bar_icon(icon, tag)
-        return UITabBarItem.alloc.initWithTabBarSystemItem(icon, tag: tag)
-      end
-
-      def tab_bar_icon_custom(title, image_name, tag)
-        icon_image = UIImage.imageNamed(image_name)
-        return UITabBarItem.alloc.initWithTitle(title, image:icon_image, tag:tag)
-      end
-
-      def tab_controllers_from_data(data)
-        mt_tab_controllers = []
-
-        data.each do |tab|
-          mt_tab_controllers << self.controller_from_tab_data(tab)
-        end
-
-        return mt_tab_controllers
-      end
-
-      def controller_from_tab_data(tab)
-        tab[:badgeNumber] = 0 unless tab[:badgeNumber]
-        tab[:tag] = 0 unless tab[:tag]
-        
-        view_controller = tab[:view_controller]
-        view_controller = tab[:view_controller].alloc.init if tab[:view_controller].respond_to?(:alloc)
-        
-        if tab[:navigationController]
-          controller = UINavigationController.alloc.initWithRootViewController(view_controller)
-        else
-          controller = view_controller
-        end
-
-        controller.tabBarItem = self.tabBarItem(tab)
-        controller.tabBarItem.title = controller.title unless tab[:title]
-
-        return controller
-      end
-
-      def tab_bar_item(tab)
-        title = "Untitled"
-        title = tab[:title] if tab[:title]
-        tab[:tag] ||= @current_tag ||= 0
-        @current_tag = tab[:tag] + 1
-        
-        tab_bar_item = tab_bar_icon(tab[:system_icon], tab[:tag]) if tab[:system_icon]
-        tab_bar_item = tab_bar_icon_custom(title, tab[:icon], tab[:tag]) if tab[:icon]
-        
-        tab_bar_item.badgeValue = tab[:badge_number].to_s unless tab[:badge_number].nil? || tab[:badge_number] <= 0
-        
-        return tab_bar_item
-      end
-
-      def select(tab_bar_controller, title: title)
-        root_controller = nil
-        tab_bar_controller.viewControllers.each do |vc|
-          if vc.tabBarItem.title == title
-            tab_bar_controller.selectedViewController = vc
-            root_controller = vc
-            break
-          end
-        end
-        root_controller
-      end
-
-      def select(tab_bar_controller, tag: tag)
-        tab_bar_controller.selectedIndex = tag
-      end
-
-      def replace_current_item(tab_bar_controller, view_controller: vc)
-        controllers = NSMutableArray.arrayWithArray(tab_bar_controller.viewControllers)
-        controllers.replaceObjectAtIndex(tab_bar_controller.selectedIndex, withObject: vc)
-        tab_bar_controller.viewControllers = controllers
-      end
-    end
-  end
-end