Merge in the WebKit popup menu changes.

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 118 matching lines @@
     int numItems() const { return static_cast<int>(m_items.size()); }
 
     void setBaseWidth(int width) { m_baseWidth = width; }
 
     // 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);
 
+    // Gets the height of a row.
+    int getRowHeight(int index);
+
+    // Returns true if the selection can be changed to index.
+    // Disabled items, or labels cannot be selected.
+    bool isSelectableItem(int index);
+
+    const Vector<PopupItem*>& items() const { return m_items; }
+
 private:
     friend class PopupContainer;
     friend class RefCounted<PopupListBox>;
 
-    // A type of List Item
-    enum ListItemType {
-        TypeOption,
-        TypeGroup,
-        TypeSeparator
-    };
-
-    // A item (represented by <option> or <optgroup>) in the <select> widget. 
-    struct ListItem {
-        ListItem(const String& label, ListItemType type)
-            : label(label.copy()), type(type), y(0) {}
-        String label;
-        ListItemType type;
-        int y;  // y offset of this item, relative to the top of the popup.
-    };
-
     PopupListBox(PopupMenuClient* client, const PopupContainerSettings& settings)
         : m_settings(settings)
         , m_originalIndex(0)
         , m_selectedIndex(0)
         , m_willAcceptOnAbandon(false)
         , m_visibleRows(0)
         , m_popupClient(client)
         , m_repeatingChar(0)
         , m_lastCharTime(0)
     {
         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.
@@ skipping 30 matching lines @@
 
     // This is the number of rows visible in the popup. The maximum number visible at a time is
     // defined as being kMaxVisibleRows. For a scrolled popup, this can be thought of as the
     // page size in data units. 
     int m_visibleRows;
 
     // Our suggested width, not including scrollbar.
     int m_baseWidth;
 
     // A list of the options contained within the <select>
-    Vector<ListItem*> m_items;
+    Vector<PopupItem*> m_items;
 
     // The <select> PopupMenuClient that opened us.
     PopupMenuClient* m_popupClient;
 
     // The scrollbar which has mouse capture.  Mouse events go straight to this
     // if non-NULL.
     RefPtr<Scrollbar> m_capturingScrollbar;
 
     // The last scrollbar that the mouse was over.  Used for mouseover highlights.
     RefPtr<Scrollbar> m_lastScrollbarUnderMouse;
@@ skipping 39 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // PopupContainer implementation
 
 // static
 PassRefPtr<PopupContainer> PopupContainer::create(PopupMenuClient* client,
                                                   const PopupContainerSettings& settings)
 {
     return adoptRef(new PopupContainer(client, settings));
 }
 
-PopupContainer::PopupContainer(PopupMenuClient* client, const PopupContainerSettings& settings)
+PopupContainer::PopupContainer(PopupMenuClient* client,
+                               const PopupContainerSettings& settings)
     : m_listBox(PopupListBox::create(client, settings))
     , m_settings(settings)
 {
     setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff);
 }
 
 PopupContainer::~PopupContainer()
 {
-    if (m_listBox)
+    if (m_listBox && m_listBox->parent())
         removeChild(m_listBox.get());
 }
 
 void PopupContainer::showPopup(FrameView* view)
 {
     // Pre-layout, our size matches the <select> dropdown control.
     int selectHeight = frameRect().height();
 
     // Lay everything out to figure out our preferred size, then tell the view's
     // WidgetClient about it.  It should assign us a client.
     layout();
 
     ChromeClientChromium* chromeClient = static_cast<ChromeClientChromium*>(
         view->frame()->page()->chrome()->client());
     if (chromeClient) {
         // If the popup would extend past the bottom of the screen, open upwards
         // instead.
         FloatRect screen = screenAvailableRect(view);
         IntRect widgetRect = chromeClient->windowToScreen(frameRect());
         if (widgetRect.bottom() > static_cast<int>(screen.bottom()))
             widgetRect.move(0, -(widgetRect.height() + selectHeight));
 
-        chromeClient->popupOpened(this, widgetRect, m_settings.focusOnShow);
+        chromeClient->popupOpened(this, widgetRect, m_settings.focusOnShow, false);
     }
 
     if (!m_listBox->parent())
         addChild(m_listBox.get());
 
     // Enable scrollbars after the listbox is inserted into the hierarchy,
     // so it has a proper WidgetClient.
     m_listBox->setVerticalScrollbarMode(ScrollbarAuto);
 
     m_listBox->scrollToRevealSelection();
 
     invalidate();
 }
 
