Make the selection loop with arrow keys in the autocomplete popup

third_party/WebKit/WebCore/platform/chromium/PopupMenuChromium.cpp

 /*
  * Copyright (c) 2008, 2009, Google Inc. All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  * 
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 71 matching lines @@
     virtual bool handleKeyEvent(const PlatformKeyboardEvent&);
 
     // ScrollView
     virtual HostWindow* hostWindow() const;
 
     // Widget
     virtual void invalidateRect(const IntRect&);
 
     // PopupListBox methods
 
-    // Show the popup
+    // Shows the popup
     void showPopup();
 
-    // Hide the popup.  Do not call this directly: use client->hidePopup().
+    // Hides the popup.  Do not call this directly: use client->hidePopup().
     void hidePopup();
 
-    // Update our internal list to match the client.
+    // Updates our internal list to match the client.
     void updateFromElement();
 
-    // Free any allocated resources used in a particular popup session. 
+    // Frees any allocated resources used in a particular popup session. 
     void clear();
 
-    // Set the index of the option that is displayed in the <select> widget in the page
+    // Sets the index of the option that is displayed in the <select> widget in the page
     void setOriginalIndex(int index);
 
-    // Get the index of the item that the user is currently moused over or has selected with
+    // Gets the index of the item that the user is currently moused over or has selected with
     // the keyboard. This is not the same as the original index, since the user has not yet
     // accepted this input.
     int selectedIndex() const { return m_selectedIndex; }
 
-    // Move selection down/up the given number of items, scrolling if necessary.
+    // Moves selection down/up the given number of items, scrolling if necessary.
     // Positive is down.  The resulting index will be clamped to the range
     // [0, numItems), and non-option items will be skipped.
     void adjustSelectedIndex(int delta);
 
     // Returns the number of items in the list.
     int numItems() const { return static_cast<int>(m_items.size()); }
 
     void setBaseWidth(int width) { m_baseWidth = width; }
 
-    // Compute size of widget and children.
+    // Computes the size of widget and children.
     void layout();
 
     // Returns whether the popup wants to process events for the passed key.
     bool isInterestedInEventForKey(int keyCode);
 
     // Sets whether the PopupMenuClient should be told to change its text when a
     // new item is selected (by using the arrow keys).  Default is true.
     void setTextOnIndexChange(bool value) { m_setTextOnIndexChange = value; }
 
     // Sets whether we should accept the selected index when the popup is
     // abandonned.
     void setAcceptOnAbandon(bool value) { m_shouldAcceptOnAbandon = value; }
 
+    // Sets whether pressing the down/up arrow when the last/first row is
+    // selected clears the selection on the first key press and then selects the
+    // first/last row on the next key press.  If false, the selected row stays
+    // the last/first row.
+    void setLoopSelectionNavigation(bool value) { m_loopSelectionNavigation = value; }
+
 private:
     friend class PopupContainer;
     friend class RefCounted<PopupListBox>;
 
     // A type of List Item
     enum ListItemType {
         TypeOption,
         TypeGroup,
         TypeSeparator
     };
@@ skipping 10 matching lines @@
     PopupListBox(PopupMenuClient* client)
         : m_originalIndex(0)
         , m_selectedIndex(0)
         , m_shouldAcceptOnAbandon(true)
         , m_willAcceptOnAbandon(false)
         , m_visibleRows(0)
         , m_popupClient(client)
         , m_repeatingChar(0)
         , m_lastCharTime(0)
         , m_setTextOnIndexChange(true)
+        , m_loopSelectionNavigation(false)
     {
         setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff);
     }
 
     ~PopupListBox()
     {
         clear();
     }
 
     void disconnectClient() { m_popupClient = 0; }
 
     // Closes the popup
     void abandon();
     // Select an index in the list, scrolling if necessary.
     void selectIndex(int index);
     // Accepts the selected index as the value to be displayed in the <select> widget on
     // the web page, and closes the popup.
     void acceptIndex(int index);
 
     // Returns true if the selection can be changed to index.
     // Disabled items, or labels cannot be selected.
     bool isSelectableItem(int index);
 
+    // Clears the selection (so no row appears selected).
+    void clearSelection();
+
     // Scrolls to reveal the given index.
     void scrollToRevealRow(int index);
     void scrollToRevealSelection() { scrollToRevealRow(m_selectedIndex); }
 
     // Invalidates the row at the given index. 
     void invalidateRow(int index);
 
     // Gets the height of a row.
     int getRowHeight(int index);
     // Get the bounds of a row. 
     IntRect getRowBounds(int index);
 
     // Converts a point to an index of the row the point is over
     int pointToRowIndex(const IntPoint&);
 
     // Paint an individual row
     void paintRow(GraphicsContext*, const IntRect&, int rowIndex);
 
     // Test if the given point is within the bounds of the popup window.
     bool isPointInBounds(const IntPoint&);
 
     // Called when the user presses a text key.  Does a prefix-search of the items.
     void typeAheadFind(const PlatformKeyboardEvent&);
 
     // Returns the font to use for the given row
     Font getRowFont(int index);
 
+    // Moves the selection down/up one item, taking care of looping back to the
+    // first/last element if m_loopSelectionNavigation is true.
+    void selectPreviousRow();
+    void selectNextRow();
+
+
     // This is the index of the item marked as "selected" - i.e. displayed in the widget on the
     // page. 
     int m_originalIndex;
 
     // This is the index of the item that the user is hovered over or has selected using the 
     // keyboard in the list. They have not confirmed this selection by clicking or pressing 
     // enter yet however.
     int m_selectedIndex;
 
     // Whether we should accept the selectedIndex as chosen when the popup is
@@ skipping 31 matching lines @@
     // The string the user has typed so far into the popup. Used for typeAheadFind.
     String m_typedString;
 
     // The char the user has hit repeatedly.  Used for typeAheadFind.
     UChar m_repeatingChar;
 
     // The last time the user hit a key.  Used for typeAheadFind.
     TimeStamp m_lastCharTime;
 
     bool m_setTextOnIndexChange;
+
+    bool m_loopSelectionNavigation;
 };
 
 static PlatformMouseEvent constructRelativeMouseEvent(const PlatformMouseEvent& e,
                                                       FramelessScrollView* parent,
                                                       FramelessScrollView* child)
 {
     IntPoint pos = parent->convertSelfToChild(child, e.pos());
 
     // FIXME: This is a horrible hack since PlatformMouseEvent has no setters for x/y.
     PlatformMouseEvent relativeEvent = e;
@@ skipping 204 matching lines @@
 void PopupContainer::setTextOnIndexChange(bool value)
 {
     listBox()->setTextOnIndexChange(value);
 }
 
 void PopupContainer::setAcceptOnAbandon(bool value)
 {
     listBox()->setAcceptOnAbandon(value);
 }
 
+void PopupContainer::setLoopSelectionNavigation(bool value) {
+    listBox()->setLoopSelectionNavigation(value);
+}
+
 void PopupContainer::refresh()
 {
     listBox()->updateFromElement();
     layout();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // PopupListBox implementation
 
 bool PopupListBox::handleMouseDownEvent(const PlatformMouseEvent& event)
@@ skipping 91 matching lines @@
         return true;
 
     if (numItems() == 0 && event.windowsVirtualKeyCode() != VKEY_ESCAPE)
         return true;
 
     switch (event.windowsVirtualKeyCode()) {
     case VKEY_ESCAPE:
         abandon();  // may delete this
         return true;
     case VKEY_RETURN:
+        if (m_selectedIndex == -1)  {
+            m_popupClient->hidePopup();
+            // Don't eat the enter if nothing is selected.

[Matt Perry, 2009/01/21 22:38:09]

Seems strange to me that the enter would propagate up if the popup menu is open,
but if that's the behavior of other browsers, that's fine.

+            return false;
+        }
         acceptIndex(m_selectedIndex);  // may delete this
         return true;
     case VKEY_UP:
-        adjustSelectedIndex(-1);
+        selectPreviousRow();
         break;
     case VKEY_DOWN:
-        adjustSelectedIndex(1);
+        selectNextRow();
         break;
     case VKEY_PRIOR:
         adjustSelectedIndex(-m_visibleRows);
         break;
     case VKEY_NEXT:
         adjustSelectedIndex(m_visibleRows);
         break;
     case VKEY_HOME:
         adjustSelectedIndex(-m_selectedIndex);
         break;
@@ skipping 312 matching lines @@
     } else if (rowRect.bottom() > scrollY() + visibleHeight()) {
         // Row is below current scroll position, scroll down.
         ScrollView::setScrollPosition(IntPoint(0, rowRect.bottom() - visibleHeight()));
     }
 }
 
 bool PopupListBox::isSelectableItem(int index) {
     return m_items[index]->type == TypeOption && m_popupClient->itemIsEnabled(index);
 }
 
+void PopupListBox::clearSelection() {
+    if (m_selectedIndex != -1) {
+        invalidateRow(m_selectedIndex);
+        m_selectedIndex = -1;
+    }
+}
+
+void PopupListBox::selectNextRow() {
+    if (!m_loopSelectionNavigation || m_selectedIndex != numItems() - 1) {
+        adjustSelectedIndex(1);
+        return;
+    }
+
+    // We are moving past the last item, no row should be selected.
+    clearSelection();
+}
+
+void PopupListBox::selectPreviousRow() {
+    if (!m_loopSelectionNavigation || m_selectedIndex > 0) {
+        adjustSelectedIndex(-1);
+        return;
+    }
+
+    if (m_selectedIndex == 0) {
+        // We are moving past the first item, clear the selection.
+        clearSelection();
+        return;
+    }
+
+    // No row are selected, jump to the last item.
+    selectIndex(numItems() - 1);
+    scrollToRevealSelection();
+}
+
 void PopupListBox::adjustSelectedIndex(int delta)
 {
     int targetIndex = m_selectedIndex + delta;
     targetIndex = min(max(targetIndex, 0), numItems() - 1);
     if (!isSelectableItem(targetIndex)) {
         // We didn't land on an option.  Try to find one.
         // We try to select the closest index to target, prioritizing any in
         // the range [current, target].
 
         int dir = delta > 0 ? 1 : -1;
@@ skipping 159 matching lines @@
 {
     p.popup->listBox()->updateFromElement();
 }
 
 bool PopupMenu::itemWritingDirectionIsNatural() 
 { 
     return false; 
 }
 
 } // namespace WebCore