rndk 0.0.1 → 0.1.0

data/lib/rndk.rb

@@ -1,25 +1,39 @@
-# Welcome to the Ruby Ncurses Development Kit!
-
+# The main RNDK module - contains everything we need.
+#
+# There's a lot of functionality inside RNDK. Besides
+# each Widget having it's own file, some methods were
+# splitted on several files:
+#
+# rndk/core/draw::      Common draw functions between Widgets.
+# rndk/core/draw::      Color initialization and handling.
+# rndk/core/display::   (??)
+# rndk/core/traverse::
+# rndk/core/widget::    Common functionality shared between widgets.
+# rndk/core/screen::
+# rndk/core/markup::    Functions to decode RNDK's markup language.
+# rndk/core/utils::     Utility functions, not urgent or anything.
+#
+# ## Developer Notes
+#
+# * Any questions on what a `Ncurses.*` function do, check it's man
+#   page with `man lowercase_function_name`.
+#
 require 'ffi-ncurses'
 require 'scanf'
 
 require 'rndk/core/draw'
+require 'rndk/core/color'
 require 'rndk/core/display'
 require 'rndk/core/traverse'
 require 'rndk/core/widget'
 require 'rndk/core/screen'
+require 'rndk/core/markup'
+require 'rndk/core/utils'
 
 # Shortcut to avoid typing FFI::NCurses all the time.
 # You can use it too!
 Ncurses = FFI::NCurses
 
-# The main RNDK module - contains everything we need.
-#
-# ## Developer Notes
-#
-# * Any questions on what a `Ncurses.*` function do, check it's man
-#   page with `man lowercase_function_name`.
-#
 module RNDK
 
   # Some nice global constants.
@@ -75,7 +89,7 @@ module RNDK
   ALL_SCREENS = []
   ALL_OBJECTS = []
 
-  # This beeps then flushes the stdout stream.
+  # Beeps then flushes the stdout stream.
   #
   # Normally it emits an audible bell - if that's not
   # possible it flashes the screen.
@@ -84,630 +98,65 @@ module RNDK
     $stdout.flush
   end
 
