Exemple #1
0
 public static class Params {
   public ControlEnvironment environment;
   public Model model;
   public Appearance appearance;
   public Transition transition = new ListUtils.DefaultTransition();
   public ListClickHandler clickHandler;
   public String name;
   public Set<Flags> flags = EnumSet.of(Flags.EMPTY_LINE_BOTTOM);
 }
Exemple #2
0
 protected boolean onAnnounce() {
   environment.playSound(Sounds.INTRO_REGULAR);
   String item = "";
   if (selected() != null)
     item =
         appearance.getScreenAppearance(selected(), EnumSet.noneOf(Appearance.Flags.class)).trim();
   if (!item.isEmpty()) item = " " + item;
   environment.say(getAreaName() + item);
   return true;
 }
Exemple #3
0
public class ListArea implements Area, RegionProvider {
  public enum Flags {
    EMPTY_LINE_TOP,
    EMPTY_LINE_BOTTOM
  };

  protected static final Set<Appearance.Flags> NONE_APPEARANCE_FLAGS =
      EnumSet.noneOf(Appearance.Flags.class);
  protected static final Set<Appearance.Flags> BRIEF_ANNOUNCEMENT_ONLY =
      EnumSet.of(Appearance.Flags.BRIEF);

  public interface Model {
    int getItemCount();

    Object getItem(int index);

    boolean toggleMark(int index);

    void refresh();
  }

  public interface Appearance {
    public enum Flags {
      BRIEF
    };

    void announceItem(Object item, Set<Flags> flags);

    String getScreenAppearance(Object item, Set<Flags> flags);

    int getObservableLeftBound(Object item);

    int getObservableRightBound(Object item);
  }

  public interface Transition {
    public enum Type {
      SINGLE_DOWN,
      SINGLE_UP,
      PAGE_DOWN,
      PAGE_UP,
      HOME,
      END
    };

    public static class State {
      public enum Type {
        EMPTY_LINE_TOP,
        EMPTY_LINE_BOTTOM,
        ITEM_INDEX,
        NO_TRANSITION
      };

      public final Type type;
      public final int itemIndex;

      public State(Type type) {
        NullCheck.notNull(type, "type");
        this.type = type;
        this.itemIndex = -1;
      }

      public State(int itemIndex) {
        this.type = Type.ITEM_INDEX;
        this.itemIndex = itemIndex;
      }
    }

    State transition(
        Type type,
        State fromState,
        int itemCount,
        boolean hasEmptyLineTop,
        boolean hasEmptyLineBottom);
  }

  public static class Params {
    public ControlEnvironment environment;
    public Model model;
    public Appearance appearance;
    public Transition transition = new ListUtils.DefaultTransition();
    public ListClickHandler clickHandler;
    public String name;
    public Set<Flags> flags = EnumSet.of(Flags.EMPTY_LINE_BOTTOM);
  }

  protected final RegionTranslator region = new RegionTranslator(this);
  protected final ControlEnvironment environment;
  protected String areaName = "";
  protected final Model model;
  protected final Appearance appearance;
  protected final Transition transition;
  protected final Set<Flags> flags;
  protected ListClickHandler clickHandler;

  protected int hotPointX = 0;
  protected int hotPointY = 0;

  public ListArea(Params params) {
    NullCheck.notNull(params, "params");
    NullCheck.notNull(params.environment, "params.environment");
    NullCheck.notNull(params.model, "params.model");
    NullCheck.notNull(params.appearance, "params.appearance");
    NullCheck.notNull(params.transition, "params.transition");
    NullCheck.notNull(params.name, "params.name");
    NullCheck.notNull(params.flags, "params.flags");
    this.environment = params.environment;
    this.model = params.model;
    this.appearance = params.appearance;
    this.transition = params.transition;
    this.clickHandler = params.clickHandler;
    this.areaName = params.name;
    this.flags = params.flags;
    //	itemsLayout.setFlags(params.flags);
    resetHotPoint();
  }

