rndk 0.2.0 → 1.0.0

data/lib/rndk/scale.rb

@@ -1,27 +1,51 @@
 require 'rndk'
 
 module RNDK
-  class SCALE < Widget
-    def initialize(rndkscreen, xplace, yplace, title, label, field_attr,
-        field_width, start, low, high, inc, fast_inc, box, shadow)
+
+  class Scale < Widget
+
+    def initialize(screen, config={})
       super()
-      parent_width = Ncurses.getmaxx(rndkscreen.window)
-      parent_height = Ncurses.getmaxy(rndkscreen.window)
-      bindings = {
-          'u'           => Ncurses::KEY_UP,
-          'U'           => Ncurses::KEY_PPAGE,
-          RNDK::BACKCHAR => Ncurses::KEY_PPAGE,
-          RNDK::FORCHAR  => Ncurses::KEY_NPAGE,
-          'g'           => Ncurses::KEY_HOME,
-          '^'           => Ncurses::KEY_HOME,
-          'G'           => Ncurses::KEY_END,
-          '$'           => Ncurses::KEY_END,
-      }
-
-      self.set_box(box)
+      @widget_type = :scale
+      @supported_signals += [:before_input, :after_input]
+
+      x              = 0
+      y              = 0
+      title          = "scale"
+      label          = "label"
+      field_color    = RNDK::Color[:normal]
+      field_width    = 0
+      start          = 0
+      low            = 0
+      high           = 100
+      inc            = 1
+      fast_increment = 5
+      box            = true
+      shadow         = false
+
+      config.each do |key, val|
+        x              = val if key == :x
+        y              = val if key == :y
+        title          = val if key == :title
+        label          = val if key == :label
+        field_color    = val if key == :field_color
+        field_width    = val if key == :field_width
+        start          = val if key == :start
+        low            = val if key == :low
+        high           = val if key == :high
+        inc            = val if key == :inc
+        fast_increment = val if key == :fast_increment
+        box            = val if key == :box
+        shadow         = val if key == :shadow
+      end
+
+      parent_width  = Ncurses.getmaxx screen.window
+      parent_height = Ncurses.getmaxy screen.window
 
+      self.set_box box
+
+      box_width  = field_width + 2 * @border_size
       box_height = @border_size * 2 + 1
-      box_width = field_width + 2 * @border_size
 
       # Set some basic values of the widget's data field.
       @label = []
@@ -31,7 +55,9 @@ module RNDK
       # If the field_width is a negative value, the field_width will
       # be COLS-field_width, otherwise the field_width will be the
       # given width.
-      field_width = RNDK.setWidgetDimension(parent_width, field_width, 0)
+      field_width = RNDK.set_widget_dimension(parent_width,
+                                              field_width,
+                                              0)
       box_width = field_width + 2 * @border_size
 
       # Translate the label string to a chtype array
@@ -55,9 +81,9 @@ module RNDK
           box_width - @label_len - 2 * @border_size].min
 
       # Rejustify the x and y positions if we need to.
-      xtmp = [xplace]
-      ytmp = [yplace]
-      RNDK.alignxy(rndkscreen.window, xtmp, ytmp, box_width, box_height)
+      xtmp = [x]
+      ytmp = [y]
+      RNDK.alignxy(screen.window, xtmp, ytmp, box_width, box_height)
       xpos = xtmp[0]
       ypos = ytmp[0]
 
@@ -98,19 +124,19 @@ module RNDK
       Ncurses.keypad(@win, true)
 
       # Create the widget's data field.
-      @screen = rndkscreen
-      @parent = rndkscreen.window
+      @screen = screen
+      @parent = screen.window
       @shadow_win = nil
       @box_width = box_width
       @box_height = box_height
       @field_width = field_width
-      @field_attr = field_attr
+      @field_color = field_color
       @current = low
       @low = low
       @high = high
       @current = start
       @inc = inc
-      @fastinc = fast_inc
+      @fastinc = fast_increment
       @accepts_focus = true
       @input_window = @win
       @shadow = shadow
@@ -129,59 +155,60 @@ module RNDK
       end
 
       # Setup the key bindings.
-      bindings.each do |from, to|
-        self.bind(self.object_type, from, :getc, to)
-      end
 
-      rndkscreen.register(self.object_type, self)
+      self.bind_key('u') { self.increment @inc     }
+      self.bind_key('U') { self.increment @fastinc }
+      self.bind_key('g') { @current = @low         }
+      self.bind_key('^') { @current = @low         }
+      self.bind_key('G') { @current = @high        }
+      self.bind_key('$') { @current = @high        }
+
+      screen.register(self.widget_type, self)
     end
 
     # This allows the person to use the widget's data field.
-    def activate(actions)
-      ret = -1
-      # Draw the widget.
-      self.draw(@box)
+    def activate(actions=[])
+      ret = false
+
+      self.draw
 
       if actions.nil? || actions.size == 0
         input = 0
         while true
-          input = self.getch([])
+          input = self.getch
 
           # Inject the character into the widget.
           ret = self.inject(input)
-          if @exit_type != :EARLY_EXIT
-            return ret
-          end
+
+          return ret if @exit_type != :EARLY_EXIT
         end
       else
         # Inject each character one at a time.
         actions.each do |action|
           ret = self.inject(action)
         end
-        if @exit_type != :EARLY_EXIT
-          return ret
-        end
+
+        return ret if @exit_type != :EARLY_EXIT
       end
 
       # Set the exit type and return.
       self.set_exit_type(0)
-      return ret
+      ret
     end
 
     # Check if the value lies outsid the low/high range. If so, force it in.
     def limitCurrentValue
       if @current < @low
         @current = @low
-        RNDK.beep
       elsif @current > @high
         @current = @high
-        RNDK.beep
       end
+      RNDK.beep
     end
 
     # Move the cursor to the given edit-position
     def moveToEditPosition(new_position)
-      return Ncurses.wmove(@field_win, 0, @field_width - new_position - 1)
+      Ncurses.wmove(@field_win, 0, @field_width - new_position - 1)
     end
 
     # Check if the cursor is on a valid edit-position. This must be one of
