rndk 0.2.0 → 1.0.0

data/lib/rndk/core/screen.rb

@@ -10,18 +10,44 @@ module RNDK
   # The only methods you should worry about are:
   #
   # * Screen#initialize
-  # * Screen#end_rndk
+  # * Screen#finish
   # * Screen#draw or #refresh
   # * Screen#erase
   #
   # ## Developer Notes
   #
-  # If you want to create your own Widget, you'll need to
-  # call some methods in here to register/unregister it
-  # to a Screen.
+  # When a Widget is created, it calls Screen#register with it's
+  # type and self pointer.
+  #
+  # That adds the widget pointer to an Array `@widget` that
+  # contains all the widgets inside this screen.
+  #
+  # During it's lifetime, most widgets would call only Screen#erase
+  # and Screen#refresh.
+  #
+  # When Widget#destroy is called, we call Screen#unregister to
+  # remove it from the `@widget` array.
+  #
+  # Now, what happens when the Ruby garbage collector kills the
+  # widget?
   #
   class Screen
-    attr_accessor :object_focus, :object_count, :object_limit, :object, :window
+    # Index of the current focused widget
+    attr_accessor :widget_focus
+
+    # How many widgets we currently have
+    attr_accessor :widget_count
+
+    # Maximum widget capacity of the screen (always expands)
+    attr_accessor :widget_limit
+
+    # Array with all the widgets currently on the screen
+    attr_accessor :widget
+
+    # Raw Ncurses window that represents this Screen
+    attr_accessor :window
+
+    # Nothing... for now
     attr_accessor :exit_status
 
     NOEXIT     = 0
@@ -47,7 +73,7 @@ module RNDK
 
       # If the user didn't start Ncurses for us,
       # we'll do it anyway.
-      if RNDK::ALL_SCREENS.size == 0 or ncurses_window.nil?
+      if RNDK::ALL_SCREENS.empty? or ncurses_window.nil?
 
         ## Why is this here?
         # Set up basic curses settings.
@@ -58,18 +84,30 @@ module RNDK
         ncurses_window = Ncurses.initscr
         Ncurses.noecho
         Ncurses.cbreak
+        Ncurses.keypad(ncurses_window, true)
       end
 
       RNDK::ALL_SCREENS << self
-      @object_count = 0
-      @object_limit = 2
-      @object = Array.new(@object_limit, nil)
+      @widget_count = 0
+      @widget_limit = 2
+      @widget = Array.new(@widget_limit, nil)
       @window = ncurses_window
-      @object_focus = 0
+      @widget_focus = 0
     end
 
-    # Shuts down RNDK and Ncurses.
-    def self.end_rndk
+    # Shuts down RNDK and Ncurses, plus destroying all the
+    # widgets ever created.
+    def self.finish
+
+      ## If I do this it gives me a segmentation fault.
+      ## I guess that would happen because of the
+      ## ruby garbage collector.
+      ##
+      ## What should I do instead?
+      #
+      # RNDK::ALL_WIDGETS.each { |obj| obj.destroy }
+      # RNDK::ALL_SCREENS.each { |scr| scr.destroy }
+
       Ncurses.echo
       Ncurses.nocbreak
       Ncurses.endwin
@@ -79,87 +117,62 @@ module RNDK
     #
     # @note This is called automatically when a widget is created.
     #
-    # `rndktype` states what RNDK Widget type this object is.
-    # `object` is a pointer to the Widget itself.
+    # * `rndktype` states what RNDK Widget type this widget is.
+    # * `widget` is a pointer to the Widget itself.
     #
-    def register(rndktype, object)
-      if @object_count + 1 >= @object_limit
-        @object_limit += 2
-        @object_limit *= 2
-        @object.concat Array.new(@object_limit - @object.size, nil)
+    def register(rndktype, widget)
+
+      # Expanding the limit by 2
+      if (@widget_count + 1) >= @widget_limit
+        @widget_limit += 2
+        @widget_limit *= 2
+        @widget.concat Array.new(@widget_limit - @widget.size, nil)
       end
 
