motion-prime 0.1.0

data/motion-prime/screens/_aliases_mixin.rb

@@ -0,0 +1,32 @@
+module MotionPrime
+  module ScreenAliasesMixin
+    def view_did_load; end
+    def view_will_appear(animated)
+      self.will_appear
+    end
+    def will_appear; end
+
+    def view_did_appear(animated)
+      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 will_rotate(orientation, duration); end
+
+    def should_autorotate
+      true
+    end
+
+    def on_rotate; end;
+  end
+end

data/motion-prime/screens/_base_mixin.rb

@@ -0,0 +1,119 @@
+motion_require "./_aliases_mixin"
+motion_require "./_orientations_mixin"
+motion_require "./_navigation_mixin"
+motion_require "./_navigation_bar_mixin"
+module MotionPrime
+  module ScreenBaseMixin
+    extend ::MotionSupport::Concern
+
+    include ::MotionSupport::Callbacks
+    include MotionPrime::ScreenAliasesMixin
+    include MotionPrime::ScreenOrientationsMixin
+    include MotionPrime::ScreenNavigationMixin
+    include MotionPrime::ScreenNavigationBarMixin
+
+    attr_accessor :parent_screen, :modal, :params, :main_section
+    class_attribute :current_screen
+
+    included do
+      define_callbacks :load
+    end
+
+    def on_load; end
+
+    def on_screen_load
+      run_callbacks :load do
+        on_load
+      end
+    end
+
+    def on_create(args = {})
+      unless self.is_a?(UIViewController)
+        raise StandardError.new("ERROR: Screens must extend UIViewController.")
+      end
+
+      self.params = args[:params] || {}
+      args.each do |k, v|
+        self.send("#{k}=", v) if self.respond_to?("#{k}=")
+      end
+
+      self.add_navigation_controller if args[:navigation]
+      self.on_init if respond_to?(:on_init)
+      self
+    end
+
+    def modal?
+      !!self.modal
+    end
+
+    def has_navigation?
+      !navigation_controller.nil?
+    end
+
+    def navigation_controller
+      @navigation_controller ||= self.navigationController
+    end
+
+    def navigation_controller=(val)
+      @navigation_controller = val
+    end
+
+    def add_navigation_controller
+      self.navigation_controller = NavigationController.alloc.initWithRootViewController(self)
+    end
+
+    def title
+      title = self.class.title
+      title = self.instance_eval(&title) if title.is_a?(Proc)
+      title
+    end
+
+    def title=(new_title)
+      self.class.title(new_title)
+      super
+    end
+
+    def main_controller
+      has_navigation? ? navigation_controller : self
+    end
+
+    # ACTIVITY INDICATOR
+    # ---------------------
+
+    def show_activity_indicator
+      if @activity_indicator_view.nil?
+        @activity_indicator_view = UIActivityIndicatorView.gray
+        @activity_indicator_view.center = CGPointMake(view.center.x, view.center.y - 50)
+        view.addSubview @activity_indicator_view
+      end
+      @activity_indicator_view.startAnimating
+    end
+
+    def hide_activity_indicator
+      return unless @activity_indicator_view
+      @activity_indicator_view.stopAnimating
+    end
+
+    def show_notice(message, time = 1.0)
+      MBHUDView.hudWithBody message,
+        type: MBAlertViewHUDTypeCheckmark, hidesAfter: time, show: true
+    end
+
+    def refresh
+      main_section.reload_data
+    end
+
+    # Class methods
+    module ClassMethods
+      def title(t = nil)
+        t ? @title = t : @title ||= self.to_s
+      end
+      def before_load(method_name)
+        set_callback :load, :before, method_name
+      end
+      def after_load(method_name)
+        set_callback :load, :after, method_name
+      end
+    end
+  end
+end

data/motion-prime/screens/_navigation_bar_mixin.rb