@@ -254,10 +281,10 @@ module RNDK
         temp[col] = input.chr
       elsif input == Ncurses::KEY_BACKSPACE
         # delete the char before the cursor
-        modify = RNDK::SCALE.removeChar(temp, col - 1)
+        modify = Scale.removeChar(temp, col - 1)
       elsif input == Ncurses::KEY_DC
         # delete the char at the cursor
-        modify = RNDK::SCALE.removeChar(temp, col)
+        modify = Scale.removeChar(temp, col)
       else
         modify = false
       end
@@ -272,64 +299,51 @@ module RNDK
       return result
     end
 
-    def self.Decrement(value, by)
-      if value - by < value
-        value - by
-      else
-        value
-      end
+    def decrement by
+      @current = @current - by if (@current - by) < @current
     end
 
-    def self.Increment(value, by)
-      if value + by > value
-        value + by
-      else
-        value
-      end
+    def increment by
+      @current = @current + by if (@current + by) > @current
     end
 
     # This function injects a single character into the widget.
-    def inject(input)
-      pp_return = 1
-      ret = -1
+    def inject input
+      pp_return = true
+      ret = false
       complete = false
 
       # Set the exit type.
       self.set_exit_type(0)
 
       # Draw the field.
-      self.drawField
+      self.draw_field
 
       # Check if there is a pre-process function to be called.
-      unless @pre_process_func.nil?
-        # Call the pre-process function.
-        pp_return = @pre_process_func.call(self.object_type, self,
-            @pre_process_data, input)
-      end
+      keep_going = self.run_signal_binding(:before_input, input)
+
+      if keep_going
 
-      # Should we continue?
-      if pp_return != 0
         # Check for a key bindings.
-        if self.checkBind(self.object_type, input)
-          complete = true
+        if self.is_bound? input
+          self.run_key_binding input
+          #complete = true
+
         else
           case input
           when Ncurses::KEY_LEFT
             self.setEditPosition(@field_edit + 1)
           when Ncurses::KEY_RIGHT
             self.setEditPosition(@field_edit - 1)
-          when Ncurses::KEY_DOWN
-            @current = RNDK::SCALE.Decrement(@current, @inc)
-          when Ncurses::KEY_UP
-            @current = RNDK::SCALE.Increment(@current, @inc)
-          when Ncurses::KEY_PPAGE
-            @current = RNDK::SCALE.Increment(@current, @fastinc)
-          when Ncurses::KEY_NPAGE
-            @current = RNDK::SCALE.Decrement(@current, @fastinc)
-          when Ncurses::KEY_HOME
-            @current = @low
-          when Ncurses::KEY_END
-            @current = @high
+
+          when Ncurses::KEY_DOWN  then self.decrement @inc
+          when Ncurses::KEY_UP    then self.increment @inc
+          when Ncurses::KEY_HOME  then @current = @low
+          when Ncurses::KEY_END   then @current = @high
+          when Ncurses::KEY_PPAGE, RNDK::BACKCHAR
+            self.increment @fastinc
+          when Ncurses::KEY_NPAGE, RNDK::FORCHAR
+            self.decrement @fastinc
           when RNDK::KEY_TAB, RNDK::KEY_RETURN, Ncurses::KEY_ENTER
             self.set_exit_type(input)
             ret = @current
@@ -368,16 +382,12 @@ module RNDK
         end
         self.limitCurrentValue
 
-        # Should we call a post-process?
-        if !complete && !(@post_process_func).nil?
-          @post_process_func.call(self.object_type, self,
-              @post_process_data, input)
-        end
+        self.run_signal_binding(:after_input) if not complete
       end
 
-      if !complete
-        self.drawField
-        self.set_exit_type(0)
+      if not complete
+        self.draw_field
+        self.set_exit_type 0
       end
 
       @result_data = ret
@@ -385,25 +395,19 @@ module RNDK
     end
 
     # This moves the widget's data field to the given location.
-    def move(xplace, yplace, relative, refresh_flag)
+    def move(x, y, relative, refresh_flag)
       windows = [@win, @label_win, @field_win, @shadow_win]
 
-      self.move_specific(xplace, yplace, relative, refresh_flag, windows, [])
+      self.move_specific(x, y, relative, refresh_flag, windows, [])
     end
 
     # This function draws the widget.
-    def draw(box)
-      # Draw the shadow.
-      unless @shadow_win.nil?
-        Draw.drawShadow(@shadow_win)
-      end
+    def draw
+      Draw.drawShadow(@shadow_win) unless @shadow_win.nil?
 
-      # Box the widget if asked.
-      if box
-        Draw.drawObjBox(@win, self)
-      end
+      Draw.drawObjBox(@win, self) if @box
 
-      self.drawTitle(@win)
+      self.draw_title @win
 
       # Draw the label.
       unless @label_win.nil?
@@ -413,16 +417,16 @@ module RNDK
                          @label, RNDK::HORIZONTAL,
                          0,
                          @label_len)
-        Ncurses.wrefresh(@label_win)
+        Ncurses.wrefresh @label_win
       end
       Ncurses.wrefresh @win
 
       # Draw the field window.
-      self.drawField
+      self.draw_field
     end
 
     # This draws the widget.
-    def drawField
+    def draw_field
       Ncurses.werase(@field_win)
 
       # Draw the value in the field.
@@ -431,7 +435,7 @@ module RNDK
                            @field_width - temp.size - 1,
                            0,
                            temp,
-                           @field_attr,
+                           @field_color,
                            RNDK::HORIZONTAL,
                            0,
                            temp.size)
@@ -441,7 +445,7 @@ module RNDK
     end
 
     # This sets the background attribute of teh widget.
-    def set_bg_attrib attrib
+    def set_bg_color attrib
       Ncurses.wbkgd(@win, attrib)
       Ncurses.wbkgd(@field_win, attrib)
       Ncurses.wbkgd(@label_win, attrib) unless @label_win.nil?
@@ -449,7 +453,7 @@ module RNDK
 
     # This function destroys the widget.
     def destroy
-      self.cleanTitle
+      self.clean_title
       @label = []
 
       # Clean up the windows.
@@ -459,15 +463,15 @@ module RNDK
       RNDK.window_delete @win
 
       # Clean the key bindings.