-  # This sets a blank string to be len of the given characer.
-  def RNDK.cleanChar(s, len, character)
-    s << character * len
-  end
-
-  def RNDK.cleanChtype(s, len, character)
-    s.concat(character * len)
-  end
-
-  # This takes an x and y position and realigns the values iff they sent in
-  # values like CENTER, LEFT, RIGHT
-  #
-  # window is an Ncurses::WINDOW object
-  # xpos, ypos is an array with exactly one value, an integer
-  # box_width, box_height is an integer
-  def RNDK.alignxy (window, xpos, ypos, box_width, box_height)
-    first = Ncurses.getbegx window
-    last = Ncurses.getmaxx window
-    if (gap = (last - box_width)) < 0
-      gap = 0
-    end
-    last = first + gap
-
-    case xpos[0]
-    when LEFT
-      xpos[0] = first
-    when RIGHT
-      xpos[0] = first + gap
-    when CENTER
-      xpos[0] = first + (gap / 2)
-    else
-      if xpos[0] > last
-        xpos[0] = last
-      elsif xpos[0] < first
-        xpos[0] = first
-      end
-    end
-
-    first = Ncurses.getbegy window
-    last = Ncurses.getmaxy window
-    if (gap = (last - box_height)) < 0
-      gap = 0
-    end
-    last = first + gap
-
-    case ypos[0]
-    when TOP
-      ypos[0] = first
-    when BOTTOM
-      ypos[0] = first + gap
-    when CENTER
-      ypos[0] = first + (gap / 2)
-    else
-      if ypos[0] > last
-        ypos[0] = last
-      elsif ypos[0] < first
-        ypos[0] = first
-      end
-    end
-  end
-
-  # This takes a string, a field width, and a justification type
-  # and returns the adjustment to make, to fill the justification
-  # requirement
-  def RNDK.justifyString (box_width, mesg_length, justify)
-
-    # make sure the message isn't longer than the width
-    # if it is, return 0
-    if mesg_length >= box_width
-      return 0
-    end
-
-    # try to justify the message
-    case justify
-    when LEFT
-      0
-    when RIGHT
-      box_width - mesg_length
-    when CENTER
-      (box_width - mesg_length) / 2
-    else
-      justify
-    end
-  end
-
-  # This reads a file and sticks it into the list provided.
-  def RNDK.readFile(filename, array)
-    begin
-      fd = File.new(filename, "r")
-    rescue
-      return -1
-    end
-
-    lines = fd.readlines.map do |line|
-      if line.size > 0 && line[-1] == "\n"
-        line[0...-1]
-      else
-        line
-      end
-    end
-    array.concat(lines)
-    fd.close
-    array.size
-  end
-
-  def RNDK.encodeAttribute (string, from, mask)
-    mask << 0
-    case string[from + 1]
-    when 'B'
-      mask[0] = Ncurses::A_BOLD
-    when 'D'
-      mask[0] = Ncurses::A_DIM
-    when 'K'
-      mask[0] = Ncurses::A_BLINK
-    when 'R'
-      mask[0] = Ncurses::A_REVERSE
-    when 'S'
-      mask[0] = Ncurses::A_STANDOUT
-    when 'U'
-      mask[0] = Ncurses::A_UNDERLINE
-    end
-
-    if mask[0] != 0
-      from += 1
-    elsif RNDK.digit?(string[from+1]) and RNDK.digit?(string[from + 2])
-      if Ncurses.has_colors
-        # XXX: Only checks if terminal has colours not if colours are started
-        pair = string[from + 1..from + 2].to_i
-        mask[0] = Ncurses.COLOR_PAIR(pair)
-      else
-        mask[0] = Ncurses.A_BOLD
-      end
-
-      from += 2
-    elsif RNDK.digit?(string[from + 1])
-      if Ncurses.has_colors
-        # XXX: Only checks if terminal has colours not if colours are started
-        pair = string[from + 1].to_i
-        mask[0] = Ncurses.COLOR_PAIR(pair)
-      else
-        mask[0] = Ncurses.A_BOLD
-      end
-
-      from += 1
-    end
-
-    return from
-  end
-
-  # The reverse of encodeAttribute
-  # Well, almost.  If attributes such as bold and underline are combined in the
-  # same string, we do not necessarily reconstruct them in the same order.
-  # Also, alignment markers and tabs are lost.
-
-  def RNDK.decodeAttribute (string, from, oldattr, newattr)
-    table = {
-      'B' => Ncurses::A_BOLD,
-      'D' => Ncurses::A_DIM,
-      'K' => Ncurses::A_BLINK,
-      'R' => Ncurses::A_REVERSE,
-      'S' => Ncurses::A_STANDOUT,
-      'U' => Ncurses::A_UNDERLINE
-    }
-
-    result = if string.nil? then '' else string end
-    base_len = result.size
-    tmpattr = oldattr & Ncurses::A_ATTRIBUTES
-
-    newattr &= Ncurses::A_ATTRIBUTES
-    if tmpattr != newattr
-      while tmpattr != newattr
-        found = false
-        table.keys.each do |key|
-          if (table[key] & tmpattr) != (table[key] & newattr)
-            found = true
-            result << RNDK::L_MARKER
-            if (table[key] & tmpattr).nonzero?
-              result << '!'
-              tmpattr &= ~(table[key])
-            else
-              result << '/'
-              tmpattr |= table[key]
-            end
-            result << key
-            break
-          end
-        end
-        # XXX: Only checks if terminal has colours not if colours are started
-        if Ncurses.has_colors
-          if (tmpattr & Ncurses::A_COLOR) != (newattr & Ncurses::A_COLOR)
-            oldpair = Ncurses.PAIR_NUMBER(tmpattr)
-            newpair = Ncurses.PAIR_NUMBER(newattr)
-            if !found
-              found = true
-              result << RNDK::L_MARKER
-            end
-            if newpair.zero?
-              result << '!'
-              result << oldpair.to_s
-            else
-              result << '/'
-              result << newpair.to_s
-            end
-            tmpattr &= ~(Ncurses::A_COLOR)
-            newattr &= ~(Ncurses::A_COLOR)
-          end
-        end
-
-        if found
-          result << RNDK::R_MARKER
-        else
-          break
-        end
-      end
-    end
-
-    return from + result.size - base_len
-  end
-
-  # This function takes a string, full of format markers and translates
-  # them into a chtype array.  This is better suited to curses because
-  # curses uses chtype almost exclusively
-  def RNDK.char2Chtype (string, to, align)
-    to << 0
-    align << LEFT
-    result = []
-
-    if string.size > 0
-      used = 0
-
-      # The original code makes two passes since it has to pre-allocate space but
-      # we should be able to make do with one since we can dynamically size it
-      adjust = 0
-      attrib = Ncurses::A_NORMAL
-      last_char = 0
-      start = 0
-      used = 0
-      x = 3
-
-      # Look for an alignment marker.
-      if string[0] == L_MARKER
-        if string[1] == 'C' && string[2] == R_MARKER
-          align[0] = CENTER
-          start = 3
-        elsif string[1] == 'R' && string[2] == R_MARKER
-          align[0] = RIGHT
-          start = 3
-        elsif string[1] == 'L' && string[2] == R_MARKER
-          start = 3
-        elsif string[1] == 'B' && string[2] == '='
-          # Set the item index value in the string.
-          result = [' '.ord, ' '.ord, ' '.ord]
-
-          # Pull out the bullet marker.
-          while x < string.size and string[x] != R_MARKER
-            result << (string[x].ord | Ncurses::A_BOLD)
-            x += 1
-          end
-          adjust = 1
-
-          # Set the alignment variables
-          start = x
-          used = x
-        elsif string[1] == 'I' && string[2] == '='
-          from = 3
-          x = 0
-
-          while from < string.size && string[from] != Ncurses.R_MARKER
-            if RNDK.digit?(string[from])
-              adjust = adjust * 10 + string[from].to_i
-              x += 1
-            end
-            from += 1
-          end
-
-          start = x + 4
-        end
-      end
-
-      while adjust > 0
-        adjust -= 1
-        result << ' '
-        used += 1
-      end
-
-      # Set the format marker boolean to false
-      inside_marker = false
-
-      # Start parsing the character string.
-      from = start
-      while from < string.size
-        # Are we inside a format marker?
-        if !inside_marker
-          if string[from] == L_MARKER &&
-              ['/', '!', '#'].include?(string[from + 1])
-            inside_marker = true
-          elsif string[from] == "\\" && string[from + 1] == L_MARKER
-            from += 1
-            result << (string[from].ord | attrib)
-            used += 1
-            from += 1
-          elsif string[from] == "\t"
-            begin
-              result << ' '
-              used += 1
-            end while (used & 7).nonzero?
-          else
-            result << (string[from].ord | attrib)
-            used += 1
-          end
-        else
-          case string[from]
-          when R_MARKER
-            inside_marker = false
-          when '#'
-            last_char = 0
-            case string[from + 2]
-            when 'L'
-              case string[from + 1]
-              when 'L'
-                last_char = Ncurses::ACS_LLCORNER
-              when 'U'
-                last_char = Ncurses::ACS_ULCORNER
-              when 'H'
-                last_char = Ncurses::ACS_HLINE
-              when 'V'
-                last_char = Ncurses::ACS_VLINE
-              when 'P'
-                last_char = Ncurses::ACS_PLUS
-              end
-            when 'R'
-              case string[from + 1]
-              when 'L'
-                last_char = Ncurses::ACS_LRCORNER
-              when 'U'
-                last_char = Ncurses::ACS_URCORNER
-              end
-            when 'T'
-              case string[from + 1]
-              when 'T'
-                last_char = Ncurses::ACS_TTEE
-              when 'R'
-                last_char = Ncurses::ACS_RTEE
-              when 'L'
-                last_char = Ncurses::ACS_LTEE
-              when 'B'
-                last_char = Ncurses::ACS_BTEE
-              end
-            when 'A'
-              case string[from + 1]
-              when 'L'
-                last_char = Ncurses::ACS_LARROW
-              when 'R'
-                last_char = Ncurses::ACS_RARROW
-              when 'U'
-                last_char = Ncurses::ACS_UARROW
-              when 'D'
-                last_char = Ncurses::ACS_DARROW
-              end
-            else
-              case [string[from + 1], string[from + 2]]
-              when ['D', 'I']
-                last_char = Ncurses::ACS_DIAMOND
-              when ['C', 'B']
-                last_char = Ncurses::ACS_CKBOARD
-              when ['D', 'G']
-                last_char = Ncurses::ACS_DEGREE
-              when ['P', 'M']
-                last_char = Ncurses::ACS_PLMINUS
-              when ['B', 'U']
-                last_char = Ncurses::ACS_BULLET
-              when ['S', '1']
-                last_char = Ncurses::ACS_S1
-              when ['S', '9']
-                last_char = Ncurses::ACS_S9
-              end
-            end
-
-            if last_char.nonzero?
-              adjust = 1
-              from += 2
-
-              if string[from + 1] == '('
-                # check for a possible numeric modifier
-                from += 2
-                adjust = 0
-
-                while from < string.size && string[from] != ')'
-                  if RNDK.digit?(string[from])
-                    adjust = (adjust * 10) + string[from].to_i
-                  end
-                  from += 1
-                end
-              end
-            end
-            (0...adjust).each do |x|
-              result << (last_char | attrib)
-              used += 1
-            end
-          when '/'
-            mask = []
-            from = RNDK.encodeAttribute(string, from, mask)
-            attrib |= mask[0]
-          when '!'
-            mask = []
-            from = RNDK.encodeAttribute(string, from, mask)
-            attrib &= ~(mask[0])
-          end
-        end
-        from += 1
-      end
-
-      if result.size == 0
-        result << attrib
-      end
-      to[0] = used
-    else
-      result = []
-    end
-    return result
-  end
-
-  # Compare a regular string to a chtype string
-  def RNDK.cmpStrChstr (str, chstr)
-    i = 0
-    r = 0
-
-    if str.nil? && chstr.nil?
-      return 0
-    elsif str.nil?
-      return 1
-    elsif chstr.nil?
-      return -1
-    end
-
-    while i < str.size && i < chstr.size
-      if str[r].ord < chstr[r]
-        return -1
-      elsif str[r].ord > chstr[r]
-        return 1
-      end
-      i += 1
-    end
-
-    if str.size < chstr.size
-      return -1
-    elsif str.size > chstr.size
-      return 1
-    else
-      return 0
-    end
-  end
-
-  def RNDK.CharOf(chtype)
-    (chtype.ord & 255).chr
-  end
-
-  # This returns a string from a chtype array
-  # Formatting codes are omitted.
-  def RNDK.chtype2Char(string)
-    newstring = ''
-
-    unless string.nil?
-      string.each do |char|
-        newstring << RNDK.CharOf(char)
-      end
-    end
-
-    return newstring
-  end
-
-  # This returns a string from a chtype array
-  # Formatting codes are embedded
-  def RNDK.chtype2String(string)
-    newstring = ''
-    unless string.nil?
-      need = 0
-      (0...string.size).each do |x|
-        need = RNDK.decodeAttribute(newstring, need,
-                                   x > 0 ? string[x - 1] : 0, string[x])
-        newstring << string[x]
-      end
-    end
+  def RNDK.digit? character
+    return false if character.nil?
 
