cdk 0.9.0 → 0.10.0

data/lib/cdk/constants.rb

@@ -0,0 +1,54 @@
+module CDK
+  VERSION_MAJOR = 0
+  VERSION_MINOR = 10
+  VERSION_PATCH = 0
+
+  CDK_PATHMAX = 256
+
+  L_MARKER = '<'
+  R_MARKER = '>'
+
+  LEFT       = 9000
+  RIGHT      = 9001
+  CENTER     = 9002
+  TOP        = 9003
+  BOTTOM     = 9004
+  HORIZONTAL = 9005
+  VERTICAL   = 9006
+  FULL       = 9007
+
+  NONE = 0
+  ROW  = 1
+  COL  = 2
+
+  MAX_BINDINGS = 300
+  MAX_ITEMS    = 2000
+  MAX_BUTTONS  = 200
+
+  def self.CTRL(c)
+    c.ord & 0x1f
+  end
+
+  REFRESH    = CTRL('L')
+  PASTE      = CTRL('V')
+  COPY       = CTRL('Y')
+  ERASE      = CTRL('U')
+  CUT        = CTRL('X')
+  BEGOFLINE  = CTRL('A')
+  ENDOFLINE  = CTRL('E')
+  BACKCHAR   = CTRL('B')
+  FORCHAR    = CTRL('F')
+  TRANSPOSE  = CTRL('T')
+  NEXT       = CTRL('N')
+  PREV       = CTRL('P')
+  DELETE     = "\177".ord
+  KEY_ESC    = "\033".ord
+  KEY_RETURN = "\012".ord
+  KEY_TAB    = "\t".ord
+
+  def self.Version
+    return "%d.%d.%d" % [CDK::VERSION_MAJOR,
+                         CDK::VERSION_MINOR,
+                         CDK::VERSION_PATCH]
+  end
+end # module CDK

data/lib/cdk/display.rb

@@ -1,40 +1,26 @@
 module CDK
   module Display
-    # Given a string, returns the equivalent display type
-    def Display.char2DisplayType(string)
-      table = {
-        "CHAR"     => :CHAR,
-        "HCHAR"    => :HCHAR,
-        "INT"      => :INT,
-        "HINT"     => :HINT,
-        "UCHAR"    => :UCHAR,
-        "LCHAR"    => :LCHAR,
-        "UHCHAR"   => :UHCHAR,
-        "LHCHAR"   => :LHCHAR,
-        "MIXED"    => :MIXED,
-        "HMIXED"   => :HMIXED,
-        "UMIXED"   => :UMIXED,
-        "LMIXED"   => :LMIXED,
-        "UHMIXED"  => :UHMIXED,
-        "LHMIXED"  => :LHMIXED,
-        "VIEWONLY" => :VIEWONLY,
-        0          => :INVALID 
-      }
- 
-      if table.include?(string)
-        table[string]
-      else
-        :INVALID
-      end
-    end
-
     # Tell if a display type is "hidden"
     def Display.isHiddenDisplayType(type)
       case type
-      when :HCHAR, :HINT, :HMIXED, :LHCHAR, :LHMIXED, :UHCHAR, :UHMIXED
+      when :HCHAR,
+           :HINT,
+           :HMIXED,
+           :LHCHAR,
+           :LHMIXED,
+           :UHCHAR,
+           :UHMIXED
         true
-      when :CHAR, :INT, :INVALID, :LCHAR, :LMIXED, :MIXED, :UCHAR,
-          :UMIXED, :VIEWONLY
+
+      when :CHAR,
+           :INT,
+           :INVALID,
+           :LCHAR,
+           :LMIXED,
+           :MIXED,
+           :UCHAR,
+           :UMIXED,
+           :VIEWONLY
         false
       end
     end
@@ -45,15 +31,24 @@ module CDK
       result = input
       if !CDK.isChar(input)
         result = Ncurses::ERR
-      elsif [:INT, :HINT].include?(type) && !CDK.digit?(result.chr)
+
+      elsif [:INT, :HINT].include?(type) &&
+            !CDK.digit?(result.chr)
         result = Ncurses::ERR
-      elsif [:CHAR, :UCHAR, :LCHAR, :UHCHAR, :LHCHAR].include?(type) && CDK.digit?(result.chr)
+
+      elsif [:CHAR, :UCHAR, :LCHAR, :UHCHAR, :LHCHAR].include?(type) &&
+            CDK.digit?(result.chr)
         result = Ncurses::ERR