-      self.clean_bindings(self.object_type)
+      self.clean_bindings
 
-      # Unregister this object
-      RNDK::Screen.unregister(self.object_type, self)
+      # Unregister this widget
+      @screen.unregister(self.widget_type, self)
     end
 
     # This function erases the widget from the screen.
     def erase
-      if self.valid_widget?
+      if self.valid?
         RNDK.window_erase @label_win
         RNDK.window_erase @field_win
         RNDK.window_erase @win
@@ -478,12 +482,12 @@ module RNDK
     # This function sets the low/high/current values of the widget.
     def set(low, high, value, box)
       self.setLowHigh(low, high)
-      self.setValue(value)
-      self.set_box(box)
+      self.setValue value
+      self.set_box box
     end
 
     # This sets the widget's value
-    def setValue(value)
+    def setValue value
       @current = value
       self.limitCurrentValue
     end
@@ -516,11 +520,11 @@ module RNDK
     end
 
     def focus
-      self.draw(@box)
+      self.draw
     end
 
     def unfocus
-      self.draw(@box)
+      self.draw
     end
 
     def position
@@ -531,8 +535,5 @@ module RNDK
       '%d%c'
     end
 
-    def object_type
-      :SCALE
-    end
   end
 end

data/lib/rndk/scroll.rb

@@ -2,27 +2,27 @@ require 'rndk/scroller'
 
 module RNDK
 
-  # A scrolling list of text.
+  # A scrolling items of text.
   #
   # ## Keybindings
   #
-  # Left Arrow::  Shift the list left one column.
-  # Right Arrow:: Shift the list right one column.
-  # Up Arrow::    Select the previous item in the list.
-  # Down Arrow::  Select the next item in the list.
+  # Left Arrow::  Shift the items left one column.
+  # Right Arrow:: Shift the items right one column.
+  # Up Arrow::    Select the previous item in the items.
+  # Down Arrow::  Select the next item in the items.
   # Prev Page::   Scroll one page backward.
   # Ctrl-B::      Scroll one page backward.
   # Next Page::   Scroll one page forward.
   # Ctrl-F::      Scroll one page forward.
-  # 1::           Move to the first element in the list.
-  # <::           Move to the first element in the list.
-  # g::           Move to the first element in the list.
-  # Home::        Move to the first element in the list.
-  # >::           Move to the last element in the list.
-  # G::           Move to the last element in the list.
-  # End::         Move to the last element in the list.
-  # $::           Shift the list to the far right.
-  # |::           Shift the list to the far left.
+  # 1::           Move to the first element in the items.
+  # <::           Move to the first element in the items.
+  # g::           Move to the first element in the items.
+  # Home::        Move to the first element in the items.
+  # >::           Move to the last element in the items.
+  # G::           Move to the last element in the items.
+  # End::         Move to the last element in the items.
+  # $::           Shift the items to the far right.
+  # |::           Shift the items to the far left.
   # Return::      Exit  the  widget and return the index
   #               of the selected item. Also  set  the
   #               widget `exit_type` to `:NORMAL`.
@@ -33,16 +33,16 @@ module RNDK
   #               set the widget `exit_type` `:ESCAPE_HIT`.
   # Ctrl-L::      Refreshes the screen.
   #
-  class Scroll < SCROLLER
-    attr_reader :item, :list_size, :current_item, :highlight
+  class Scroll < Scroller
+    attr_reader :item, :current_item, :highlight
 
     # Creates a Scroll Widget.
     #
-    # * `xplace` is the x position - can be an integer or
+    # * `x` is the x position - can be an integer or
     #   `RNDK::LEFT`, `RNDK::RIGHT`, `RNDK::CENTER`.
-    # * `yplace` is the y position - can be an integer or
+    # * `y` is the y position - can be an integer or
     #   `RNDK::TOP`, `RNDK::BOTTOM`, `RNDK::CENTER`.
-    # * `splace` is where the scrollbar will be placed.
+    # * `scroll_bar` is where the scrollbar will be placed.
     #   It can be only `RNDK::LEFT`, `RNDK::RIGHT` or
     #   `RNDK::NONE`, for no scrollbar.
     # * `width`/`height` are integers - if either are 0, Widget
@@ -51,68 +51,76 @@ module RNDK
     #   minus the value.
     # * `title` can be more than one line - just split them
     #   with `\n`s.
-    # * `list` is an Array of Strings to be shown on the Widget.
+    # * `items` is an Array of Strings to be shown on the Widget.
     # * `numbers` is a flag to turn on/off line numbering at
-    #   the front of the list items.
+    #   the front of the items items.
     # * `highlight` is the attribute/color of the currently selected
-    #   item at the list.
+    #   item at the items.
     # * `box` if the Widget is drawn with a box outside it.
     # * `shadow` turns on/off the shadow around the Widget.
     #
-    def initialize (rndkscreen,
-                    xplace,
-                    yplace,
-                    splace,
-                    width,
-                    height,
-                    title,
-                    list,
-                    numbers,
-                    highlight,
-                    box,
-                    shadow)
+    def initialize(screen, config={})
       super()
+      @widget_type = :scroll
+      @supported_signals += [:before_input,
+                             :after_input,
+                             :after_scrolling]
+      x          = 0
+      y          = 0
+      scroll_bar = RNDK::RIGHT
+      width      = 0
+      height     = 0
+      title      = "scroll"
+      items      = []
+      numbers    = false
+      highlight  = RNDK::Color[:reverse]
+      box        = true
+      shadow     = false
+
+      config.each do |key, val|
+        x         = val if key == :x
+        y         = val if key == :y
+        scroll_bar    = val if key == :scroll_bar
+        width     = val if key == :width
+        height    = val if key == :height
+        title     = val if key == :title
+        items     = val if key == :items
+        numbers   = val if key == :numbers
+        highlight = val if key == :highlight
+        box       = val if key == :box
+        shadow    = val if key == :shadow
+      end
 
-      parent_width  = Ncurses.getmaxx rndkscreen.window
-      parent_height = Ncurses.getmaxy rndkscreen.window
+      parent_width  = Ncurses.getmaxx screen.window
+      parent_height = Ncurses.getmaxy screen.window
 
       box_width  = width
       box_height = height
 