-    return newstring
+    not character.match(/^[[:digit:]]$/).nil?
   end
 
+  def RNDK.is_alpha? character
+    return false if character.nil?
 
-
-  # This returns the length of the integer.
-  #
-  # Currently a wrapper maintained for easy of porting.
-  def RNDK.intlen (value)
-    value.to_str.size
+    not character.match(/^[[:alpha:]]$/).nil?
   end
 
-  # This opens the current directory and reads the contents.
-  def RNDK.getDirectoryContents(directory, list)
-    counter = 0
+  def RNDK.is_char? character
+    return false if character.nil?
 
-    # Open the directory.
-    Dir.foreach(directory) do |filename|
-      next if filename == '.'
-      list << filename
-    end
-
-    list.sort!
-    return list.size
+    (character >= 0) and (character < Ncurses::KEY_MIN)
   end
 
-  # This looks for a subset of a word in the given list
-  def RNDK.searchList(list, list_size, pattern)
-    index = -1
-
-    if pattern.size > 0
-      (0...list_size).each do |x|
-        len = [list[x].size, pattern.size].min
-        ret = (list[x][0...len] <=> pattern)
-
-        # If 'ret' is less than 0 then the current word is alphabetically
-        # less than the provided word.  At this point we will set the index
-        # to the current position.  If 'ret' is greater than 0, then the
-        # current word is alphabetically greater than the given word. We
-        # should return with index, which might contain the last best match.
-        # If they are equal then we've found it.
-        if ret < 0
-          index = ret
-        else
-          if ret == 0
-            index = x
-          end
-          break
-        end
-      end
-    end
-    return index
-  end
-
-  # This function checks to see if a link has been requested
-  def RNDK.checkForLink (line, filename)
-    f_pos = 0
-    x = 3
-    if line.nil?
-      return -1
-    end
-
-    # Strip out the filename.
-    if line[0] == L_MARKER && line[1] == 'F' && line[2] == '='
-      while x < line.size
-        if line[x] == R_MARKER
-          break
-        end
-        if f_pos < RNDK_PATHMAX
-          filename << line[x]
-          f_pos += 1
-        end
-        x += 1
-      end
-    end
-    return f_pos != 0
+  # Returns the function keys - F1, F2 ... F12 ...
+  def RNDK.KEY_F(n)
+    264 + n
   end
 
