cdk 0.9.0

data/lib/cdk/display.rb

@@ -0,0 +1,63 @@
+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
+        true
+      when :CHAR, :INT, :INVALID, :LCHAR, :LMIXED, :MIXED, :UCHAR,
+          :UMIXED, :VIEWONLY
+        false
+      end
+    end
+
+    # Given a character input, check if it is allowed by the display type
+    # and return the character to apply to the display, or ERR if not
+    def Display.filterByDisplayType(type, input)
+      result = input
+      if !CDK.isChar(input)
+        result = Ncurses::ERR
+      elsif [:INT, :HINT].include?(type) && !CDK.digit?(result.chr)
+        result = Ncurses::ERR
+      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)
+        result = result.chr.upcase.ord
+      elsif [:LCHAR, :LHCHAR, :LMIXED, :LHMIXED].include?(type) && CDK.alpha?(result.chr)
+        result = result.chr.downcase.ord
+      end
+
+      return result
+    end
+  end
+end

data/lib/cdk/draw.rb

@@ -0,0 +1,233 @@
+module CDK
+  module Draw
+    # This sets up a basic set of color pairs. These can be redefined if wanted
+    def Draw.initCDKColor
+      color = [Ncurses::COLOR_WHITE, Ncurses::COLOR_RED, Ncurses::COLOR_GREEN,
+          Ncurses::COLOR_YELLOW, Ncurses::COLOR_BLUE, Ncurses::COLOR_MAGENTA,
+          Ncurses::COLOR_CYAN, Ncurses::COLOR_BLACK]
+      pair = 1
+
+      if Ncurses.has_colors?
+        # XXX: Only checks if terminal has colours not if colours are started
+        Ncurses.start_color
+        limit = if Ncurses.COLORS < 8 then Ncurses.COLORS else 8 end
+
+        # Create the color pairs
+        (0...limit).each do |fg|
+          (0...limit).each do |bg|
+            Ncurses.init_pair(pair, color[fg], color[bg])
+            pair += 1
+          end
+        end
+      end
+    end
+
+    # This prints out a box around a window with attributes
+    def Draw.boxWindow(window, attr)
+      tlx = 0
+      tly = 0
+      brx = window.getmaxx - 1
+      bry = window.getmaxy - 1
+
+      # Draw horizontal lines.
+      window.mvwhline(tly, 0, Ncurses::ACS_HLINE | attr, window.getmaxx)
+      window.mvwhline(bry, 0, Ncurses::ACS_HLINE | attr, window.getmaxx)
+
+      # Draw horizontal lines.
+      window.mvwvline(0, tlx, Ncurses::ACS_VLINE | attr, window.getmaxy)
+      window.mvwvline(0, brx, Ncurses::ACS_VLINE | attr, window.getmaxy)
+
+      # Draw in the corners.
+      window.mvwaddch(tly, tlx, Ncurses::ACS_ULCORNER | attr)
+      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
+    end
+
+    # This draws a box with attributes and lets the user define each
+    # element of the box
+    def Draw.attrbox(win, tlc, trc, blc, brc, horz, vert, attr)
+      x1 = 0
+      y1 = 0
+      y2 = win.getmaxy - 1
+      x2 = win.getmaxx - 1
+      count = 0
+
+      # Draw horizontal lines
+      if horz != 0
+        win.mvwhline(y1, 0, horz | attr, win.getmaxx)
+        win.mvwhline(y2, 0, horz | attr, win.getmaxx)
+        count += 1
+      end
+
+      # Draw vertical lines
+      if vert != 0
+        win.mvwvline(0, x1, vert | attr, win.getmaxy)
+        win.mvwvline(0, x2, vert | attr, win.getmaxy)
+        count += 1
+      end
+
+      # Draw in the corners.
+      if tlc != 0
+        win.mvwaddch(y1, x1, tlc | attr)
+        count += 1
+      end
+      if trc != 0
+        win.mvwaddch(y1, x2, trc | attr)
+        count += 1
+      end
+      if blc != 0
+        win.mvwaddch(y2, x1, blc | attr)
+        count += 1
+      end
+      if brc != 0
+        win.mvwaddch(y2, x2, brc | attr)
+        count += 1
+      end
+      if count != 0
+        win.wrefresh
+      end
+    end
+
+    # Draw a box around the given window using the object's defined
+    # line-drawing characters
+    def Draw.drawObjBox(win, object)
+      Draw.attrbox(win,
+          object.ULChar, object.URChar, object.LLChar, object.LRChar,
+          object.HZChar, object.VTChar, object.BXAttr)
+    end
+
+    # This draws a line on the given window. (odd angle lines not working yet)
+    def Draw.drawLine(window, startx, starty, endx, endy, line)
+      xdiff = endx - startx
+      ydiff = endy - starty
+      x = 0
+      y = 0
+
+      # Determine if we're drawing a horizontal or vertical line.
+      if ydiff == 0
+        if xdiff > 0
+          window.mvwhline(starty, startx, line, xdiff)
+        end
+      elsif xdiff == 0
+        if ydiff > 0
+          window.mvwvline(starty, startx, line, ydiff)
+        end
+      else
+        # We need to determine the angle of the line.
+        height = xdiff
+        width = ydiff
+        xratio = if height > width then 1 else width / height end
+        yration = if width > height then width / height else 1 end
+        xadj = 0
+        yadj = 0
+
+        # Set the vars
+        x = startx
+        y = starty
+        while x!= endx && y != endy
+          # Add the char to the window
+          window.mvwaddch(y, x, line)
+
+          # Make the x and y adjustments.
+          if xadj != xratio
+            x = if xdiff < 0 then x - 1 else x + 1 end
+            xadj += 1
+          else
+            xadj = 0
+          end
+          if yadj != yratio
+            y = if ydiff < 0 then y - 1 else y + 1 end
+            yadj += 1
+          else
+            yadj = 0
+          end
+        end
+      end
+    end
+
+    # This draws a shadow around a window.
+    def Draw.drawShadow(shadow_win)
+      unless shadow_win.nil?
+        x_hi = shadow_win.getmaxx - 1
+        y_hi = shadow_win.getmaxy - 1
+
+        # Draw the line on the bottom.
+        shadow_win.mvwhline(y_hi, 1, Ncurses::ACS_HLINE | Ncurses::A_DIM, x_hi)
+        
+        # Draw the line on teh right.
+        shadow_win.mvwvline(0, x_hi, Ncurses::ACS_VLINE | Ncurses::A_DIM, y_hi)
+
+        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
+      end
+    end
+
+    # Write a string of blanks using writeChar()
+    def Draw.writeBlanks(window, xpos, ypos, align, start, endn)
+      if start < endn
+        want = (endn - start) + 1000
+        blanks = ''
+
+        CDK.cleanChar(blanks, want - 1, ' ')
+        Draw.writeChar(window, xpos, ypos, blanks, align, start, endn)
+      end
+    end
+
+    # This writes out a char string with no attributes
+    def Draw.writeChar(window, xpos, ypos, string, align, start, endn)
+      Draw.writeCharAttrib(window, xpos, ypos, string, Ncurses::A_NORMAL,
+          align, start, endn)
+    end
+
+    # This writes out a char string with attributes
+    def Draw.writeCharAttrib(window, xpos, ypos, string, attr, align,
+        start, endn)
+      display = endn - start
+
+      if align == CDK::HORIZONTAL
+        # Draw the message on a horizontal axis
+        display = [display, window.getmaxx - 1].min
+        (0...display).each do |x|
+          window.mvwaddch(ypos, xpos + x, string[x + start].ord | attr)
+        end
+      else
+        # Draw the message on a vertical axis
+        display = [display, window.getmaxy - 1].min
+        (0...display).each do |x|
+          window.mvwaddch(ypos + x, xpos, string[x + start].ord | attr)
+        end
+      end
+    end
+
+    # This writes out a chtype string
+    def Draw.writeChtype (window, xpos, ypos, string, align, start, endn)
+      Draw.writeChtypeAttrib(window, xpos, ypos, string, Ncurses::A_NORMAL,
+          align, start, endn)
+    end
+
+    # This writes out a chtype string with the given attributes added.
+    def Draw.writeChtypeAttrib(window, xpos, ypos, string, attr,
+        align, start, endn)
+      diff = endn - start
+      display = 0
+      x = 0
+      if align == CDK::HORIZONTAL
+        # Draw the message on a horizontal axis.
+        display = [diff, window.getmaxx - xpos].min
+        (0...display).each do |x|
+          window.mvwaddch(ypos, xpos + x, string[x + start].ord | attr)
+        end
+      else
+        # Draw the message on a vertical axis.
+        display = [diff, window.getmaxy - ypos].min
+        (0...display).each do |x|
+          window.mvwaddch(ypos + x, xpos, string[x + start].ord | attr)
+        end
+      end
+    end
+  end
+end