+void PopupContainer::showExternal(const IntRect& rect, FrameView* v, int index)
+{
+     if (!listBox())
+        return;
+
+     listBox()->updateFromElement();
+
+     // Get the ChromeClient and pass it the popup menu's listbox data.
+     ChromeClientChromium* client = static_cast<ChromeClientChromium*>(
+          v->frame()->page()->chrome()->client());
+     client->popupOpened(this, rect, true, true);
+}
+
 void PopupContainer::hidePopup()
 {
     if (client())
         client()->popupClosed(this);
 }
 
 void PopupContainer::layout()
 {
     m_listBox->layout();
 
@@ skipping 108 matching lines @@
 {
     listBox()->updateFromElement();
     layout();
 }
 
 int PopupContainer::selectedIndex() const
 {
     return m_listBox->selectedIndex();
 }
 
+int PopupContainer::menuItemHeight() const
+{
+    return m_listBox->getRowHeight(0);
+}
+
+const WTF::Vector<PopupItem*>& PopupContainer:: popupData() const
+{
+    return m_listBox->items();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // PopupListBox implementation
 
 bool PopupListBox::handleMouseDownEvent(const PlatformMouseEvent& event)
 {
     Scrollbar* scrollbar = scrollbarUnderMouse(event);
     if (scrollbar) {
         m_capturingScrollbar = scrollbar;
         m_capturingScrollbar->mouseDown(event);
         return true;
@@ skipping 323 matching lines @@
     if (m_willAcceptOnAbandon)
         m_popupClient->valueChanged(m_selectedIndex);
 }
 
 int PopupListBox::pointToRowIndex(const IntPoint& point)
 {
     int y = scrollY() + point.y();
 
     // FIXME: binary search if perf matters.
     for (int i = 0; i < numItems(); ++i) {
-        if (y < m_items[i]->y)
+        if (y < m_items[i]->yOffset)
             return i-1;
     }
 
     // Last item?
     if (y < contentsHeight())
         return m_items.size()-1;
 
     return -1;
 }
 
@@ skipping 41 matching lines @@
         return 0;
 
     return m_popupClient->itemStyle(index).font().height();
 }
 
 IntRect PopupListBox::getRowBounds(int index)
 {
     if (index < 0)
         return IntRect(0, 0, visibleWidth(), getRowHeight(index));
 
-    return IntRect(0, m_items[index]->y, visibleWidth(), getRowHeight(index));
+    return IntRect(0, m_items[index]->yOffset, visibleWidth(), getRowHeight(index));
 }
 
 void PopupListBox::invalidateRow(int index)
 {
     if (index < 0)
         return;
 
     // Invalidate in the window contents, as FramelessScrollView::invalidateRect
     // paints in the window coordinates.
     invalidateRect(contentsToWindow(getRowBounds(index)));
@@ skipping 10 matching lines @@
         // Row is above current scroll position, scroll up.
         ScrollView::setScrollPosition(IntPoint(0, rowRect.y()));
     } 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);
+    return m_items[index]->type == PopupItem::TypeOption && m_popupClient->itemIsEnabled(index);
 }
 
 void PopupListBox::clearSelection()
 {
     if (m_selectedIndex != -1) {
         invalidateRow(m_selectedIndex);
         m_selectedIndex = -1;
     }
 }
 