@@ -0,0 +1,57 @@
+module MotionPrime
+  module ScreenNavigationBarMixin
+    def navigation_right_button
+      navigationItem.rightBarButtonItem
+    end
+
+    def navigation_left_button
+      navigationItem.leftBarButtonItem
+    end
+
+    def set_navigation_right_button(title, args = {})
+      navigationItem.rightBarButtonItem = create_navigation_button(title, args)
+    end
+
+    def set_navigation_left_button(title, args = {})
+      navigationItem.leftBarButtonItem = create_navigation_button(title, args)
+    end
+
+    def set_navigation_back_button(title, args = {})
+      navigationItem.leftBarButtonItem = create_navigation_button(title, {action: :back}.merge(args))
+    end
+
+    def create_navigation_button(title, args = {})
+      args[:style]  ||= UIBarButtonItemStylePlain
+      args[:target] ||= self
+      args[:action] ||= nil
+
+      # TODO: Find better place for this code, may be just create custom control
+      if args[:image]
+        image = args[:image].uiimage
+        face = UIButton.buttonWithType UIButtonTypeCustom
+        face.bounds = CGRectMake(0, 0, image.size.width, image.size.height)
+        face.setImage image, forState: UIControlStateNormal
+        face.on :touch do
+          args[:action].to_proc.call(self)
+        end
+        button = UIBarButtonItem.alloc.initWithCustomView(face)
+        button
+      elsif args[:icon]
+        image = args[:icon].uiimage
+        face = UIButton.buttonWithType UIButtonTypeCustom
+        face.setImage(image, forState: UIControlStateNormal)
+        face.setTitle(title, forState: UIControlStateNormal)
+        face.bounds = CGRectMake(0, 0, 100, 60)
+        face.setContentHorizontalAlignment UIControlContentHorizontalAlignmentLeft
+        face.on :touch do
+          args[:action].to_proc.call(self)
+        end
+        button = UIBarButtonItem.alloc.initWithCustomView(face)
+        button
+      else
+        UIBarButtonItem.alloc.initWithTitle(title,
+            style: args[:style], target: args[:target], action: args[:action])
+      end
+    end
+  end
+end

data/motion-prime/screens/_navigation_mixin.rb

@@ -0,0 +1,118 @@
+module MotionPrime
+  module ScreenNavigationMixin
+    def app_delegate
+      UIApplication.sharedApplication.delegate
+    end
+
+    def open_screen(screen, args = {})
+      # Apply properties to instance
+      screen = setup_screen_for_open(screen, args)
+      ensure_wrapper_controller_in_place(screen, args)
+      screen.send(:on_screen_load) if screen.respond_to?(:on_screen_load)
+      if args[:modal]
+        present_modal_view_controller screen, (args[:animated] || true)
+      elsif has_navigation?
+        push_view_controller screen
+      else
+        app_delegate.open_screen(screen.main_controller)
+      end
+    end
+
+    def open_root_screen(screen)
+      app_delegate.open_root_screen(screen)
+    end
+
+    def show_sidebar
+      app_delegate.show_sidebar
+    end
+
+    def hide_sidebar
+      app_delegate.hide_sidebar
+    end
+
+    def close_screen(args = {})
+      args ||= {}
+      args[:animated] ||= true
+      # Pop current view, maybe with arguments, if in navigation controller
+      if modal?
+        close_modal_screen args
+      elsif has_navigation?
+        close_navigation args
+        send_on_return(args)
+      end
+    end
+
+    def back
+      close_screen
+    end
+
+    def send_on_return(args = {})
+      if parent_screen && parent_screen.respond_to?(:on_return)
+        parent_screen.send(:on_return)
+      end
+    end
+
+    def push_view_controller(vc)
+      navigation_controller.pushViewController(vc, animated: true)
+    end
+
+    protected
+
+    def setup_screen_for_open(screen, args = {})
+      # Instantiate screen if given a class
+      screen = screen.new if screen.respond_to?(:new)
+
+      # Set parent, title & modal properties
+      screen.parent_screen = self if screen.respond_to?("parent_screen=")
+      screen.title = args[:title] if args[:title] && screen.respond_to?("title=")
+      screen.modal = args[:modal] if args[:modal] && screen.respond_to?("modal=")
+
+      # Wrap in a NavigationController?
+      screen.add_navigation if args[:navigation] && screen.respond_to?(:add_navigation)
+
+      # Return modified screen instance
+      screen
+    end
+
+    def ensure_wrapper_controller_in_place(screen, args={})
+      if !args[:modal] && screen.respond_to?(:navigation_controller=)
+        screen.navigation_controller ||= navigation_controller
+      end
+    end
+
+    def present_modal_view_controller(screen, animated)
+      self.presentModalViewController(screen.main_controller, animated: animated)
+    end
+
+    def close_modal_screen(args = {})
+      parent_screen.dismissViewControllerAnimated(args[:animated], completion: lambda {
+        send_on_return(args)
+      })
+    end
+
+    def close_navigation(args = {})
+      if args[:to_screen] && args[:to_screen].is_a?(UIViewController)
+        self.parent_screen = args[:to_screen]
+        self.navigation_controller.popToViewController(args[:to_screen], animated: args[:animated])
+      else
+        self.navigation_controller.popViewControllerAnimated(args[:animated])
+      end
+    end
+
+    def has_navigation?
+      !navigation_controller.nil?
+    end
+
+    def navigation_controller
+      @navigation_controller ||= self.navigationController
+    end
+
+    def navigation_controller=(val)
+      @navigation_controller = val
+    end
+
+    def add_navigation_controller
+      self.navigation_controller = NavigationController.alloc.initWithRootViewController(self)
+    end
+  end
+end