data/lib/cdk/dscale.rb

@@ -0,0 +1,13 @@
+require_relative 'fscale'
+
+module CDK
+  class DSCALE < CDK::FSCALE
+    # The original DScale handled unsigned values.
+    # Since Ruby's typing is different this is really just FSCALE
+    # but is nice it's nice to have this for compatibility/completeness
+    # sake.
+    def object_type
+      :DSCALE
+    end
+  end
+end

data/lib/cdk/entry.rb

@@ -0,0 +1,556 @@
+require_relative 'cdk_objs'
+
+module CDK
+  class ENTRY < CDK::CDKOBJS
+    attr_accessor :info, :left_char, :screen_col
+    attr_reader :win, :box_height, :box_width, :max, :field_width
+    attr_reader :min, :max
+
+    def initialize(cdkscreen, xplace, yplace, title, label, field_attr, filler,
+        disp_type, f_width, min, max, box, shadow)
+      super()
+      parent_width = cdkscreen.window.getmaxx
+      parent_height = cdkscreen.window.getmaxy
+      field_width = f_width
+      box_width = 0
+      xpos = xplace
+      ypos = yplace
+      
+      self.setBox(box)
+      box_height = @border_size * 2 + 1
+
+      # 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 = CDK.setWidgetDimension(parent_width, field_width, 0)
+      box_width = field_width + 2 * @border_size
+
+      # Set some basic values of the entry field.
+      @label = 0
+      @label_len = 0
+      @label_win = nil
+
+      # Translate the label string to a chtype array
+      if !(label.nil?) && label.size > 0
+        label_len = [@label_len]
+        @label = CDK.char2Chtype(label, label_len, [])
+        @label_len = label_len[0]
+        box_width += @label_len
+      end
+
+      old_width = box_width
+      box_width = self.setTitle(title, box_width)
+      horizontal_adjust = (box_width - old_width) / 2
+
+      box_height += @title_lines
+
+      # Make sure we didn't extend beyond the dimensinos of the window.
+      box_width = [box_width, parent_width].min
+      box_height = [box_height, parent_height].min
+      field_width = [field_width,
+          box_width - @label_len - 2 * @border_size].min
+
+      # Rejustify the x and y positions if we need to.
+      xtmp = [xpos]
+      ytmp = [ypos]
+      CDK.alignxy(cdkscreen.window, xtmp, ytmp, box_width, box_height)
+      xpos = xtmp[0]
+      ypos = ytmp[0]
+
+      # Make the label window.
+      @win = cdkscreen.window.subwin(box_height, box_width, ypos, xpos)
+      if @win.nil?
+        self.destroy
+        return nil
+      end
+      @win.keypad(true)
+
+      # Make the field window.
+      @field_win = @win.subwin(1, field_width,
+          ypos + @title_lines + @border_size,
+          xpos + @label_len + horizontal_adjust + @border_size)
+
+      if @field_win.nil?
+        self.destroy
+        return nil
+      end
+      @field_win.keypad(true)
+
+      # make the label win, if we need to
+      if !(label.nil?) && label.size > 0
+        @label_win = @win.subwin(1, @label_len,
+            ypos + @title_lines + @border_size,
+            xpos + horizontal_adjust + @border_size)
+      end
+
+      # cleanChar (entry->info, max + 3, '\0');
+      @info = ''
+      @info_width = max + 3
+
+      # Set up the rest of the structure.
+      @screen = cdkscreen
+      @parent = cdkscreen.window
+      @shadow_win = nil
+      @field_attr = field_attr
+      @field_width = field_width
+      @filler = filler
+      @hidden = filler
+      @input_window = @field_win
+      @accepts_focus = true
+      @data_ptr = nil
+      @shadow = shadow
+      @screen_col = 0
+      @left_char = 0
+      @min = min
+      @max = max
+      @box_width = box_width
+      @box_height = box_height
+      @disp_type = disp_type
+      @callbackfn = lambda do |entry, character|
+        plainchar = Display.filterByDisplayType(entry, character)
+
+        if plainchar == Ncurses::ERR || entry.info.size >= entry.max
+          CDK.Beep
+        else
+          # Update the screen and pointer
+          if entry.screen_col != entry.field_width - 1
+            front = (entry.info[0...(entry.screen_col + entry.left_char)] or '')
+            back = (entry.info[(entry.screen_col + entry.left_char)..-1] or '')
+            entry.info = front + plainchar.chr + back
+            entry.screen_col += 1
+          else
+            # Update the character pointer.
+            entry.info << plainchar
+            # Do not update the pointer if it's the last character
+            if entry.info.size < entry.max
+              entry.left_char += 1
+            end
+          end
+
+          # Update the entry field.
+          entry.drawField
+        end
+      end
+
+      # Do we want a shadow?
+      if shadow
+        @shadow_win = cdkscreen.window.subwin(box_height, box_width,
+            ypos + 1, xpos + 1)
+      end
+
+      cdkscreen.register(:ENTRY, self)
+    end
+
+    # This means you want to use the given entry field. It takes input
+    # from the keyboard, and when it's done, it fills the entry info
+    # element of the structure with what was typed.
+    def activate(actions)
+      input = 0
+      ret = 0
+
+      # Draw the widget.
+      self.draw(@box)
+
+      if actions.nil? or actions.size == 0
+        while true
+          input = self.getch([])
+
+          # Inject the character into the widget.
+          ret = self.inject(input)
+          if @exit_type != :EARLY_EXIT
+            return ret
+          end
+        end
+      else
+        # Inject each character one at a time.
+        actions.each do |action|
+          ret = self.inject(action)
+          if @exit_type != :EARLY_EXIT
+            return ret
+          end
+        end
+      end
+
+      # Make sure we return the correct info.
+      if @exit_type == :NORMAL
+        return @info
+      else
+        return 0
+      end
+    end
+
+    def setPositionToEnd
+      if @info.size >= @field_width
+        if @info.size < @max
+          char_count = @field_width - 1
+          @left_char = @info.size - char_count
+          @screen_col = char_count
+        else
+          @left_char = @info.size - @field_width
+          @screen_col = @info.size - 1
+        end
+      else
+        @left_char = 0
+        @screen_col = @info.size
+      end
+    end
+
+    # This injects a single character into the widget.
+    def inject(input)
+      pp_return = 1
+      ret = 1
+      complete = false
+
+      # Set the exit type
+      self.setExitType(0)
+      
+      # Refresh the widget field.
+      self.drawField
+
+      unless @pre_process_func.nil?
+        pp_return = @pre_process_func.call(:ENTRY, self,
+            @pre_process_data, input)
+      end
+
+      # Should we continue?
+      if pp_return != 0
+        # Check a predefined binding
+        if self.checkBind(:ENTRY, input)
+          complete = true
+        else
+          curr_pos = @screen_col + @left_char
+
+          case input
+          when Ncurses::KEY_UP, Ncurses::KEY_DOWN
+            CDK.Beep
+          when Ncurses::KEY_HOME
+            @left_char = 0
+            @screen_col = 0
+            self.drawField
+          when CDK::TRANSPOSE
+            if curr_pos >= @info.size - 1
+              CDK.Beep
+            else
+              holder = @info[curr_pos]
+              @info[curr_pos] = @info[curr_pos + 1]
+              @info[curr_pos + 1] = holder
+              self.drawField
+            end
+          when Ncurses::KEY_END
+            self.setPositionToEnd
+            self.drawField
+          when Ncurses::KEY_LEFT
+            if curr_pos <= 0
+              CDK.Beep
+            elsif @screen_col == 0
+              # Scroll left.
+              @left_char -= 1
+              self.drawField
+            else
+              @screen_col -= 1
+              @field_win.wmove(0, @screen_col)
+            end
+          when Ncurses::KEY_RIGHT
+            if curr_pos >= @info.size
+              CDK.Beep
+            elsif @screen_col == @field_width - 1
+              # Scroll to the right.
+              @left_char += 1
+              self.drawField
+            else
+              # Move right.
+              @screen_col += 1
+              @field_win.wmove(0, @screen_col)
+            end
+          when Ncurses::KEY_BACKSPACE, Ncurses::KEY_DC
+            if @disp_type == :VIEWONLY
+              CDK.Beep
+            else
+              success = false
+              if input == Ncurses::KEY_BACKSPACE
+                curr_pos -= 1
+              end
+
+              if curr_pos >= 0 && @info.size > 0
+                if curr_pos < @info.size
+                  @info = @info[0...curr_pos] + @info[curr_pos+1..-1]
+                  success = true
+                elsif input == Ncurses::KEY_BACKSPACE
+                  @info = @info[0...-1]
+                  success = true
+                end
+              end
+              
+              if success
+                if input == Ncurses::KEY_BACKSPACE
+                  if @screen_col > 0
+                    @screen_col -= 1
+                  else
+                    @left_char -= 1
+                  end
+                end
+                self.drawField
+              else
+                CDK.Beep
+              end
+            end
+          when CDK::KEY_ESC
+            self.setExitType(input)
+            complete = true
+          when CDK::ERASE
+            if @info.size != 0
+              self.clean
+              self.drawField
+            end
+          when CDK::CUT
+            if @info.size != 0
+              @@g_paste_buffer = @info.clone
+              self.clean
+              self.drawField
+            else
+              CDK.Beep
+            end
+          when CDK::COPY
+            if @info.size != 0
+              @@g_paste_buffer = @info.clone
+            else
+              CDK.Beep
+            end
+          when CDK::PASTE
+            if @@g_paste_buffer != 0
+              self.setValue(@@g_paste_buffer)
+              self.drawField
+            else
+              CDK.Beep
+            end
+          when CDK::KEY_TAB, CDK::KEY_RETURN, Ncurses::KEY_ENTER
+            if @info.size >= @min
+              self.setExitType(input)
+              ret = @info
+              complete = true
+            else
+              CDK.Beep
+            end
+          when Ncurses::ERR
+            self.setExitType(input)
+            complete = true
+          when CDK::REFRESH
+            @screen.erase
+            @screen.refresh
+          else
+            @callbackfn.call(self, input)
+          end
+        end
+
+        if !complete && !(@post_process_func.nil?)
+          @post_process_func.call(:ENTRY, self, @post_process_data, input)
+        end
+      end
+
+      unless complete
+        self.setExitType(0)
+      end
+
+      @result_data = ret
+      return ret
+    end
+
+    # This moves the entry field to the given location.
+    def move(xplace, yplace, relative, refresh_flag)
+      windows = [@win, @field_win, @label_win, @shadow_win]
+      self.move_specific(xplace, yplace, relative, refresh_flag,
+          windows, [])
+    end
+    
+    # This erases the information in the entry field and redraws
+    # a clean and empty entry field.
+    def clean
+      width = @field_width
+
+      @info = ''
+
+      # Clean the entry screen field.
+      @field_win.mvwhline(0, 0, @filler.ord, width)
+
+      # Reset some variables
+      @screen_col = 0
+      @left_char = 0
+
+      # Refresh the entry field.
+      @field_win.wrefresh
+    end
+
+    # This draws the entry field.
+    def draw(box)
+      # Did we ask for a shadow?
+      unless @shadow_win.nil?
+        Draw.drawShadow(@shadow_win)
+      end
+
+      # Box the widget if asked.
+      if box
+        Draw.drawObjBox(@win, self)
+      end
+
+      self.drawTitle(@win)
+
+      @win.wrefresh
+
+      # Draw in the label to the widget.
+      unless @label_win.nil?
+        Draw.writeChtype(@label_win, 0, 0, @label, CDK::HORIZONTAL, 0,
+            @label_len)
+        @label_win.wrefresh
+      end
+
+      self.drawField
+    end
+
+    def drawField
+      # Draw in the filler characters.
+      @field_win.mvwhline(0, 0, @filler.ord, @field_width)
+
+      # If there is information in the field then draw it in.
+      if !(@info.nil?) && @info.size > 0
+        # Redraw the field.
+        if Display.isHiddenDisplayType(@disp_type)
+          (@left_char...@info.size).each do |x|
+            @field_win.mvwaddch(0, x - @left_char, @hidden)
+          end
+        else
+          (@left_char...@info.size).each do |x|
+            @field_win.mvwaddch(0, x - @left_char, @info[x].ord | @field_attr)
+          end
+        end
+        @field_win.wmove(0, @screen_col)
+      end
+
+      @field_win.wrefresh
+    end
+
+    # This erases an entry widget from the screen.
+    def erase
+      if self.validCDKObject
+        CDK.eraseCursesWindow(@field_win)
+        CDK.eraseCursesWindow(@label_win)
+        CDK.eraseCursesWindow(@win)
+        CDK.eraseCursesWindow(@shadow_win)
+      end
+    end
+
+    # This destroys an entry widget.
+    def destroy
+      self.cleanTitle
+
+      CDK.deleteCursesWindow(@field_win)
+      CDK.deleteCursesWindow(@label_win)
+      CDK.deleteCursesWindow(@shadow_win)
+      CDK.deleteCursesWindow(@win)
+
+      self.cleanBindings(:ENTRY)
+
+      CDK::SCREEN.unregister(:ENTRY, self)
+    end
+
+    # This sets specific attributes of the entry field.
+    def set(value, min, max, box)
+      self.setValue(value)
+      self.setMin(min)
+      self.setMax(max)
+    end
+
+    # This removes the old information in the entry field and keeps
+    # the new information given.
+    def setValue(new_value)
+      if new_value.nil?
+        @info = ''
+
+        @left_char = 0
+        @screen_col = 0
+      else
+        @info = new_value.clone
+
+        self.setPositionToEnd
+      end
+    end
+
+    def getValue
+      return @info
+    end
+
+    # This sets the maximum length of the string that will be accepted
+    def setMax(max)
+      @max = max
+    end
+
+    def getMax
+      @max
+    end
+
+    # This sets the minimum length of the string that will be accepted.
+    def setMin(min)
+      @min = min
+    end
+
+    def getMin
+      @min
+    end
+
+    # This sets the filler character to be used in the entry field.
+    def setFillerChar(filler_char)
+      @filler = filler_char
+    end
+
+    def getFillerChar
+      @filler
+    end
+
+    # This sets the character to use when a hidden type is used.
+    def setHiddenChar(hidden_characer)
+      @hidden = hidden_character
+    end
+
+    def getHiddenChar
+      @hidden
+    end
+
+    # This sets the background attribute of the widget.
+    def setBKattr(attrib)
+      @win.wbkgd(attrib)
+      @field_win.wbkgd(attrib)
+      unless @label_win.nil?
+        @label_win.wbkgd(attrib)
+      end
+    end
+
+    # This sets the attribute of the entry field.
+    def setHighlight(highlight, cursor)
+      @field_win.wbkgd(highlight)
+      @field_attr = highlight
+      Ncurses.curs_set(cursor)
+      # FIXME(original) - if (cursor) { move the cursor to this widget }
+    end
+
+    # This sets the entry field callback function.
+    def setCB(callback)
+      @callbackfn = callback
+    end
+
+    def focus
+      @field_win.wmove(0, @screen_col)
+      @field_win.wrefresh
+    end
+
+    def unfocus
+      self.draw(box)
+      @field_win.wrefresh
+    end
+
+    def position
+      super(@win)
+    end
+
+    def object_type
+      :ENTRY
+    end
+  end
+end