  public void setListClickHandler(ListClickHandler clickHandler) {
    this.clickHandler = clickHandler;
  }

  public Model getListModel() {
    return model;
  }

  public Appearance getListAppearance() {
    return appearance;
  }

  /**
   * Returns the object in the model corresponding to current hot point position. If the model is
   * empty or hot point is on an empty line, this method always returns {@code null}.
   *
   * @return The object in the model associated with the currently selected line or {@code null} if
   *     there is no any
   */
  public final Object selected() {
    final int index = selectedIndex();
    return (index >= 0 && index < model.getItemCount()) ? model.getItem(index) : null;
  }

  /**
   * The index of the item in the model which is under the hot point in this list. This method
   * returns the index in the model, not on the screen. It means that the value returned by this
   * method may be different than the value returned by {@code getHotPointY()} (but may be equal as
   * well). If the list is empty or an empty line is selected, this method returns -1.
   *
   * @return The index of the selected line in the model or -1 if there is no any
   */
  public final int selectedIndex() {
    return getItemIndexOnLine(hotPointY);
  }

  /**
   * Searches for the item in the model and sets hot point on it. Given an arbitrary object, this
   * method looks through all items in the model and does a couple of checks: literal pointers
   * equality and a check with {@code equals()} method. If at least one of these checks succeeds,
   * the item is considered equal to the given one, and hot points is set on it.
   *
   * @param obj The object to search for
   * @param introduce Must be true if it is necessary to introduce the object, once it's found
   * @return True if the request object is found, false otherwise
   */
  public boolean select(Object obj, boolean introduce) {
    NullCheck.notNull(obj, "obj");
    for (int i = 0; i < model.getItemCount(); ++i) {
      final Object o = model.getItem(i);
      if (o == null || (obj != o && !obj.equals(o))) continue;
      hotPointY = i;
      hotPointX = appearance.getObservableLeftBound(o);
      environment.onAreaNewHotPoint(this);
      if (introduce) appearance.announceItem(o, NONE_APPEARANCE_FLAGS);
      return true;
    }
    return false;
  }

  /**
   * Selects the item by its index. Given the non-negative integer value as an index, this method
   * sets the hot point on the item addressed with this index, checking only that index is in
   * appropriate bounds. Index must address the object as a number in the model, ignoring any empty
   * lines.
   *
   * @param index The item index to select
   * @param announce Must be true, if it is necessary to announce the item , once it has been
   *     selected
   * @return True if the index is valid and the item gets hot point on it
   */
  public boolean select(int index, boolean announce) {
    if (index < 0 || index >= model.getItemCount()) return false;
    final int emptyCountAbove = flags.contains(Flags.EMPTY_LINE_TOP) ? 1 : 0;
    hotPointY = index + emptyCountAbove;
    final Object item = model.getItem(index);
    if (item != null) {
      hotPointX = appearance.getObservableLeftBound(item);
      if (announce) appearance.announceItem(item, NONE_APPEARANCE_FLAGS);
    } else {
      hotPointX = 0;
      if (announce) environment.hint(Hints.EMPTY_LINE);
    }
    environment.onAreaNewHotPoint(this);
    return true;
  }

  public int getItemIndexOnLine(int index) {
    final int linesTop = flags.contains(Flags.EMPTY_LINE_TOP) ? 1 : 0;
    if (index < linesTop) return -1;
    if (index - linesTop < model.getItemCount()) return index - linesTop;
    return -1;
  }

  public int getLineIndexByItemIndex(int index) {
    final int count = model.getItemCount();
    if (index < 0 || index >= count) return -1;
    final int linesTop = flags.contains(Flags.EMPTY_LINE_TOP) ? 1 : 0;
    return index + linesTop;
  }

  public void reset(boolean announce) {
    EnvironmentEvent.resetRegionPoint(this);
    resetHotPoint(announce);
  }

  public void resetHotPoint() {
    resetHotPoint(false);
  }