-      if object.validObjType(rndktype)
-        self.setScreenIndex(@object_count, object)
-        @object_count += 1
+      if widget.valid_type?
+        self.set_screen_index(@widget_count, widget)
+        @widget_count += 1
       end
     end
 
-    # Removes a Widget from the Screen.
+    # Removes a Widget from this Screen.
     #
     # @note This is called automatically when a widget is destroyed.
     #
-    # This does NOT destroy the object, it removes the Widget
+    # This does NOT destroy the widget, it removes the Widget
     # from any further refreshes by Screen#refresh.
     #
-    # `rndktype` states what RNDK Widget type this object is.
-    # `object` is a pointer to the Widget itself.
+    # `rndktype` states what RNDK Widget type this widget is.
+    # `widget` is a pointer to the Widget itself.
     #
-    def self.unregister(rndktype, object)
-      return if not (object.validObjType(rndktype) && object.screen_index >= 0)
-
-      screen = object.screen
-      return if screen.nil?
+    def unregister widget
+      return unless (widget.valid_type? and (widget.screen_index >= 0))
 
-      index = object.screen_index
-      object.screen_index = -1
+      index = widget.screen_index
+      widget.screen_index = -1
 
-      # Resequence the objects
-      (index...screen.object_count - 1).each do |x|
-        screen.setScreenIndex(x, screen.object[x+1])
+      # Resequence the widgets
+      (index...self.widget_count - 1).each do |x|
+        self.set_screen_index(x, self.widget[x+1])
       end
 
-      if screen.object_count <= 1
-        # if no more objects, remove the array
-        screen.object = []
-        screen.object_count = 0
-        screen.object_limit = 0
-      else
-        screen.object[screen.object_count] = nil
-        screen.object_count -= 1
-
-        # Update the object-focus
-        if screen.object_focus == index
-          screen.object_focus -= 1
-          Traverse.setRNDKFocusNext(screen)
-
-        elsif screen.object_focus > index
-          screen.object_focus -= 1
-        end
-      end
-    end
+      if self.widget_count <= 1
+        # if no more widgets, remove the array
+        self.widget = []
+        self.widget_count = 0
+        self.widget_limit = 0
 
-    def setScreenIndex(number, obj)
-      obj.screen_index = number
-      obj.screen = self
-      @object[number] = obj
-    end
+      else
+        self.widget[self.widget_count] = nil
+        self.widget_count -= 1
 
-    def validIndex(n)
-      n >= 0 && n < @object_count
-    end
+        # Update the widget-focus
+        if self.widget_focus == index
+          self.widget_focus -= 1
+          Traverse.set_next_focus(screen)
 
-    def swapRNDKIndices(n1, n2)
-      if n1 != n2 && self.validIndex(n1) && self.validIndex(n2)
-        o1 = @object[n1]
-        o2 = @object[n2]
-        self.setScreenIndex(n1, o2)
-        self.setScreenIndex(n2, o1)
-
-        if @object_focus == n1
-          @object_focus = n2
-        elsif @object_focus == n2
-          @object_focus = n1
+        elsif self.widget_focus > index
+          self.widget_focus -= 1
         end
       end
     end
@@ -167,21 +180,21 @@ module RNDK
     # Raises the Widget to the top of the screen.
     # It will now overlap any other obstructing Widgets.
     #
-    # `rndktype` states what RNDK Widget type this object is.
-    # `object` is a pointer to the Widget itself.
+    # `rndktype` states what RNDK Widget type this widget is.
+    # `widget` is a pointer to the Widget itself.
     #
-    def self.raise_widget(rndktype, object)
-      if object.validObjType(rndktype)
-        screen = object.screen
-        screen.swapRNDKIndices(object.screen_index, screen.object_count - 1)
-      end
+    def self.raise_widget widget
+      return unless widget.valid_type?
+
+      screen = widget.screen
+      screen.swap_indexes(widget.screen_index, screen.widget_count - 1)
     end
 
     # Has the opposite effect of #raise_widget.