-  # Returns the filename portion of the given pathname, i.e. after the last
-  # slash
-  # For now this function is just a wrapper for File.basename kept for ease of
-  # porting and will be completely replaced in the future
-  def RNDK.baseName (pathname)
-    File.basename(pathname)
+  # This sets a blank string to be len of the given character.
+  def RNDK.cleanChar(s, len, character)
+    s << character * len
   end
 
-  # Returns the directory for the given pathname, i.e. the part before the
-  # last slash
-  # For now this function is just a wrapper for File.dirname kept for ease of
-  # porting and will be completely replaced in the future
-  def RNDK.dirName (pathname)
-    File.dirname(pathname)
+  def RNDK.cleanChtype(s, len, character)
+    s.concat(character * len)
   end
 
-  # If the dimension is a negative value, the dimension will be the full
-  # height/width of the parent window - the value of the dimension. Otherwise,
-  # the dimension will be the given value.
-  def RNDK.setWidgetDimension (parent_dim, proposed_dim, adjustment)
-    # If the user passed in FULL, return the parents size
-    if proposed_dim == FULL or proposed_dim == 0
-      parent_dim
-    elsif proposed_dim >= 0
-      # if they gave a positive value, return it
-
-      if proposed_dim >= parent_dim
-        parent_dim
-      else
-        proposed_dim + adjustment
-      end
-    else
-      # if they gave a negative value then return the dimension
-      # of the parent plus the value given
-      #
-      if parent_dim + proposed_dim < 0
-        parent_dim
-      else
-        parent_dim + proposed_dim
-      end
-    end
-  end
+  # Functions that handle raw Ncurses windows.
+  # TODO perhaps change them when I create my dedicated
+  #      Window class.
 