  public void resetHotPoint(boolean introduce) {
    hotPointY = 0;
    final int count = model.getItemCount();
    if (count < 1) {
      hotPointX = 0;
      environment.onAreaNewHotPoint(this);
      return;
    }
    final Object item = model.getItem(0);
    if (item != null) {
      hotPointX = item != null ? appearance.getObservableLeftBound(item) : 0;
      if (introduce) appearance.announceItem(item, NONE_APPEARANCE_FLAGS);
    } else {
      hotPointX = 0;
      environment.hint(Hints.EMPTY_LINE);
    }
    environment.onAreaNewHotPoint(this);
  }

  public void announceSelected() {
    final Object item = selected();
    if (item != null) appearance.announceItem(item, NONE_APPEARANCE_FLAGS);
  }

  /**
   * Refreshes the content of the list. This method calls {@code refresh()} method of the model and
   * displays new items. It does not produce any speech announcement of the change. HotPointY is
   * preserved if it is possible (meaning, the new number of lines not less than old value of
   * hotPointY), but hotPointX is moved to the beginning of the line.
   */
  public void refresh() {
    model.refresh();
    final int count = model.getItemCount();
    if (count == 0) {
      hotPointX = 0;
      hotPointY = 0;
      environment.onAreaNewContent(this);
      environment.onAreaNewHotPoint(this);
      return;
    }
    hotPointY = hotPointY < count ? hotPointY : count - 1;
    final Object item = model.getItem(hotPointY);
    if (item != null) hotPointX = appearance.getObservableLeftBound(item);
    else hotPointX = 0;
    environment.onAreaNewContent(this);
    environment.onAreaNewHotPoint(this);
  }

  public boolean isEmpty() {
    return model.getItemCount() <= 0;
  }

  @Override
  public boolean onKeyboardEvent(KeyboardEvent event) {
    NullCheck.notNull(event, "event");
    if (!event.isSpecial() && (!event.isModified() || event.withShiftOnly())) return onChar(event);
    if (!event.isSpecial() || event.isModified()) return false;
    switch (event.getSpecial()) {
      case ARROW_DOWN:
        return onArrowDown(event, false);
      case ARROW_UP:
        return onArrowUp(event, false);
      case ARROW_RIGHT:
        return onArrowRight(event);
      case ARROW_LEFT:
        return onArrowLeft(event);
      case ALTERNATIVE_ARROW_DOWN:
        return onArrowDown(event, true);
      case ALTERNATIVE_ARROW_UP:
        return onArrowUp(event, true);
      case ALTERNATIVE_ARROW_RIGHT:
        return onAltRight(event);
      case ALTERNATIVE_ARROW_LEFT:
        return onAltLeft(event);
      case HOME:
        return onHome(event);
      case END:
        return onEnd(event);
      case ALTERNATIVE_HOME:
        return onAltHome(event);
      case ALTERNATIVE_END:
        return onAltEnd(event);
      case PAGE_DOWN:
        return onPageDown(event, false);
      case PAGE_UP:
        return onPageUp(event, false);
      case ALTERNATIVE_PAGE_DOWN:
        return onPageDown(event, true);
      case ALTERNATIVE_PAGE_UP:
        return onPageUp(event, true);
      case INSERT:
        return onInsert(event);
      case ENTER:
        return onEnter(event);
      default:
        return false;
    }
  }

  @Override
  public boolean onEnvironmentEvent(EnvironmentEvent event) {
    NullCheck.notNull(event, "event");
    if (event.getType() != EnvironmentEvent.Type.REGULAR) return false;
    switch (event.getCode()) {
      case REFRESH:
        refresh();
        return true;
      case INTRODUCE:
        return onAnnounce();
      case ANNOUNCE_LINE:
        return onAnnounceLine();
      case OK:
        return onOk(event);
      case LISTENING_FINISHED:
        if (event instanceof ListeningFinishedEvent)
          return onListeningFinishedEvent((ListeningFinishedEvent) event);
        return false;
      case MOVE_HOT_POINT:
        if (event instanceof MoveHotPointEvent) return onMoveHotPoint((MoveHotPointEvent) event);
        return false;
      default:
        return region.onEnvironmentEvent(event, hotPointX, hotPointY);
    }
  }