-    def self.lower_widget(rndktype, object)
-      if object.validObjType(rndktype)
-        object.screen.swapRNDKIndices(object.screen_index, 0)
-      end
+    def self.lower_widget widget
+      return unless widget.valid_type?
+
+      widget.screen.swap_indexes(widget.screen_index, 0)
     end
 
     # Redraws all Widgets inside this Screen.
@@ -196,12 +209,12 @@ module RNDK
 
       RNDK.window_refresh(@window)
 
-      # We erase all the invisible objects, then only draw it all back, so
-      # that the objects can overlap, and the visible ones will always be
+      # We erase all the invisible widgets, then only draw it all back, so
+      # that the widgets can overlap, and the visible ones will always be
       # drawn after all the invisible ones are erased
-      (0...@object_count).each do |x|
-        obj = @object[x]
-        if obj.validObjType(obj.object_type)
+      (0...@widget_count).each do |x|
+        obj = @widget[x]
+        if obj.valid_type?
           if obj.is_visible
             if visible < 0
               visible = x
@@ -215,14 +228,14 @@ module RNDK
         end
       end
 
-      (0...@object_count).each do |x|
-        obj = @object[x]
+      (0...@widget_count).each do |x|
+        obj = @widget[x]
 
-        if obj.validObjType(obj.object_type)
+        if obj.valid_type?
           obj.has_focus = (x == focused)
 
           if obj.is_visible
-            obj.draw(obj.box)
+            obj.draw
           end
         end
       end
@@ -234,28 +247,29 @@ module RNDK
     #       characters on the terminal screen.
     #       This does NOT destroy any widgets.
     def erase
-      (0...@object_count).each do |x|
-        obj = @object[x]
-        obj.erase if obj.validObjType obj.object_type
+      (0...@widget_count).each do |x|
+        obj = @widget[x]
+        obj.erase if obj.valid_type?
       end
       Ncurses.wrefresh(@window)
     end
 
     # Destroys all the Widgets inside this Screen.
     def destroy_widgets
-      (0...@object_count).each do |x|
-        obj    = @object[x]
-        before = @object_count
+      (0...@widget_count).each do |x|
+        obj    = @widget[x]
+        before = @widget_count
 
-        if obj.validObjType(obj.object_type)
+        if obj.valid_type?
           obj.erase
           obj.destroy
-          x -= (@object_count - before)
+          x -= (@widget_count - before)
         end
       end
     end
 
     # Destroys this Screen.
+    #
     # @note It does nothing to the widgets inside it.
     #       You must either destroy them separatedly
     #       or call #destroy_widgets before.
@@ -263,6 +277,35 @@ module RNDK
       RNDK::ALL_SCREENS.delete self
     end
 
+    protected
+
+    def set_screen_index(number, obj)
+      obj.screen_index = number
+      obj.screen = self
+      @widget[number] = obj
+    end
+
+    def valid_index? n
+      (n >= 0) and (n < @widget_count)
+    end
+
+    # Swap positions of widgets with indexes `n1` and `n2`.
+    def swap_indexes(n1, n2)
+      return unless (n1 != n2) and (self.valid_index? n1) and (self.valid_index? n2)
+
+      o1 = @widget[n1]
+      o2 = @widget[n2]
+      self.set_screen_index(n1, o2)
+      self.set_screen_index(n2, o1)
+
+      if @widget_focus == n1
+        @widget_focus = n2
+
+      elsif @widget_focus == n2
+        @widget_focus = n1
+      end
+    end
+
   end
 end
 

data/lib/rndk/core/traverse.rb

@@ -1,43 +1,128 @@
 module RNDK
+
+  #
+  #
   module Traverse
