cdk 0.9.0

data/lib/cdk/menu.rb

@@ -0,0 +1,448 @@
+require_relative 'cdk_objs'
+
+module CDK
+  class MENU < CDK::CDKOBJS
+    TITLELINES = 1
+    MAX_MENU_ITEMS = 30
+    MAX_SUB_ITEMS = 98
+
+    attr_reader :current_title, :current_subtitle
+    attr_reader :sublist
+
+    def initialize(cdkscreen, menu_list, menu_items, subsize,
+        menu_location, menu_pos, title_attr, subtitle_attr)
+      super()
+
+      right_count = menu_items - 1
+      rightloc = cdkscreen.window.getmaxx
+      leftloc = 0
+      xpos = cdkscreen.window.getbegx
+      ypos = cdkscreen.window.getbegy
+      ymax = cdkscreen.window.getmaxy
+      
+      # Start making a copy of the information.
+      @screen = cdkscreen
+      @box = false
+      @accepts_focus = false
+      rightcount = menu_items - 1
+      @parent = cdkscreen.window
+      @menu_items = menu_items
+      @title_attr = title_attr
+      @subtitle_attr = subtitle_attr
+      @current_title = 0
+      @current_subtitle = 0
+      @last_selection = -1
+      @menu_pos = menu_pos
+
+      @pull_win = [nil] * menu_items
+      @title_win = [nil] * menu_items
+      @title = [''] * menu_items
+      @title_len = [0] * menu_items
+      @sublist = (1..menu_items).map {[nil] * subsize.max}.compact
+      @sublist_len = (1..menu_items).map {
+          [0] * subsize.max}.compact
+      @subsize = [0] * menu_items
+
+
+      # Create the pull down menus.
+      (0...menu_items).each do |x|
+        x1 = if menu_location[x] == CDK::LEFT
+             then x
+             else 
+               rightcount -= 1
+               rightcount + 1
+             end
+        x2 = 0
+        y1 = if menu_pos == CDK::BOTTOM then ymax - 1 else 0 end
+        y2 = if menu_pos == CDK::BOTTOM
+             then ymax - subsize[x] - 2
+             else CDK::MENU::TITLELINES
+             end
+        high = subsize[x] + CDK::MENU::TITLELINES
+
+        # Limit the menu height to fit on the screen.
+        if high + y2 > ymax
+          high = ymax - CDK::MENU::TITLELINES
+        end
+
+        max = -1
+        (CDK::MENU::TITLELINES...subsize[x]).to_a.each do |y|
+          y0 = y - CDK::MENU::TITLELINES
+          sublist_len = []
+          @sublist[x1][y0] = CDK.char2Chtype(menu_list[x][y],
+              sublist_len, [])
+          @sublist_len[x1][y0] = sublist_len[0]
+          max = [max, sublist_len[0]].max
+        end
+
+        if menu_location[x] == CDK::LEFT
+          x2 = leftloc
+        else
+          x2 = (rightloc -= max + 2)
+        end
+
+        title_len = []
+        @title[x1] = CDK.char2Chtype(menu_list[x][0], title_len, [])
+        @title_len[x1] = title_len[0]
+        @subsize[x1] = subsize[x] - CDK::MENU::TITLELINES
+        @title_win[x1] = cdkscreen.window.subwin(CDK::MENU::TITLELINES,
+            @title_len[x1] + 2, ypos + y1, xpos + x2)
+        @pull_win[x1] = cdkscreen.window.subwin(high, max + 2,
+            ypos + y2, xpos + x2)
+        if @title_win[x1].nil? || @pull_win[x1].nil?
+          self.destroy
+          return nil
+        end
+
+        leftloc += @title_len[x] + 1
+        @title_win[x1].keypad(true)
+        @pull_win[x1].keypad(true)
+      end
+      @input_window = @title_win[@current_title]
+
+      # Register this baby.
+      cdkscreen.register(:MENU, self)
+    end
+
+    # This activates the CDK Menu
+    def activate(actions)
+      ret = 0
+
+      # Draw in the screen.
+      @screen.refresh
+
+      # Display the menu titles.
+      self.draw(@box)
+
+      # Highlight the current title and window.
+      self.drawSubwin
+
+      # If the input string is empty this is an interactive activate.
+      if actions.nil? || actions.size == 0
+        @input_window = @title_win[@current_title]
+
+        # Start taking input from the keyboard.
+        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
+        actions.each do |action|
+          if @exit_type != :EARLY_EXIT
+            return ret
+          end
+        end
+      end
+
+      # Set the exit type and return.
+      self.setExitType(0)
+      return -1
+    end
+
+    def drawTitle(item)
+      Draw.writeChtype(@title_win[item], 0, 0, @title[item],
+          CDK::HORIZONTAL, 0, @title_len[item])
+    end
+
+    def drawItem(item, offset)
+      Draw.writeChtype(@pull_win[@current_title], 1,
+          item + CDK::MENU::TITLELINES - offset,
+          @sublist[@current_title][item],
+          CDK::HORIZONTAL, 0, @sublist_len[@current_title][item])
+    end
+
+    # Highlight the current sub-menu item
+    def selectItem(item, offset)
+      Draw.writeChtypeAttrib(@pull_win[@current_title], 1,
+          item + CDK::MENU::TITLELINES - offset,
+          @sublist[@current_title][item], @subtitle_attr,
+          CDK::HORIZONTAL, 0, @sublist_len[@current_title][item])
+    end
+
+    def withinSubmenu(step)
+      next_item = CDK::MENU.wrapped(@current_subtitle + step,
+          @subsize[@current_title])
+
+      if next_item != @current_subtitle
+        ymax = @screen.window.getmaxy
+
+        if 1 + @pull_win[@current_title].getbegy + @subsize[@current_title] >=
+            ymax
+          @current_subtitle = next_item
+          self.drawSubwin
+        else
+          # Erase the old subtitle.
+          self.drawItem(@current_subtitle, 0)
+
+          # Set the values
+          @current_subtitle = next_item
+
+          # Draw the new sub-title.
+          self.selectItem(@current_subtitle, 0)
+
+          @pull_win[@current_title].wrefresh
+        end
+
+        @input_window = @title_win[@current_title]
+      end
+    end
+
+    def acrossSubmenus(step)
+      next_item = CDK::MENU.wrapped(@current_title + step, @menu_items)
+
+      if next_item != @current_title
+        # Erase the menu sub-window.
+        self.eraseSubwin
+        @screen.refresh
+
+        # Set the values.
+        @current_title = next_item
+        @current_subtitle = 0
+
+        # Draw the new menu sub-window.
+        self.drawSubwin
+        @input_window = @title_win[@current_title]
+      end
+    end
+
+    # Inject a character into the menu widget.
+    def inject(input)
+      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?
+        # Call the pre-process function.
+        pp_return = @pre_process_func.call(:MENU, self,
+            @pre_process_data, input)
+      end
+
+      # Should we continue?
+
+      if pp_return != 0
+        # Check for key bindings.
+        if self.checkBind(:MENU, input)
+          complete = true
+        else
+          case input
+          when Ncurses::KEY_LEFT
+            self.acrossSubmenus(-1)
+          when Ncurses::KEY_RIGHT, CDK::KEY_TAB
+            self.acrossSubmenus(1)
+          when Ncurses::KEY_UP
+            self.withinSubmenu(-1)
+          when Ncurses::KEY_DOWN, ' '.ord
+            self.withinSubmenu(1)
+          when Ncurses::KEY_ENTER, CDK::KEY_RETURN
+            self.cleanUpMenu
+            self.setExitType(input)
+            @last_selection = @current_title * 100 + @current_subtitle
+            ret = @last_selection
+            complete = true
+          when CDK::KEY_ESC
+            self.cleanUpMenu
+            self.setExitType(input)
+            @last_selection = -1
+            ret = @last_selection
+            complete = true
+          when Ncurses::ERR
+            self.setExitType(input)
+            complete = true
+          when CDK::REFRESH
+            self.erase
+            self.refresh
+          end
+        end
+
+        # Should we call a post-process?
+        if !complete && !(@post_process_func.nil?)
+          @post_process_func.call(:MENU, self, @post_process_data, input)
+        end
+      end
+
+      if !complete
+        self.setExitType(0)
+      end
+
+      @result_data = ret
+      return ret
+    end
+
+    # Draw a menu item subwindow
+    def drawSubwin
+      high = @pull_win[@current_title].getmaxy - 2
+      x0 = 0
+      x1 = @subsize[@current_title]
+
+      if x1 > high
+        x1 = high
+      end
+
+      if @current_subtitle >= x1
+        x0 = @current_subtitle - x1 + 1
+        x1 += x0
+      end
+
+      # Box the window
+      @pull_win[@current_title]
+      @pull_win[@current_title].box(Ncurses::ACS_VLINE, Ncurses::ACS_HLINE)
+      if @menu_pos == CDK::BOTTOM
+        @pull_win[@current_title].mvwaddch(@subsize[@current_title] + 1,
+            0, Ncurses::ACS_LTEE)
+      else
+        @pull_win[@current_title].mvwaddch(0, 0, Ncurses::ACS_LTEE)
+      end
+
+      # Draw the items.
+      (x0...x1).each do |x|
+        self.drawItem(x, x0)
+      end
+
+      self.selectItem(@current_subtitle, x0)
+      @pull_win[@current_title].wrefresh
+
+      # Highlight the title.
+      Draw.writeChtypeAttrib(@title_win[@current_title], 0, 0,
+          @title[@current_title], @title_attr, CDK::HORIZONTAL,
+          0, @title_len[@current_title])
+      @title_win[@current_title].wrefresh
+    end
+
+    # Erase a menu item subwindow
+    def eraseSubwin
+      CDK.eraseCursesWindow(@pull_win[@current_title])
+
+      # Redraw the sub-menu title.
+      self.drawTitle(@current_title)
+      @title_win[@current_title].wrefresh
+    end
+
+    # Draw the menu.
+    def draw(box)
+      # Draw in the menu titles.
+      (0...@menu_items).each do |x|
+        self.drawTitle(x)
+        @title_win[x].wrefresh
+      end
+    end
+
+    # Move the menu to the given location.
+    def move(xplace, yplace, relative, refresh_flag)
+      windows = [@screen.window]
+      (0...@menu_items).each do |x|
+        windows << @title_win[x]
+      end
+      self.move_specific(xplace, yplace, relative, refresh_flag,
+          windows, [])
+    end
+
+    # Set the background attribute of the widget.
+    def setBKattr(attrib)
+      (0...@menu_items).each do |x|
+        @title_win[x].wbkgd(attrib)
+        @pull_win[x].wbkgd(attrib)
+      end
+    end
+
+    # Destroy a menu widget.
+    def destroy
+      # Clean up the windows
+      (0...@menu_items).each do |x|
+        CDK.deleteCursesWindow(@title_win[x])
+        CDK.deleteCursesWindow(@pull_win[x])
+      end
+
+      # Clean the key bindings.
+      self.cleanBindings(:MENU)
+
+      # Unregister the object
+      CDK::SCREEN.unregister(:MENU, self)
+    end
+
+    # Erase the menu widget from the screen.
+    def erase
+      if self.validCDKObject
+        (0...@menu_items).each do |x|
+          @title_win[x].werase
+          @title_win[x].wrefresh
+          @pull_win[x].werase
+          @pull_win[x].wrefresh
+        end
+      end
+    end
+
+    def set(menu_item, submenu_item, title_highlight, subtitle_highlight)
+      self.setCurrentItem(menu_item, submenu_item)
+      self.setTitleHighlight(title_highlight)
+      self.setSubTitleHighlight(subtitle_highlight)
+    end
+
+    # Set the current menu item to highlight.
+    def setCurrentItem(menuitem, submenuitem)
+      @current_title = CDK::MENU.wrapped(menuitem, @menu_items)
+      @current_subtitle = CDK::MENU.wrapped(
+          submenuitem, @subsize[@current_title])
+    end
+
+    def getCurrentItem(menu_item, submenu_item)
+      menu_item << @current_title
+      submenu_item << @current_subtitle
+    end
+
+    # Set the attribute of the menu titles.
+    def setTitleHighlight(highlight)
+      @title_attr = highlight
+    end
+
+    def getTitleHighlight
+      return @title_attr
+    end
+
+    # Set the attribute of the sub-title.
+    def setSubTitleHighlight(highlight)
+      @subtitle_attr = highlight
+    end
+
+    def getSubTitleHighlight
+      return @subtitle_attr
+    end
+
+    # Exit the menu.
+    def cleanUpMenu
+      # Erase the sub-menu.
+      self.eraseSubwin
+      @pull_win[@current_title].wrefresh
+
+      # Refresh the screen.
+      @screen.refresh
+    end
+
+    def focus
+      self.drawSubwin
+      @input_window = @title_win[@current_title]
+    end
+
+    # The "%" operator is simpler but does not handle negative values
+    def self.wrapped(within, limit)
+      if within < 0
+        within = limit - 1
+      elsif within >= limit
+        within = 0
+      end
+      return within
+    end
+          
+    def object_type
+      :MENU
+    end
+  end
+end