  @Override
  public boolean onAreaQuery(AreaQuery query) {
    NullCheck.notNull(query, "query");
    switch (query.getQueryCode()) {
      case AreaQuery.BEGIN_LISTENING:
        if (query instanceof BeginListeningQuery)
          return onBeginListeningQuery((BeginListeningQuery) query);
        return false;
      default:
        return region.onAreaQuery(query, hotPointX, hotPointY);
    }
  }

  @Override
  public Action[] getAreaActions() {
    return new Action[0];
  }

  @Override
  public int getLineCount() {
    final int emptyCountTop = flags.contains(Flags.EMPTY_LINE_TOP) ? 1 : 0;
    final int emptyCountBottom = flags.contains(Flags.EMPTY_LINE_BOTTOM) ? 1 : 0;

    final int res = model.getItemCount() + emptyCountTop + emptyCountBottom;
    return res >= 1 ? res : 1;
  }

  @Override
  public String getLine(int index) {
    if (isEmpty()) return index == 0 ? noContentStr() : "";
    final int itemIndex = getItemIndexOnLine(index);
    if (itemIndex < 0 || itemIndex >= model.getItemCount()) return "";
    final Object res = model.getItem(itemIndex);
    return res != null ? appearance.getScreenAppearance(res, NONE_APPEARANCE_FLAGS) : "";
  }

  @Override
  public int getHotPointX() {
    return hotPointX >= 0 ? hotPointX : 0;
  }

  @Override
  public int getHotPointY() {
    return hotPointY >= 0 ? hotPointY : 0;
  }

  @Override
  public String getAreaName() {
    NullCheck.notNull(areaName, "areaName");
    return areaName;
  }

  public void setAreaName(String areaName) {
    NullCheck.notNull(areaName, "areaName");
    this.areaName = areaName;
    environment.onAreaNewName(this);
  }

  protected boolean onAnnounce() {
    environment.playSound(Sounds.INTRO_REGULAR);
    String item = "";
    if (selected() != null)
      item =
          appearance.getScreenAppearance(selected(), EnumSet.noneOf(Appearance.Flags.class)).trim();
    if (!item.isEmpty()) item = " " + item;
    environment.say(getAreaName() + item);
    return true;
  }

  protected boolean onAnnounceLine() {
    if (isEmpty()) return false;
    final Object item = selected();
    if (item == null) {
      environment.hint(Hints.EMPTY_LINE);
      return true;
    }
    appearance.announceItem(item, NONE_APPEARANCE_FLAGS);
    return true;
  }

  protected boolean onMoveHotPoint(MoveHotPointEvent event) {
    NullCheck.notNull(event, "event");
    final int x = event.getNewHotPointX();
    final int y = event.getNewHotPointY();
    final int newY;
    if (y >= getLineCount()) {
      if (event.precisely()) return false;
      newY = getLineCount() - 1;
    } else newY = y;
    if (getItemIndexOnLine(newY) >= 0) {
      // Line with item, not empty
      final Object item = model.getItem(getItemIndexOnLine(newY));
      final int leftBound = appearance.getObservableLeftBound(item);
      final int rightBound = appearance.getObservableRightBound(item);
      if (event.precisely() && (x < leftBound || x > rightBound)) return false;
      hotPointY = newY;
      hotPointX = x;
      if (hotPointX < leftBound) hotPointX = leftBound;
      if (hotPointX > rightBound) hotPointX = rightBound;
      environment.onAreaNewHotPoint(this);
      return true;
    }
    // On empty line
    hotPointY = newY;
    hotPointX = 0;
    environment.onAreaNewHotPoint(this);
    return true;
  }

