Replace WTF::move with WTFMove
[WebKit-https.git] / Source / WebCore / platform / win / PopupMenuWin.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2011, 2015 Apple Inc. All rights reserved.
3  * Copyright (C) 2007-2009 Torch Mobile Inc.
4  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #include "config.h"
24 #include "PopupMenuWin.h"
25
26 #include "BString.h"
27 #include "BitmapInfo.h"
28 #include "Document.h"
29 #include "FloatRect.h"
30 #include "Font.h"
31 #include "FontSelector.h"
32 #include "Frame.h"
33 #include "FrameView.h"
34 #include "GraphicsContext.h"
35 #include "HTMLNames.h"
36 #include "HWndDC.h"
37 #include "HostWindow.h"
38 #include "LengthFunctions.h"
39 #include "Page.h"
40 #include "PlatformMouseEvent.h"
41 #include "PlatformScreen.h"
42 #include "RenderMenuList.h"
43 #include "RenderTheme.h"
44 #include "RenderView.h"
45 #include "Scrollbar.h"
46 #include "ScrollbarTheme.h"
47 #include "ScrollbarThemeWin.h"
48 #include "TextRun.h"
49 #include "WebCoreInstanceHandle.h"
50 #include <wtf/WindowsExtras.h>
51
52 #include <windows.h>
53 #include <windowsx.h>
54
55 #define HIGH_BIT_MASK_SHORT 0x8000
56
57 using std::min;
58
59 namespace WebCore {
60
61 using namespace HTMLNames;
62
63 // Default Window animation duration in milliseconds
64 static const int defaultAnimationDuration = 200;
65 // Maximum height of a popup window
66 static const int maxPopupHeight = 320;
67
68 const int optionSpacingMiddle = 1;
69 const int popupWindowBorderWidth = 1;
70
71 static LPCWSTR kPopupWindowClassName = L"PopupWindowClass";
72
73 // This is used from within our custom message pump when we want to send a
74 // message to the web view and not have our message stolen and sent to
75 // the popup window.
76 static const UINT WM_HOST_WINDOW_FIRST = WM_USER;
77 static const UINT WM_HOST_WINDOW_CHAR = WM_USER + WM_CHAR; 
78 static const UINT WM_HOST_WINDOW_MOUSEMOVE = WM_USER + WM_MOUSEMOVE;
79
80 // FIXME: Remove this as soon as practical.
81 static inline bool isASCIIPrintable(unsigned c)
82 {
83     return c >= 0x20 && c <= 0x7E;
84 }
85
86 static void translatePoint(LPARAM& lParam, HWND from, HWND to)
87 {
88     POINT pt;
89     pt.x = (short)GET_X_LPARAM(lParam);
90     pt.y = (short)GET_Y_LPARAM(lParam);    
91     ::MapWindowPoints(from, to, &pt, 1);
92     lParam = MAKELPARAM(pt.x, pt.y);
93 }
94
95 static FloatRect monitorFromHwnd(HWND hwnd)
96 {
97     HMONITOR monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY);
98     MONITORINFOEX monitorInfo;
99     monitorInfo.cbSize = sizeof(MONITORINFOEX);
100     GetMonitorInfo(monitor, &monitorInfo);
101     return monitorInfo.rcWork;
102 }
103
104 PopupMenuWin::PopupMenuWin(PopupMenuClient* client)
105     : m_popupClient(client)
106     , m_scrollbar(0)
107     , m_popup(0)
108     , m_wasClicked(false)
109     , m_itemHeight(0)
110     , m_scrollOffset(0)
111     , m_wheelDelta(0)
112     , m_focusedIndex(0)
113     , m_hoveredIndex(0)
114     , m_scrollbarCapturingMouse(false)
115     , m_showPopup(false)
116 {
117 }
118
119 PopupMenuWin::~PopupMenuWin()
120 {
121     if (m_popup)
122         ::DestroyWindow(m_popup);
123     if (m_scrollbar)
124         m_scrollbar->setParent(0);
125 }
126
127 void PopupMenuWin::disconnectClient()
128 {
129     m_popupClient = 0;
130 }
131
132 LPCWSTR PopupMenuWin::popupClassName()
133 {
134     return kPopupWindowClassName;
135 }
136
137 void PopupMenuWin::show(const IntRect& r, FrameView* view, int index)
138 {
139     calculatePositionAndSize(r, view);
140     if (clientRect().isEmpty())
141         return;
142
143     HWND hostWindow = view->hostWindow()->platformPageClient();
144
145     if (!m_scrollbar && visibleItems() < client()->listSize()) {
146         // We need a scroll bar
147         m_scrollbar = client()->createScrollbar(*this, VerticalScrollbar, SmallScrollbar);
148         m_scrollbar->styleChanged();
149     }
150
151     // We need to reposition the popup window to its final coordinates.
152     // Before calling this, the popup hwnd is currently the size of and at the location of the menu list client so it needs to be updated.
153     ::MoveWindow(m_popup, m_windowRect.x(), m_windowRect.y(), m_windowRect.width(), m_windowRect.height(), false);
154
155     // Determine whether we should animate our popups
156     // Note: Must use 'BOOL' and 'FALSE' instead of 'bool' and 'false' to avoid stack corruption with SystemParametersInfo
157     BOOL shouldAnimate = FALSE;
158
159     if (client()) {
160         int index = client()->selectedIndex();
161         if (index >= 0)
162             setFocusedIndex(index);
163     }
164
165     if (!::SystemParametersInfo(SPI_GETCOMBOBOXANIMATION, 0, &shouldAnimate, 0))
166         shouldAnimate = FALSE;
167
168     if (shouldAnimate) {
169         RECT viewRect = {0};
170         ::GetWindowRect(hostWindow, &viewRect);
171         if (!::IsRectEmpty(&viewRect))
172             ::AnimateWindow(m_popup, defaultAnimationDuration, AW_BLEND);
173     } else
174         ::ShowWindow(m_popup, SW_SHOWNOACTIVATE);
175
176     m_showPopup = true;
177
178     // Protect the popup menu in case its owner is destroyed while we're running the message pump.
179     RefPtr<PopupMenu> protect(this);
180
181     ::SetCapture(hostWindow);
182
183     MSG msg;
184     HWND activeWindow;
185
186     while (::GetMessage(&msg, 0, 0, 0)) {
187         switch (msg.message) {
188             case WM_HOST_WINDOW_MOUSEMOVE:
189             case WM_HOST_WINDOW_CHAR: 
190                 if (msg.hwnd == m_popup) {
191                     // This message should be sent to the host window.
192                     msg.hwnd = hostWindow;
193                     msg.message -= WM_HOST_WINDOW_FIRST;
194                 }
195                 break;
196
197             // Steal mouse messages.
198             case WM_NCMOUSEMOVE:
199             case WM_NCLBUTTONDOWN:
200             case WM_NCLBUTTONUP:
201             case WM_NCLBUTTONDBLCLK:
202             case WM_NCRBUTTONDOWN:
203             case WM_NCRBUTTONUP:
204             case WM_NCRBUTTONDBLCLK:
205             case WM_NCMBUTTONDOWN:
206             case WM_NCMBUTTONUP:
207             case WM_NCMBUTTONDBLCLK:
208             case WM_MOUSEWHEEL:
209                 msg.hwnd = m_popup;
210                 break;
211
212             // These mouse messages use client coordinates so we need to convert them.
213             case WM_MOUSEMOVE:
214             case WM_LBUTTONDOWN:
215             case WM_LBUTTONUP:
216             case WM_LBUTTONDBLCLK:
217             case WM_RBUTTONDOWN:
218             case WM_RBUTTONUP:
219             case WM_RBUTTONDBLCLK:
220             case WM_MBUTTONDOWN:
221             case WM_MBUTTONUP:
222             case WM_MBUTTONDBLCLK: {
223                 // Translate the coordinate.
224                 translatePoint(msg.lParam, msg.hwnd, m_popup);
225
226                 msg.hwnd = m_popup;
227                 break;
228             }
229
230             // Steal all keyboard messages.
231             case WM_KEYDOWN:
232             case WM_KEYUP:
233             case WM_CHAR:
234             case WM_DEADCHAR:
235             case WM_SYSKEYDOWN:
236             case WM_SYSKEYUP:
237             case WM_SYSCHAR:
238             case WM_SYSDEADCHAR:
239                 msg.hwnd = m_popup;
240                 break;
241         }
242
243         ::TranslateMessage(&msg);
244         ::DispatchMessage(&msg);
245
246         if (!m_popupClient)
247             break;
248
249         if (!m_showPopup)
250             break;
251         activeWindow = ::GetActiveWindow();
252         if (activeWindow != hostWindow && !::IsChild(activeWindow, hostWindow))
253             break;
254         if (::GetCapture() != hostWindow)
255             break;
256     }
257
258     if (::GetCapture() == hostWindow)
259         ::ReleaseCapture();
260
261     // We're done, hide the popup if necessary.
262     hide();
263 }
264
265 void PopupMenuWin::hide()
266 {
267     if (!m_showPopup)
268         return;
269
270     m_showPopup = false;
271
272     ::ShowWindow(m_popup, SW_HIDE);
273
274     if (client())
275         client()->popupDidHide();
276
277     // Post a WM_NULL message to wake up the message pump if necessary.
278     ::PostMessage(m_popup, WM_NULL, 0, 0);
279 }
280
281 // The screen that the popup is placed on should be whichever one the popup menu button lies on.
282 // We fake an hwnd (here we use the popup's hwnd) on top of the button which we can then use to determine the screen.
283 // We can then proceed with our final position/size calculations.
284 void PopupMenuWin::calculatePositionAndSize(const IntRect& r, FrameView* v)
285 {
286     // First get the screen coordinates of the popup menu client.
287     HWND hostWindow = v->hostWindow()->platformPageClient();
288     IntRect absoluteBounds = ((RenderMenuList*)m_popupClient)->absoluteBoundingBoxRect();
289     IntRect absoluteScreenCoords(v->contentsToWindow(absoluteBounds.location()), absoluteBounds.size());
290     POINT absoluteLocation(absoluteScreenCoords.location());
291     if (!::ClientToScreen(hostWindow, &absoluteLocation))
292         return;
293     absoluteScreenCoords.setLocation(absoluteLocation);
294
295     // Now set the popup menu's location temporarily to these coordinates so we can determine which screen the popup should lie on.
296     // We create or move m_popup as necessary.
297     if (!m_popup) {
298         registerClass();
299         DWORD exStyle = WS_EX_LTRREADING;
300         m_popup = ::CreateWindowExW(exStyle, kPopupWindowClassName, L"PopupMenu",
301             WS_POPUP | WS_BORDER,
302             absoluteScreenCoords.x(), absoluteScreenCoords.y(), absoluteScreenCoords.width(), absoluteScreenCoords.height(),
303             hostWindow, 0, WebCore::instanceHandle(), this);
304
305         if (!m_popup)
306             return;
307     } else
308         ::MoveWindow(m_popup, absoluteScreenCoords.x(), absoluteScreenCoords.y(), absoluteScreenCoords.width(), absoluteScreenCoords.height(), false);
309
310     FloatRect screen = monitorFromHwnd(m_popup);
311     
312     // Now we determine the actual location and measurements of the popup itself.
313     // r is in absolute document coordinates, but we want to be in screen coordinates.
314
315     // First, move to WebView coordinates
316     IntRect rScreenCoords(v->contentsToWindow(r.location()), r.size());
317     if (Page* page = v->frame().page())
318         rScreenCoords.scale(page->deviceScaleFactor());
319
320     // Then, translate to screen coordinates
321     POINT location(rScreenCoords.location());
322     if (!::ClientToScreen(hostWindow, &location))
323         return;
324
325     rScreenCoords.setLocation(location);
326
327     // First, determine the popup's height
328     int itemCount = client()->listSize();
329     m_itemHeight = client()->menuStyle().font().fontMetrics().height() + optionSpacingMiddle;
330     int naturalHeight = m_itemHeight * itemCount;
331     int popupHeight = std::min(maxPopupHeight, naturalHeight);
332     // The popup should show an integral number of items (i.e. no partial items should be visible)
333     popupHeight -= popupHeight % m_itemHeight;
334     
335     // Next determine its width
336     int popupWidth = 0;
337     for (int i = 0; i < itemCount; ++i) {
338         String text = client()->itemText(i);
339         if (text.isEmpty())
340             continue;
341
342         FontCascade itemFont = client()->menuStyle().font();
343         if (client()->itemIsLabel(i)) {
344             auto d = itemFont.fontDescription();
345             d.setWeight(d.bolderWeight());
346             itemFont = FontCascade(d, itemFont.letterSpacing(), itemFont.wordSpacing());
347             itemFont.update(m_popupClient->fontSelector());
348         }
349
350         popupWidth = std::max(popupWidth, static_cast<int>(ceilf(itemFont.width(TextRun(text)))));
351     }
352
353     if (naturalHeight > maxPopupHeight)
354         // We need room for a scrollbar
355         popupWidth += ScrollbarTheme::theme().scrollbarThickness(SmallScrollbar);
356
357     // Add padding to align the popup text with the <select> text
358     popupWidth += std::max<int>(0, client()->clientPaddingRight() - client()->clientInsetRight()) + std::max<int>(0, client()->clientPaddingLeft() - client()->clientInsetLeft());
359
360     // Leave room for the border
361     popupWidth += 2 * popupWindowBorderWidth;
362     popupHeight += 2 * popupWindowBorderWidth;
363
364     // The popup should be at least as wide as the control on the page
365     popupWidth = std::max(rScreenCoords.width() - client()->clientInsetLeft() - client()->clientInsetRight(), popupWidth);
366
367     // Always left-align items in the popup.  This matches popup menus on the mac.
368     int popupX = rScreenCoords.x() + client()->clientInsetLeft();
369
370     IntRect popupRect(popupX, rScreenCoords.maxY(), popupWidth, popupHeight);
371
372     // Check that we don't go off the screen vertically
373     if (popupRect.maxY() > screen.height()) {
374         // The popup will go off the screen, so try placing it above the client
375         if (rScreenCoords.y() - popupRect.height() < 0) {
376             // The popup won't fit above, either, so place it whereever's bigger and resize it to fit
377             if ((rScreenCoords.y() + rScreenCoords.height() / 2) < (screen.height() / 2)) {
378                 // Below is bigger
379                 popupRect.setHeight(screen.height() - popupRect.y());
380             } else {
381                 // Above is bigger
382                 popupRect.setY(0);
383                 popupRect.setHeight(rScreenCoords.y());
384             }
385         } else {
386             // The popup fits above, so reposition it
387             popupRect.setY(rScreenCoords.y() - popupRect.height());
388         }
389     }
390
391     // Check that we don't go off the screen horizontally
392     if (popupRect.x() + popupRect.width() > screen.width() + screen.x())
393         popupRect.setX(screen.x() + screen.width() - popupRect.width());
394     if (popupRect.x() < screen.x())
395         popupRect.setX(screen.x());
396
397     m_windowRect = popupRect;
398     return;
399 }
400
401 bool PopupMenuWin::setFocusedIndex(int i, bool hotTracking)
402 {
403     if (i < 0 || i >= client()->listSize() || i == focusedIndex())
404         return false;
405
406     if (!client()->itemIsEnabled(i))
407         return false;
408
409     invalidateItem(focusedIndex());
410     invalidateItem(i);
411
412     m_focusedIndex = i;
413
414     if (!hotTracking)
415         client()->setTextFromItem(i);
416
417     if (!scrollToRevealSelection())
418         ::UpdateWindow(m_popup);
419
420     return true;
421 }
422
423 int PopupMenuWin::visibleItems() const
424 {
425     return clientRect().height() / m_itemHeight;
426 }
427
428 int PopupMenuWin::listIndexAtPoint(const IntPoint& point) const
429 {
430     return m_scrollOffset + point.y() / m_itemHeight;
431 }
432
433 int PopupMenuWin::focusedIndex() const
434 {
435     return m_focusedIndex;
436 }
437
438 void PopupMenuWin::focusFirst()
439 {
440     if (!client())
441         return;
442
443     int size = client()->listSize();
444
445     for (int i = 0; i < size; ++i)
446         if (client()->itemIsEnabled(i)) {
447             setFocusedIndex(i);
448             break;
449         }
450 }
451
452 void PopupMenuWin::focusLast()
453 {
454     if (!client())
455         return;
456
457     int size = client()->listSize();
458
459     for (int i = size - 1; i > 0; --i)
460         if (client()->itemIsEnabled(i)) {
461             setFocusedIndex(i);
462             break;
463         }
464 }
465
466 bool PopupMenuWin::down(unsigned lines)
467 {
468     if (!client())
469         return false;
470
471     int size = client()->listSize();
472
473     int lastSelectableIndex, selectedListIndex;
474     lastSelectableIndex = selectedListIndex = focusedIndex();
475     for (int i = selectedListIndex + 1; i >= 0 && i < size; ++i)
476         if (client()->itemIsEnabled(i)) {
477             lastSelectableIndex = i;
478             if (i >= selectedListIndex + (int)lines)
479                 break;
480         }
481
482     return setFocusedIndex(lastSelectableIndex);
483 }
484
485 bool PopupMenuWin::up(unsigned lines)
486 {
487     if (!client())
488         return false;
489
490     int size = client()->listSize();
491
492     int lastSelectableIndex, selectedListIndex;
493     lastSelectableIndex = selectedListIndex = focusedIndex();
494     for (int i = selectedListIndex - 1; i >= 0 && i < size; --i)
495         if (client()->itemIsEnabled(i)) {
496             lastSelectableIndex = i;
497             if (i <= selectedListIndex - (int)lines)
498                 break;
499         }
500
501     return setFocusedIndex(lastSelectableIndex);
502 }
503
504 void PopupMenuWin::invalidateItem(int index)
505 {
506     if (!m_popup)
507         return;
508
509     IntRect damageRect(clientRect());
510     damageRect.setY(m_itemHeight * (index - m_scrollOffset));
511     damageRect.setHeight(m_itemHeight);
512     if (m_scrollbar)
513         damageRect.setWidth(damageRect.width() - m_scrollbar->frameRect().width());
514
515     RECT r = damageRect;
516     ::InvalidateRect(m_popup, &r, TRUE);
517 }
518
519 IntRect PopupMenuWin::clientRect() const
520 {
521     IntRect clientRect = m_windowRect;
522     clientRect.inflate(-popupWindowBorderWidth);
523     clientRect.setLocation(IntPoint(0, 0));
524     return clientRect;
525 }
526
527 void PopupMenuWin::incrementWheelDelta(int delta)
528 {
529     m_wheelDelta += delta;
530 }
531
532 void PopupMenuWin::reduceWheelDelta(int delta)
533 {
534     ASSERT(delta >= 0);
535     ASSERT(delta <= abs(m_wheelDelta));
536
537     if (m_wheelDelta > 0)
538         m_wheelDelta -= delta;
539     else if (m_wheelDelta < 0)
540         m_wheelDelta += delta;
541     else
542         return;
543 }
544
545 bool PopupMenuWin::scrollToRevealSelection()
546 {
547     if (!m_scrollbar)
548         return false;
549
550     int index = focusedIndex();
551
552     if (index < m_scrollOffset) {
553         ScrollableArea::scrollToOffsetWithoutAnimation(VerticalScrollbar, index);
554         return true;
555     }
556
557     if (index >= m_scrollOffset + visibleItems()) {
558         ScrollableArea::scrollToOffsetWithoutAnimation(VerticalScrollbar, index - visibleItems() + 1);
559         return true;
560     }
561
562     return false;
563 }
564
565 void PopupMenuWin::updateFromElement()
566 {
567     if (!m_popup)
568         return;
569
570     m_focusedIndex = client()->selectedIndex();
571
572     ::InvalidateRect(m_popup, 0, TRUE);
573     if (!scrollToRevealSelection())
574         ::UpdateWindow(m_popup);
575 }
576
577 const int separatorPadding = 4;
578 const int separatorHeight = 1;
579 void PopupMenuWin::paint(const IntRect& damageRect, HDC hdc)
580 {
581     if (!m_popup)
582         return;
583
584     if (!m_DC) {
585         m_DC = adoptGDIObject(::CreateCompatibleDC(HWndDC(m_popup)));
586         if (!m_DC)
587             return;
588     }
589
590     if (m_bmp) {
591         bool keepBitmap = false;
592         BITMAP bitmap;
593         if (::GetObject(m_bmp.get(), sizeof(bitmap), &bitmap))
594             keepBitmap = bitmap.bmWidth == clientRect().width()
595                 && bitmap.bmHeight == clientRect().height();
596         if (!keepBitmap)
597             m_bmp.clear();
598     }
599     if (!m_bmp) {
600         BitmapInfo bitmapInfo = BitmapInfo::createBottomUp(clientRect().size());
601         void* pixels = 0;
602         m_bmp = adoptGDIObject(::CreateDIBSection(m_DC.get(), &bitmapInfo, DIB_RGB_COLORS, &pixels, 0, 0));
603         if (!m_bmp)
604             return;
605
606         ::SelectObject(m_DC.get(), m_bmp.get());
607     }
608
609     GraphicsContext context(m_DC.get());
610
611     int itemCount = client()->listSize();
612
613     // listRect is the damageRect translated into the coordinates of the entire menu list (which is itemCount * m_itemHeight pixels tall)
614     IntRect listRect = damageRect;
615     listRect.move(IntSize(0, m_scrollOffset * m_itemHeight));
616
617     for (int y = listRect.y(); y < listRect.maxY(); y += m_itemHeight) {
618         int index = y / m_itemHeight;
619
620         Color optionBackgroundColor, optionTextColor;
621         PopupMenuStyle itemStyle = client()->itemStyle(index);
622         if (index == focusedIndex()) {
623             optionBackgroundColor = RenderTheme::defaultTheme()->activeListBoxSelectionBackgroundColor();
624             optionTextColor = RenderTheme::defaultTheme()->activeListBoxSelectionForegroundColor();
625         } else {
626             optionBackgroundColor = itemStyle.backgroundColor();
627             optionTextColor = itemStyle.foregroundColor();
628         }
629
630         // itemRect is in client coordinates
631         IntRect itemRect(0, (index - m_scrollOffset) * m_itemHeight, damageRect.width(), m_itemHeight);
632
633         // Draw the background for this menu item
634         if (itemStyle.isVisible())
635             context.fillRect(itemRect, optionBackgroundColor);
636
637         if (client()->itemIsSeparator(index)) {
638             IntRect separatorRect(itemRect.x() + separatorPadding, itemRect.y() + (itemRect.height() - separatorHeight) / 2, itemRect.width() - 2 * separatorPadding, separatorHeight);
639             context.fillRect(separatorRect, optionTextColor);
640             continue;
641         }
642
643         String itemText = client()->itemText(index);
644
645         TextRun textRun(itemText, 0, 0, AllowTrailingExpansion, itemStyle.textDirection(), itemStyle.hasTextDirectionOverride());
646         context.setFillColor(optionTextColor);
647         
648         FontCascade itemFont = client()->menuStyle().font();
649         if (client()->itemIsLabel(index)) {
650             auto d = itemFont.fontDescription();
651             d.setWeight(d.bolderWeight());
652             itemFont = FontCascade(d, itemFont.letterSpacing(), itemFont.wordSpacing());
653             itemFont.update(m_popupClient->fontSelector());
654         }
655         
656         // Draw the item text
657         if (itemStyle.isVisible()) {
658             int textX = 0;
659             if (client()->menuStyle().textDirection() == LTR) {
660                 textX = std::max<int>(0, client()->clientPaddingLeft() - client()->clientInsetLeft());
661                 if (RenderTheme::defaultTheme()->popupOptionSupportsTextIndent())
662                     textX += minimumIntValueForLength(itemStyle.textIndent(), itemRect.width());
663             } else {
664                 textX = itemRect.width() - client()->menuStyle().font().width(textRun);
665                 textX = std::min<int>(textX, textX - client()->clientPaddingRight() + client()->clientInsetRight());
666                 if (RenderTheme::defaultTheme()->popupOptionSupportsTextIndent())
667                     textX -= minimumIntValueForLength(itemStyle.textIndent(), itemRect.width());
668             }
669             int textY = itemRect.y() + itemFont.fontMetrics().ascent() + (itemRect.height() - itemFont.fontMetrics().height()) / 2;
670             context.drawBidiText(itemFont, textRun, IntPoint(textX, textY));
671         }
672     }
673
674     if (m_scrollbar)
675         m_scrollbar->paint(context, damageRect);
676
677     HWndDC hWndDC;
678     HDC localDC = hdc ? hdc : hWndDC.setHWnd(m_popup);
679
680     ::BitBlt(localDC, damageRect.x(), damageRect.y(), damageRect.width(), damageRect.height(), m_DC.get(), damageRect.x(), damageRect.y(), SRCCOPY);
681 }
682
683 int PopupMenuWin::scrollSize(ScrollbarOrientation orientation) const
684 {
685     return ((orientation == VerticalScrollbar) && m_scrollbar) ? (m_scrollbar->totalSize() - m_scrollbar->visibleSize()) : 0;
686 }
687
688 int PopupMenuWin::scrollPosition(Scrollbar*) const
689 {
690     return m_scrollOffset;
691 }
692
693 void PopupMenuWin::setScrollOffset(const IntPoint& offset)
694 {
695     scrollTo(offset.y());
696 }
697
698 void PopupMenuWin::scrollTo(int offset)
699 {
700     ASSERT(m_scrollbar);
701
702     if (!m_popup)
703         return;
704
705     if (m_scrollOffset == offset)
706         return;
707
708     int scrolledLines = m_scrollOffset - offset;
709     m_scrollOffset = offset;
710
711     UINT flags = SW_INVALIDATE;
712
713 #ifdef CAN_SET_SMOOTH_SCROLLING_DURATION
714     BOOL shouldSmoothScroll = FALSE;
715     ::SystemParametersInfo(SPI_GETLISTBOXSMOOTHSCROLLING, 0, &shouldSmoothScroll, 0);
716     if (shouldSmoothScroll)
717         flags |= MAKEWORD(SW_SMOOTHSCROLL, smoothScrollAnimationDuration);
718 #endif
719
720     IntRect listRect = clientRect();
721     if (m_scrollbar)
722         listRect.setWidth(listRect.width() - m_scrollbar->frameRect().width());
723     RECT r = listRect;
724     ::ScrollWindowEx(m_popup, 0, scrolledLines * m_itemHeight, &r, 0, 0, 0, flags);
725     if (m_scrollbar) {
726         r = m_scrollbar->frameRect();
727         ::InvalidateRect(m_popup, &r, TRUE);
728     }
729     ::UpdateWindow(m_popup);
730 }
731
732 void PopupMenuWin::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
733 {
734     IntRect scrollRect = rect;
735     scrollRect.move(scrollbar->x(), scrollbar->y());
736     RECT r = scrollRect;
737     ::InvalidateRect(m_popup, &r, false);
738 }
739
740 IntSize PopupMenuWin::visibleSize() const
741 {
742     return IntSize(m_windowRect.width(), m_scrollbar ? m_scrollbar->visibleSize() : m_windowRect.height());
743 }
744
745 IntSize PopupMenuWin::contentsSize() const
746 {
747     return m_windowRect.size();
748 }
749
750 IntRect PopupMenuWin::scrollableAreaBoundingBox(bool*) const
751 {
752     return m_windowRect;
753 }
754
755 bool PopupMenuWin::onGetObject(WPARAM wParam, LPARAM lParam, LRESULT& lResult)
756 {
757     lResult = 0;
758
759     if (static_cast<LONG>(lParam) != OBJID_CLIENT)
760         return false;
761
762     if (!m_accessiblePopupMenu)
763         m_accessiblePopupMenu = new AccessiblePopupMenu(*this);
764
765     static HMODULE accessibilityLib = nullptr;
766     if (!accessibilityLib) {
767         if (!(accessibilityLib = ::LoadLibraryW(L"oleacc.dll")))
768             return false;
769     }
770
771     static LPFNLRESULTFROMOBJECT procPtr = reinterpret_cast<LPFNLRESULTFROMOBJECT>(::GetProcAddress(accessibilityLib, "LresultFromObject"));
772     if (!procPtr)
773         return false;
774
775     // LresultFromObject returns a reference to the accessible object, stored
776     // in an LRESULT. If this call is not successful, Windows will handle the
777     // request through DefWindowProc.
778     return SUCCEEDED(lResult = procPtr(__uuidof(IAccessible), wParam, m_accessiblePopupMenu.get()));
779 }
780
781 void PopupMenuWin::registerClass()
782 {
783     static bool haveRegisteredWindowClass = false;
784
785     if (haveRegisteredWindowClass)
786         return;
787
788     WNDCLASSEX wcex;
789     wcex.cbSize = sizeof(WNDCLASSEX);
790     wcex.hIconSm        = 0;
791     wcex.style          = CS_DROPSHADOW;
792
793     wcex.lpfnWndProc    = PopupMenuWndProc;
794     wcex.cbClsExtra     = 0;
795     wcex.cbWndExtra     = sizeof(PopupMenu*); // For the PopupMenu pointer
796     wcex.hInstance      = WebCore::instanceHandle();
797     wcex.hIcon          = 0;
798     wcex.hCursor        = LoadCursor(0, IDC_ARROW);
799     wcex.hbrBackground  = 0;
800     wcex.lpszMenuName   = 0;
801     wcex.lpszClassName  = kPopupWindowClassName;
802
803     haveRegisteredWindowClass = true;
804
805     RegisterClassEx(&wcex);
806 }
807
808
809 LRESULT CALLBACK PopupMenuWin::PopupMenuWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
810 {
811     if (PopupMenuWin* popup = static_cast<PopupMenuWin*>(getWindowPointer(hWnd, 0)))
812         return popup->wndProc(hWnd, message, wParam, lParam);
813
814     if (message == WM_CREATE) {
815         LPCREATESTRUCT createStruct = reinterpret_cast<LPCREATESTRUCT>(lParam);
816
817         // Associate the PopupMenu with the window.
818         setWindowPointer(hWnd, 0, createStruct->lpCreateParams);
819         return 0;
820     }
821
822     return ::DefWindowProc(hWnd, message, wParam, lParam);
823 }
824
825 const int smoothScrollAnimationDuration = 5000;
826
827 LRESULT PopupMenuWin::wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
828 {
829     LRESULT lResult = 0;
830
831     switch (message) {
832         case WM_MOUSEACTIVATE:
833             return MA_NOACTIVATE;
834         case WM_SIZE: {
835             if (!scrollbar())
836                 break;
837
838             IntSize size(LOWORD(lParam), HIWORD(lParam));
839             scrollbar()->setFrameRect(IntRect(size.width() - scrollbar()->width(), 0, scrollbar()->width(), size.height()));
840
841             int visibleItems = this->visibleItems();
842             scrollbar()->setEnabled(visibleItems < client()->listSize());
843             scrollbar()->setSteps(1, std::max(1, visibleItems - 1));
844             scrollbar()->setProportion(visibleItems, client()->listSize());
845
846             break;
847         }
848         case WM_SYSKEYDOWN:
849         case WM_KEYDOWN: {
850             if (!client())
851                 break;
852
853             bool altKeyPressed = GetKeyState(VK_MENU) & HIGH_BIT_MASK_SHORT;
854             bool ctrlKeyPressed = GetKeyState(VK_CONTROL) & HIGH_BIT_MASK_SHORT;
855
856             lResult = 0;
857             switch (LOWORD(wParam)) {
858                 case VK_F4: {
859                     if (!altKeyPressed && !ctrlKeyPressed) {
860                         int index = focusedIndex();
861                         ASSERT(index >= 0);
862                         client()->valueChanged(index);
863                         hide();
864                     }
865                     break;
866                 }
867                 case VK_DOWN:
868                     if (altKeyPressed) {
869                         int index = focusedIndex();
870                         ASSERT(index >= 0);
871                         client()->valueChanged(index);
872                         hide();
873                     } else
874                         down();
875                     break;
876                 case VK_RIGHT:
877                     down();
878                     break;
879                 case VK_UP:
880                     if (altKeyPressed) {
881                         int index = focusedIndex();
882                         ASSERT(index >= 0);
883                         client()->valueChanged(index);
884                         hide();
885                     } else
886                         up();
887                     break;
888                 case VK_LEFT:
889                     up();
890                     break;
891                 case VK_HOME:
892                     focusFirst();
893                     break;
894                 case VK_END:
895                     focusLast();
896                     break;
897                 case VK_PRIOR:
898                     if (focusedIndex() != scrollOffset()) {
899                         // Set the selection to the first visible item
900                         int firstVisibleItem = scrollOffset();
901                         up(focusedIndex() - firstVisibleItem);
902                     } else {
903                         // The first visible item is selected, so move the selection back one page
904                         up(visibleItems());
905                     }
906                     break;
907                 case VK_NEXT: {
908                     int lastVisibleItem = scrollOffset() + visibleItems() - 1;
909                     if (focusedIndex() != lastVisibleItem) {
910                         // Set the selection to the last visible item
911                         down(lastVisibleItem - focusedIndex());
912                     } else {
913                         // The last visible item is selected, so move the selection forward one page
914                         down(visibleItems());
915                     }
916                     break;
917                 }
918                 case VK_TAB:
919                     ::SendMessage(client()->hostWindow()->platformPageClient(), message, wParam, lParam);
920                     hide();
921                     break;
922                 case VK_ESCAPE:
923                     hide();
924                     break;
925                 default:
926                     if (isASCIIPrintable(wParam))
927                         // Send the keydown to the WebView so it can be used for type-to-select.
928                         // Since we know that the virtual key is ASCII printable, it's OK to convert this to
929                         // a WM_CHAR message. (We don't want to call TranslateMessage because that will post a
930                         // WM_CHAR message that will be stolen and redirected to the popup HWND.
931                         ::PostMessage(m_popup, WM_HOST_WINDOW_CHAR, wParam, lParam);
932                     else
933                         lResult = 1;
934                     break;
935             }
936             break;
937         }
938         case WM_CHAR: {
939             if (!client())
940                 break;
941
942             lResult = 0;
943             int index;
944             switch (wParam) {
945                 case 0x0D:   // Enter/Return
946                     hide();
947                     index = focusedIndex();
948                     ASSERT(index >= 0);
949                     client()->valueChanged(index);
950                     break;
951                 case 0x1B:   // Escape
952                     hide();
953                     break;
954                 case 0x09:   // TAB
955                 case 0x08:   // Backspace
956                 case 0x0A:   // Linefeed
957                 default:     // Character
958                     lResult = 1;
959                     break;
960             }
961             break;
962         }
963         case WM_MOUSEMOVE: {
964             IntPoint mousePoint(MAKEPOINTS(lParam));
965             if (scrollbar()) {
966                 IntRect scrollBarRect = scrollbar()->frameRect();
967                 if (scrollbarCapturingMouse() || scrollBarRect.contains(mousePoint)) {
968                     // Put the point into coordinates relative to the scroll bar
969                     mousePoint.move(-scrollBarRect.x(), -scrollBarRect.y());
970                     PlatformMouseEvent event(hWnd, message, wParam, MAKELPARAM(mousePoint.x(), mousePoint.y()));
971                     scrollbar()->mouseMoved(event);
972                     break;
973                 }
974             }
975
976             BOOL shouldHotTrack = FALSE;
977             if (!::SystemParametersInfo(SPI_GETHOTTRACKING, 0, &shouldHotTrack, 0))
978                 shouldHotTrack = FALSE;
979
980             RECT bounds;
981             GetClientRect(popupHandle(), &bounds);
982             if (!::PtInRect(&bounds, mousePoint) && !(wParam & MK_LBUTTON) && client()) {
983                 // When the mouse is not inside the popup menu and the left button isn't down, just
984                 // repost the message to the web view.
985
986                 // Translate the coordinate.
987                 translatePoint(lParam, m_popup, client()->hostWindow()->platformPageClient());
988
989                 ::PostMessage(m_popup, WM_HOST_WINDOW_MOUSEMOVE, wParam, lParam);
990                 break;
991             }
992
993             if ((shouldHotTrack || wParam & MK_LBUTTON) && ::PtInRect(&bounds, mousePoint)) {
994                 setFocusedIndex(listIndexAtPoint(mousePoint), true);
995                 m_hoveredIndex = listIndexAtPoint(mousePoint);
996             }
997
998             break;
999         }
1000         case WM_LBUTTONDOWN: {
1001             IntPoint mousePoint(MAKEPOINTS(lParam));
1002             if (scrollbar()) {
1003                 IntRect scrollBarRect = scrollbar()->frameRect();
1004                 if (scrollBarRect.contains(mousePoint)) {
1005                     // Put the point into coordinates relative to the scroll bar
1006                     mousePoint.move(-scrollBarRect.x(), -scrollBarRect.y());
1007                     PlatformMouseEvent event(hWnd, message, wParam, MAKELPARAM(mousePoint.x(), mousePoint.y()));
1008                     scrollbar()->mouseDown(event);
1009                     setScrollbarCapturingMouse(true);
1010                     break;
1011                 }
1012             }
1013
1014             // If the mouse is inside the window, update the focused index. Otherwise, 
1015             // hide the popup.
1016             RECT bounds;
1017             GetClientRect(m_popup, &bounds);
1018             if (::PtInRect(&bounds, mousePoint)) {
1019                 setFocusedIndex(listIndexAtPoint(mousePoint), true);
1020                 m_hoveredIndex = listIndexAtPoint(mousePoint);
1021             }
1022             else
1023                 hide();
1024             break;
1025         }
1026         case WM_LBUTTONUP: {
1027             IntPoint mousePoint(MAKEPOINTS(lParam));
1028             if (scrollbar()) {
1029                 IntRect scrollBarRect = scrollbar()->frameRect();
1030                 if (scrollbarCapturingMouse() || scrollBarRect.contains(mousePoint)) {
1031                     setScrollbarCapturingMouse(false);
1032                     // Put the point into coordinates relative to the scroll bar
1033                     mousePoint.move(-scrollBarRect.x(), -scrollBarRect.y());
1034                     PlatformMouseEvent event(hWnd, message, wParam, MAKELPARAM(mousePoint.x(), mousePoint.y()));
1035                     scrollbar()->mouseUp(event);
1036                     // FIXME: This is a hack to work around Scrollbar not invalidating correctly when it doesn't have a parent widget
1037                     RECT r = scrollBarRect;
1038                     ::InvalidateRect(popupHandle(), &r, TRUE);
1039                     break;
1040                 }
1041             }
1042             // Only hide the popup if the mouse is inside the popup window.
1043             RECT bounds;
1044             GetClientRect(popupHandle(), &bounds);
1045             if (client() && ::PtInRect(&bounds, mousePoint)) {
1046                 hide();
1047                 int index = m_hoveredIndex;
1048                 if (!client()->itemIsEnabled(index))
1049                     index = client()->selectedIndex();
1050                 if (index >= 0)
1051                     client()->valueChanged(index);
1052             }
1053             break;
1054         }
1055
1056         case WM_MOUSEWHEEL: {
1057             if (!scrollbar())
1058                 break;
1059
1060             int i = 0;
1061             for (incrementWheelDelta(GET_WHEEL_DELTA_WPARAM(wParam)); abs(wheelDelta()) >= WHEEL_DELTA; reduceWheelDelta(WHEEL_DELTA)) {
1062                 if (wheelDelta() > 0)
1063                     ++i;
1064                 else
1065                     --i;
1066             }
1067
1068             ScrollableArea::scroll(i > 0 ? ScrollUp : ScrollDown, ScrollByLine, abs(i));
1069             break;
1070         }
1071
1072         case WM_PAINT: {
1073             PAINTSTRUCT paintInfo;
1074             ::BeginPaint(popupHandle(), &paintInfo);
1075             paint(paintInfo.rcPaint, paintInfo.hdc);
1076             ::EndPaint(popupHandle(), &paintInfo);
1077             lResult = 0;
1078             break;
1079         }
1080         case WM_PRINTCLIENT:
1081             paint(clientRect(), (HDC)wParam);
1082             break;
1083         case WM_GETOBJECT:
1084             onGetObject(wParam, lParam, lResult);
1085             break;
1086         default:
1087             lResult = DefWindowProc(hWnd, message, wParam, lParam);
1088     }
1089
1090     return lResult;
1091 }
1092
1093 AccessiblePopupMenu::AccessiblePopupMenu(const PopupMenuWin& popupMenu)
1094     : m_refCount(0)
1095     , m_popupMenu(popupMenu)
1096 {
1097 }
1098
1099 AccessiblePopupMenu::~AccessiblePopupMenu()
1100 {
1101 }
1102
1103 HRESULT AccessiblePopupMenu::QueryInterface(REFIID riid, __RPC__deref_out void __RPC_FAR *__RPC_FAR *ppvObject)
1104 {
1105     if (IsEqualGUID(riid, __uuidof(IAccessible)))
1106         *ppvObject = static_cast<IAccessible*>(this);
1107     else if (IsEqualGUID(riid, __uuidof(IDispatch)))
1108         *ppvObject = static_cast<IAccessible*>(this);
1109     else if (IsEqualGUID(riid, __uuidof(IUnknown)))
1110         *ppvObject = static_cast<IAccessible*>(this);
1111     else {
1112         *ppvObject = 0;
1113         return E_NOINTERFACE;
1114     }
1115     AddRef();
1116     return S_OK;
1117 }
1118
1119 ULONG AccessiblePopupMenu::AddRef()
1120 {
1121     return ++m_refCount;
1122 }
1123
1124 ULONG AccessiblePopupMenu::Release()
1125 {
1126     int refCount = --m_refCount;
1127     if (!refCount)
1128         delete this;
1129     return refCount;
1130 }
1131
1132 HRESULT AccessiblePopupMenu::GetTypeInfoCount(UINT* count)
1133 {
1134     return E_NOTIMPL;
1135 }
1136
1137 HRESULT AccessiblePopupMenu::GetTypeInfo(UINT, LCID, ITypeInfo** ppTInfo)
1138 {
1139     return E_NOTIMPL;
1140 }
1141
1142 HRESULT AccessiblePopupMenu::GetIDsOfNames(REFIID, LPOLESTR*, UINT, LCID, DISPID*)
1143 {
1144     return E_NOTIMPL;
1145 }
1146
1147 HRESULT AccessiblePopupMenu::Invoke(DISPID, REFIID, LCID, WORD, DISPPARAMS*, VARIANT*, EXCEPINFO*, UINT*)
1148 {
1149     return E_NOTIMPL;
1150 }
1151
1152 HRESULT AccessiblePopupMenu::get_accParent(IDispatch**)
1153 {
1154     return E_NOTIMPL;
1155 }
1156
1157 HRESULT AccessiblePopupMenu::get_accChildCount(long* count)
1158 {
1159     if (!count)
1160         return E_POINTER;
1161
1162     *count = m_popupMenu.visibleItems();
1163     return S_OK;
1164 }
1165
1166 HRESULT AccessiblePopupMenu::get_accChild(VARIANT vChild, IDispatch** ppChild)
1167 {
1168     if (!ppChild)
1169         return E_POINTER;
1170
1171     if (vChild.vt != VT_I4) {
1172         *ppChild = nullptr;
1173         return E_INVALIDARG;
1174     }
1175     *ppChild = nullptr;
1176     return S_FALSE;
1177 }
1178
1179 HRESULT AccessiblePopupMenu::get_accName(VARIANT vChild, BSTR* name)
1180 {
1181     return get_accValue(vChild, name);
1182 }
1183
1184 HRESULT AccessiblePopupMenu::get_accValue(VARIANT vChild, BSTR* value)
1185 {
1186     if (!value)
1187         return E_POINTER;
1188
1189     if (vChild.vt != VT_I4)
1190         return E_INVALIDARG;
1191
1192     int index = vChild.lVal - 1;
1193
1194     if (index < 0)
1195         return E_INVALIDARG;
1196
1197     BString itemText(m_popupMenu.client()->itemText(index));
1198     *value = itemText.release();
1199
1200     return S_OK;
1201 }
1202
1203 HRESULT AccessiblePopupMenu::get_accDescription(VARIANT, BSTR*)
1204 {
1205     return E_NOTIMPL;
1206 }
1207
1208 HRESULT AccessiblePopupMenu::get_accRole(VARIANT vChild, VARIANT* pvRole)
1209 {
1210     if (!pvRole)
1211         return E_POINTER;
1212
1213     if (vChild.vt != VT_I4)
1214         return E_INVALIDARG;
1215
1216     // Scrollbar parts are encoded as negative values.
1217     if (vChild.lVal < 0) {
1218         V_VT(pvRole) = VT_I4;
1219         V_I4(pvRole) = ROLE_SYSTEM_SCROLLBAR;
1220     } else {
1221         V_VT(pvRole) = VT_I4;
1222         V_I4(pvRole) = ROLE_SYSTEM_LISTITEM;
1223     }
1224
1225     return S_OK;
1226 }
1227
1228 HRESULT AccessiblePopupMenu::get_accState(VARIANT vChild, VARIANT* pvState)
1229 {
1230     if (!pvState)
1231         return E_POINTER;
1232
1233     if (vChild.vt != VT_I4)
1234         return E_INVALIDARG;
1235
1236     V_VT(pvState) = VT_I4;
1237     V_I4(pvState) = 0; // STATE_SYSTEM_NORMAL
1238     
1239     return S_OK;
1240 }
1241
1242 HRESULT AccessiblePopupMenu::get_accHelp(VARIANT vChild, BSTR* helpText)
1243 {
1244     return E_NOTIMPL;
1245 }
1246
1247 HRESULT AccessiblePopupMenu::get_accKeyboardShortcut(VARIANT vChild, BSTR*)
1248 {
1249     return E_NOTIMPL;
1250 }
1251
1252 HRESULT AccessiblePopupMenu::get_accFocus(VARIANT* pvFocusedChild)
1253 {
1254     return E_NOTIMPL;
1255 }
1256
1257 HRESULT AccessiblePopupMenu::get_accSelection(VARIANT* pvSelectedChild)
1258 {
1259     return E_NOTIMPL;
1260 }
1261
1262 HRESULT AccessiblePopupMenu::get_accDefaultAction(VARIANT vChild, BSTR* actionDescription)
1263 {
1264     return E_NOTIMPL;
1265 }
1266
1267 HRESULT AccessiblePopupMenu::accSelect(long selectionFlags, VARIANT vChild)
1268 {
1269     return E_NOTIMPL;
1270 }
1271
1272 HRESULT AccessiblePopupMenu::accLocation(long* left, long* top, long* width, long* height, VARIANT vChild)
1273 {
1274     if (!left || !top || !width || !height)
1275         return E_POINTER;
1276
1277     if (vChild.vt != VT_I4)
1278         return E_INVALIDARG;
1279
1280     const IntRect& windowRect = m_popupMenu.windowRect();
1281
1282     // Scrollbar parts are encoded as negative values.
1283     if (vChild.lVal < 0) {
1284         if (!m_popupMenu.scrollbar())
1285             return E_FAIL;
1286
1287         Scrollbar& scrollbar = *m_popupMenu.scrollbar();
1288         WebCore::ScrollbarPart part = static_cast<WebCore::ScrollbarPart>(-vChild.lVal);
1289
1290         ScrollbarThemeWin& theme = static_cast<ScrollbarThemeWin&>(scrollbar.theme());
1291
1292         IntRect partRect;
1293
1294         switch (part) {
1295         case BackTrackPart:
1296         case BackButtonStartPart:
1297             partRect = theme.backButtonRect(scrollbar, WebCore::BackTrackPart);
1298             break;
1299         case ThumbPart:
1300             partRect = theme.thumbRect(scrollbar);
1301             break;
1302         case ForwardTrackPart:
1303         case ForwardButtonEndPart:
1304             partRect = theme.forwardButtonRect(scrollbar, WebCore::ForwardTrackPart);
1305             break;
1306         case ScrollbarBGPart:
1307             partRect = theme.trackRect(scrollbar);
1308             break;
1309         default:
1310             return E_FAIL;
1311         }
1312
1313         partRect.move(windowRect.x(), windowRect.y());
1314
1315         *left = partRect.x();
1316         *top = partRect.y();
1317         *width = partRect.width();
1318         *height = partRect.height();
1319
1320         return S_OK;
1321     }
1322
1323     int index = vChild.lVal - 1;
1324
1325     if (index < 0)
1326         return E_INVALIDARG;
1327
1328     *left = windowRect.x();
1329     *top = windowRect.y() + (index - m_popupMenu.m_scrollOffset) * m_popupMenu.itemHeight();
1330     *width = windowRect.width();
1331     *height = m_popupMenu.itemHeight();
1332
1333     return S_OK;
1334 }
1335
1336 HRESULT AccessiblePopupMenu::accNavigate(long direction, VARIANT vFromChild, VARIANT* pvNavigatedTo)
1337 {
1338     return E_NOTIMPL;
1339 }
1340
1341 HRESULT AccessiblePopupMenu::accHitTest(long x, long y, VARIANT* pvChildAtPoint)
1342 {
1343     if (!pvChildAtPoint)
1344         return E_POINTER;
1345
1346     ::VariantInit(pvChildAtPoint);
1347
1348     IntRect windowRect = m_popupMenu.windowRect();
1349
1350     IntPoint pt(x - windowRect.x(), y - windowRect.y());
1351
1352     IntRect scrollRect;
1353
1354     if (m_popupMenu.scrollbar())
1355         scrollRect = m_popupMenu.scrollbar()->frameRect();
1356
1357     if (m_popupMenu.scrollbar() && scrollRect.contains(pt)) {
1358         Scrollbar& scrollbar = *m_popupMenu.scrollbar();
1359
1360         pt.move(-scrollRect.x(), -scrollRect.y());
1361
1362         WebCore::ScrollbarPart part = scrollbar.theme().hitTest(scrollbar, pt);
1363
1364         V_VT(pvChildAtPoint) = VT_I4;
1365         V_I4(pvChildAtPoint) = -part; // Scrollbar parts are encoded as negative, to avoid mixup with item indexes.
1366         return S_OK;
1367     }
1368
1369     int index = m_popupMenu.listIndexAtPoint(pt);
1370
1371     if (index < 0) {
1372         V_VT(pvChildAtPoint) = VT_EMPTY;
1373         return S_OK;
1374     }
1375
1376     V_VT(pvChildAtPoint) = VT_I4;
1377     V_I4(pvChildAtPoint) = index + 1; // CHILDID_SELF is 0, need to add 1.
1378
1379     return S_OK;
1380 }
1381
1382 HRESULT AccessiblePopupMenu::accDoDefaultAction(VARIANT vChild)
1383 {
1384     return E_NOTIMPL;
1385 }
1386
1387 HRESULT AccessiblePopupMenu::put_accName(VARIANT, BSTR)
1388 {
1389     return E_NOTIMPL;
1390 }
1391
1392 HRESULT AccessiblePopupMenu::put_accValue(VARIANT, BSTR)
1393 {
1394     return E_NOTIMPL;
1395 }
1396
1397 HRESULT AccessiblePopupMenu::get_accHelpTopic(BSTR* helpFile, VARIANT, long* topicID)
1398 {
1399     return E_NOTIMPL;
1400 }
1401
1402 }