-    def Traverse.resetRNDKScreen(screen)
-      refreshDataRNDKScreen(screen)
+
+    # Traverse the screen just one time.
+    def Traverse.once(screen,
+                      curobj,
+                      key_code,
+                      function_key,
+                      func_menu_key)
+
+      case key_code
+      when Ncurses::KEY_BTAB
+        switch_focus(set_previous_focus(screen), curobj)
+
+      when RNDK::KEY_TAB
+        switch_focus(set_next_focus(screen), curobj)
+
+      when RNDK.KEY_F(10)
+        # save data and exit
+        exit_ok(screen)
+
+      when RNDK.CTRL('X')
+        exit_cancel screen
+
+      when RNDK.CTRL('R')
+        # reset data to defaults
+        reset(screen)
+        set_focus(curobj)
+
+      when RNDK::REFRESH
+        # redraw screen
+        screen.refresh
+        set_focus(curobj)
+
+      else
+        # not everyone wants menus, so we make them optional here
+        if !(func_menu_key.nil?) &&
+            (func_menu_key.call(key_code, function_key))
+          # find and enable drop down menu
+          screen.widget.each do |widget|
+            if !(widget.nil?) && widget.widget_type == :MENU
+              Traverse.handleMenu(screen, widget, curobj)
+            end
+          end
+
+        else
+          curobj.inject(key_code)
+        end
+      end
+    end
+
+    # Traverse continuously the widgets on a screen.
+    def Traverse.over screen
+      result = 0
+      curobj = set_first_focus(screen)
+
+      unless curobj.nil?
+        refresh_data(screen)
+
+        screen.exit_status = RNDK::Screen::NOEXIT
+
+        while !((curobj = get_current_focus(screen)).nil?) &&
+            screen.exit_status == RNDK::Screen::NOEXIT
+          function = []
+          key = curobj.getch(function)
+
+          # TODO look at more direct way to do this
+          check_menu_key = lambda do |key_code, function_key|
+            Traverse.checkMenuKey(key_code, function_key)
+          end
+
+
+          Traverse.once(screen, curobj, key,
+              function[0], check_menu_key)
+        end
+
+        if screen.exit_status == RNDK::Screen::EXITOK
+          save_data(screen)
+          result = 1
+        end
+      end
+      return result
+    end
+
+    def Traverse.reset screen
+      refresh_data(screen)
     end
 
-    def Traverse.exitOKRNDKScreen(screen)
+    def Traverse.exit_ok screen
       screen.exit_status = RNDK::Screen::EXITOK
     end
 
-    def Traverse.exitCancelRNDKScreen(screen)
+    def Traverse.exit_cancel screen
       screen.exit_status = RNDK::Screen::EXITCANCEL
     end
 
-    def Traverse.exitOKRNDKScreenOf(obj)
-      exitOKRNDKScreen(obj.screen)
+    def Traverse.exit_ok_of(obj)
+      exit_ok obj.screen
     end
 
-    def Traverse.exitCancelRNDKScreenOf(obj)
-      exitCancelRNDKScreen(obj.screen)
+    def Traverse.exit_cancel_of(obj)
+      exit_cancel obj.screen
     end
 
-    def Traverse.resetRNDKScreenOf(obj)
-      resetRNDKScreen(obj.screen)
+    def Traverse.reset_of(obj)
+      reset(obj.screen)
     end
 
-    # Returns the object on which the focus lies.
-    def Traverse.getRNDKFocusCurrent(screen)
+    # Returns the widget on which the focus lies.
+    def Traverse.get_current_focus(screen)
       result = nil
-      n = screen.object_focus
+      n = screen.widget_focus
 
-      if n >= 0 && n < screen.object_count
-        result = screen.object[n]
+      if n >= 0 && n < screen.widget_count
+        result = screen.widget[n]
       end
 
       return result
     end
 
-    # Set focus to the next object, returning it.
-    def Traverse.setRNDKFocusNext(screen)
+    # Set focus to the next widget, returning it.
+    def Traverse.set_next_focus(screen)
       result = nil
       curobj = nil
       n = getFocusIndex(screen)
@@ -45,10 +130,10 @@ module RNDK
 
       while true
         n+= 1
-        if n >= screen.object_count
+        if n >= screen.widget_count
           n = 0
         end
-        curobj = screen.object[n]
+        curobj = screen.widget[n]
         if !(curobj.nil?) && curobj.accepts_focus
           result = curobj
           break
@@ -59,12 +144,12 @@ module RNDK
         end
       end
 
-      setFocusIndex(screen, if !(result.nil?) then n else -1 end)
+      set_focusIndex(screen, if !(result.nil?) then n else -1 end)
       return result
     end
 