  protected boolean onBeginListeningQuery(BeginListeningQuery query) {
    NullCheck.notNull(query, "query");
    final int index = selectedIndex();
    if (index < 0) return false;
    final int count = model.getItemCount();
    if (index >= count) return false;
    final Object current = model.getItem(index);
    final String text =
        appearance
            .getScreenAppearance(current, NONE_APPEARANCE_FLAGS)
            .substring(hotPointX, appearance.getObservableRightBound(current));
    //	Log.debug("listen", appearance.getScreenAppearance(current, NONE_APPEARANCE_FLAGS));
    //	Log.debug("listen", "" + hotPointX);
    if (text.isEmpty() && index + 1 >= count) return false;
    if (index + 1 < count) {
      final Object next = model.getItem(index + 1);
      query.answer(
          new BeginListeningQuery.Answer(
              text, new ListeningInfo(index + 1, appearance.getObservableLeftBound(next))));
    } else
      query.answer(
          new BeginListeningQuery.Answer(
              text, new ListeningInfo(index, appearance.getObservableRightBound(current))));
    return true;
  }

  protected boolean onListeningFinishedEvent(ListeningFinishedEvent event) {
    NullCheck.notNull(event, "event");
    if (!(event.getExtraInfo() instanceof ListeningInfo)) return false;
    final ListeningInfo info = (ListeningInfo) event.getExtraInfo();
    final int count = model.getItemCount();
    if (info.itemIndex >= count) return false;
    final Object item = model.getItem(info.itemIndex);
    final int leftBound = appearance.getObservableLeftBound(item);
    final int rightBound = appearance.getObservableRightBound(item);
    if (info.pos < leftBound || info.pos > rightBound) return false;
    hotPointY = getLineIndexByItemIndex(info.itemIndex);
    hotPointX = info.pos;
    environment.onAreaNewHotPoint(this);
    return true;
  }

  protected boolean onChar(KeyboardEvent event) {
    if (noContent()) return true;
    final int count = model.getItemCount();
    final char c = event.getChar();
    final String beginning;
    if (selected() != null) {
      if (hotPointX >= appearance.getObservableRightBound(selected())) return false;
      final String name = getObservableSubstr(selected());
      final int pos =
          Math.min(hotPointX - appearance.getObservableLeftBound(selected()), name.length());
      if (pos < 0) return false;
      beginning = name.substring(0, pos);
    } else beginning = "";
    Log.debug("list", "beginning:" + beginning);
    final String mustBegin = beginning + c;
    for (int i = 0; i < count; ++i) {
      Log.debug("list", "checking:" + i);
      final String name = getObservableSubstr(model.getItem(i));
      Log.debug("list", "name:" + name);
      if (!name.startsWith(mustBegin)) continue;
      hotPointY = getLineIndexByItemIndex(i);
      Log.debug("list", "hotPointY:" + hotPointY);
      ++hotPointX;
      appearance.announceItem(model.getItem(hotPointY), NONE_APPEARANCE_FLAGS);
      environment.onAreaNewHotPoint(this);
      return true;
    }
    return false;
  }

  protected boolean onArrowDown(KeyboardEvent event, boolean briefAnnouncement) {
    return onTransition(Transition.Type.SINGLE_DOWN, Hints.NO_ITEMS_BELOW, briefAnnouncement);
  }

  protected boolean onArrowUp(KeyboardEvent event, boolean briefAnnouncement) {
    return onTransition(Transition.Type.SINGLE_UP, Hints.NO_ITEMS_ABOVE, briefAnnouncement);
  }

  protected boolean onPageDown(KeyboardEvent event, boolean briefAnnouncement) {
    return onTransition(Transition.Type.PAGE_DOWN, Hints.NO_ITEMS_BELOW, briefAnnouncement);
  }

  protected boolean onPageUp(KeyboardEvent event, boolean briefAnnouncement) {
    return onTransition(Transition.Type.PAGE_UP, Hints.NO_ITEMS_ABOVE, briefAnnouncement);
  }