@@ skipping 68 matching lines @@
     // is called before abandon, which causes discarding of the select result.    
     if (m_willAcceptOnAbandon) {
         m_popupClient->valueChanged(m_selectedIndex);
         m_willAcceptOnAbandon = false;
     }
 
     clear();
 
     int size = m_popupClient->listSize();
     for (int i = 0; i < size; ++i) {
-        ListItemType type;
+        PopupItem::Type type;
         if (m_popupClient->itemIsSeparator(i))
-            type = PopupListBox::TypeSeparator;
+            type = PopupItem::TypeSeparator;
         else if (m_popupClient->itemIsLabel(i))
-            type = PopupListBox::TypeGroup;
+            type = PopupItem::TypeGroup;
         else
-            type = PopupListBox::TypeOption;
-        m_items.append(new ListItem(m_popupClient->itemText(i), type));
+            type = PopupItem::TypeOption;
+        m_items.append(new PopupItem(m_popupClient->itemText(i), type));
+        m_items[i]->enabled = isSelectableItem(i);
     }
 
     m_selectedIndex = m_popupClient->selectedIndex();
     setOriginalIndex(m_selectedIndex);
 
     layout();
 }
 
 void PopupListBox::layout()
 {
     // Size our child items.
     int baseWidth = 0;
     int paddingWidth = 0;
     int y = 0;
     for (int i = 0; i < numItems(); ++i) {
         Font itemFont = getRowFont(i);
 
         // Place the item vertically.
-        m_items[i]->y = y;
+        m_items[i]->yOffset = y;
         y += itemFont.height();
 
         // Ensure the popup is wide enough to fit this item.
         String text = m_popupClient->itemText(i);
         if (!text.isEmpty()) {
             int width = itemFont.width(TextRun(text));
             baseWidth = max(baseWidth, width);
         }
         // FIXME: http://b/1210481 We should get the padding of individual option elements.
         paddingWidth = max(paddingWidth, 
@@ skipping 31 matching lines @@
     setContentsSize(IntSize(contentWidth, getRowBounds(numItems() - 1).bottom()));
 
     if (hostWindow())
         scrollToRevealSelection();
 
     invalidate();
 }
 
 void PopupListBox::clear()
 {
-    for (Vector<ListItem*>::iterator it = m_items.begin(); it != m_items.end(); ++it)
+    for (Vector<PopupItem*>::iterator it = m_items.begin(); it != m_items.end(); ++it)
         delete *it;
     m_items.clear();
 }
 
 bool PopupListBox::isPointInBounds(const IntPoint& point)
 {
     return numItems() != 0 && IntRect(0, 0, width(), height()).contains(point);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // PopupMenu implementation
 // 
 // Note: you cannot add methods to this class, since it is defined above the 
 //       portability layer. To access methods and properties on the
 //       popup widgets, use |popupWindow| above. 
 
 PopupMenu::PopupMenu(PopupMenuClient* client) 
     : m_popupClient(client)
 {
 }
 
 PopupMenu::~PopupMenu()
 {
     hide();
 }
 
-void PopupMenu::show(const IntRect& r, FrameView* v, int index) 
+// The Mac Chromium implementation relies on external control (a Cocoa control)
+// to display, handle the input tracking and menu item selection for the popup.
+// Windows and Linux Chromium let our WebKit port handle the display, while
+// another process manages the popup window and input handling.
+void PopupMenu::show(const IntRect& r, FrameView* v, int index)
 {
     if (!p.popup)
         p.popup = PopupContainer::create(client(), dropDownSettings);
+#if PLATFORM(DARWIN)
+    p.popup->showExternal(r, v, index);
+#else
     p.popup->show(r, v, index);
+#endif
 }
 
 void PopupMenu::hide()
 {
     if (p.popup)
         p.popup->hidePopup();
 }
 
 void PopupMenu::updateFromElement()
 {
     p.popup->listBox()->updateFromElement();
 }
 
 bool PopupMenu::itemWritingDirectionIsNatural() 
 { 
     return false; 
 }
 
 } // namespace WebCore