rndk 0.0.1

data/lib/rndk/dialog.rb

@@ -0,0 +1,367 @@
+require 'rndk'
+
+module RNDK
+  class DIALOG < RNDK::Widget
+    attr_reader :current_button
+    MIN_DIALOG_WIDTH = 10
+
+    def initialize(rndkscreen, xplace, yplace, mesg, rows, button_label,
+        button_count, highlight, separator, box, shadow)
+      super()
+      box_width = DIALOG::MIN_DIALOG_WIDTH
+      max_message_width = -1
+      button_width = 0
+      xpos = xplace
+      ypos = yplace
+      temp = 0
+      buttonadj = 0
+      @info = []
+      @info_len = []
+      @info_pos = []
+      @button_label = []
+      @button_len = []
+      @button_pos = []
+
+      if rows <= 0 || button_count <= 0
+        self.destroy
+        return nil
+      end
+
+      self.setBox(box)
+      box_height = if separator then 1 else 0 end
+      box_height += rows + 2 * @border_size + 1
+
+      # Translate the string message to a chtype array
+      (0...rows).each do |x|
+        info_len = []
+        info_pos = []
+        @info << RNDK.char2Chtype(mesg[x], info_len, info_pos)
+        @info_len << info_len[0]
+        @info_pos << info_pos[0]
+        max_message_width = [max_message_width, info_len[0]].max
+      end
+
+      # Translate the button label string to a chtype array
+      (0...button_count).each do |x|
+        button_len = []
+        @button_label << RNDK.char2Chtype(button_label[x], button_len, [])
+        @button_len << button_len[0]
+        button_width += button_len[0] + 1
+      end
+
+      button_width -= 1
+
+      # Determine the final dimensions of the box.
+      box_width = [box_width, max_message_width, button_width].max
+      box_width = box_width + 2 + 2 * @border_size
+
+      # Now we have to readjust the x and y positions.
+      xtmp = [xpos]
+      ytmp = [ypos]
+      RNDK.alignxy(rndkscreen.window, xtmp, ytmp, box_width, box_height)
+      xpos = xtmp[0]
+      ypos = ytmp[0]
+
+      # Set up the dialog box attributes.
+      @screen = rndkscreen
+      @parent = rndkscreen.window
+      @win = Ncurses.newwin(box_height, box_width, ypos, xpos)
+      @shadow_win = nil
+      @button_count = button_count
+      @current_button = 0
+      @message_rows = rows
+      @box_height = box_height
+      @box_width = box_width
+      @highlight = highlight
+      @separator = separator
+      @accepts_focus = true
+      @input_window = @win
+      @shadow = shadow
+
+      # If we couldn't create the window, we should return a nil value.
+      if @win.nil?
+        self.destroy
+        return nil
+      end
+      Ncurses.keypad(@win, true)
+
+      # Find the button positions.
+      buttonadj = (box_width - button_width) / 2
+      (0...button_count).each do |x|
+        @button_pos[x] = buttonadj
+        buttonadj = buttonadj + @button_len[x] + @border_size
+      end
+
+      # Create the string alignments.
+      (0...rows).each do |x|
+        @info_pos[x] = RNDK.justifyString(box_width - 2 * @border_size,
+            @info_len[x], @info_pos[x])
+      end
+
+      # Was there a shadow?
+      if shadow
+        @shadow_win = Ncurses.newwin(box_height, box_width,
+            ypos + 1, xpos + 1)
+      end
+
+      # Register this baby.
+      rndkscreen.register(:DIALOG, self)
+    end
+
+    # This lets the user select the button.
+    def activate(actions)
+      input = 0
+
+      # Draw the dialog box.
+      self.draw(@box)
+
+      # Lets move to the first button.
+      Draw.writeChtypeAttrib(@win,
+                             @button_pos[@current_button],
+                             @box_height - 1 - @border_size, @button_label[@current_button],
+                             @highlight,
+                             RNDK::HORIZONTAL,
+                             0,
+                             @button_len[@current_button])
+      Ncurses.wrefresh @win
+
+      if actions.nil? || 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
+
+      # Set the exit type and exit
+      self.setExitType(0)
+      return -1
+    end
+
+    # This injects a single character into the dialog widget
+    def inject(input)
+      first_button = 0
+      last_button = @button_count - 1
+      pp_return = 1
+      ret = -1
+      complete = false
+
+      # Set the exit type.
+      self.setExitType(0)
+
+      # Check if there is a pre-process function to be called.
+      unless @pre_process_func.nil?
+        pp_return = @pre_process_func.call(:DIALOG, self,
+            @pre_process_data, input)
+      end
+
+      # Should we continue?
+      if pp_return != 0
+        # Check for a key binding.
+        if self.checkBind(:DIALOG, input)
+          complete = true
+        else
+          case input
+          when Ncurses::KEY_LEFT, Ncurses::KEY_BTAB, Ncurses::KEY_BACKSPACE
+            if @current_button == first_button
+              @current_button = last_button
+            else
+              @current_button -= 1
+            end
+          when Ncurses::KEY_RIGHT, RNDK::KEY_TAB, ' '.ord
+            if @current_button == last_button
+              @current_button = first_button
+            else
+              @current_button += 1
+            end
+          when Ncurses::KEY_UP, Ncurses::KEY_DOWN
+            RNDK.beep
+          when RNDK::REFRESH
+            @screen.erase
+            @screen.refresh
+          when RNDK::KEY_ESC
+            self.setExitType(input)
+            complete = true
+          when Ncurses::ERR
+            self.setExitType(input)
+          when Ncurses::KEY_ENTER, RNDK::KEY_RETURN
+            self.setExitType(input)
+            ret = @current_button
+            complete = true
+          end
+        end
+
+        # Should we call a post_process?
+        if !complete && !(@post_process_func.nil?)
+          @post_process_func.call(:DIALOG, self,
+              @post_process_data, input)
+        end
+      end
+
+      unless complete
+        self.drawButtons
+        Ncurses.wrefresh @win
+        self.setExitType(0)
+      end
+
+      @result_data = ret
+      return ret
+    end
+
+    # This moves the dialog field to the given location.
+    # Inherited
+    # def move(xplace, yplace, relative, refresh_flag)
+    # end
+
+    # This function draws the dialog widget.
+    def draw(box)
+      # Is there a shadow?
+      unless @shadow_win.nil?
+        Draw.drawShadow(@shadow_win)
+      end
+
+      # Box the widget if they asked.
+      if box
+        Draw.drawObjBox(@win, self)
+      end
+
+      # Draw in the message.
+      (0...@message_rows).each do |x|
+        Draw.writeChtype(@win,
+                         @info_pos[x] + @border_size,
+                         x + @border_size,
+                         @info[x],
+                         RNDK::HORIZONTAL,
+                         0,
+                         @info_len[x])
+      end
+
+      # Draw in the buttons.
+      self.drawButtons
+
+      Ncurses.wrefresh @win
+    end
+
+    # This function destroys the dialog widget.
+    def destroy
+      # Clean up the windows.
+      RNDK.deleteCursesWindow(@win)
+      RNDK.deleteCursesWindow(@shadow_win)
+
+      # Clean the key bindings
+      self.cleanBindings(:DIALOG)
+
+      # Unregister this object
+      RNDK::Screen.unregister(:DIALOG, self)
+    end
+
+    # This function erases the dialog widget from the screen.
+    def erase
+      if self.validRNDKObject
+        RNDK.eraseCursesWindow(@win)
+        RNDK.eraseCursesWindow(@shadow_win)
+      end
+    end
+
+    # This sets attributes of the dialog box.
+    def set(highlight, separator, box)
+      self.setHighlight(highlight)
+      self.setSeparator(separator)
+      self.setBox(box)
+    end
+
+    # This sets the highlight attribute for the buttons.
+    def setHighlight(highlight)
+      @highlight = highlight
+    end
+
+    def getHighlight
+      return @highlight
+    end
+
+    # This sets whether or not the dialog box will have a separator line.
+    def setSeparator(separator)
+      @separator = separator
+    end
+
+    def getSeparator
+      return @separator
+    end
+
+    # This sets the background attribute of the widget.
+    def setBKattr(attrib)
+      Ncurses.wbkgd(@win, attrib)
+    end
+
+    # This draws the dialog buttons and the separation line.
+    def drawButtons
+      (0...@button_count).each do |x|
+        Draw.writeChtype(@win,
+                         @button_pos[x],
+                         @box_height -1 - @border_size,
+                         @button_label[x],
+                         RNDK::HORIZONTAL,
+                         0,
+                         @button_len[x])
+      end
+
+      # Draw the separation line.
+      if @separator
+        boxattr = @BXAttr
+
+        (1...@box_width).each do |x|
+          Ncurses.mvwaddch(@win,
+                           @box_height - 2 - @border_size,
+                           x,
+                           Ncurses::ACS_HLINE | boxattr)
+        end
+
+        Ncurses.mvwaddch(@win,
+                         @box_height - 2 - @border_size,
+                         0,
+                         Ncurses::ACS_LTEE | boxattr)
+        Ncurses.mvwaddch(@win,
+                         @box_height - 2 - @border_size,
+                         Ncurses.getmaxx(@win) - 1,
+                         Ncurses::ACS_RTEE | boxattr)
+      end
+      Draw.writeChtypeAttrib(@win,
+                             @button_pos[@current_button],
+                             @box_height - 1 - @border_size,
+                             @button_label[@current_button],
+                             @highlight,
+                             RNDK::HORIZONTAL,
+                             0,
+                             @button_len[@current_button])
+    end
+
+    def focus
+      self.draw @box
+    end
+
+    def unfocus
+      self.draw @box
+    end
+
+    def object_type
+      :DIALOG
+    end
+
+    def position
+      super(@win)
+    end
+  end
+end
+