  protected boolean onEnd(KeyboardEvent event) {
    return onTransition(Transition.Type.END, Hints.NO_ITEMS_BELOW, false);
  }

  protected boolean onHome(KeyboardEvent event) {
    return onTransition(Transition.Type.HOME, Hints.NO_ITEMS_ABOVE, false);
  }

  protected boolean onTransition(Transition.Type type, int hint, boolean briefAnnouncement) {
    NullCheck.notNull(type, "type");
    //	NullCheck.notNull(hint, "hint");
    if (noContent()) return true;
    final int index = selectedIndex();
    final int count = model.getItemCount();
    final int emptyCountTop = flags.contains(Flags.EMPTY_LINE_TOP) ? 1 : 0;
    final Transition.State current;
    if (index >= 0) current = new Transition.State(index);
    else if (flags.contains(Flags.EMPTY_LINE_TOP) && hotPointY == 0)
      current = new Transition.State(Transition.State.Type.EMPTY_LINE_TOP);
    else if (flags.contains(Flags.EMPTY_LINE_BOTTOM) && hotPointY == count + emptyCountTop)
      current = new Transition.State(Transition.State.Type.EMPTY_LINE_BOTTOM);
    else return false;
    final Transition.State newState =
        transition.transition(
            type,
            current,
            count,
            flags.contains(Flags.EMPTY_LINE_TOP),
            flags.contains(Flags.EMPTY_LINE_BOTTOM));
    NullCheck.notNull(newState, "newState");
    Log.debug("list", "newState=" + newState.type);
    switch (newState.type) {
      case NO_TRANSITION:
        environment.hint(hint);
        return true;
      case EMPTY_LINE_TOP:
        if (!flags.contains(Flags.EMPTY_LINE_TOP)) return false;
        hotPointY = 0;
        break;
      case EMPTY_LINE_BOTTOM:
        if (!flags.contains(Flags.EMPTY_LINE_BOTTOM)) return false;
        hotPointY = count + emptyCountTop;
        break;
      case ITEM_INDEX:
        if (newState.itemIndex < 0 || newState.itemIndex >= count) return false;
        hotPointY = newState.itemIndex + emptyCountTop;
        break;
      default:
        return false;
    }
    onNewHotPointY(briefAnnouncement);
    return true;
  }

  protected boolean onArrowRight(KeyboardEvent event) {
    if (noContent()) return true;
    final Object item = selected();
    NullCheck.notNull(item, "item");
    final String line = appearance.getScreenAppearance(item, NONE_APPEARANCE_FLAGS);
    NullCheck.notNull(line, "line");
    if (line.isEmpty()) {
      environment.hint(Hints.EMPTY_LINE);
      return true;
    }
    final int rightBound = appearance.getObservableRightBound(item);
    if (hotPointX >= rightBound) {
      environment.hint(Hints.END_OF_LINE);
      return true;
    }
    ++hotPointX;
    announceChar(line, hotPointX, rightBound);
    environment.onAreaNewHotPoint(this);
    return true;
  }

  protected boolean onArrowLeft(KeyboardEvent event) {
    if (noContent()) return true;
    final Object item = selected();
    NullCheck.notNull(item, "item");
    final String line = appearance.getScreenAppearance(item, NONE_APPEARANCE_FLAGS);
    NullCheck.notNull(line, "line");
    if (line.isEmpty()) {
      environment.hint(Hints.EMPTY_LINE);
      return true;
    }
    final int leftBound = appearance.getObservableLeftBound(item);
    final int rightBound = appearance.getObservableRightBound(item);
    if (hotPointX <= leftBound) {
      environment.hint(Hints.BEGIN_OF_LINE);
      return true;
    }
    --hotPointX;
    announceChar(line, hotPointX, rightBound);
    environment.onAreaNewHotPoint(this);
    return true;
  }