-    # Set focus to the previous object, returning it.
-    def Traverse.setRNDKFocusPrevious(screen)
+    # Set focus to the previous widget, returning it.
+    def Traverse.set_previous_focus(screen)
       result = nil
       curobj = nil
       n = getFocusIndex(screen)
@@ -73,9 +158,9 @@ module RNDK
       while true
         n -= 1
         if n < 0
-          n = screen.object_count - 1
+          n = screen.widget_count - 1
         end
-        curobj = screen.object[n]
+        curobj = screen.widget[n]
         if !(curobj.nil?) && curobj.accepts_focus
           result = curobj
           break
@@ -84,13 +169,13 @@ module RNDK
         end
       end
 
-      setFocusIndex(screen, if !(result.nil?) then n else -1 end)
+      set_focusIndex(screen, if !(result.nil?) then n else -1 end)
       return result
     end
 
-    # Set focus to a specific object, returning it.
-    # If the object cannot be found, return nil.
-    def Traverse.setRNDKFocusCurrent(screen, newobj)
+    # Set focus to a specific widget, returning it.
+    # If the widget cannot be found, return nil.
+    def Traverse.set_current_focus(screen, newobj)
       result = nil
       curobj = nil
       n = getFocusIndex(screen)
@@ -98,11 +183,11 @@ module RNDK
 
       while true
         n += 1
-        if n >= screen.object_count
+        if n >= screen.widget_count
           n = 0
         end
 
-        curobj = screen.object[n]
+        curobj = screen.widget[n]
         if curobj == newobj
           result = curobj
           break
@@ -111,95 +196,26 @@ module RNDK
         end
       end
 
-      setFocusIndex(screen, if !(result.nil?) then n else -1 end)
+      set_focusIndex(screen, if !(result.nil?) then n else -1 end)
       return result
     end
 
-    # Set focus to the first object in the screen.
-    def Traverse.setRNDKFocusFirst(screen)
-      setFocusIndex(screen, screen.object_count - 1)
-      return switchFocus(setRNDKFocusNext(screen), nil)
+    # Set focus to the first widget in the screen.
+    def Traverse.set_first_focus(screen)
+      set_focusIndex(screen, screen.widget_count - 1)
+      return switch_focus(set_next_focus(screen), nil)
     end
 
-    # Set focus to the last object in the screen.
-    def Traverse.setRNDKFocusLast(screen)
-      setFocusIndex(screen, 0)
-      return switchFocus(setRNDKFocusPrevious(screen), nil)
-    end
-
-    def Traverse.traverseRNDKOnce(screen, curobj, key_code,
-        function_key, func_menu_key)
-      case key_code
-      when Ncurses::KEY_BTAB
-        switchFocus(setRNDKFocusPrevious(screen), curobj)
-      when RNDK::KEY_TAB
-        switchFocus(setRNDKFocusNext(screen), curobj)
-      when RNDK.KEY_F(10)
-        # save data and exit
-        exitOKRNDKScreen(screen)
-      when RNDK.CTRL('X')
-        exitCancelRNDKScreen(screen)
-      when RNDK.CTRL('R')
-        # reset data to defaults
-        resetRNDKScreen(screen)
-        setFocus(curobj)
-      when RNDK::REFRESH
-        # redraw screen
-        screen.refresh
-        setFocus(curobj)
-      else
-        # not everyone wants menus, so we make them optional here
-        if !(func_menu_key.nil?) &&
-            (func_menu_key.call(key_code, function_key))
-          # find and enable drop down menu
-          screen.object.each do |object|
-            if !(object.nil?) && object.object_type == :MENU
-              Traverse.handleMenu(screen, object, curobj)
-            end
-          end
-        else
-          curobj.inject(key_code)
-        end
-      end
-    end
-
-    # Traverse the widgets on a screen.
-    def Traverse.traverseRNDKScreen(screen)
-      result = 0
-      curobj = setRNDKFocusFirst(screen)
-
-      unless curobj.nil?
-        refreshDataRNDKScreen(screen)
-
-        screen.exit_status = RNDK::Screen::NOEXIT
-
-        while !((curobj = getRNDKFocusCurrent(screen)).nil?) &&
-            screen.exit_status == RNDK::Screen::NOEXIT
-          function = []
-          key = curobj.getch(function)
-
-          # TODO look at more direct way to do this
-          check_menu_key = lambda do |key_code, function_key|
-            Traverse.checkMenuKey(key_code, function_key)
-          end
-
-
-          Traverse.traverseRNDKOnce(screen, curobj, key,
-              function[0], check_menu_key)
-        end
-
-        if screen.exit_status == RNDK::Screen::EXITOK
-          saveDataRNDKScreen(screen)
-          result = 1
-        end
-      end
-      return result
+    # Set focus to the last widget in the screen.
+    def Traverse.set_last_focus(screen)
+      set_focusIndex(screen, 0)
+      return switch_focus(set_previous_focus(screen), nil)
     end
 
     private
 
     def Traverse.limitFocusIndex(screen, value)
