Method: CDK::ALPHALIST#initialize

Defined in:

lib/cdk/components/alphalist.rb

#initialize(cdkscreen, xplace, yplace, height, width, title, label, list, list_size, filler_char, highlight, box, shadow) ⇒ ALPHALIST

Returns a new instance of ALPHALIST.

# File 'lib/cdk/components/alphalist.rb', line 10

def initialize(cdkscreen, xplace, yplace, height, width, title, label,
    list, list_size, filler_char, highlight, box, shadow)
  super()
  parent_width = cdkscreen.window.getmaxx
  parent_height = cdkscreen.window.getmaxy
  box_width = width
  box_height = height
  label_len = 0
  bindings = {
    CDK::BACKCHAR => Ncurses::KEY_PPAGE,
    CDK::FORCHAR  => Ncurses::KEY_NPAGE,
  }

  if !self.createList(list, list_size)
    self.destroy
    return nil
  end

  self.setBox(box)

  # If the height is a negative value, the 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, 0)

  # Translate the label string to a chtype array
  if label.size > 0
    lentmp = []
    chtype_label = char2Chtype(label, lentmp, [])
    label_len = lentmp[0]
  end

  # Rejustify the x and y positions if we need to.
  xtmp = [xplace]
  ytmp = [yplace]
  alignxy(cdkscreen.window, xtmp, ytmp, box_width, box_height)
  xpos = xtmp[0]
  ypos = ytmp[0]

  # Make the file selector window.
  @win = Ncurses::WINDOW.new(box_height, box_width, ypos, xpos)

  if @win.nil?
    self.destroy
    return nil
  end
  @win.keypad(true)

  # Set some variables.
  @screen = cdkscreen
  @parent = cdkscreen.window
  @highlight = highlight
  @filler_char = filler_char
  @box_height = box_height
  @box_width = box_width
  @shadow = shadow
  @shadow_win = nil

  # Do we want a shadow?
  if shadow
    @shadow_win = Ncurses::WINDOW.new(box_height, box_width,
        ypos + 1, xpos + 1)
  end

  # Create the entry field.
  temp_width =  if CDK::ALPHALIST.isFullWidth(width)
                then CDK::FULL
                else box_width - 2 - label_len
                end
  @entry_field = CDK::ENTRY.new(cdkscreen, @win.getbegx, @win.getbegy,
      title, label, Ncurses::A_NORMAL, filler_char, :MIXED, temp_width,
      0, 512, box, false)
  if @entry_field.nil?
    self.destroy
    return nil
  end
  @entry_field.setLLchar(Ncurses::ACS_LTEE)
  @entry_field.setLRchar(Ncurses::ACS_RTEE)

  # Callback functions
  adjust_alphalist_cb = lambda do |object_type, object, alphalist, key|
    scrollp = alphalist.scroll_field
    entry = alphalist.entry_field

    if scrollp.list_size > 0
      # Adjust the scrolling list.
      alphalist.injectMyScroller(key)

      # Set the value in the entry field.
      current = chtype2Char(scrollp.item[scrollp.current_item])
      entry.setValue(current)
      entry.draw(entry.box)
      return true
    end
    CDK.Beep
    return false
  end

  complete_word_cb = lambda do |object_type, object, alphalist, key|
    entry = alphalist.entry_field
    scrollp = nil
    selected = -1
    ret = 0
    alt_words = []

    if entry.info.size == 0
      CDK.Beep
      return true
    end
    
    # Look for a unique word match.
    index = search_list(alphalist.list, alphalist.list.size, entry.info)

    # if the index is less than zero, return we didn't find a match
    if index < 0
      CDK.Beep
      return true
    end

    # Did we find the last word in the list?
    if index == alphalist.list.size - 1
      entry.setValue(alphalist.list[index])
      entry.draw(entry.box)
      return true
    end


    # Ok, we found a match, is the next item similar?
    len = [entry.info.size, alphalist.list[index + 1].size].min
    ret = alphalist.list[index + 1][0...len] <=> entry.info
    if ret == 0
      current_index = index
      match = 0
      selected = -1

      # Start looking for alternate words
      # FIXME(original): bsearch would be more suitable.
      while current_index < alphalist.list.size &&
          (alphalist.list[current_index][0...len] <=> entry.info) == 0
        alt_words << alphalist.list[current_index]
        current_index += 1
      end

      # Determine the height of the scrolling list.
      height = if alt_words.size < 8 then alt_words.size + 3 else 11 end

      # Create a scrolling list of close matches.
      scrollp = CDK::SCROLL.new(entry.screen,
          CDK::CENTER, CDK::CENTER, CDK::RIGHT, height, -30,
          "<C></B/5>Possible Matches.", alt_words, alt_words.size,
          true, Ncurses::A_REVERSE, true, false)

      # Allow them to select a close match.
      match = scrollp.activate([])
      selected = scrollp.current_item

      # Check how they exited the list.
      if scrollp.exit_type == :ESCAPE_HIT
        # Destroy the scrolling list.
        scrollp.destroy

        # Beep at the user.
        CDK.Beep

        # Redraw the alphalist and return.
        alphalist.draw(alphalist.box)
        return true
      end

      # Destroy the scrolling list.
      scrollp.destroy

      # Set the entry field to the selected value.
      entry.set(alt_words[match], entry.min, entry.max, entry.box)

      # Move the highlight bar down to the selected value.
      (0...selected).each do |x|
        alphalist.injectMyScroller(Ncurses::KEY_DOWN)
      end

      # Redraw the alphalist.
      alphalist.draw(alphalist.box)
    else
      # Set the entry field with the found item.
      entry.set(alphalist.list[index], entry.min, entry.max, entry.box)
      entry.draw(entry.box)
    end
    return true
  end

  pre_process_entry_field = lambda do |cdktype, object, alphalist, input|
    scrollp = alphalist.scroll_field
    entry = alphalist.entry_field
    info_len = entry.info.size
    result = 1
    empty = false

    if alphalist.isBind(:ALPHALIST, input)
      result = 1  # Don't try to use this key in editing
    elsif (CDK.isChar(input) &&
        input.chr.match(/^[[:alnum:][:punct:]]$/)) ||
        [Ncurses::KEY_BACKSPACE, Ncurses::KEY_DC].include?(input)
      index = 0
      curr_pos = entry.screen_col + entry.left_char
      pattern = entry.info.clone
      if [Ncurses::KEY_BACKSPACE, Ncurses::KEY_DC].include?(input)
        if input == Ncurses::KEY_BACKSPACE
          curr_pos -= 1
        end
        if curr_pos >= 0
          pattern.slice!(curr_pos)
        end
      else
        front = (pattern[0...curr_pos] or '')
        back = (pattern[curr_pos..-1] or '')
        pattern = front + input.chr + back
      end

      if pattern.size == 0
        empty = true
      elsif (index = search_list(alphalist.list,
          alphalist.list.size, pattern)) >= 0
        # XXX: original uses n scroll downs/ups for <10 positions change
          scrollp.setPosition(index)
        alphalist.drawMyScroller
      else
        CDK.Beep
        result = 0
      end
    end

    if empty
      scrollp.setPosition(0)
      alphalist.drawMyScroller
    end

    return result
  end

  # Set the key bindings for the entry field.
  @entry_field.bind(:ENTRY, Ncurses::KEY_UP, adjust_alphalist_cb, self)
  @entry_field.bind(:ENTRY, Ncurses::KEY_DOWN, adjust_alphalist_cb, self)
  @entry_field.bind(:ENTRY, Ncurses::KEY_NPAGE, adjust_alphalist_cb, self)
  @entry_field.bind(:ENTRY, Ncurses::KEY_PPAGE, adjust_alphalist_cb, self)
  @entry_field.bind(:ENTRY, CDK::KEY_TAB, complete_word_cb, self)

  # Set up the post-process function for the entry field.
  @entry_field.setPreProcess(pre_process_entry_field, self)

  # Create the scrolling list.  It overlaps the entry field by one line if
  # we are using box-borders.
  temp_height = @entry_field.win.getmaxy - @border_size
  temp_width = if CDK::ALPHALIST.isFullWidth(width)
               then CDK::FULL
               else box_width - 1
               end
  @scroll_field = CDK::SCROLL.new(cdkscreen, @win.getbegx,
      @entry_field.win.getbegy + temp_height, CDK::RIGHT,
      box_height - temp_height, temp_width, '', list, list_size,
      false, Ncurses::A_REVERSE, box, false)
  @scroll_field.setULchar(Ncurses::ACS_LTEE)
  @scroll_field.setURchar(Ncurses::ACS_RTEE)

  # Setup the key bindings.
  bindings.each do |from, to|
    self.bind(:ALPHALIST, from, :getc, to)
  end

  cdkscreen.register(:ALPHALIST, self)
end