  private boolean onAltRight(KeyboardEvent event) {
    if (noContent()) return true;
    final Object item = selected();
    if (item == null) {
      environment.hint(Hints.EMPTY_LINE);
      return true;
    }
    final String line = appearance.getScreenAppearance(item, NONE_APPEARANCE_FLAGS);
    NullCheck.notNull(line, "line");
    if (line.isEmpty()) {
      environment.hint(Hints.EMPTY_LINE);
      return true;
    }
    final int leftBound = appearance.getObservableLeftBound(item);
    final int rightBound = appearance.getObservableRightBound(item);
    if (hotPointX >= rightBound) {
      environment.hint(Hints.END_OF_LINE);
      return true;
    }
    final String subline = line.substring(leftBound, rightBound);
    final WordIterator it = new WordIterator(subline, hotPointX - leftBound);
    if (!it.stepForward()) {
      environment.hint(Hints.END_OF_LINE);
      return true;
    }
    hotPointX = it.pos() + leftBound;
    if (it.announce().length() > 0) environment.say(it.announce());
    else environment.hint(Hints.END_OF_LINE);
    environment.onAreaNewHotPoint(this);
    return true;
  }

  private boolean onAltLeft(KeyboardEvent event) {
    if (noContent()) return true;
    final Object item = selected();
    if (item == null) {
      environment.hint(Hints.EMPTY_LINE);
      return true;
    }
    final String line = appearance.getScreenAppearance(item, NONE_APPEARANCE_FLAGS);
    NullCheck.notNull(line, "line");
    if (line.isEmpty()) {
      environment.hint(Hints.EMPTY_LINE);
      return true;
    }
    final int leftBound = appearance.getObservableLeftBound(item);
    final int rightBound = appearance.getObservableRightBound(item);
    if (hotPointX <= leftBound) {
      environment.hint(Hints.BEGIN_OF_LINE);
      return true;
    }
    final String subline = line.substring(leftBound, rightBound);
    final WordIterator it = new WordIterator(subline, hotPointX - leftBound);
    if (!it.stepBackward()) {
      environment.hint(Hints.BEGIN_OF_LINE);
      return true;
    }
    hotPointX = it.pos() + leftBound;
    environment.say(it.announce());
    environment.onAreaNewHotPoint(this);
    return true;
  }

  private boolean onAltEnd(KeyboardEvent event) {
    if (noContent()) return true;
    final Object item = selected();
    if (item == null) {
      environment.hint(Hints.EMPTY_LINE);
      return true;
    }
    final String line = appearance.getScreenAppearance(item, NONE_APPEARANCE_FLAGS);
    NullCheck.notNull(line, "line");
    hotPointX = appearance.getObservableRightBound(item);
    environment.hint(Hints.END_OF_LINE);
    environment.onAreaNewHotPoint(this);
    return true;
  }

  private boolean onAltHome(KeyboardEvent event) {
    if (noContent()) return true;
    final Object item = selected();
    NullCheck.notNull(item, "item");
    final String line = appearance.getScreenAppearance(item, NONE_APPEARANCE_FLAGS);
    NullCheck.notNull(line, "line");
    hotPointX = appearance.getObservableLeftBound(item);
    announceChar(line, hotPointX, appearance.getObservableRightBound(item));
    environment.onAreaNewHotPoint(this);
    return true;
  }

  protected boolean onInsert(KeyboardEvent event) {
    final int index = selectedIndex();
    if (index < 0) return false;
    if (!model.toggleMark(index)) return false;
    environment.onAreaNewContent(this);
    if (hotPointY + 1 < getLineCount()) {
      ++hotPointY;
      onNewHotPointY(false);
    }
    return true;
  }

  protected boolean onEnter(KeyboardEvent event) {
    if (isEmpty() || clickHandler == null) return false;
    if (selected() == null || selectedIndex() < 0) return false;
    return clickHandler.onListClick(this, selectedIndex(), selected());
  }

  private boolean onOk(EnvironmentEvent event) {
    if (clickHandler == null) return false;
    final int index = selectedIndex();
    final Object item = selected();
    if (index < 0 || item == null) return false;
    return clickHandler.onListClick(this, index, item);
  }