-  # This safely erases a given window
-  def RNDK.eraseCursesWindow (window)
+  # Safely erases a raw Ncurses window.
+  def RNDK.window_erase window
     return if window.nil?
 
     Ncurses.werase window
     Ncurses.wrefresh window
   end
 
-  # This safely deletes a given window.
-  def RNDK.deleteCursesWindow (window)
+  # Safely deletes a raw Ncurses window.
+  def RNDK.window_delete window
     return if window.nil?
 
-    RNDK.eraseCursesWindow(window)
+    RNDK.window_erase window
     Ncurses.delwin window
   end
 
-  # This moves a given window (if we're able to set the window's beginning).
+  # Safely moves a raw Ncurses window.
+  #
+  # ## Developer Note:
+  #
+  # Moves a given window if we're able to set the window's beginning.
   # We do not use mvwin(), because it does not (usually) move subwindows.
-  def RNDK.moveCursesWindow (window, xdiff, ydiff)
+  def RNDK.window_move(window, xdiff, ydiff)
     return if window.nil?
 
     xpos = []
@@ -723,190 +172,63 @@ module RNDK
     end
   end
 
-  def RNDK.digit? character
-    false if character.nil?
-    !(character.match(/^[[:digit:]]$/).nil?)
-  end
-
-  def RNDK.alpha? character
-    false if character.nil?
-    !(character.match(/^[[:alpha:]]$/).nil?)
-  end
-
-  def RNDK.isChar c
-    false if c.nil?
-    c >= 0 && c < Ncurses::KEY_MIN
-  end
-
-  # Returns the function keys - F1, F2 ... F12 ...
-  def RNDK.KEY_F(n)
-    264 + n
-  end
-
-  def RNDK.getString(screen, title, label, init_value)
-    # Create the widget.
-    widget = RNDK::ENTRY.new(screen, RNDK::CENTER, RNDK::CENTER, title, label,
-        Ncurses::A_NORMAL, '.', :MIXED, 40, 0, 5000, true, false)
-
-    # Set the default value.
-    widget.setValue(init_value)
-
-    # Get the string.
-    value = widget.activate([])
-
-    # Make sure they exited normally.
-    if widget.exit_type != :NORMAL
-      widget.destroy
-      return nil
-    end
-
-    # Return a copy of the string typed in.
-    value = entry.getValue.clone
-    widget.destroy
-    return value
-  end
-
-  # This allows a person to select a file.
-  def RNDK.selectFile(screen, title)
-    # Create the file selector.
-    fselect = RNDK::FSELECT.new(screen, RNDK::CENTER, RNDK::CENTER, -4, -20,
-        title, 'File: ', Ncurses::A_NORMAL, '_', Ncurses::A_REVERSE,
-        '</5>', '</48>', '</N>', '</N>', true, false)
-
-    # Let the user play.
-    filename = fselect.activate([])
-
-    # Check the way the user exited the selector.
-    if fselect.exit_type != :NORMAL
-      fselect.destroy
-      screen.refresh
-      return nil
-    end
-
-    # Otherwise...
-    fselect.destroy
-    screen.refresh
-    return filename
-  end
-
-  # This returns a selected value in a list
-  def RNDK.getListindex(screen, title, list, list_size, numbers)
-    selected = -1
-    height = 10
-    width = -1
-    len = 0
-
-    # Determine the height of the list.
-    if list_size < 10
-      height = list_size + if title.size == 0 then 2 else 3 end
-    end
-
-    # Determine the width of the list.
-    list.each do |item|
-      width = [width, item.size + 10].max
-    end
-
-    width = [width, title.size].max
-    width += 5
-
-    # Create the scrolling list.
-    scrollp = RNDK::SCROLL.new(screen, RNDK::CENTER, RNDK::CENTER, RNDK::RIGHT,
-        height, width, title, list, list_size, numbers, Ncurses::A_REVERSE,
-        true, false)
-
-    # Check if we made the lsit.
-    if scrollp.nil?
-      screen.refresh
-      return -1
-    end
-
-    # Let the user play.
-    selected = scrollp.activate([])
-
-    # Check how they exited.
-    if scrollp.exit_type != :NORMAL
-      selected = -1
-    end
-
-    # Clean up.
-    scrollp.destroy
-    screen.refresh
-    return selected
+  # Refreshes a raw Ncurses window.
+  #
+  # ## Developer Notes
+  #
+  # FIXME(original): this should be rewritten to use the panel library, so
+  # it would not be necessary to touch the window to ensure that it covers
+  # other windows.
+  def RNDK.window_refresh win
+    Ncurses.touchwin win
+    Ncurses.wrefresh win
   end
 