+
       elsif type == :VIEWONLY
         result = ERR
-      elsif [:UCHAR, :UHCHAR, :UMIXED, :UHMIXED].include?(type) && CDK.alpha?(result.chr)
+
+      elsif [:UCHAR, :UHCHAR, :UMIXED, :UHMIXED].include?(type) &&
+            CDK.alpha?(result.chr)
         result = result.chr.upcase.ord
-      elsif [:LCHAR, :LHCHAR, :LMIXED, :LHMIXED].include?(type) && CDK.alpha?(result.chr)
+
+      elsif [:LCHAR, :LHCHAR, :LMIXED, :LHMIXED].include?(type) &&
+            CDK.alpha?(result.chr)
         result = result.chr.downcase.ord
       end
 

data/lib/cdk/draw.rb

@@ -42,7 +42,7 @@ module CDK
       window.mvwaddch(tly, brx, Ncurses::ACS_URCORNER | attr)
       window.mvwaddch(bry, tlx, Ncurses::ACS_LLCORNER | attr)
       window.mvwaddch(bry, brx, Ncurses::ACS_LRCORNER | attr)
-      window.wrefresh
+      SCREEN.wrefresh(window)
     end
 
     # This draws a box with attributes and lets the user define each
@@ -86,7 +86,7 @@ module CDK
         count += 1
       end
       if count != 0
-        win.wrefresh
+        SCREEN.wrefresh(win)
       end
     end
 
@@ -162,7 +162,7 @@ module CDK
         shadow_win.mvwaddch(0, x_hi, Ncurses::ACS_URCORNER | Ncurses::A_DIM)
         shadow_win.mvwaddch(y_hi, 0, Ncurses::ACS_LLCORNER | Ncurses::A_DIM)
         shadow_win.mvwaddch(y_hi, x_hi, Ncurses::ACS_LRCORNER | Ncurses::A_DIM)
-        shadow_win.wrefresh
+        SCREEN.wrefresh(shadow_win)
       end
     end
 
@@ -170,9 +170,7 @@ module CDK
     def Draw.writeBlanks(window, xpos, ypos, align, start, endn)
       if start < endn
         want = (endn - start) + 1000
-        blanks = ''
-
-        CDK.cleanChar(blanks, want - 1, ' ')
+        blanks = ' ' * (want - 1)
         Draw.writeChar(window, xpos, ypos, blanks, align, start, endn)
       end
     end

data/lib/cdk/helpers/file.rb

@@ -0,0 +1,43 @@
+module CDK
+  # This reads a file and sticks it into the list provided.
+  def self.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
+
+  # This opens the current directory and reads the contents.
+  def self.getDirectoryContents(directory, list)
+    counter = 0
+
+    # Open the directory.
+    Dir.foreach(directory) do |filename|
+      next if filename == '.'
+      list << filename
+    end
+
+    list.sort!
+    return list.size
+  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 self.dirName (pathname)
+    File.dirname(pathname)
+  end
+end # module CDK

data/lib/cdk/helpers/types.rb

@@ -0,0 +1,13 @@
+module CDK
+  def self.digit?(character)
+    !(character.match(/^[[:digit:]]$/).nil?)
+  end
+
+  def self.alpha?(character)
+    !(character.match(/^[[:alpha:]]$/).nil?)
+  end
+
+  def self.isChar(c)
+    c >= 0 && c < Ncurses::KEY_MIN
+  end
+end # module CDK

data/lib/cdk/helpers/window.rb

@@ -0,0 +1,64 @@
+module CDK
+  # This safely erases a given window
+  def self.eraseCursesWindow (window)
+    return if window.nil?
+
+    window.werase
+    SCREEN.wrefresh(window)
+  end
+
+  # This safely deletes a given window.
+  def self.deleteCursesWindow (window)
+    return if window.nil?
+
+    eraseCursesWindow(window)
+    window.delwin
+  end
+
+  # This 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 self.moveCursesWindow (window, xdiff, ydiff)
+    return if window.nil?
+
+    xpos = []
+    ypos = []
+    window.getbegyx(ypos, xpos)
+    if window.mvwin(ypos[0], xpos[0]) != Ncurses::ERR
+      xpos[0] += xdiff
+      ypos[0] += ydiff
+      window.werase
+      window.mvwin(ypos[0], xpos[0])
+    else
+      CDK.Beep
+    end
+  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 self.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
+end # module CDK