data/motion-prime/screens/_orientations_mixin.rb

@@ -0,0 +1,39 @@
+module MotionPrime
+  module ScreenOrientationsMixin
+    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 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
+end

data/motion-prime/screens/base_screen.rb

@@ -0,0 +1,22 @@
+motion_require '../support/dm_view_controller.rb'
+motion_require '../views/layout.rb'
+motion_require '../screens/_base_mixin.rb'
+motion_require '../helpers/has_authorization'
+motion_require '../helpers/has_search_bar'
+module MotionPrime
+  class BaseScreen < DMViewController
+    include Layout
+    include ScreenBaseMixin
+    include HasAuthorization
+    include HasSearchBar
+
+    def render
+    end
+
+    def on_load
+      setup view, styles: [:base_screen, self.class.name.underscore.to_sym] do
+        render
+      end
+    end
+  end
+end

data/motion-prime/screens/sidebar_container_screen.rb

@@ -0,0 +1,58 @@
+module MotionPrime
+  class SidebarContainerScreen < PKRevealController
+
+    include ::MotionPrime::ScreenBaseMixin
+
+    def self.new(menu, content, options={})
+      screen = self.revealControllerWithFrontViewController(nil, leftViewController: nil, options: nil)
+      screen.on_create(options) if screen.respond_to?(:on_create)
+      screen.menu_controller = menu unless menu.nil?
+      screen.content_controller = content unless content.nil?
+      screen
+    end
+
+    def show_sidebar
+      show_controller menu_controller
+    end
+
+    def hide_sidebar
+      show_controller content_controller
+    end
+
+    def menu_controller=(c)
+      setLeftViewController prepare_controller(c),
+        focusAfterChange: true, completion: default_completion_block
+    end
+
+    def content_controller=(c)
+      setFrontViewController prepare_controller(c),
+        focusAfterChange: true, completion: default_completion_block
+    end
+
+    def menu_controller
+      self.leftViewController
+    end
+
+    def content_controller
+      self.frontViewController
+    end
+
+    private
+
+      def show_controller(controller)
+        showViewController controller, animated: true, completion: default_completion_block
+      end
+
+      def prepare_controller(controller)
+        controller.on_screen_load if controller.respond_to?(:on_screen_load)
+        controller = setup_screen_for_open(controller, {})
+        ensure_wrapper_controller_in_place(controller, {})
+        controller = controller.main_controller if controller.respond_to?(:main_controller)
+        controller
+      end
+
+      def default_completion_block
+        -> (completed) { true }
+      end
+  end
+end