-  # This allows the user to view information.
-  def RNDK.viewInfo(screen, title, info, count, buttons, button_count,
-      interpret)
-    selected = -1
+  # Aligns a box on the given `window` with the width and height given.
+  #
+  # x and y position values are like `RNDK::CENTER`, `RNDK::LEFT`,
+  # `RNDK::RIGHT`.
+  #
+  # `xpos`, `ypos` is an Array with exactly one value, an integer.
+  #
+  # `box_width`, `box_height` is an integer.
+  #
+  def RNDK.alignxy (window, xpos, ypos, box_width, box_height)
 
-    # Create the file viewer to view the file selected.
-    viewer = RNDK::VIEWER.new(screen, RNDK::CENTER, RNDK::CENTER, -6, -16,
-        buttons, button_count, Ncurses::A_REVERSE, true, true)
+    # Handling xpos
+    first = Ncurses.getbegx window
+    last  = Ncurses.getmaxx window
 
-    # Set up the viewer title, and the contents to the widget.
-    viewer.set(title, info, count, Ncurses::A_REVERSE, interpret, true, true)
+    gap = 0 if (gap = (last - box_width)) < 0
 
-    # Activate the viewer widget.
-    selected = viewer.activate([])
+    last = first + gap
 
-    # Make sure they exited normally.
-    if viewer.exit_type != :NORMAL
-      viewer.destroy
-      return -1
+    case xpos[0]
+    when LEFT   then xpos[0] = first
+    when RIGHT  then xpos[0] = first +  gap
+    when CENTER then xpos[0] = first + (gap / 2)
+    else
+      xpos[0] = last  if xpos[0] > last
+      xpos[0] = first if xpos[0] < first
     end
 