data/lib/cdk/mixins/alignments.rb

@@ -0,0 +1,55 @@
+module CDK
+  module Alignments
+    # 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 alignxy (window, xpos, ypos, box_width, box_height)
+      first = window.getbegx
+      last = window.getmaxx
+      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 = window.getbegy
+      last = window.getmaxy
+      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
+  end # module Alignments
+end # module CDK

data/lib/cdk/mixins/bindings.rb

@@ -0,0 +1,73 @@
+module CDK
+  module Bindings
+    attr_reader :binding_list
+
+    def init_bindings
+      # Bound functions
+      @binding_list = {}
+    end
+
+    def bindableObject(cdktype)
+      if cdktype != self.object_type
+        return nil
+      elsif [:FSELECT, :ALPHALIST].include?(self.object_type)
+        return @entry_field
+      else
+        return self
+      end
+    end
+
+    def bind(type, key, function, data)
+      obj = self.bindableObject(type)
+      if key.ord < Ncurses::KEY_MAX && !(obj.nil?)
+        if key.ord != 0
+          obj.binding_list[key.ord] = [function, data]
+        end
+      end
+    end
+
+    def unbind(type, key)
+      obj = self.bindableObject(type)
+      unless obj.nil?
+        obj.binding_list.delete(key)
+      end
+    end
+
+    def cleanBindings(type)
+      obj = self.bindableObject(type)
+      if !(obj.nil?) && !(obj.binding_list.nil?)
+        obj.binding_list.clear
+      end
+    end
+
+    # This checks to see if the binding for the key exists:
+    # If it does then it runs the command and returns its value, normally true
+    # If it doesn't it returns a false.  This way we can 'overwrite' coded
+    # bindings.
+    def checkBind(type, key)
+      obj = self.bindableObject(type)
+      if !(obj.nil?) && obj.binding_list.include?(key)
+        function = obj.binding_list[key][0]
+        data = obj.binding_list[key][1]
+
+        if function == :getc
+          return data
+        else
+          return function.call(type, obj, data, key)
+        end
+      end
+      return false
+    end
+
+    # This checks to see if the binding for the key exists.
+    def isBind(type, key)
+      result = false
+      obj = self.bindableObject(type)
+      unless obj.nil?
+        result = obj.binding_list.include?(key)
+      end
+
+      return result
+    end
+  end # module Bindings
+end # module CDK

data/lib/cdk/mixins/borders.rb

@@ -0,0 +1,62 @@
+module CDK
+  module Borders
+    attr_accessor :box
+    attr_accessor :ULChar, :URChar, :LLChar, :LRChar, :HZChar, :VTChar, :BXAttr
+    attr_reader :border_size
+
+    def init_borders
+      # set default line-drawing characters
+      @ULChar = Ncurses::ACS_ULCORNER
+      @URChar = Ncurses::ACS_URCORNER
+      @LLChar = Ncurses::ACS_LLCORNER
+      @LRChar = Ncurses::ACS_LRCORNER
+      @HZChar = Ncurses::ACS_HLINE
+      @VTChar = Ncurses::ACS_VLINE
+      @BXAttr = Ncurses::A_NORMAL
+    end
+
+    def setBox(box)
+      @box = box
+      @border_size = if @box then 1 else 0 end
+    end
+
+    def getBox
+      return @box
+    end
+
+    # Set the object's upper-left-corner line-drawing character.
+    def setULchar(ch)
+      @ULChar = ch
+    end
+
+    # Set the object's upper-right-corner line-drawing character.
+    def setURchar(ch)
+      @URChar = ch
+    end
+
+    # Set the object's lower-left-corner line-drawing character.
+    def setLLchar(ch)
+      @LLChar = ch
+    end
+
+    # Set the object's upper-right-corner line-drawing character.
+    def setLRchar(ch)
+      @LRChar = ch
+    end
+
+    # Set the object's horizontal line-drawing character
+    def setHZchar(ch)
+      @HZChar = ch
+    end
+
+    # Set the object's vertical line-drawing character
+    def setVTchar(ch)
+      @VTChar = ch
+    end
+
+    # Set the object's box-attributes.
+    def setBXattr(ch)
+      @BXAttr = ch
+    end
+  end # module Borders
+end # module CDK