-      xpos = xplace
-      ypos = yplace
+      xpos = x
+      ypos = y
 
       scroll_adjust = 0
 
-      bindings = {
-        RNDK::BACKCHAR => Ncurses::KEY_PPAGE,
-        RNDK::FORCHAR  => Ncurses::KEY_NPAGE,
-        'g'            => Ncurses::KEY_HOME,
-        '1'            => Ncurses::KEY_HOME,
-        'G'            => Ncurses::KEY_END,
-        '<'            => Ncurses::KEY_HOME,
-        '>'            => Ncurses::KEY_END
-      }
-
       self.set_box box
 
       # If the height is a negative value, the height will be ROWS-height,
       # otherwise the height will be the given height
-      box_height = RNDK.setWidgetDimension(parent_height, height, 0)
+      box_height = RNDK.set_widget_dimension(parent_height, height, 0)
 
       # If the width is a negative value, the width will be COLS-width,
       # otherwise the width will be the given width
-      box_width = RNDK.setWidgetDimension(parent_width, width, 0)
+      box_width = RNDK.set_widget_dimension(parent_width, width, 0)
 
       box_width = self.set_title(title, box_width)
 
       # Set the box height.
       if @title_lines > box_height
-        box_height = @title_lines + [list.size, 8].min + 2 * @border_size
+        box_height = @title_lines + [items.size, 8].min + 2 * @border_size
       end
 
       # Adjust the box width if there is a scroll bar
-      if splace == RNDK::LEFT || splace == RNDK::RIGHT
+      if scroll_bar == RNDK::LEFT || scroll_bar == RNDK::RIGHT
         @scrollbar = true
         box_width += 1
       else
@@ -129,12 +137,12 @@ module RNDK
                     else box_height
                     end
 
-      self.setViewSize(list.size)
+      self.set_view_size(items.size)
 
       # Rejustify the x and y positions if we need to.
       xtmp = [xpos]
       ytmp = [ypos]
-      RNDK.alignxy(rndkscreen.window, xtmp, ytmp, @box_width, @box_height)
+      RNDK.alignxy(screen.window, xtmp, ytmp, @box_width, @box_height)
       xpos = xtmp[0]
       ypos = ytmp[0]
 
@@ -150,15 +158,15 @@ module RNDK
       Ncurses.keypad(@win, true)
 
       # Create the scrollbar window.
-      if splace == RNDK::RIGHT
+      if scroll_bar == RNDK::RIGHT
         @scrollbar_win = Ncurses.subwin(@win,
-                                        self.maxViewSize,
+                                        self.max_view_size,
                                         1,
                                         self.Screen_YPOS(ypos),
                                         xpos + box_width - @border_size - 1)
-      elsif splace == RNDK::LEFT
+      elsif scroll_bar == RNDK::LEFT
         @scrollbar_win = Ncurses.subwin(@win,
-                                        self.maxViewSize,
+                                        self.max_view_size,
                                         1,
                                         self.Screen_YPOS(ypos),
                                         self.Screen_XPOS(xpos))
@@ -166,18 +174,18 @@ module RNDK
         @scrollbar_win = nil
       end
 
-      # create the list window
-      @list_win = Ncurses.subwin(@win,
-                                 self.maxViewSize,
+      # create the items window
+      @items_win = Ncurses.subwin(@win,
+                                 self.max_view_size,
                                  box_width - (2 * @border_size) - scroll_adjust,
                                  self.Screen_YPOS(ypos),
-                                 self.Screen_XPOS(xpos) + (if splace == RNDK::LEFT then 1 else 0 end))
+                                 self.Screen_XPOS(xpos) + (if scroll_bar == RNDK::LEFT then 1 else 0 end))
 
       # Set the rest of the variables
-      @screen = rndkscreen
-      @parent = rndkscreen.window
+      @screen = screen
+      @parent = screen.window
       @shadow_win = nil
-      @scrollbar_placement = splace
+      @scrollbar_placement = scroll_bar
       @max_left_char = 0
       @left_char = 0
       @highlight = highlight
@@ -186,12 +194,10 @@ module RNDK
       @input_window = @win
       @shadow = shadow
 
-      self.setPosition(0);
+      self.set_position(0);
 
-      # Create the scrolling list item list and needed variables.
-      if self.createItemList(numbers, list, list.size) <= 0
-        return nil
-      end
+      # Create the scrolling items item items and needed variables.
+      return nil unless self.create_item_list(numbers, items)
 
       # Do we need to create a shadow?
       if shadow
@@ -201,19 +207,15 @@ module RNDK
                                      xpos + 1)
       end
 
-      # Set up the key bindings.
-      bindings.each do |from, to|
-        #self.bind(:scroll, from, getc_lambda, to)
-        self.bind(:scroll, from, :getc, to)
-      end
-
-      rndkscreen.register(:scroll, self);
-
-      return self
-    end
+      # Standard keybindings (plus the Arrow Keys)
+      self.bind_key('g') { self.scroll_begin }
+      self.bind_key('1') { self.scroll_begin }
+      self.bind_key('G') { self.scroll_end   }
+      self.bind_key('<') { self.scroll_begin }
+      self.bind_key('>') { self.scroll_end   }
 
-    def object_type
-      :scroll
+      screen.register(:scroll, self);
+      self
     end
 
     # @see Widget#position
@@ -221,29 +223,18 @@ module RNDK
       super @win
     end
 
-    # Put the cursor on the currently-selected item's row.
-    def fixCursorPosition
-      scrollbar_adj = if @scrollbar_placement == LEFT then 1 else 0 end
-      ypos = self.Screen_YPOS(@current_item - @current_top)
-      xpos = self.Screen_XPOS(0) + scrollbar_adj
-
-      Ncurses.wmove(@input_window, ypos, xpos)
-      Ncurses.wrefresh(@input_window)
-    end
-
     # Activates the Widget, letting the user interact with it.
     #
     # `actions` is an Array of characters. If it's non-null,
     # will #inject each char on it into the Widget.
     #
     def activate(actions=[])
-      # Draw the scrolling list
-      self.draw(@box)
+      self.draw
 
       if actions.nil? || actions.size == 0
         loop do