-    # Clean up and return the button index selected
-    viewer.destroy
-    return selected
-  end
+    # Handling ypos
+    first = Ncurses.getbegy window
+    last  = Ncurses.getmaxy window
 
-  # This allows the user to view a file.
-  def RNDK.viewFile(screen, title, filename, buttons, button_count)
-    info = []
-    result = 0
+    gap = 0 if (gap = (last - box_height)) < 0
 
-    # Open the file and read the contents.
-    lines = RNDK.readFile(filename, info)
+    last = first + gap
 
-    # If we couldn't read the file, return an error.
-    if lines == -1
-      result = lines
+    case ypos[0]
+    when TOP    then ypos[0] = first
+    when BOTTOM then ypos[0] = first +  gap
+    when CENTER then ypos[0] = first + (gap / 2)
     else
-      result = RNDK.viewInfo(screen, title, info, lines, buttons,
-          button_count, true)
+      ypos[0] = last  if ypos[0] > last
+      ypos[0] = first if ypos[0] < first
     end
-    return result
   end
-end
 
-# Why is this here?
-#
-# require 'rndk/alphalist'
-# require 'rndk/button'
-# require 'rndk/buttonbox'
-# require 'rndk/calendar'
-# require 'rndk/dialog'
-# require 'rndk/dscale'
-# require 'rndk/entry'
-# require 'rndk/fscale'
-# require 'rndk/fslider'
-# require 'rndk/fselect'
-# require 'rndk/graph'
-# require 'rndk/histogram'
-# require 'rndk/itemlist'
-# require 'rndk/label'
-# require 'rndk/marquee'
-# require 'rndk/matrix'
-# require 'rndk/mentry'
-# require 'rndk/menu'
-# require 'rndk/radio'
-# require 'rndk/scale'
-# require 'rndk/scroll'
-# require 'rndk/selection'
-# require 'rndk/slider'
-# require 'rndk/swindow'
-# require 'rndk/template'
-# require 'rndk/uscale'
-# require 'rndk/uslider'
-# require 'rndk/viewer'
+end