Source/WebCore/platform/chromium/PopupMenuChromium.cpp

   1 /*
   2  * Copyright (c) 2008, 2009, Google Inc. All rights reserved.
   3  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met:
   8  *
   9  *     * Redistributions of source code must retain the above copyright
  10  * notice, this list of conditions and the following disclaimer.
  11  *     * Redistributions in binary form must reproduce the above
  12  * copyright notice, this list of conditions and the following disclaimer
  13  * in the documentation and/or other materials provided with the
  14  * distribution.
  15  *     * Neither the name of Google Inc. nor the names of its
  16  * contributors may be used to endorse or promote products derived from
  17  * this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include "config.h"
  33 #include "PopupMenuChromium.h"
  34
  35 #include "Chrome.h"
  36 #include "ChromeClientChromium.h"
  37 #include "Font.h"
  38 #include "FontSelector.h"
  39 #include "FrameView.h"
  40 #include "Frame.h"
  41 #include "FramelessScrollView.h"
  42 #include "FramelessScrollViewClient.h"
  43 #include "GraphicsContext.h"
  44 #include "IntRect.h"
  45 #include "KeyboardCodes.h"
  46 #include "Page.h"
  47 #include "PlatformKeyboardEvent.h"
  48 #include "PlatformMouseEvent.h"
  49 #include "PlatformScreen.h"
  50 #include "PlatformWheelEvent.h"
  51 #include "PopupMenuClient.h"
  52 #include "RenderTheme.h"
  53 #include "ScrollbarTheme.h"
  54 #include "StringTruncator.h"
  55 #include "SystemTime.h"
  56 #include "TextRun.h"
  57 #include "UserGestureIndicator.h"
  58 #include <wtf/CurrentTime.h>
  59 #include <wtf/unicode/CharacterNames.h>
  60
  61 using namespace WTF;
  62 using namespace Unicode;
  63
  64 using std::min;
  65 using std::max;
  66
  67 namespace WebCore {
  68
  69 typedef unsigned long long TimeStamp;
  70
  71 static const int kMaxVisibleRows = 20;
  72 static const int kMaxHeight = 500;
  73 static const int kBorderSize = 1;
  74 static const int kTextToLabelPadding = 10;
  75 static const int kLabelToIconPadding = 5;
  76 static const int kMinEndOfLinePadding = 2;
  77 static const TimeStamp kTypeAheadTimeoutMs = 1000;
  78
  79 // The settings used for the drop down menu.
  80 // This is the delegate used if none is provided.
  81 static const PopupContainerSettings dropDownSettings = {
  82     true, // setTextOnIndexChange
  83     true, // acceptOnAbandon
  84     false, // loopSelectionNavigation
  85     false // restrictWidthOfListBox
  86 };
  87
  88 // This class uses WebCore code to paint and handle events for a drop-down list
  89 // box ("combobox" on Windows).
  90 class PopupListBox : public FramelessScrollView {
  91 public:
  92     static PassRefPtr<PopupListBox> create(PopupMenuClient* client, const PopupContainerSettings& settings)
  93     {
  94         return adoptRef(new PopupListBox(client, settings));
  95     }
  96
  97     // FramelessScrollView
  98     virtual void paint(GraphicsContext*, const IntRect&);
  99     virtual bool handleMouseDownEvent(const PlatformMouseEvent&);
 100     virtual bool handleMouseMoveEvent(const PlatformMouseEvent&);
 101     virtual bool handleMouseReleaseEvent(const PlatformMouseEvent&);
 102     virtual bool handleWheelEvent(const PlatformWheelEvent&);
 103     virtual bool handleKeyEvent(const PlatformKeyboardEvent&);
 104
 105     // ScrollView
 106     virtual HostWindow* hostWindow() const;
 107
 108     // PopupListBox methods
 109
 110     // Hides the popup.
 111     void hidePopup();
 112
 113     // Updates our internal list to match the client.
 114     void updateFromElement();
 115
 116     // Frees any allocated resources used in a particular popup session.
 117     void clear();
 118
 119     // Sets the index of the option that is displayed in the <select> widget in the page
 120     void setOriginalIndex(int index);
 121
 122     // Gets the index of the item that the user is currently moused over or has selected with
 123     // the keyboard. This is not the same as the original index, since the user has not yet
 124     // accepted this input.
 125     int selectedIndex() const { return m_selectedIndex; }
 126
 127     // Moves selection down/up the given number of items, scrolling if necessary.
 128     // Positive is down.  The resulting index will be clamped to the range
 129     // [0, numItems), and non-option items will be skipped.
 130     void adjustSelectedIndex(int delta);
 131
 132     // Returns the number of items in the list.
 133     int numItems() const { return static_cast<int>(m_items.size()); }
 134
 135     void setBaseWidth(int width) { m_baseWidth = width; }
 136
 137     // Computes the size of widget and children.
 138     void layout();
 139
 140     // Returns whether the popup wants to process events for the passed key.
 141     bool isInterestedInEventForKey(int keyCode);
 142
 143     // Gets the height of a row.
 144     int getRowHeight(int index);
 145
 146     void setMaxHeight(int maxHeight) { m_maxHeight = maxHeight; }
 147
 148     void disconnectClient() { m_popupClient = 0; }
 149
 150     const Vector<PopupItem*>& items() const { return m_items; }
 151
 152 private:
 153     friend class PopupContainer;
 154     friend class RefCounted<PopupListBox>;
 155
 156     PopupListBox(PopupMenuClient* client, const PopupContainerSettings& settings)
 157         : m_settings(settings)
 158         , m_originalIndex(0)
 159         , m_selectedIndex(0)
 160         , m_acceptedIndexOnAbandon(-1)
 161         , m_visibleRows(0)
 162         , m_baseWidth(0)
 163         , m_maxHeight(kMaxHeight)
 164         , m_popupClient(client)
 165         , m_repeatingChar(0)
 166         , m_lastCharTime(0)
 167     {
 168         setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff);
 169     }
 170
 171     ~PopupListBox()
 172     {
 173         clear();
 174     }
 175
 176     // Closes the popup
 177     void abandon();
 178
 179     // Returns true if the selection can be changed to index.
 180     // Disabled items, or labels cannot be selected.
 181     bool isSelectableItem(int index);
 182
 183     // Select an index in the list, scrolling if necessary.
 184     void selectIndex(int index);
 185
 186     // Accepts the selected index as the value to be displayed in the <select> widget on
 187     // the web page, and closes the popup.
 188     void acceptIndex(int index);
 189
 190     // Clears the selection (so no row appears selected).
 191     void clearSelection();
 192
 193     // Scrolls to reveal the given index.
 194     void scrollToRevealRow(int index);
 195     void scrollToRevealSelection() { scrollToRevealRow(m_selectedIndex); }
 196
 197     // Invalidates the row at the given index.
 198     void invalidateRow(int index);
 199
 200     // Get the bounds of a row.
 201     IntRect getRowBounds(int index);
 202
 203     // Converts a point to an index of the row the point is over
 204     int pointToRowIndex(const IntPoint&);
 205
 206     // Paint an individual row
 207     void paintRow(GraphicsContext*, const IntRect&, int rowIndex);
 208
 209     // Test if the given point is within the bounds of the popup window.
 210     bool isPointInBounds(const IntPoint&);
 211
 212     // Called when the user presses a text key.  Does a prefix-search of the items.
 213     void typeAheadFind(const PlatformKeyboardEvent&);
 214
 215     // Returns the font to use for the given row
 216     Font getRowFont(int index);
 217
 218     // Moves the selection down/up one item, taking care of looping back to the
 219     // first/last element if m_loopSelectionNavigation is true.
 220     void selectPreviousRow();
 221     void selectNextRow();
 222
 223     // The settings that specify the behavior for this Popup window.
 224     PopupContainerSettings m_settings;
 225
 226     // This is the index of the item marked as "selected" - i.e. displayed in the widget on the
 227     // page.
 228     int m_originalIndex;
 229
 230     // This is the index of the item that the user is hovered over or has selected using the
 231     // keyboard in the list. They have not confirmed this selection by clicking or pressing
 232     // enter yet however.
 233     int m_selectedIndex;
 234
 235     // If >= 0, this is the index we should accept if the popup is "abandoned".
 236     // This is used for keyboard navigation, where we want the
 237     // selection to change immediately, and is only used if the settings
 238     // acceptOnAbandon field is true.
 239     int m_acceptedIndexOnAbandon;
 240
 241     // This is the number of rows visible in the popup. The maximum number visible at a time is
 242     // defined as being kMaxVisibleRows. For a scrolled popup, this can be thought of as the
 243     // page size in data units.
 244     int m_visibleRows;
 245
 246     // Our suggested width, not including scrollbar.
 247     int m_baseWidth;
 248
 249     // The maximum height we can be without being off-screen.
 250     int m_maxHeight;
 251
 252     // A list of the options contained within the <select>
 253     Vector<PopupItem*> m_items;
 254
 255     // The <select> PopupMenuClient that opened us.
 256     PopupMenuClient* m_popupClient;
 257
 258     // The scrollbar which has mouse capture.  Mouse events go straight to this
 259     // if non-NULL.
 260     RefPtr<Scrollbar> m_capturingScrollbar;
 261
 262     // The last scrollbar that the mouse was over.  Used for mouseover highlights.
 263     RefPtr<Scrollbar> m_lastScrollbarUnderMouse;
 264
 265     // The string the user has typed so far into the popup. Used for typeAheadFind.
 266     String m_typedString;
 267
 268     // The char the user has hit repeatedly.  Used for typeAheadFind.
 269     UChar m_repeatingChar;
 270
 271     // The last time the user hit a key.  Used for typeAheadFind.
 272     TimeStamp m_lastCharTime;
 273 };
 274
 275 static PlatformMouseEvent constructRelativeMouseEvent(const PlatformMouseEvent& e,
 276                                                       FramelessScrollView* parent,
 277                                                       FramelessScrollView* child)
 278 {
 279     IntPoint pos = parent->convertSelfToChild(child, e.pos());
 280
 281     // FIXME: This is a horrible hack since PlatformMouseEvent has no setters for x/y.
 282     PlatformMouseEvent relativeEvent = e;
 283     IntPoint& relativePos = const_cast<IntPoint&>(relativeEvent.pos());
 284     relativePos.setX(pos.x());
 285     relativePos.setY(pos.y());
 286     return relativeEvent;
 287 }
 288
 289 static PlatformWheelEvent constructRelativeWheelEvent(const PlatformWheelEvent& e,
 290                                                       FramelessScrollView* parent,
 291                                                       FramelessScrollView* child)
 292 {
 293     IntPoint pos = parent->convertSelfToChild(child, e.pos());
 294
 295     // FIXME: This is a horrible hack since PlatformWheelEvent has no setters for x/y.
 296     PlatformWheelEvent relativeEvent = e;
 297     IntPoint& relativePos = const_cast<IntPoint&>(relativeEvent.pos());
 298     relativePos.setX(pos.x());
 299     relativePos.setY(pos.y());
 300     return relativeEvent;
 301 }
 302
 303 ///////////////////////////////////////////////////////////////////////////////
 304 // PopupContainer implementation
 305
 306 // static
 307 PassRefPtr<PopupContainer> PopupContainer::create(PopupMenuClient* client,
 308                                                   PopupType popupType,
 309                                                   const PopupContainerSettings& settings)
 310 {
 311     return adoptRef(new PopupContainer(client, popupType, settings));
 312 }
 313
 314 PopupContainer::PopupContainer(PopupMenuClient* client,
 315                                PopupType popupType,
 316                                const PopupContainerSettings& settings)
 317     : m_listBox(PopupListBox::create(client, settings))
 318     , m_settings(settings)
 319     , m_popupType(popupType)
 320     , m_popupOpen(false)
 321 {
 322     setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff);
 323 }
 324
 325 PopupContainer::~PopupContainer()
 326 {
 327     if (m_listBox && m_listBox->parent())
 328         removeChild(m_listBox.get());
 329 }
 330
 331 IntRect PopupContainer::layoutAndCalculateWidgetRect(int targetControlHeight, const IntPoint& popupInitialCoordinate)
 332 {
 333     // Reset the max height to its default value, it will be recomputed below
 334     // if necessary.
 335     m_listBox->setMaxHeight(kMaxHeight);
 336
 337     // Lay everything out to figure out our preferred size, then tell the view's
 338     // WidgetClient about it.  It should assign us a client.
 339     int rightOffset = layoutAndGetRightOffset();
 340
 341     // Assume m_listBox size is already calculated.
 342     IntSize targetSize(m_listBox->width() + kBorderSize * 2,
 343                        m_listBox->height() + kBorderSize * 2);
 344
 345     IntRect widgetRect;
 346     ChromeClientChromium* chromeClient = chromeClientChromium();
 347     if (chromeClient) {
 348         // If the popup would extend past the bottom of the screen, open upwards
 349         // instead.
 350         FloatRect screen = screenAvailableRect(m_frameView.get());
 351         // Use popupInitialCoordinate.x() + rightOffset because RTL position
 352         // needs to be considered.
 353         widgetRect = chromeClient->windowToScreen(IntRect(popupInitialCoordinate.x() + rightOffset, popupInitialCoordinate.y(), targetSize.width(), targetSize.height()));
 354
 355         // If we have multiple screens and the browser rect is in one screen, we have
 356         // to clip the window width to the screen width.
 357         FloatRect windowRect = chromeClient->windowRect();
 358         if (windowRect.x() >= screen.x() && windowRect.maxX() <= screen.maxX()) {
 359             if (m_listBox->m_popupClient->menuStyle().textDirection() == RTL && widgetRect.x() < screen.x()) {
 360                 widgetRect.setWidth(widgetRect.maxX() - screen.x());
 361                 widgetRect.setX(screen.x());
 362             } else if (widgetRect.maxX() > screen.maxX())
 363                 widgetRect.setWidth(screen.maxX() - widgetRect.x());
 364         }
 365
 366         // Calculate Y axis size.
 367         if (widgetRect.maxY() > static_cast<int>(screen.maxY())) {
 368             if (widgetRect.y() - widgetRect.height() - targetControlHeight > 0) {
 369                 // There is enough room to open upwards.
 370                 widgetRect.move(0, -(widgetRect.height() + targetControlHeight));
 371             } else {
 372                 // Figure whether upwards or downwards has more room and set the
 373                 // maximum number of items.
 374                 int spaceAbove = widgetRect.y() - targetControlHeight;
 375                 int spaceBelow = screen.maxY() - widgetRect.y();
 376                 if (spaceAbove > spaceBelow)
 377                     m_listBox->setMaxHeight(spaceAbove);
 378                 else
 379                     m_listBox->setMaxHeight(spaceBelow);
 380                 layoutAndGetRightOffset();
 381                 // Our height has changed, so recompute only Y axis of widgetRect.
 382                 // We don't have to recompute X axis, so we only replace Y axis
 383                 // in widgetRect.
 384                 IntRect frameInScreen = chromeClient->windowToScreen(frameRect());
 385                 widgetRect.setY(frameInScreen.y());
 386                 widgetRect.setHeight(frameInScreen.height());
 387                 // And move upwards if necessary.
 388                 if (spaceAbove > spaceBelow)
 389                     widgetRect.move(0, -(widgetRect.height() + targetControlHeight));
 390             }
 391         }
 392     }
 393     return widgetRect;
 394 }
 395
 396 void PopupContainer::showPopup(FrameView* view)
 397 {
 398     m_frameView = view;
 399
 400     ChromeClientChromium* chromeClient = chromeClientChromium();
 401     if (chromeClient) {
 402         IntRect popupRect = frameRect();
 403         chromeClient->popupOpened(this, layoutAndCalculateWidgetRect(popupRect.height(), popupRect.location()), false);
 404         m_popupOpen = true;
 405     }
 406
 407     if (!m_listBox->parent())
 408         addChild(m_listBox.get());
 409
 410     // Enable scrollbars after the listbox is inserted into the hierarchy,
 411     // so it has a proper WidgetClient.
 412     m_listBox->setVerticalScrollbarMode(ScrollbarAuto);
 413
 414     m_listBox->scrollToRevealSelection();
 415
 416     invalidate();
 417 }
 418
 419 void PopupContainer::hidePopup()
 420 {
 421     listBox()->hidePopup();
 422 }
 423
 424 void PopupContainer::notifyPopupHidden()
 425 {
 426     if (!m_popupOpen)
 427         return;
 428     m_popupOpen = false;
 429     chromeClientChromium()->popupClosed(this);
 430 }
 431
 432 int PopupContainer::layoutAndGetRightOffset()
 433 {
 434     m_listBox->layout();
 435
 436     // Place the listbox within our border.
 437     m_listBox->move(kBorderSize, kBorderSize);
 438
 439     // popupWidth is the width of <select> element. Record it before resize frame.
 440     int popupWidth = frameRect().width();
 441     // Size ourselves to contain listbox + border.
 442     int listBoxWidth = m_listBox->width() + kBorderSize * 2;
 443     resize(listBoxWidth, m_listBox->height() + kBorderSize * 2);
 444
 445     // Adjust the starting x-axis for RTL dropdown. For RTL dropdown, the right edge
 446     // of dropdown box should be aligned with the right edge of <select> element box,
 447     // and the dropdown box should be expanded to left if more space needed.
 448     PopupMenuClient* popupClient = m_listBox->m_popupClient;
 449     int rightOffset = 0;
 450     if (popupClient) {
 451         bool rightAligned = m_listBox->m_popupClient->menuStyle().textDirection() == RTL;
 452         if (rightAligned)
 453             rightOffset = popupWidth - listBoxWidth;
 454     }
 455     invalidate();
 456
 457     return rightOffset;
 458 }
 459
 460 bool PopupContainer::handleMouseDownEvent(const PlatformMouseEvent& event)
 461 {
 462     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
 463     return m_listBox->handleMouseDownEvent(
 464         constructRelativeMouseEvent(event, this, m_listBox.get()));
 465 }
 466
 467 bool PopupContainer::handleMouseMoveEvent(const PlatformMouseEvent& event)
 468 {
 469     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
 470     return m_listBox->handleMouseMoveEvent(
 471         constructRelativeMouseEvent(event, this, m_listBox.get()));
 472 }
 473
 474 bool PopupContainer::handleMouseReleaseEvent(const PlatformMouseEvent& event)
 475 {
 476     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
 477     return m_listBox->handleMouseReleaseEvent(
 478         constructRelativeMouseEvent(event, this, m_listBox.get()));
 479 }
 480
 481 bool PopupContainer::handleWheelEvent(const PlatformWheelEvent& event)
 482 {
 483     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
 484     return m_listBox->handleWheelEvent(
 485         constructRelativeWheelEvent(event, this, m_listBox.get()));
 486 }
 487
 488 bool PopupContainer::handleKeyEvent(const PlatformKeyboardEvent& event)
 489 {
 490     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
 491     return m_listBox->handleKeyEvent(event);
 492 }
 493
 494 void PopupContainer::hide()
 495 {
 496     m_listBox->abandon();
 497 }
 498
 499 void PopupContainer::paint(GraphicsContext* gc, const IntRect& rect)
 500 {
 501     // adjust coords for scrolled frame
 502     IntRect r = intersection(rect, frameRect());
 503     int tx = x();
 504     int ty = y();
 505
 506     r.move(-tx, -ty);
 507
 508     gc->translate(static_cast<float>(tx), static_cast<float>(ty));
 509     m_listBox->paint(gc, r);
 510     gc->translate(-static_cast<float>(tx), -static_cast<float>(ty));
 511
 512     paintBorder(gc, rect);
 513 }
 514
 515 void PopupContainer::paintBorder(GraphicsContext* gc, const IntRect& rect)
 516 {
 517     // FIXME: Where do we get the border color from?
 518     Color borderColor(127, 157, 185);
 519
 520     gc->setStrokeStyle(NoStroke);
 521     gc->setFillColor(borderColor, ColorSpaceDeviceRGB);
 522
 523     int tx = x();
 524     int ty = y();
 525
 526     // top, left, bottom, right
 527     gc->drawRect(IntRect(tx, ty, width(), kBorderSize));
 528     gc->drawRect(IntRect(tx, ty, kBorderSize, height()));
 529     gc->drawRect(IntRect(tx, ty + height() - kBorderSize, width(), kBorderSize));
 530     gc->drawRect(IntRect(tx + width() - kBorderSize, ty, kBorderSize, height()));
 531 }
 532
 533 bool PopupContainer::isInterestedInEventForKey(int keyCode)
 534 {
 535     return m_listBox->isInterestedInEventForKey(keyCode);
 536 }
 537
 538 ChromeClientChromium* PopupContainer::chromeClientChromium()
 539 {
 540     return static_cast<ChromeClientChromium*>(m_frameView->frame()->page()->chrome()->client());
 541 }
 542
 543 void PopupContainer::showInRect(const IntRect& r, FrameView* v, int index)
 544 {
 545     // The rect is the size of the select box. It's usually larger than we need.
 546     // subtract border size so that usually the container will be displayed
 547     // exactly the same width as the select box.
 548     listBox()->setBaseWidth(max(r.width() - kBorderSize * 2, 0));
 549
 550     listBox()->updateFromElement();
 551
 552     // We set the selected item in updateFromElement(), and disregard the
 553     // index passed into this function (same as Webkit's PopupMenuWin.cpp)
 554     // FIXME: make sure this is correct, and add an assertion.
 555     // ASSERT(popupWindow(popup)->listBox()->selectedIndex() == index);
 556
 557     // Convert point to main window coords.
 558     IntPoint location = v->contentsToWindow(r.location());
 559
 560     // Move it below the select widget.
 561     location.move(0, r.height());
 562
 563     setFrameRect(IntRect(location, r.size()));
 564     showPopup(v);
 565 }
 566
 567 void PopupContainer::refresh(const IntRect& targetControlRect)
 568 {
 569     IntPoint location = m_frameView->contentsToWindow(targetControlRect.location());
 570     // Move it below the select widget.
 571     location.move(0, targetControlRect.height());
 572
 573     listBox()->updateFromElement();
 574     // Store the original size to check if we need to request the location.
 575     IntSize originalSize = size();
 576     IntRect widgetRect = layoutAndCalculateWidgetRect(targetControlRect.height(), location);
 577     if (originalSize != widgetRect.size())
 578         setFrameRect(widgetRect);
 579
 580     invalidate();
 581 }
 582
 583 int PopupContainer::selectedIndex() const
 584 {
 585     return m_listBox->selectedIndex();
 586 }
 587
 588 int PopupContainer::menuItemHeight() const
 589 {
 590     return m_listBox->getRowHeight(0);
 591 }
 592
 593 int PopupContainer::menuItemFontSize() const
 594 {
 595     return m_listBox->getRowFont(0).size();
 596 }
 597
 598 PopupMenuStyle PopupContainer::menuStyle() const
 599 {
 600     return m_listBox->m_popupClient->menuStyle();
 601 }
 602
 603 const WTF::Vector<PopupItem*>& PopupContainer:: popupData() const
 604 {
 605     return m_listBox->items();
 606 }
 607
 608 ///////////////////////////////////////////////////////////////////////////////
 609 // PopupListBox implementation
 610
 611 bool PopupListBox::handleMouseDownEvent(const PlatformMouseEvent& event)
 612 {
 613     Scrollbar* scrollbar = scrollbarAtPoint(event.pos());
 614     if (scrollbar) {
 615         m_capturingScrollbar = scrollbar;
 616         m_capturingScrollbar->mouseDown(event);
 617         return true;
 618     }
 619
 620     if (!isPointInBounds(event.pos()))
 621         abandon();
 622
 623     return true;
 624 }
 625
 626 bool PopupListBox::handleMouseMoveEvent(const PlatformMouseEvent& event)
 627 {
 628     if (m_capturingScrollbar) {
 629         m_capturingScrollbar->mouseMoved(event);
 630         return true;
 631     }
 632
 633     Scrollbar* scrollbar = scrollbarAtPoint(event.pos());
 634     if (m_lastScrollbarUnderMouse != scrollbar) {
 635         // Send mouse exited to the old scrollbar.
 636         if (m_lastScrollbarUnderMouse)
 637             m_lastScrollbarUnderMouse->mouseExited();
 638         m_lastScrollbarUnderMouse = scrollbar;
 639     }
 640
 641     if (scrollbar) {
 642         scrollbar->mouseMoved(event);
 643         return true;
 644     }
 645
 646     if (!isPointInBounds(event.pos()))
 647         return false;
 648
 649     selectIndex(pointToRowIndex(event.pos()));
 650     return true;
 651 }
 652
 653 bool PopupListBox::handleMouseReleaseEvent(const PlatformMouseEvent& event)
 654 {
 655     if (m_capturingScrollbar) {
 656         m_capturingScrollbar->mouseUp();
 657         m_capturingScrollbar = 0;
 658         return true;
 659     }
 660
 661     if (!isPointInBounds(event.pos()))
 662         return true;
 663
 664     acceptIndex(pointToRowIndex(event.pos()));
 665     return true;
 666 }
 667
 668 bool PopupListBox::handleWheelEvent(const PlatformWheelEvent& event)
 669 {
 670     if (!isPointInBounds(event.pos())) {
 671         abandon();
 672         return true;
 673     }
 674
 675     // Pass it off to the scroll view.
 676     // Sadly, WebCore devs don't understand the whole "const" thing.
 677     wheelEvent(const_cast<PlatformWheelEvent&>(event));
 678     return true;
 679 }
 680
 681 // Should be kept in sync with handleKeyEvent().
 682 bool PopupListBox::isInterestedInEventForKey(int keyCode)
 683 {
 684     switch (keyCode) {
 685     case VKEY_ESCAPE:
 686     case VKEY_RETURN:
 687     case VKEY_UP:
 688     case VKEY_DOWN:
 689     case VKEY_PRIOR:
 690     case VKEY_NEXT:
 691     case VKEY_HOME:
 692     case VKEY_END:
 693     case VKEY_TAB:
 694         return true;
 695     default:
 696         return false;
 697     }
 698 }
 699
 700 static bool isCharacterTypeEvent(const PlatformKeyboardEvent& event)
 701 {
 702     // Check whether the event is a character-typed event or not.
 703     // We use RawKeyDown/Char/KeyUp event scheme on all platforms,
 704     // so PlatformKeyboardEvent::Char (not RawKeyDown) type event
 705     // is considered as character type event.
 706     return event.type() == PlatformKeyboardEvent::Char;
 707 }
 708
 709 bool PopupListBox::handleKeyEvent(const PlatformKeyboardEvent& event)
 710 {
 711     if (event.type() == PlatformKeyboardEvent::KeyUp)
 712         return true;
 713
 714     if (numItems() == 0 && event.windowsVirtualKeyCode() != VKEY_ESCAPE)
 715         return true;
 716
 717     switch (event.windowsVirtualKeyCode()) {
 718     case VKEY_ESCAPE:
 719         abandon();  // may delete this
 720         return true;
 721     case VKEY_RETURN:
 722         if (m_selectedIndex == -1)  {
 723             hidePopup();
 724             // Don't eat the enter if nothing is selected.
 725             return false;
 726         }
 727         acceptIndex(m_selectedIndex);  // may delete this
 728         return true;
 729     case VKEY_UP:
 730         selectPreviousRow();
 731         break;
 732     case VKEY_DOWN:
 733         selectNextRow();
 734         break;
 735     case VKEY_PRIOR:
 736         adjustSelectedIndex(-m_visibleRows);
 737         break;
 738     case VKEY_NEXT:
 739         adjustSelectedIndex(m_visibleRows);
 740         break;
 741     case VKEY_HOME:
 742         adjustSelectedIndex(-m_selectedIndex);
 743         break;
 744     case VKEY_END:
 745         adjustSelectedIndex(m_items.size());
 746         break;
 747     default:
 748         if (!event.ctrlKey() && !event.altKey() && !event.metaKey()
 749             && isPrintableChar(event.windowsVirtualKeyCode())
 750             && isCharacterTypeEvent(event))
 751             typeAheadFind(event);
 752         break;
 753     }
 754
 755     if (m_originalIndex != m_selectedIndex) {
 756         // Keyboard events should update the selection immediately (but we don't
 757         // want to fire the onchange event until the popup is closed, to match
 758         // IE).  We change the original index so we revert to that when the
 759         // popup is closed.
 760         if (m_settings.acceptOnAbandon)
 761             m_acceptedIndexOnAbandon = m_selectedIndex;
 762
 763         setOriginalIndex(m_selectedIndex);
 764         if (m_settings.setTextOnIndexChange)
 765             m_popupClient->setTextFromItem(m_selectedIndex);
 766     }
 767     if (event.windowsVirtualKeyCode() == VKEY_TAB) {
 768         // TAB is a special case as it should select the current item if any and
 769         // advance focus.
 770         if (m_selectedIndex >= 0) {
 771             acceptIndex(m_selectedIndex); // May delete us.
 772             // Return false so the TAB key event is propagated to the page.
 773             return false;
 774         }
 775         // Call abandon() so we honor m_acceptedIndexOnAbandon if set.
 776         abandon();
 777         // Return false so the TAB key event is propagated to the page.
 778         return false;
 779     }
 780
 781     return true;
 782 }
 783
 784 HostWindow* PopupListBox::hostWindow() const
 785 {
 786     // Our parent is the root ScrollView, so it is the one that has a
 787     // HostWindow.  FrameView::hostWindow() works similarly.
 788     return parent() ? parent()->hostWindow() : 0;
 789 }
 790
 791 // From HTMLSelectElement.cpp
 792 static String stripLeadingWhiteSpace(const String& string)
 793 {
 794     int length = string.length();
 795     int i;
 796     for (i = 0; i < length; ++i)
 797         if (string[i] != noBreakSpace
 798             && (string[i] <= 0x7F ? !isspace(string[i]) : (direction(string[i]) != WhiteSpaceNeutral)))
 799             break;
 800
 801     return string.substring(i, length - i);
 802 }
 803
 804 // From HTMLSelectElement.cpp, with modifications
 805 void PopupListBox::typeAheadFind(const PlatformKeyboardEvent& event)
 806 {
 807     TimeStamp now = static_cast<TimeStamp>(currentTime() * 1000.0f);
 808     TimeStamp delta = now - m_lastCharTime;
 809
 810     // Reset the time when user types in a character. The time gap between
 811     // last character and the current character is used to indicate whether
 812     // user typed in a string or just a character as the search prefix.
 813     m_lastCharTime = now;
 814
 815     UChar c = event.windowsVirtualKeyCode();
 816
 817     String prefix;
 818     int searchStartOffset = 1;
 819     if (delta > kTypeAheadTimeoutMs) {
 820         m_typedString = prefix = String(&c, 1);
 821         m_repeatingChar = c;
 822     } else {
 823         m_typedString.append(c);
 824
 825         if (c == m_repeatingChar)
 826             // The user is likely trying to cycle through all the items starting with this character, so just search on the character
 827             prefix = String(&c, 1);
 828         else {
 829             m_repeatingChar = 0;
 830             prefix = m_typedString;
 831             searchStartOffset = 0;
 832         }
 833     }
 834
 835     // Compute a case-folded copy of the prefix string before beginning the search for
 836     // a matching element. This code uses foldCase to work around the fact that
 837     // String::startWith does not fold non-ASCII characters. This code can be changed
 838     // to use startWith once that is fixed.
 839     String prefixWithCaseFolded(prefix.foldCase());
 840     int itemCount = numItems();
 841     int index = (max(0, m_selectedIndex) + searchStartOffset) % itemCount;
 842     for (int i = 0; i < itemCount; i++, index = (index + 1) % itemCount) {
 843         if (!isSelectableItem(index))
 844             continue;
 845
 846         if (stripLeadingWhiteSpace(m_items[index]->label).foldCase().startsWith(prefixWithCaseFolded)) {
 847             selectIndex(index);
 848             return;
 849         }
 850     }
 851 }
 852
 853 void PopupListBox::paint(GraphicsContext* gc, const IntRect& rect)
 854 {
 855     // adjust coords for scrolled frame
 856     IntRect r = intersection(rect, frameRect());
 857     int tx = x() - scrollX();
 858     int ty = y() - scrollY();
 859
 860     r.move(-tx, -ty);
 861
 862     // set clip rect to match revised damage rect
 863     gc->save();
 864     gc->translate(static_cast<float>(tx), static_cast<float>(ty));
 865     gc->clip(r);
 866
 867     // FIXME: Can we optimize scrolling to not require repainting the entire
 868     // window?  Should we?
 869     for (int i = 0; i < numItems(); ++i)
 870         paintRow(gc, r, i);
 871
 872     // Special case for an empty popup.
 873     if (numItems() == 0)
 874         gc->fillRect(r, Color::white, ColorSpaceDeviceRGB);
 875
 876     gc->restore();
 877
 878     ScrollView::paint(gc, rect);
 879 }
 880
 881 static const int separatorPadding = 4;
 882 static const int separatorHeight = 1;
 883
 884 void PopupListBox::paintRow(GraphicsContext* gc, const IntRect& rect, int rowIndex)
 885 {
 886     // This code is based largely on RenderListBox::paint* methods.
 887
 888     IntRect rowRect = getRowBounds(rowIndex);
 889     if (!rowRect.intersects(rect))
 890         return;
 891
 892     PopupMenuStyle style = m_popupClient->itemStyle(rowIndex);
 893
 894     // Paint background
 895     Color backColor, textColor, labelColor;
 896     if (rowIndex == m_selectedIndex) {
 897         backColor = RenderTheme::defaultTheme()->activeListBoxSelectionBackgroundColor();
 898         textColor = RenderTheme::defaultTheme()->activeListBoxSelectionForegroundColor();
 899         labelColor = textColor;
 900     } else {
 901         backColor = style.backgroundColor();
 902         textColor = style.foregroundColor();
 903         // FIXME: for now the label color is hard-coded. It should be added to
 904         // the PopupMenuStyle.
 905         labelColor = Color(115, 115, 115);
 906     }
 907
 908     // If we have a transparent background, make sure it has a color to blend
 909     // against.
 910     if (backColor.hasAlpha())
 911         gc->fillRect(rowRect, Color::white, ColorSpaceDeviceRGB);
 912
 913     gc->fillRect(rowRect, backColor, ColorSpaceDeviceRGB);
 914
 915     if (m_popupClient->itemIsSeparator(rowIndex)) {
 916         IntRect separatorRect(
 917             rowRect.x() + separatorPadding,
 918             rowRect.y() + (rowRect.height() - separatorHeight) / 2,
 919             rowRect.width() - 2 * separatorPadding, separatorHeight);
 920         gc->fillRect(separatorRect, textColor, ColorSpaceDeviceRGB);
 921         return;
 922     }
 923
 924     if (!style.isVisible())
 925         return;
 926
 927     gc->setFillColor(textColor, ColorSpaceDeviceRGB);
 928
 929     Font itemFont = getRowFont(rowIndex);
 930     // FIXME: http://crbug.com/19872 We should get the padding of individual option
 931     // elements.  This probably implies changes to PopupMenuClient.
 932     bool rightAligned = m_popupClient->menuStyle().textDirection() == RTL;
 933     int textX = 0;
 934     int maxWidth = 0;
 935     if (rightAligned)
 936         maxWidth = rowRect.width() - max(0, m_popupClient->clientPaddingRight() - m_popupClient->clientInsetRight());
 937     else {
 938         textX = max(0, m_popupClient->clientPaddingLeft() - m_popupClient->clientInsetLeft());
 939         maxWidth = rowRect.width() - textX;
 940     }
 941     // Prepare text to be drawn.
 942     String itemText = m_popupClient->itemText(rowIndex);
 943     String itemLabel = m_popupClient->itemLabel(rowIndex);
 944     String itemIcon = m_popupClient->itemIcon(rowIndex);
 945     if (m_settings.restrictWidthOfListBox) { // Truncate strings to fit in.
 946         // FIXME: We should leftTruncate for the rtl case.
 947         // StringTruncator::leftTruncate would have to be implemented.
 948         String str = StringTruncator::rightTruncate(itemText, maxWidth, itemFont);
 949         if (str != itemText) {
 950             itemText = str;
 951             // Don't display the label or icon, we already don't have enough room for the item text.
 952             itemLabel = "";
 953             itemIcon = "";
 954         } else if (!itemLabel.isEmpty()) {
 955             int availableWidth = maxWidth - kTextToLabelPadding -
 956                 StringTruncator::width(itemText, itemFont);
 957             itemLabel = StringTruncator::rightTruncate(itemLabel, availableWidth, itemFont);
 958         }
 959     }
 960
 961     // Prepare the directionality to draw text.
 962     bool rtl = style.textDirection() == RTL;
 963     TextRun textRun(itemText.characters(), itemText.length(), false, 0, 0, TextRun::AllowTrailingExpansion, rtl, style.hasTextDirectionOverride());
 964     // If the text is right-to-left, make it right-aligned by adjusting its
 965     // beginning position.
 966     if (rightAligned)
 967         textX += maxWidth - itemFont.width(textRun);
 968
 969     // Draw the item text.
 970     int textY = rowRect.y() + itemFont.fontMetrics().ascent() + (rowRect.height() - itemFont.fontMetrics().height()) / 2;
 971     gc->drawBidiText(itemFont, textRun, IntPoint(textX, textY));
 972
 973     // We are using the left padding as the right padding includes room for the scroll-bar which
 974     // does not show in this case.
 975     int rightPadding = max(0, m_popupClient->clientPaddingLeft() - m_popupClient->clientInsetLeft());
 976     int remainingWidth = rowRect.width() - rightPadding;
 977
 978     // Draw the icon if applicable.
 979     RefPtr<Image> image(Image::loadPlatformResource(itemIcon.utf8().data()));
 980     if (image && !image->isNull()) {
 981         IntRect imageRect = image->rect();
 982         remainingWidth -= (imageRect.width() + kLabelToIconPadding);
 983         imageRect.setX(rowRect.width() - rightPadding - imageRect.width());
 984         imageRect.setY(rowRect.y() + (rowRect.height() - imageRect.height()) / 2);
 985         gc->drawImage(image.get(), ColorSpaceDeviceRGB, imageRect);
 986     }
 987
 988     // Draw the the label if applicable.
 989     if (itemLabel.isEmpty())
 990         return;
 991     TextRun labelTextRun(itemLabel.characters(), itemLabel.length(), false, 0, 0, TextRun::AllowTrailingExpansion, rtl, style.hasTextDirectionOverride());
 992     if (rightAligned)
 993         textX = max(0, m_popupClient->clientPaddingLeft() - m_popupClient->clientInsetLeft());
 994     else
 995         textX = remainingWidth - itemFont.width(labelTextRun);
 996
 997     gc->setFillColor(labelColor, ColorSpaceDeviceRGB);
 998     gc->drawBidiText(itemFont, labelTextRun, IntPoint(textX, textY));
 999 }
1000
1001 Font PopupListBox::getRowFont(int rowIndex)
1002 {
1003     Font itemFont = m_popupClient->itemStyle(rowIndex).font();
1004     if (m_popupClient->itemIsLabel(rowIndex)) {
1005         // Bold-ify labels (ie, an <optgroup> heading).
1006         FontDescription d = itemFont.fontDescription();
1007         d.setWeight(FontWeightBold);
1008         Font font(d, itemFont.letterSpacing(), itemFont.wordSpacing());
1009         font.update(0);
1010         return font;
1011     }
1012
1013     return itemFont;
1014 }
1015
1016 void PopupListBox::abandon()
1017 {
1018     RefPtr<PopupListBox> keepAlive(this);
1019
1020     m_selectedIndex = m_originalIndex;
1021
1022     hidePopup();
1023
1024     if (m_acceptedIndexOnAbandon >= 0) {
1025         if (m_popupClient)
1026             m_popupClient->valueChanged(m_acceptedIndexOnAbandon);
1027         m_acceptedIndexOnAbandon = -1;
1028     }
1029 }
1030
1031 int PopupListBox::pointToRowIndex(const IntPoint& point)
1032 {
1033     int y = scrollY() + point.y();
1034
1035     // FIXME: binary search if perf matters.
1036     for (int i = 0; i < numItems(); ++i) {
1037         if (y < m_items[i]->yOffset)
1038             return i-1;
1039     }
1040
1041     // Last item?
1042     if (y < contentsHeight())
1043         return m_items.size()-1;
1044
1045     return -1;
1046 }
1047
1048 void PopupListBox::acceptIndex(int index)
1049 {
1050     // Clear m_acceptedIndexOnAbandon once user accepts the selected index.
1051     if (m_acceptedIndexOnAbandon >= 0)
1052         m_acceptedIndexOnAbandon = -1;
1053
1054     if (index >= numItems())
1055         return;
1056
1057     if (index < 0) {
1058         if (m_popupClient) {
1059             // Enter pressed with no selection, just close the popup.
1060             hidePopup();
1061         }
1062         return;
1063     }
1064
1065     if (isSelectableItem(index)) {
1066         RefPtr<PopupListBox> keepAlive(this);
1067
1068         // Hide ourselves first since valueChanged may have numerous side-effects.
1069         hidePopup();
1070
1071         // Tell the <select> PopupMenuClient what index was selected.
1072         m_popupClient->valueChanged(index);
1073     }
1074 }
1075
1076 void PopupListBox::selectIndex(int index)
1077 {
1078     if (index < 0 || index >= numItems())
1079         return;
1080
1081     bool isSelectable = isSelectableItem(index);
1082     if (index != m_selectedIndex && isSelectable) {
1083         invalidateRow(m_selectedIndex);
1084         m_selectedIndex = index;
1085         invalidateRow(m_selectedIndex);
1086
1087         scrollToRevealSelection();
1088         m_popupClient->selectionChanged(m_selectedIndex);
1089     } else if (!isSelectable) {
1090         clearSelection();
1091     }
1092 }
1093
1094 void PopupListBox::setOriginalIndex(int index)
1095 {
1096     m_originalIndex = m_selectedIndex = index;
1097 }
1098
1099 int PopupListBox::getRowHeight(int index)
1100 {
1101     if (index < 0)
1102         return 0;
1103
1104     if (m_popupClient->itemStyle(index).isDisplayNone())
1105         return 0;
1106
1107     String icon = m_popupClient->itemIcon(index);
1108     RefPtr<Image> image(Image::loadPlatformResource(icon.utf8().data()));
1109
1110     int fontHeight = getRowFont(index).fontMetrics().height();
1111     int iconHeight = (image && !image->isNull()) ? image->rect().height() : 0;
1112
1113     return max(fontHeight, iconHeight);
1114 }
1115
1116 IntRect PopupListBox::getRowBounds(int index)
1117 {
1118     if (index < 0)
1119         return IntRect(0, 0, visibleWidth(), getRowHeight(index));
1120
1121     return IntRect(0, m_items[index]->yOffset, visibleWidth(), getRowHeight(index));
1122 }
1123
1124 void PopupListBox::invalidateRow(int index)
1125 {
1126     if (index < 0)
1127         return;
1128
1129     // Invalidate in the window contents, as FramelessScrollView::invalidateRect
1130     // paints in the window coordinates.
1131     invalidateRect(contentsToWindow(getRowBounds(index)));
1132 }
1133
1134 void PopupListBox::scrollToRevealRow(int index)
1135 {
1136     if (index < 0)
1137         return;
1138
1139     IntRect rowRect = getRowBounds(index);
1140
1141     if (rowRect.y() < scrollY()) {
1142         // Row is above current scroll position, scroll up.
1143         ScrollView::setScrollPosition(IntPoint(0, rowRect.y()));
1144     } else if (rowRect.maxY() > scrollY() + visibleHeight()) {
1145         // Row is below current scroll position, scroll down.
1146         ScrollView::setScrollPosition(IntPoint(0, rowRect.maxY() - visibleHeight()));
1147     }
1148 }
1149
1150 bool PopupListBox::isSelectableItem(int index)
1151 {
1152     ASSERT(index >= 0 && index < numItems());
1153     return m_items[index]->type == PopupItem::TypeOption && m_popupClient->itemIsEnabled(index);
1154 }
1155
1156 void PopupListBox::clearSelection()
1157 {
1158     if (m_selectedIndex != -1) {
1159         invalidateRow(m_selectedIndex);
1160         m_selectedIndex = -1;
1161         m_popupClient->selectionCleared();
1162     }
1163 }
1164
1165 void PopupListBox::selectNextRow()
1166 {
1167     if (!m_settings.loopSelectionNavigation || m_selectedIndex != numItems() - 1) {
1168         adjustSelectedIndex(1);
1169         return;
1170     }
1171
1172     // We are moving past the last item, no row should be selected.
1173     clearSelection();
1174 }
1175
1176 void PopupListBox::selectPreviousRow()
1177 {
1178     if (!m_settings.loopSelectionNavigation || m_selectedIndex > 0) {
1179         adjustSelectedIndex(-1);
1180         return;
1181     }
1182
1183     if (m_selectedIndex == 0) {
1184         // We are moving past the first item, clear the selection.
1185         clearSelection();
1186         return;
1187     }
1188
1189     // No row is selected, jump to the last item.
1190     selectIndex(numItems() - 1);
1191     scrollToRevealSelection();
1192 }
1193
1194 void PopupListBox::adjustSelectedIndex(int delta)
1195 {
1196     int targetIndex = m_selectedIndex + delta;
1197     targetIndex = min(max(targetIndex, 0), numItems() - 1);
1198     if (!isSelectableItem(targetIndex)) {
1199         // We didn't land on an option.  Try to find one.
1200         // We try to select the closest index to target, prioritizing any in
1201         // the range [current, target].
1202
1203         int dir = delta > 0 ? 1 : -1;
1204         int testIndex = m_selectedIndex;
1205         int bestIndex = m_selectedIndex;
1206         bool passedTarget = false;
1207         while (testIndex >= 0 && testIndex < numItems()) {
1208             if (isSelectableItem(testIndex))
1209                 bestIndex = testIndex;
1210             if (testIndex == targetIndex)
1211                 passedTarget = true;
1212             if (passedTarget && bestIndex != m_selectedIndex)
1213                 break;
1214
1215             testIndex += dir;
1216         }
1217
1218         // Pick the best index, which may mean we don't change.
1219         targetIndex = bestIndex;
1220     }
1221
1222     // Select the new index, and ensure its visible.  We do this regardless of
1223     // whether the selection changed to ensure keyboard events always bring the
1224     // selection into view.
1225     selectIndex(targetIndex);
1226     scrollToRevealSelection();
1227 }
1228
1229 void PopupListBox::hidePopup()
1230 {
1231     if (parent()) {
1232         PopupContainer* container = static_cast<PopupContainer*>(parent());
1233         if (container->client())
1234             container->client()->popupClosed(container);
1235         container->notifyPopupHidden();
1236     }
1237
1238     if (m_popupClient)
1239         m_popupClient->popupDidHide();
1240 }
1241
1242 void PopupListBox::updateFromElement()
1243 {
1244     clear();
1245
1246     int size = m_popupClient->listSize();
1247     for (int i = 0; i < size; ++i) {
1248         PopupItem::Type type;
1249         if (m_popupClient->itemIsSeparator(i))
1250             type = PopupItem::TypeSeparator;
1251         else if (m_popupClient->itemIsLabel(i))
1252             type = PopupItem::TypeGroup;
1253         else
1254             type = PopupItem::TypeOption;
1255         m_items.append(new PopupItem(m_popupClient->itemText(i), type));
1256         m_items[i]->enabled = isSelectableItem(i);
1257         PopupMenuStyle style = m_popupClient->itemStyle(i);
1258         m_items[i]->textDirection = style.textDirection();
1259         m_items[i]->hasTextDirectionOverride = style.hasTextDirectionOverride();
1260     }
1261
1262     m_selectedIndex = m_popupClient->selectedIndex();
1263     setOriginalIndex(m_selectedIndex);
1264
1265     layout();
1266 }
1267
1268 void PopupListBox::layout()
1269 {
1270     bool isRightAligned = m_popupClient->menuStyle().textDirection() == RTL;
1271
1272     // Size our child items.
1273     int baseWidth = 0;
1274     int paddingWidth = 0;
1275     int lineEndPaddingWidth = 0;
1276     int y = 0;
1277     for (int i = 0; i < numItems(); ++i) {
1278         // Place the item vertically.
1279         m_items[i]->yOffset = y;
1280         if (m_popupClient->itemStyle(i).isDisplayNone())
1281             continue;
1282         y += getRowHeight(i);
1283
1284         // Ensure the popup is wide enough to fit this item.
1285         Font itemFont = getRowFont(i);
1286         String text = m_popupClient->itemText(i);
1287         String label = m_popupClient->itemLabel(i);
1288         String icon = m_popupClient->itemIcon(i);
1289         RefPtr<Image> iconImage(Image::loadPlatformResource(icon.utf8().data()));
1290         int width = 0;
1291         if (!text.isEmpty())
1292             width = itemFont.width(TextRun(text));
1293         if (!label.isEmpty()) {
1294             if (width > 0)
1295                 width += kTextToLabelPadding;
1296             width += itemFont.width(TextRun(label));
1297         }
1298         if (iconImage && !iconImage->isNull()) {
1299             if (width > 0)
1300                 width += kLabelToIconPadding;
1301             width += iconImage->rect().width();
1302         }
1303
1304         baseWidth = max(baseWidth, width);
1305         // FIXME: http://b/1210481 We should get the padding of individual option elements.
1306         paddingWidth = max(paddingWidth,
1307             m_popupClient->clientPaddingLeft() + m_popupClient->clientPaddingRight());
1308         lineEndPaddingWidth = max(lineEndPaddingWidth,
1309             isRightAligned ? m_popupClient->clientPaddingLeft() : m_popupClient->clientPaddingRight());
1310     }
1311
1312     // Calculate scroll bar width.
1313     int windowHeight = 0;
1314     m_visibleRows = min(numItems(), kMaxVisibleRows);
1315
1316     for (int i = 0; i < m_visibleRows; ++i) {
1317         int rowHeight = getRowHeight(i);
1318
1319         // Only clip the window height for non-Mac platforms.
1320         if (windowHeight + rowHeight > m_maxHeight) {
1321             m_visibleRows = i;
1322             break;
1323         }
1324
1325         windowHeight += rowHeight;
1326     }
1327
1328     // Set our widget and scrollable contents sizes.
1329     int scrollbarWidth = 0;
1330     if (m_visibleRows < numItems()) {
1331         scrollbarWidth = ScrollbarTheme::nativeTheme()->scrollbarThickness();
1332
1333         // Use kMinEndOfLinePadding when there is a scrollbar so that we use
1334         // as much as (lineEndPaddingWidth - kMinEndOfLinePadding) padding
1335         // space for scrollbar and allow user to use CSS padding to make the
1336         // popup listbox align with the select element.
1337         paddingWidth = paddingWidth - lineEndPaddingWidth + kMinEndOfLinePadding;
1338     }
1339
1340     int windowWidth;
1341     int contentWidth;
1342     if (m_settings.restrictWidthOfListBox) {
1343         windowWidth = m_baseWidth;
1344         contentWidth = m_baseWidth - scrollbarWidth;
1345     } else {
1346         windowWidth = baseWidth + scrollbarWidth + paddingWidth;
1347         contentWidth = baseWidth + paddingWidth;
1348
1349         if (windowWidth < m_baseWidth) {
1350             windowWidth = m_baseWidth;
1351             contentWidth = m_baseWidth - scrollbarWidth;
1352         } else
1353             m_baseWidth = baseWidth;
1354     }
1355
1356     resize(windowWidth, windowHeight);
1357     setContentsSize(IntSize(contentWidth, getRowBounds(numItems() - 1).maxY()));
1358
1359     if (hostWindow())
1360         scrollToRevealSelection();
1361
1362     invalidate();
1363 }
1364
1365 void PopupListBox::clear()
1366 {
1367     for (Vector<PopupItem*>::iterator it = m_items.begin(); it != m_items.end(); ++it)
1368         delete *it;
1369     m_items.clear();
1370 }
1371
1372 bool PopupListBox::isPointInBounds(const IntPoint& point)
1373 {
1374     return numItems() != 0 && IntRect(0, 0, width(), height()).contains(point);
1375 }
1376
1377 ///////////////////////////////////////////////////////////////////////////////
1378 // PopupMenuChromium implementation
1379 //
1380 // Note: you cannot add methods to this class, since it is defined above the
1381 //       portability layer. To access methods and properties on the
1382 //       popup widgets, use |popupWindow| above.
1383
1384 PopupMenuChromium::PopupMenuChromium(PopupMenuClient* client)
1385     : m_popupClient(client)
1386 {
1387 }
1388
1389 PopupMenuChromium::~PopupMenuChromium()
1390 {
1391     // When the PopupMenuChromium is destroyed, the client could already have been
1392     // deleted.
1393     if (p.popup)
1394         p.popup->listBox()->disconnectClient();
1395     hide();
1396 }
1397
1398 void PopupMenuChromium::show(const IntRect& r, FrameView* v, int index)
1399 {
1400     if (!p.popup)
1401         p.popup = PopupContainer::create(client(), PopupContainer::Select, dropDownSettings);
1402     p.popup->showInRect(r, v, index);
1403 }
1404
1405 void PopupMenuChromium::hide()
1406 {
1407     if (p.popup)
1408         p.popup->hide();
1409 }
1410
1411 void PopupMenuChromium::updateFromElement()
1412 {
1413     p.popup->listBox()->updateFromElement();
1414 }
1415
1416
1417 void PopupMenuChromium::disconnectClient()
1418 {
1419     m_popupClient = 0;
1420 }
1421
1422 } // namespace WebCore