data/lib/cdk/radio.rb

@@ -0,0 +1,533 @@
+require_relative 'scroller'
+
+module CDK
+  class RADIO < CDK::SCROLLER
+    def initialize(cdkscreen, xplace, yplace, splace, height, width, title,
+        list, list_size, choice_char, def_item, highlight, box, shadow)
+      super()
+      parent_width = cdkscreen.window.getmaxx
+      parent_height = cdkscreen.window.getmaxy
+      box_width = width
+      box_height = height
+      widest_item = 0
+
+      bindings = {
+        CDK::BACKCHAR => Ncurses::KEY_PPAGE,
+        CDK::FORCHAR  => Ncurses::KEY_NPAGE,
+        'g'           => Ncurses::KEY_HOME,
+        '1'           => Ncurses::KEY_HOME,
+        'G'           => Ncurses::KEY_END,
+        '<'           => Ncurses::KEY_HOME,
+        '>'           => Ncurses::KEY_END,
+      }
+      
+      self.setBox(box)
+
+      # If the height is a negative value, height will be ROWS-height,
+      # otherwise the height will be the given height.
+      box_height = CDK.setWidgetDimension(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 = CDK.setWidgetDimension(parent_width, width, 5)
+
+      box_width = self.setTitle(title, box_width)
+
+      # Set the box height.
+      if @title_lines > box_height
+        box_height = @title_lines + [list_size, 8].min + 2 * @border_size
+      end
+
+      # Adjust the box width if there is a scroll bar.
+      if splace == CDK::LEFT || splace == CDK::RIGHT
+        box_width += 1
+        @scrollbar = true
+      else
+        scrollbar = false
+      end
+
+      # Make sure we didn't extend beyond the dimensions of the window
+      @box_width = [box_width, parent_width].min
+      @box_height = [box_height, parent_height].min
+
+      self.setViewSize(list_size)
+
+      # Each item in the needs to be converted to chtype array
+      widest_item = self.createList(list, list_size, @box_width)
+      if widest_item > 0
+        self.updateViewWidth(widest_item)
+      elsif list_size > 0
+        self.destroy
+        return nil
+      end
+
+      # Rejustify the x and y positions if we need to.
+      xtmp = [xplace]
+      ytmp = [yplace]
+      CDK.alignxy(cdkscreen.window, xtmp, ytmp, @box_width, @box_height)
+      xpos = xtmp[0]
+      ypos = ytmp[0]
+
+      # Make the radio window
+      @win = Ncurses::WINDOW.new(@box_height, @box_width, ypos, xpos)
+
+      # Is the window nil?
+      if @win.nil?
+        self.destroy
+        return nil
+      end
+
+      # Turn on the keypad.
+      @win.keypad(true)
+
+      # Create the scrollbar window.
+      if splace == CDK::RIGHT
+        @scrollbar_win = @win.subwin(self.maxViewSize, 1,
+            self.SCREEN_YPOS(ypos), xpos + @box_width - @border_size - 1)
+      elsif splace == CDK::LEFT
+        @scrollbar_win = @win.subwin(self.maxViewSize, 1,
+            self.SCREEN_YPOS(ypos), self.SCREEN_XPOS(xpos))
+      else
+        @scrollbar_win = nil
+      end
+
+      # Set the rest of the variables
+      @screen = cdkscreen
+      @parent = cdkscreen.window
+      @scrollbar_placement = splace
+      @widest_item = widest_item
+      @left_char = 0
+      @selected_item = 0
+      @highlight = highlight
+      @choice_char = choice_char.ord
+      @left_box_char = '['.ord
+      @right_box_char = ']'.ord
+      @def_item = def_item
+      @input_window = @win
+      @accepts_focus = true
+      @shadow = shadow
+
+      self.setCurrentItem(0)
+
+      # Do we need to create the shadow?
+      if shadow
+        @shadow_win = Ncurses::WINDOW.new(box_height, box_width + 1,
+            ypos + 1, xpos + 1)
+      end
+
+      # Setup the key bindings
+      bindings.each do |from, to|
+        self.bind(:RADIO, from, :getc, to)
+      end
+
+      cdkscreen.register(:RADIO, self)
+    end
+
+    # Put the cursor on the currently-selected item.
+    def fixCursorPosition
+      scrollbar_adj = if @scrollbar_placement == CDK::LEFT then 1 else 0 end
+      ypos = self.SCREEN_YPOS(@current_item - @current_top)
+      xpos = self.SCREEN_XPOS(0) + scrollbar_adj
+
+      @input_window.wmove(ypos, xpos)
+      @input_window.wrefresh
+    end
+
+    # This actually manages the radio widget.
+    def activate(actions)
+      # Draw the radio list.
+      self.draw(@box)
+
+      if actions.nil? || actions.size == 0
+        while true
+          self.fixCursorPosition
+          input = self.getch([])
+
+          # Inject the character into the widget.
+          ret = self.inject(input)
+          if @exit_type != :EARLY_EXIT
+            return ret
+          end
+        end
+      else
+        actions.each do |action|
+          ret = self.inject(action)
+          if @exit_type != :EARLY_EXIT
+            return ret
+          end
+        end
+      end
+
+      # Set the exit type and return
+      self.setExitType(0)
+      return -1
+    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)
+
+      # Draw the widget list
+      self.drawList(@box)
+
+      # 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(:RADIO, self,
+            @pre_process_data, input)
+      end
+
+      # Should we continue?
+      if pp_return != 0
+        # Check for a predefined key binding.
+        if self.checkBind(:RADIO, input)
+          complete = true
+        else
+          case input
+          when Ncurses::KEY_UP
+            self.KEY_UP
+          when Ncurses::KEY_DOWN
+            self.KEY_DOWN
+          when Ncurses::KEY_RIGHT
+            self.KEY_RIGHT
+          when Ncurses::KEY_LEFT
+            self.KEY_LEFT
+          when Ncurses::KEY_PPAGE
+            self.KEY_PPAGE
+          when Ncurses::KEY_NPAGE
+            self.KEY_NPAGE
+          when Ncurses::KEY_HOME
+            self.KEY_HOME
+          when Ncurses::KEY_END
+            self.KEY_END
+          when '$'.ord
+            @left_char = @max_left_char
+          when '|'.ord
+            @left_char = 0
+          when ' '.ord
+            @selected_item = @current_item
+          when CDK::KEY_ESC
+            self.setExitType(input)
+            ret = -1
+            complete = true
+          when Ncurses::ERR
+            self.setExitType(input)
+            complete = true
+          when CDK::KEY_TAB, CDK::KEY_RETURN, Ncurses::KEY_ENTER
+            self.setExitType(input)
+            ret = @selected_item
+            complete = true
+          when CDK::REFRESH
+            @screen.erase
+            @screen.refresh
+          end
+        end
+
+        # Should we call a post-process?
+        if !complete && !(@post_process_func.nil?)
+          @post_process_func.call(:RADIO, self, @post_process_data, input)
+        end
+      end
+
+      if !complete
+        self.drawList(@box)
+        self.setExitType(0)
+      end
+
+      self.fixCursorPosition
+      @return_data = ret
+      return ret
+    end
+
+    # This moves the radio field to the given location.
+    def move(xplace, yplace, relative, refresh_flag)
+      windows = [@win, @scrollbar_win, @shadow_win]
+      self.move_specific(xplace, yplace, relative, refresh_flag,
+          windows, subwidgets)
+    end
+
+    # This function draws the radio widget.
+    def draw(box)
+      # Do we need to draw in the shadow?
+      if !(@shadow_win.nil?)
+        Draw.drawShadow(@shadow_win)
+      end
+
+      self.drawTitle(@win)
+
+      # Draw in the radio list.
+      self.drawList(@box)
+    end
+
+    # This redraws the radio list.
+    def drawList(box)
+      scrollbar_adj = if @scrollbar_placement == CDK::LEFT then 1 else 0 end
+      screen_pos = 0
+
+      # Draw the list
+      (0...@view_size).each do |j|
+        k = j + @current_top
+        if k < @list_size
+          xpos = self.SCREEN_XPOS(0)
+          ypos = self.SCREEN_YPOS(j)
+
+          screen_pos = self.SCREENPOS(k, scrollbar_adj)
+
+          # Draw the empty string.
+          Draw.writeBlanks(@win, xpos, ypos, CDK::HORIZONTAL, 0,
+              @box_width - @border_size)
+
+          # Draw the line.
+          Draw.writeChtype(@win,
+              if screen_pos >= 0 then screen_pos else 1 end,
+              ypos, @item[k], CDK::HORIZONTAL,
+              if screen_pos >= 0 then 0 else 1 - screen_pos end,
+              @item_len[k])
+
+          # Draw the selected choice
+          xpos += scrollbar_adj
+          @win.mvwaddch(ypos, xpos, @left_box_char)
+          @win.mvwaddch(ypos, xpos + 1,
+              if k == @selected_item then @choice_char else ' '.ord end)
+          @win.mvwaddch(ypos, xpos + 2, @right_box_char)
+        end
+      end
+
+      # Highlight the current item
+      if @has_focus
+        k = @current_item
+        if k < @list_size
+          screen_pos = self.SCREENPOS(k, scrollbar_adj)
+          ypos = self.SCREEN_YPOS(@current_high)
+
+          Draw.writeChtypeAttrib(@win,
+              if screen_pos >= 0 then screen_pos else 1 + scrollbar_adj end,
+              ypos, @item[k], @highlight, CDK::HORIZONTAL,
+              if screen_pos >= 0 then 0 else 1 - screen_pos end,
+              @item_len[k])
+        end
+      end
+
+      if @scrollbar
+        @toggle_pos = (@current_item * @step).floor
+        @toggle_pos = [@toggle_pos, @scrollbar_win.getmaxy - 1].min
+
+        @scrollbar_win.mvwvline(0, 0, Ncurses::ACS_CKBOARD,
+            @scrollbar_win.getmaxy)
+        @scrollbar_win.mvwvline(@toggle_pos, 0, ' '.ord | Ncurses::A_REVERSE,
+            @toggle_size)
+      end
+
+      # Box it if needed.
+      if box
+        Draw.drawObjBox(@win, self)
+      end
+
+      self.fixCursorPosition
+    end
+
+    # This sets the background attribute of the widget.
+    def setBKattr(attrib)
+      @win.wbkgd(attrib)
+      unless @scrollbar_win.nil?
+        @scrollbar_win.wbkgd(attrib)
+      end
+    end
+
+    def destroyInfo
+      @item = ''
+    end
+
+    # This function destroys the radio widget.
+    def destroy
+      self.cleanTitle
+      self.destroyInfo
+
+      # Clean up the windows.
+      CDK.deleteCursesWindow(@scrollbar_win)
+      CDK.deleteCursesWindow(@shadow_win)
+      CDK.deleteCursesWindow(@win)
+
+      # Clean up the key bindings.
+      self.cleanBindings(:RADIO)
+
+      # Unregister this object.
+      CDK::SCREEN.unregister(:RADIO, self)
+    end
+
+    # This function erases the radio widget
+    def erase
+      if self.validCDKObject
+        CDK.eraseCursesWindow(@win)
+        CDK.eraseCursesWindow(@shadow_win)
+      end
+    end
+
+    # This sets various attributes of the radio list.
+    def set(highlight, choice_char, box)
+      self.setHighlight(highlight)
+      self.setChoiceCHaracter(choice_char)
+      self.setBox(box)
+    end
+
+    # This sets the radio list items.
+    def setItems(list, list_size)
+      widest_item = self.createList(list, list_size, @box_width)
+      if widest_item <= 0
+        return
+      end
+
+      # Clean up the display.
+      (0...@view_size).each do |j|
+        Draw.writeBlanks(@win, self.SCREEN_XPOS(0), self.SCREEN_YPOS(j),
+            CDK::HORIZONTAL, 0, @box_width - @border_size)
+      end
+
+      self.setViewSize(list_size)
+
+      self.setCurrentItem(0)
+      @left_char = 0
+      @selected_item = 0
+
+      self.updateViewWidth(widest_item)
+    end
+
+    def getItems(list)
+      (0...@list_size).each do |j|
+        list << CDK.chtype2Char(@item[j])
+      end
+      return @list_size
+    end
+
+    # This sets the highlight bar of the radio list.
+    def setHighlight(highlight)
+      @highlight = highlight
+    end
+
+    def getHighlight
+      return @highlight
+    end
+
+    # This sets the character to use when selecting na item in the list.
+    def setChoiceCharacter(character)
+      @choice_char = character
+    end
+
+    def getChoiceCharacter
+      return @choice_char
+    end
+
+    # This sets the character to use to drw the left side of the choice box
+    # on the list
+    def setLeftBrace(character)
+      @left_box_char = character
+    end
+
+    def getLeftBrace
+      return @left_box_char
+    end
+
+    # This sets the character to use to draw the right side of the choice box
+    # on the list
+    def setRightBrace(character)
+      @right_box_char = character
+    end
+
+    def getRightBrace
+      return @right_box_char
+    end
+
+    # This sets the current highlighted item of the widget
+    def setCurrentItem(item)
+      self.setPosition(item)
+      @selected_item = item
+    end
+
+    def getCurrentItem
+      return @current_item
+    end
+
+    # This sets the selected item of the widget
+    def setSelectedItem(item)
+      @selected_item = item
+    end
+
+    def getSelectedItem
+      return @selected_item
+    end
+
+    def focus
+      self.drawList(@box)
+    end
+
+    def unfocus
+      self.drawList(@box)
+    end
+
+    def createList(list, list_size, box_width)
+      status = false
+      widest_item = 0
+
+      if list_size >= 0
+        new_list = []
+        new_len = []
+        new_pos = []
+
+        # Each item in the needs to be converted to chtype array
+        status = true
+        box_width -= 2 + @border_size
+        (0...list_size).each do |j|
+          lentmp = []
+          postmp = []
+          new_list << CDK.char2Chtype(list[j], lentmp, postmp)
+          new_len << lentmp[0]
+          new_pos << postmp[0]
+          if new_list[j].nil? || new_list[j].size == 0
+            status = false
+            break
+          end
+          new_pos[j] = CDK.justifyString(box_width, new_len[j], new_pos[j]) + 3
+          widest_item = [widest_item, new_len[j]].max
+        end
+        if status
+          self.destroyInfo
+          @item = new_list
+          @item_len = new_len
+          @item_pos = new_pos
+        end
+      end
+
+      return (if status then widest_item else 0 end)
+    end
+
+    # Determine how many characters we can shift to the right
+    # before all the items have been scrolled off the screen.
+    def AvailableWidth
+      @box_width - 2 * @border_size - 3
+    end
+
+    def updateViewWidth(widest)
+      @max_left_char = if @box_width > widest
+                       then 0
+                       else widest - self.AvailableWidth
+                       end
+    end
+
+    def WidestItem
+      @max_left_char + self.AvailableWidth
+    end
+
+    def SCREENPOS(n, scrollbar_adj)
+      @item_pos[n] - @left_char + scrollbar_adj + @border_size
+    end
+
+    def object_type
+      :RADIO
+    end
+  end
+end