data/lib/rndk/dscale.rb

@@ -0,0 +1,13 @@
+require 'rndk/fscale'
+
+module RNDK
+  class DSCALE < RNDK::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/rndk/entry.rb

@@ -0,0 +1,575 @@
+require 'rndk'
+
+module RNDK
+
+  class ENTRY < RNDK::Widget
+    attr_accessor :info, :left_char, :screen_col
+    attr_reader :win, :box_height, :box_width, :max, :field_width
+    attr_reader :min, :max
+
+    def initialize(rndkscreen,
+                   xplace,
+                   yplace,
+                   title,
+                   label,
+                   field_attr,
+                   filler,
+                   disp_type,
+                   f_width,
+                   min,
+                   max,
+                   box,
+                   shadow)
+      super()
+      parent_width = Ncurses.getmaxx rndkscreen.window
+      parent_height = Ncurses.getmaxy rndkscreen.window
+      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 = RNDK.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 = RNDK.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]
+      RNDK.alignxy(rndkscreen.window, xtmp, ytmp, box_width, box_height)
+      xpos = xtmp[0]
+      ypos = ytmp[0]
+
+      # Make the label window.
+      @win = Ncurses.subwin(rndkscreen.window, box_height, box_width, ypos, xpos)
+      if @win.nil?
+        self.destroy
+        return nil
+      end
+      Ncurses.keypad(@win, true)
+
+      # Make the field window.
+      @field_win = Ncurses.subwin(@win,
+                                  1,
+                                  field_width,
+                                  ypos + @title_lines + @border_size,
+                                  xpos + @label_len + horizontal_adjust + @border_size)
+
+      if @field_win.nil?
+        self.destroy
+        return nil
+      end
+      Ncurses.keypad(@field_win, true)
+
+      # make the label win, if we need to
+      if !(label.nil?) && label.size > 0
+        @label_win = Ncurses.subwin(@win, 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 = rndkscreen
+      @parent = rndkscreen.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
+          RNDK.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 = Ncurses.subwin(rndkscreen.window, box_height, box_width,
+            ypos + 1, xpos + 1)
+      end
+
+      rndkscreen.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
+            RNDK.beep
+          when Ncurses::KEY_HOME
+            @left_char = 0
+            @screen_col = 0
+            self.drawField
+          when RNDK::TRANSPOSE
+            if curr_pos >= @info.size - 1
+              RNDK.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
+              RNDK.beep
+            elsif @screen_col == 0
+              # Scroll left.
+              @left_char -= 1
+              self.drawField
+            else
+              @screen_col -= 1
+              Ncurses.wmove(@field_win, 0, @screen_col)
+            end
+          when Ncurses::KEY_RIGHT
+            if curr_pos >= @info.size
+              RNDK.beep
+            elsif @screen_col == @field_width - 1
+              # Scroll to the right.
+              @left_char += 1
+              self.drawField
+            else
+              # Move right.
+              @screen_col += 1
+              Ncurses.wmove(@field_win, 0, @screen_col)
+            end
+          when Ncurses::KEY_BACKSPACE, Ncurses::KEY_DC
+            if @disp_type == :VIEWONLY
+              RNDK.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
+                RNDK.beep
+              end
+            end
+          when RNDK::KEY_ESC
+            self.setExitType(input)
+            complete = true
+          when RNDK::ERASE
+            if @info.size != 0
+              self.clean
+              self.drawField
+            end
+          when RNDK::CUT
+            if @info.size != 0
+              @@g_paste_buffer = @info.clone
+              self.clean
+              self.drawField
+            else
+              RNDK.beep
+            end
+          when RNDK::COPY
+            if @info.size != 0
+              @@g_paste_buffer = @info.clone
+            else
+              RNDK.beep
+            end
+          when RNDK::PASTE
+            if @@g_paste_buffer != 0
+              self.setValue(@@g_paste_buffer)
+              self.drawField
+            else
+              RNDK.beep
+            end
+          when RNDK::KEY_TAB, RNDK::KEY_RETURN, Ncurses::KEY_ENTER
+            if @info.size >= @min
+              self.setExitType(input)
+              ret = @info
+              complete = true
+            else
+              RNDK.beep
+            end
+          when Ncurses::ERR
+            self.setExitType(input)
+            complete = true
+          when RNDK::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.
+      Ncurses.mvwhline(@field_win, 0, 0, @filler.ord, width)
+
+      # Reset some variables
+      @screen_col = 0
+      @left_char = 0
+
+      # Refresh the entry field.
+      Ncurses.wrefresh @field_win
+    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
+
+      Ncurses.wrefresh @win
+
+      # Draw in the label to the widget.
+      unless @label_win.nil?
+        Draw.writeChtype(@label_win,
+                         0,
+                         0,
+                         @label,
+                         RNDK::HORIZONTAL,
+                         0,
+                         @label_len)
+        Ncurses.wrefresh @label_win
+      end
+
+      self.drawField
+    end
+
+    def drawField
+      # Draw in the filler characters.
+      Ncurses.mvwhline(@field_win, 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|
+            Ncurses.mvwaddch(@field_win, 0, x - @left_char, @hidden)
+          end
+        else
+          (@left_char...@info.size).each do |x|
+            Ncurses.mvwaddch(@field_win, 0, x - @left_char, @info[x].ord | @field_attr)
+          end
+        end
+        Ncurses.wmove(@field_win, 0, @screen_col)
+      end
+
+      Ncurses.wrefresh @field_win
+    end
+
+    # This erases an entry widget from the screen.
+    def erase
+      if self.validRNDKObject
+        RNDK.eraseCursesWindow(@field_win)
+        RNDK.eraseCursesWindow(@label_win)
+        RNDK.eraseCursesWindow(@win)
+        RNDK.eraseCursesWindow(@shadow_win)
+      end
+    end
+
+    # This destroys an entry widget.
+    def destroy
+      self.cleanTitle
+
+      RNDK.deleteCursesWindow(@field_win)
+      RNDK.deleteCursesWindow(@label_win)
+      RNDK.deleteCursesWindow(@shadow_win)
+      RNDK.deleteCursesWindow(@win)
+
+      self.cleanBindings(:ENTRY)
+
+      RNDK::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)
+      Ncurses.wbkgd(@win, attrib)
+      Ncurses.wbkgd(@field_win, attrib)
+      unless @label_win.nil?
+        @label_win.wbkgd(attrib)
+      end
+    end
+
+    # This sets the attribute of the entry field.
+    def setHighlight(highlight, cursor)
+      Ncurses.wbkgd(@field_win, 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
+      Ncurses.wmove(@field_win, 0, @screen_col)
+      Ncurses.wrefresh @field_win
+    end
+
+    def unfocus
+      self.draw(box)
+      Ncurses.wrefresh @field_win
+    end
+
+    def position
+      super(@win)
+    end
+
+    def object_type
+      :ENTRY
+    end
+  end
+end