-      if value >= screen.object_count || value < 0
+      if value >= screen.widget_count || value < 0
         0
       else
         value
@@ -207,33 +223,33 @@ module RNDK
     end
 
     def Traverse.getFocusIndex(screen)
-      return limitFocusIndex(screen, screen.object_focus)
+      return limitFocusIndex(screen, screen.widget_focus)
     end
 
-    def Traverse.setFocusIndex(screen, value)
-      screen.object_focus = limitFocusIndex(screen, value)
+    def Traverse.set_focusIndex(screen, value)
+      screen.widget_focus = limitFocusIndex(screen, value)
     end
 
-    def Traverse.unsetFocus(obj)
-      Ncurses.curs_set(0)
+    def Traverse.unset_focus(obj)
+      RNDK::blink_cursor false
       unless obj.nil?
         obj.has_focus = false
         obj.unfocus
       end
     end
 
-    def Traverse.setFocus(obj)
+    def Traverse.set_focus(obj)
       unless obj.nil?
         obj.has_focus = true
         obj.focus
       end
-      Ncurses.curs_set(1)
+      RNDK::blink_cursor true
     end
 
-    def Traverse.switchFocus(newobj, oldobj)
+    def Traverse.switch_focus(newobj, oldobj)
       if oldobj != newobj
-        Traverse.unsetFocus(oldobj)
-        Traverse.setFocus(newobj)
+        Traverse.unset_focus(oldobj)
+        Traverse.set_focus(newobj)
       end
       return newobj
     end
@@ -245,9 +261,9 @@ module RNDK
     def Traverse.handleMenu(screen, menu, oldobj)
       done = false
 
-      switchFocus(menu, oldobj)
+      switch_focus(menu, oldobj)
       while !done
-        key = menu.getch([])
+        key = menu.getch
 
         case key
         when RNDK::KEY_TAB
@@ -261,29 +277,27 @@ module RNDK
         end
       end
 
-      if (newobj = Traverse.getRNDKFocusCurrent(screen)).nil?
-        newobj = Traverse.setRNDKFocusNext(screen)
+      if (newobj = Traverse.get_current_focus(screen)).nil?
+        newobj = Traverse.set_next_focus(screen)
       end
 
-      return switchFocus(newobj, menu)
+      return switch_focus(newobj, menu)
     end
 
-    # Save data in widgets on a screen
-    def Traverse.saveDataRNDKScreen(screen)
-      screen.object.each do |object|
-        unless object.nil?
-          object.saveData
-        end
+    # Calls Widget#save_data on all widgets of `screen`.
+    def Traverse.save_data screen
+      screen.widget.each do |widget|
+        widget.save_data unless widget.nil?
       end
     end
 
-    # Refresh data in widgets on a screen
-    def Traverse.refreshDataRNDKScreen(screen)
-      screen.object.each do |object|
-        unless object.nil?
-          object.refreshData
-        end
+    # Calls Widget#refresh_data on all widgets of `screen`.
+    def Traverse.refresh_data screen
+      screen.widget.each do |widget|
+        widget.refresh_data unless widget.nil?
       end
     end
+
   end
 end
+