-          self.fixCursorPosition
-          input = self.getch([])
+          self.fix_cursor_position
+          input = self.getch
 
           # Inject the character into the widget.
           ret = self.inject input
@@ -261,64 +252,87 @@ module RNDK
 
       # Set the exit type for the widget and return
       self.set_exit_type(0)
-      return -1
+      return nil
     end
 
     # @see Widget#inject
     def inject input
-      pp_return = 1
-      ret = -1
+      ret = nil
       complete = false
 
-      # Set the exit type for the widget.
-      self.set_exit_type(0)
+      self.set_exit_type 0
 
-      # Draw the scrolling list
-      self.drawList(@box)
+      # Draw the scrolling items
+      self.draw_items @box
 
-      #Check if there is a pre-process function to be called.
-      unless @pre_process_func.nil?
-        pp_return = @pre_process_func.call(:scroll, self,
-            @pre_process_data, input)
-      end
+      # Calls a pre-process block if exists.
+      # They can interrup input.
+      continue = run_signal_binding(:before_input, input)
+
+      if continue
 
-      # Should we continue?
-      if pp_return != 0
         # Check for a predefined key binding.
-        if self.checkBind(:scroll, input) != false
-          #self.checkEarlyExit
-          complete = true
+        if self.is_bound? input
+          self.run_key_binding input
+
         else
           case input
+
           when Ncurses::KEY_UP
-            self.KEY_UP
+            self.scroll_up
+            run_signal_binding(:after_scrolling, @current_item)
+
           when Ncurses::KEY_DOWN
-            self.KEY_DOWN
-          when Ncurses::KEY_RIGHT
-            self.KEY_RIGHT
+            self.scroll_down
+            run_signal_binding(:after_scrolling, @current_item)
+
           when Ncurses::KEY_LEFT
-            self.KEY_LEFT
+            self.scroll_left
+            run_signal_binding(:after_scrolling, @current_item)
+
+          when Ncurses::KEY_RIGHT
+            self.scroll_right
+            run_signal_binding(:after_scrolling, @current_item)
+
           when Ncurses::KEY_PPAGE
-            self.KEY_PPAGE
+            self.scroll_page_up
+            run_signal_binding(:after_scrolling, @current_item)
+
           when Ncurses::KEY_NPAGE
-            self.KEY_NPAGE
+            self.scroll_page_down
+            run_signal_binding(:after_scrolling, @current_item)
+
           when Ncurses::KEY_HOME
-            self.KEY_HOME
+            self.scroll_begin
+            run_signal_binding(:after_scrolling, @current_item)
+
           when Ncurses::KEY_END
-            self.KEY_END
-          when '$'
-            @left_char = @max_left_char
-          when '|'
-            @left_char = 0
+            self.scroll_end
+            run_signal_binding(:after_scrolling, @current_item)
+
+          when RNDK::BACKCHAR
+            self.scroll_page_up
+            run_signal_binding(:after_scrolling, @current_item)
+
+          when RNDK::FORCHAR
+            self.scroll_page_down
+            run_signal_binding(:after_scrolling, @current_item)
+
+          when '$' then @left_char = @max_left_char
+          when '|' then @left_char = 0
+
           when RNDK::KEY_ESC
             self.set_exit_type(input)
             complete = true
+
           when Ncurses::ERR
             self.set_exit_type(input)
             complete = true
+
           when RNDK::REFRESH
             @screen.erase
             @screen.refresh
+
           when RNDK::KEY_TAB, Ncurses::KEY_ENTER, RNDK::KEY_RETURN
             self.set_exit_type(input)
             ret = @current_item
@@ -326,136 +340,43 @@ module RNDK
           end
         end
 
-        if !complete && !(@post_process_func.nil?)
-          @post_process_func.call(:scroll, self, @post_process_data, input)
-        end
+        run_signal_binding(:after_input, input) if not complete
       end
 
-      if !complete
-        self.drawList(@box)
+      if not complete
+        self.draw_items @box
         self.set_exit_type(0)
       end
 
-      self.fixCursorPosition
+      self.fix_cursor_position
       @result_data = ret
 
-      #return ret != -1
-      return ret
-    end
-
-    def getCurrentTop
-      return @current_top
-    end
-
-    def setCurrentTop(item)
-      if item < 0
-        item = 0
-      elsif item > @max_top_item
-        item = @max_top_item
-      end
-      @current_top = item
-
-      self.setPosition(item);
+      ret
     end
 
     # This moves the scroll field to the given location.
-    def move(xplace, yplace, relative, refresh_flag)
-      windows = [@win, @list_win, @shadow_win, @scrollbar_win]
+    def move(x, y, relative, refresh_flag)
+      windows = [@win, @items_win, @shadow_win, @scrollbar_win]
 
-      self.move_specific(xplace, yplace, relative, refresh_flag, windows, [])
+      self.move_specific(x, y, relative, refresh_flag, windows, [])
     end
 
-    # This function draws the scrolling list widget.
-    def draw(box)
+    # This function draws the scrolling items widget.
+    def draw
       # Draw in the shadow if we need to.
-      unless @shadow_win.nil?
-        Draw.drawShadow(@shadow_win)
-      end
-
-      self.drawTitle(@win)
-
-      # Draw in the scrolling list items.
-      self.drawList(box)
-    end
-
-    def drawCurrent
-      # Rehighlight the current menu item.
-      screen_pos = @item_pos[@current_item] - @left_char
-      highlight = if self.has_focus
-                  then @highlight
-                  else Ncurses::A_NORMAL
-                  end
-
-      Draw.writeChtypeAttrib(@list_win,
-          if screen_pos >= 0 then screen_pos else 0 end,
-          @current_high, @item[@current_item], highlight, RNDK::HORIZONTAL,
-          if screen_pos >= 0 then 0 else 1 - screen_pos end,
-          @item_len[@current_item])
-    end
-
-    def drawList box
-      # If the list is empty, don't draw anything.
-      if @list_size > 0
-        # Redraw the list
-        (0...@view_size).each do |j|
-          k = j + @current_top
-
-          Draw.writeBlanks(@list_win, 0, j, RNDK::HORIZONTAL, 0,
-            @box_width - (2 * @border_size))
-
-          # Draw the elements in the scrolling list.
-          if k < @list_size
-            screen_pos = @item_pos[k] - @left_char
-            ypos = j
-
-            # Write in the correct line.
-            Draw.writeChtype(@list_win,
-                if screen_pos >= 0 then screen_pos else 1 end,
-                ypos, @item[k], RNDK::HORIZONTAL,
-                if screen_pos >= 0 then 0 else 1 - screen_pos end,
-                @item_len[k])
-          end
-        end
-
-        self.drawCurrent
+      Draw.drawShadow(@shadow_win) unless @shadow_win.nil?
 