  @Override
  public RegionContent getWholeRegion() {
    if (model == null || model.getItemCount() < 0) return null;
    final LinkedList<String> res = new LinkedList<String>();
    final int count = model.getItemCount();
    for (int i = 0; i < count; ++i) {
      final String line = appearance.getScreenAppearance(model.getItem(i), NONE_APPEARANCE_FLAGS);
      res.add(line != null ? line : "");
    }
    res.add("");
    return new RegionContent(res.toArray(new String[res.size()]));
  }

  @Override
  public RegionContent getRegion(int fromX, int fromY, int toX, int toY) {
    if (model == null || model.getItemCount() < 0) return null;
    if (fromY >= model.getItemCount() || toY > model.getItemCount()) return null;
    if (fromY == toY) {
      final String line =
          appearance.getScreenAppearance(model.getItem(fromY), NONE_APPEARANCE_FLAGS);
      if (line == null || line.isEmpty()) return null;
      final int fromPos = fromX < line.length() ? fromX : line.length();
      final int toPos = toX < line.length() ? toX : line.length();
      if (fromPos >= toPos) return null;
      return new RegionContent(new String[] {line.substring(fromPos, toPos)});
    }
    final LinkedList<String> res = new LinkedList<String>();
    for (int i = fromY; i < toY; ++i) {
      final String line = appearance.getScreenAppearance(model.getItem(i), NONE_APPEARANCE_FLAGS);
      res.add(line != null ? line : "");
    }
    res.add("");
    return new RegionContent(res.toArray(new String[res.size()]));
  }

  @Override
  public boolean deleteWholeRegion() {
    return false;
  }

  @Override
  public boolean deleteRegion(int fromX, int fromY, int toX, int toY) {
    return false;
  }

  @Override
  public boolean insertRegion(int x, int y, RegionContent data) {
    return false;
  }

  protected void onNewHotPointY(boolean briefAnnouncement) {
    final int index = selectedIndex();
    if (index < 0) {
      environment.hint(Hints.EMPTY_LINE);
      hotPointX = 0;
      environment.onAreaNewHotPoint(this);
      return;
    }
    final Object item = model.getItem(index);
    if (item == null) {
      environment.hint(Hints.EMPTY_LINE);
      hotPointX = 0;
      environment.onAreaNewHotPoint(this);
      return;
    }
    appearance.announceItem(
        item, briefAnnouncement ? BRIEF_ANNOUNCEMENT_ONLY : NONE_APPEARANCE_FLAGS);
    hotPointX = appearance.getObservableLeftBound(item);
    environment.onAreaNewHotPoint(this);
  }

  protected String getObservableSubstr(Object item) {
    NullCheck.notNull(item, "item");
    final String line = appearance.getScreenAppearance(item, NONE_APPEARANCE_FLAGS);
    NullCheck.notNull(line, "line");
    if (line.isEmpty()) return "";
    final int leftBound = Math.min(appearance.getObservableLeftBound(item), line.length());
    final int rightBound = Math.min(appearance.getObservableRightBound(item), line.length());
    if (leftBound >= rightBound) return "";
    return line.substring(leftBound, rightBound);
  }

  protected String noContentStr() {
    return environment.getStaticStr("ListNoContent");
  }

  protected void announceChar(String line, int pos, int rightBound) {
    NullCheck.notNull(line, "line");
    if (pos < rightBound) environment.sayLetter(line.charAt(pos));
    else environment.hint(Hints.END_OF_LINE);
  }

  protected boolean noContent() {
    if (model == null || model.getItemCount() < 1) {
      environment.hint(noContentStr(), Hints.NO_CONTENT);
      return true;
    }
    return false;
  }

  protected static class ListeningInfo {
    final int itemIndex;
    final int pos;

    ListeningInfo(int itemIndex, int pos) {
      this.itemIndex = itemIndex;
      this.pos = pos;
    }
  }
}