-        # Determine where the toggle is supposed to be.
-        unless @scrollbar_win.nil?
-          @toggle_pos = (@current_item * @step).floor
-
-          # Make sure the toggle button doesn't go out of bounds.
-          if @toggle_pos >= Ncurses.getmaxy(@scrollbar_win)
-            @toggle_pos = Ncurses.getmaxy(@scrollbar_win) - 1
-          end
-
-          # Draw the scrollbar
-          Ncurses.mvwvline(@scrollbar_win,
-                           0,
-                           0,
-                           Ncurses::ACS_CKBOARD,
-                           Ncurses.getmaxy(@scrollbar_win))
+      self.draw_title @win
 
-          Ncurses.mvwvline(@scrollbar_win,
-                           @toggle_pos,
-                           0,
-                           ' '.ord | Ncurses::A_REVERSE,
-                           @toggle_size)
-        end
-      end
-
-      # Box it if needed.
-      if box
-        Draw.drawObjBox(@win, self)
-      end
-
-      # Refresh the window
-      Ncurses.wrefresh @win
+      # Draw in the scrolling items items.
+      self.draw_items @box
     end
 
     # This sets the background attribute of the widget.
-    def set_bg_attrib(attrib)
+    def set_bg_color(attrib)
       Ncurses.wbkgd(@win, attrib)
-      Ncurses.wbkgd(@list_win, attrib)
+      Ncurses.wbkgd(@items_win, attrib)
+
       unless @scrollbar_win.nil?
         Ncurses.wbkgd(@scrollbar_win, attrib)
       end
@@ -463,78 +384,182 @@ module RNDK
 
     # This function destroys
     def destroy
-      self.cleanTitle
+      self.clean_title
 
       # Clean up the windows.
       RNDK.window_delete(@scrollbar_win)
       RNDK.window_delete(@shadow_win)
-      RNDK.window_delete(@list_win)
+      RNDK.window_delete(@items_win)
       RNDK.window_delete(@win)
 
       # Clean the key bindings.
-      self.clean_bindings(:scroll)
+      self.clean_bindings
 
-      # Unregister this object
-      RNDK::Screen.unregister(:scroll, self)
+      # Unregister this widget
+      @screen.unregister self
     end
 
-    # This function erases the scrolling list from the screen.
+    # This function erases the scrolling items from the screen.
     def erase
       RNDK.window_erase(@win)
       RNDK.window_erase(@shadow_win)
     end
 
-    def allocListArrays(old_size, new_size)
-      result = true
-      new_list = Array.new(new_size)
-      new_len = Array.new(new_size)
-      new_pos = Array.new(new_size)
+    # This sets certain attributes of the scrolling items.
+    def set(items, numbers, highlight, box)
+      self.set_items(items, numbers)
+      self.set_highlight(highlight)
+      self.set_box(box)
+    end
 
-      (0...old_size).each do |n|
-        new_list[n] = @item[n]
-        new_len[n] = @item_len[n]
-        new_pos[n] = @item_pos[n]
+    # Sets the scrolling items items.
+    # See Scroll#initialize.
+    def set_items(items, numbers)
+      return unless self.create_item_list(numbers, items)
+
+      # Clean up the display.
+      (0...@view_size).each do |x|
+        Draw.writeBlanks(@win, 1, x, RNDK::HORIZONTAL, 0, @box_width - 2);
       end
 
-      @item = new_list
-      @item_len = new_len
-      @item_pos = new_pos
+      self.set_view_size(items.size)
+      self.set_position(0)
+      self.erase
 
-      return result
+      @left_char = 0
     end
 
-    def allocListItem(which, work, used, number, value)
-      if number > 0
-        value = "%4d. %s" % [number, value]
+    def get_items(items)
+      (0...@item.size).each do |x|
+        items << RNDK.chtype2Char(@item[x])
       end
 
-      item_len = []
-      item_pos = []
-      @item[which] = RNDK.char2Chtype(value, item_len, item_pos)
-      @item_len[which] = item_len[0]
-      @item_pos[which] = item_pos[0]
+      @item.size
+    end
 
-      @item_pos[which] = RNDK.justifyString(@box_width,
-          @item_len[which], @item_pos[which])
-      return true
+    # This sets the highlight of the scrolling items.
+    def set_highlight(highlight)
+      @highlight = highlight
     end
 
-    # This function creates the scrolling list information and sets up the
-    # needed variables for the scrolling list to work correctly.
-    def createItemList(numbers, list, list_size)
-      status = 0
-      if list_size > 0
+    def get_highlight(highlight)
+      return @highlight
+    end
+
+    # # Adds a single item to a scrolling items, at the end of
+    # # the items.
+    # def add_item(item)
+    #   item_number = @item.size
+    #   widest_item = self.widest_item
+    #   temp = ''
+    #   have = 0
+
+    #   if (self.alloc_items_arrays(@item.size, @item.size + 1)) and
+    #       (self.alloc_items_item(item_number,
+    #                            temp,
+    #                            have,
+    #                            if @numbers then item_number + 1 else 0 end,
+    #                            item))
+    #     # Determine the size of the widest item.
+    #     widest_item = [@item_len[item_number], widest_item].max
+
+    #     self.update_view_width(widest_item)
+    #     self.set_view_size(@item.size + 1)
+    #   end
+    # end
+
+    # # Adds a single item to a scrolling items before the current
+    # # item.
+    # def insert_item(item)
+    #   widest_item = self.widest_item
+    #   temp = ''
+    #   have = 0
+
+    #   if (self.alloc_items_arrays(@item.size, @item.size + 1)) and
+    #       (self.insert_items_item(@current_item)) and
+    #       (self.alloc_items_item(@current_item,
+    #                            temp,
+    #                            have,
+    #                            if @numbers then @current_item + 1 else 0 end,
+    #                            item))
+
+    #     # Determine the size of the widest item.
+    #     widest_item = [@item_len[@current_item], widest_item].max
+
+    #     self.update_view_width(widest_item)
+    #     self.set_view_size(@item.size + 1)
+    #     self.resequence
+    #   end
+    # end
+
+    # # This removes a single item from a scrolling items.
+    # def delete_item(position)
+    #   if position >= 0 && position < @item.size
+    #     # Adjust the items
+    #     @item = @item[0...position] + @item[position+1..-1]
+    #     @item_len = @item_len[0...position] + @item_len[position+1..-1]
+    #     @item_pos = @item_pos[0...position] + @item_pos[position+1..-1]
+
+    #     self.set_view_size(@item.size - 1)
+
+    #     self.resequence if @item.size > 0
+
+    #     if @item.size < self.max_view_size
+    #       Ncurses.werase @win  # force the next redraw to be complete
+    #     end
+
+    #     # do this to update the view size, etc
+    #     self.set_position(@current_item)
+    #   end
+    # end
+
+    def focus
+      self.draw_current
+      Ncurses.wrefresh @items_win
+    end
+
+    def unfocus
+      self.draw_current
+      Ncurses.wrefresh @items_win
+    end
+
+    #                  _            _           _
+    #                 | |          | |         | |
+    #  _ __  _ __ ___ | |_ ___  ___| |_ ___  __| |
+    # | '_ \| '__/ _ \| __/ _ \/ __| __/ _ \/ _` |
+    # | |_) | | | (_) | ||  __| (__| ||  __| (_| |
+    # | .__/|_|  \___/ \__\___|\___|\__\___|\__,_|
+    # | |
+    # |_|
+    protected
+
+    # Creates the scrolling items information and sets up the
+    # needed variables for the scrolling items to work correctly.
+    def create_item_list(numbers, items)
+      status = false
+
+      # If any element is not a String, try to convert
+      # it anyway.
+      items.each_with_index do |item, i|
+        if item.class != String
+          items[i] = item.to_s
+        end
+      end
+
+      if items.size > 0
         widest_item = 0
         x = 0
         have = 0
         temp = ''
-        if allocListArrays(0, list_size)
-          # Create the items in the scrolling list.
-          status = 1
-          (0...list_size).each do |x|
+
+        if alloc_items_arrays(0, items.size)
+          # Create the items in the scrolling items.
+          status = true
+          (0...items.size).each do |x|
             number = if numbers then x + 1 else 0 end
-            if !self.allocListItem(x, temp, have, number, list[x])
-              status = 0
+
+            unless self.alloc_items_item(x, temp, have, number, items[x])
+              status = false
               break
             end
 
@@ -542,175 +567,203 @@ module RNDK
           end
 
           if status
-            self.updateViewWidth(widest_item);
+            self.update_view_width widest_item
 
             # Keep the boolean flag 'numbers'
             @numbers = numbers
           end
         end
+
       else
-        status = 1  # null list is ok - for a while
+        status = true  # null items is ok - for a while
       end
-
-      return status
+      status
     end
 
-    # This sets certain attributes of the scrolling list.
-    def set(list, list_size, numbers, highlight, box)
-      self.setItems(list, list_size, numbers)
-      self.set_highlight(highlight)
-      self.set_box(box)
-    end
+    def alloc_items_arrays(old_size, new_size)
 
-    # This sets the scrolling list items
-    def setItems(list, list_size, numbers)
-      if self.createItemList(numbers, list, list_size) <= 0
-        return
-      end
+      new_items = Array.new new_size
+      new_len  = Array.new new_size
+      new_pos  = Array.new new_size
 
-      # Clean up the display.
-      (0...@view_size).each do |x|
-        Draw.writeBlanks(@win, 1, x, RNDK::HORIZONTAL, 0, @box_width - 2);
+      (0...old_size).each do |n|
+        new_items[n] = @item[n]
+        new_len[n]  = @item_len[n]
+        new_pos[n]  = @item_pos[n]
       end
 
-      self.setViewSize(list_size)
-      self.setPosition(0)
-      @left_char = 0
+      @item     = new_items
+      @item_len = new_len
+      @item_pos = new_pos
+
+      true
     end
 
-    def getItems(list)
-      (0...@list_size).each do |x|
-        list << RNDK.chtype2Char(@item[x])
-      end
+    # Creates a single item on the scroll items.
+    def alloc_items_item(which, work, used, number, value)
 
-      return @list_size
-    end
+      if number > 0
+        value = "%4d. %s" % [number, value]
+      end
 
-    # This sets the highlight of the scrolling list.
-    def set_highlight(highlight)
-      @highlight = highlight
-    end
+      item_len = []
+      item_pos = []
+      @item[which] = RNDK.char2Chtype(value, item_len, item_pos)
+      @item_len[which] = item_len[0]
+      @item_pos[which] = item_pos[0]
 
-    def getHighlight(highlight)
-      return @highlight
+      @item_pos[which] = RNDK.justifyString(@box_width,
+                                            @item_len[which],
+                                            @item_pos[which])
+      true
     end
 
     # Resequence the numbers after an insertion/deletion.
     def resequence
-      if @numbers
-        (0...@list_size).each do |j|
-          target = @item[j]
+      return unless @numbers
 
-          source = "%4d. %s" % [j + 1, ""]
+      (0...@item.size).each do |j|
+        target = @item[j]
 
-          k = 0
-          while k < source.size
-            # handle deletions that change the length of number
-            if source[k] == "." && target[k] != "."
-              source = source[0...k] + source[k+1..-1]
-            end
+        source = "%4d. %s" % [j + 1, ""]
 
-            target[k] &= Ncurses::A_ATTRIBUTES
-            target[k] |= source[k].ord
-            k += 1
+        k = 0
+        while k < source.size
+          # handle deletions that change the length of number
+          if (source[k] == ".") and (target[k] != ".")
+            source = source[0...k] + source[k+1..-1]
           end
+
+          target[k] &= RNDK::Color[:extract]
+          target[k] |= source[k].ord
+          k += 1
         end
       end
     end
 
-    def insertListItem(item)
+    def insert_items_item(item)
       @item = @item[0..item] + @item[item..-1]
       @item_len = @item_len[0..item] + @item_len[item..-1]
       @item_pos = @item_pos[0..item] + @item_pos[item..-1]
-      return true
+
+      true
     end
 
-    # This adds a single item to a scrolling list, at the end of the list.
-    def addItem(item)
-      item_number = @list_size
-      widest_item = self.WidestItem
-      temp = ''
-      have = 0
-
-      if self.allocListArrays(@list_size, @list_size + 1) &&
-          self.allocListItem(item_number, temp, have,
-          if @numbers then item_number + 1 else 0 end,
-          item)
-        # Determine the size of the widest item.
-        widest_item = [@item_len[item_number], widest_item].max
-
-        self.updateViewWidth(widest_item)
-        self.setViewSize(@list_size + 1)
-      end
+    def available_width
+      @box_width - (2 * @border_size)
     end
 
-    # This adds a single item to a scrolling list before the current item
-    def insertItem(item)
-      widest_item = self.WidestItem
-      temp = ''
-      have = 0
-
-      if self.allocListArrays(@list_size, @list_size + 1) &&
-          self.insertListItem(@current_item) &&
-          self.allocListItem(@current_item, temp, have,
-          if @numbers then @current_item + 1 else 0 end,
-          item)
-        # Determine the size of the widest item.
-        widest_item = [@item_len[@current_item], widest_item].max
-
-        self.updateViewWidth(widest_item)
-        self.setViewSize(@list_size + 1)
-        self.resequence
-      end
+    def update_view_width(widest)
+      @max_left_char = if @box_width > widest
+                       then 0
+                       else widest - self.available_width
+                       end
     end
 
-    # This removes a single item from a scrolling list.
-    def deleteItem(position)
-      if position >= 0 && position < @list_size
-        # Adjust the list
-        @item = @item[0...position] + @item[position+1..-1]
-        @item_len = @item_len[0...position] + @item_len[position+1..-1]
-        @item_pos = @item_pos[0...position] + @item_pos[position+1..-1]
+    def widest_item
+      @max_left_char + self.available_width
+    end
+
+    # Draws the scrolling items.
+    def draw_items box
+
+      # If the items is empty, don't draw anything.
+      if @item.size > 0
+
+        # Redraw the items
+        (0...@view_size).each do |j|
+          k = j + @current_top
+
+          Draw.writeBlanks(@items_win,
+                           0,
+                           j,
+                           RNDK::HORIZONTAL, 0,
+                           @box_width - (2 * @border_size))
 
-        self.setViewSize(@list_size - 1)
+          # Draw the elements in the scrolling items.
+          if k < @item.size
 
-        self.resequence if @list_size > 0
+            screen_pos = @item_pos[k] - @left_char
+            ypos = j
 
-        if @list_size < self.maxViewSize
-          Ncurses.werase @win  # force the next redraw to be complete
+            # Write in the correct line.
+            Draw.writeChtype(@items_win,
+                             if screen_pos >= 0 then screen_pos else 1 end,
+                             ypos, @item[k], RNDK::HORIZONTAL,
+                             if screen_pos >= 0 then 0 else 1 - screen_pos end,
+                             @item_len[k])
+          end
         end
 
-        # do this to update the view size, etc
-        self.setPosition(@current_item)
+        self.draw_current
+
+        # Determine where the toggle is supposed to be.
+        unless @scrollbar_win.nil?
+          @toggle_pos = (@current_item * @step).floor
+
+          # Make sure the toggle button doesn't go out of bounds.
+          if @toggle_pos >= Ncurses.getmaxy(@scrollbar_win)
+            @toggle_pos = Ncurses.getmaxy(@scrollbar_win) - 1
+          end
+
+          # Draw the scrollbar
+          Ncurses.mvwvline(@scrollbar_win,
+                           0,
+                           0,
+                           Ncurses::ACS_CKBOARD,
+                           Ncurses.getmaxy(@scrollbar_win))
+
+          Ncurses.mvwvline(@scrollbar_win,
+                           @toggle_pos,
+                           0,
+                           ' '.ord | RNDK::Color[:reverse],
+                           @toggle_size)
+        end
       end
-    end
 
-    def focus
-      self.drawCurrent
-      Ncurses.wrefresh @list_win
+      Draw.drawObjBox(@win, self) if box
+      Ncurses.wrefresh @win
     end
 
-    def unfocus
-      self.drawCurrent
-      Ncurses.wrefresh @list_win
+    def get_current_top
+      @current_top
     end
 
-    def AvailableWidth
-      @box_width - (2 * @border_size)
-    end
+    def set_current_top(item)
+      if item < 0
+        item = 0
+      elsif item > @max_top_item
+        item = @max_top_item
+      end
+      @current_top = item
 
-    def updateViewWidth(widest)
-      @max_left_char = if @box_width > widest
-                       then 0
-                       else widest - self.AvailableWidth
-                       end
+      self.set_position(item);
     end
 
-    def WidestItem
-      @max_left_char + self.AvailableWidth
+    def draw_current
+      # Rehighlight the current menu item.
+      screen_pos = @item_pos[@current_item] - @left_char
+      highlight = if self.has_focus
+                  then @highlight
+                  else RNDK::Color[:normal]
+                  end
+
+      Draw.writeChtypeAttrib(@items_win,
+                             if screen_pos >= 0 then screen_pos else 0 end,
+                             @current_high, @item[@current_item], highlight, RNDK::HORIZONTAL,
+                             if screen_pos >= 0 then 0 else 1 - screen_pos end,
+                             @item_len[@current_item])
     end
 
-    private
+    # Put the cursor on the currently-selected item's row.
+    def fix_cursor_position
+      scrollbar_adj = if @scrollbar_placement == LEFT then 1 else 0 end
+      ypos = self.Screen_YPOS(@current_item - @current_top)
+      xpos = self.Screen_XPOS(0) + scrollbar_adj
+
+      Ncurses.wmove(@input_window, ypos, xpos)
+      Ncurses.wrefresh(@input_window)
+    end
 
   end
 end