Unify Windows version checks.
[WebKit-https.git] / Source / WebCore / rendering / RenderThemeWin.cpp
1 /*
2  * Copyright (C) 2006, 2007 Apple Inc.
3  * Copyright (C) 2009 Kenneth Rohde Christiansen
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18  * Boston, MA 02111-1307, USA.
19  *
20  */
21
22 #include "config.h"
23 #include "RenderThemeWin.h"
24
25 #include "CSSValueKeywords.h"
26 #include "Element.h"
27 #include "Frame.h"
28 #include "GraphicsContext.h"
29 #include "LocalWindowsContext.h"
30 #include "PaintInfo.h"
31 #include "RenderSlider.h"
32 #include "Settings.h"
33 #include "SoftLinking.h"
34 #include "SystemInfo.h"
35 #include "UserAgentStyleSheets.h"
36
37 #if ENABLE(VIDEO)
38 #include "RenderMediaControls.h"
39 #endif
40
41 #include <tchar.h>
42
43 /* 
44  * The following constants are used to determine how a widget is drawn using
45  * Windows' Theme API. For more information on theme parts and states see
46  * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/shellcc/platform/commctls/userex/topics/partsandstates.asp
47  */
48
49 // Generic state constants
50 #define TS_NORMAL    1
51 #define TS_HOVER     2
52 #define TS_ACTIVE    3
53 #define TS_DISABLED  4
54 #define TS_FOCUSED   5
55
56 // Button constants
57 #define BP_BUTTON    1
58 #define BP_RADIO     2
59 #define BP_CHECKBOX  3
60
61 // Textfield constants
62 #define TFP_TEXTFIELD 1
63 #define EP_EDITBORDER_NOSCROLL 6
64 #define TFS_READONLY  6
65
66 // ComboBox constants (from vsstyle.h)
67 #define CP_DROPDOWNBUTTON 1
68 #define CP_BORDER 4
69 #define CP_READONLY 5
70 #define CP_DROPDOWNBUTTONRIGHT 6
71
72 // TrackBar (slider) parts
73 #define TKP_TRACK       1
74 #define TKP_TRACKVERT   2
75
76 // TrackBar (slider) thumb parts
77 #define TKP_THUMBBOTTOM 4
78 #define TKP_THUMBTOP    5
79 #define TKP_THUMBLEFT   7
80 #define TKP_THUMBRIGHT  8
81
82 // Trackbar (slider) thumb states
83 #define TUS_NORMAL      1
84 #define TUS_HOT         2
85 #define TUS_PRESSED     3
86 #define TUS_FOCUSED     4
87 #define TUS_DISABLED    5
88
89 // button states
90 #define PBS_NORMAL      1
91 #define PBS_HOT         2
92 #define PBS_PRESSED     3
93 #define PBS_DISABLED    4
94 #define PBS_DEFAULTED   5
95
96 // Spin button parts
97 #define SPNP_UP         1
98 #define SPNP_DOWN       2
99
100 // Spin button states
101 #define DNS_NORMAL      1
102 #define DNS_HOT         2
103 #define DNS_PRESSED     3
104 #define DNS_DISABLED    4
105 #define UPS_NORMAL      1
106 #define UPS_HOT         2
107 #define UPS_PRESSED     3
108 #define UPS_DISABLED    4
109
110
111 SOFT_LINK_LIBRARY(uxtheme)
112 SOFT_LINK(uxtheme, OpenThemeData, HANDLE, WINAPI, (HWND hwnd, LPCWSTR pszClassList), (hwnd, pszClassList))
113 SOFT_LINK(uxtheme, CloseThemeData, HRESULT, WINAPI, (HANDLE hTheme), (hTheme))
114 SOFT_LINK(uxtheme, DrawThemeBackground, HRESULT, WINAPI, (HANDLE hTheme, HDC hdc, int iPartId, int iStateId, const RECT* pRect, const RECT* pClipRect), (hTheme, hdc, iPartId, iStateId, pRect, pClipRect))
115 SOFT_LINK(uxtheme, IsThemeActive, BOOL, WINAPI, (), ())
116 SOFT_LINK(uxtheme, IsThemeBackgroundPartiallyTransparent, BOOL, WINAPI, (HANDLE hTheme, int iPartId, int iStateId), (hTheme, iPartId, iStateId))
117
118 static bool haveTheme;
119
120 static const unsigned vistaMenuListButtonOutset = 1;
121
122 using namespace std;
123
124 namespace WebCore {
125
126 // This is the fixed width IE and Firefox use for buttons on dropdown menus
127 static const int dropDownButtonWidth = 17;
128
129 static const int shell32MagnifierIconIndex = 22;
130
131 // Default font size to match Firefox.
132 static const float defaultControlFontPixelSize = 13;
133
134 static const float defaultCancelButtonSize = 9;
135 static const float minCancelButtonSize = 5;
136 static const float maxCancelButtonSize = 21;
137 static const float defaultSearchFieldResultsDecorationSize = 13;
138 static const float minSearchFieldResultsDecorationSize = 9;
139 static const float maxSearchFieldResultsDecorationSize = 30;
140 static const float defaultSearchFieldResultsButtonWidth = 18;
141
142 static bool gWebKitIsBeingUnloaded;
143
144 static bool documentIsInApplicationChromeMode(const Document* document)
145 {
146     Settings* settings = document->settings();
147     return settings && settings->inApplicationChromeMode();
148 }
149
150 void RenderThemeWin::setWebKitIsBeingUnloaded()
151 {
152     gWebKitIsBeingUnloaded = true;
153 }
154
155 PassRefPtr<RenderTheme> RenderThemeWin::create()
156 {
157     return adoptRef(new RenderThemeWin);
158 }
159
160 #if !USE(SAFARI_THEME)
161 PassRefPtr<RenderTheme> RenderTheme::themeForPage(Page* page)
162 {
163     static RenderTheme* winTheme = RenderThemeWin::create().releaseRef();
164     return winTheme;
165 }
166 #endif
167
168 RenderThemeWin::RenderThemeWin()
169     : m_buttonTheme(0)
170     , m_textFieldTheme(0)
171     , m_menuListTheme(0)
172     , m_sliderTheme(0)
173     , m_spinButtonTheme(0)
174 {
175     haveTheme = uxthemeLibrary() && IsThemeActive();
176 }
177
178 RenderThemeWin::~RenderThemeWin()
179 {
180     // If WebKit is being unloaded, then uxtheme.dll is no longer available.
181     if (gWebKitIsBeingUnloaded || !uxthemeLibrary())
182         return;
183     close();
184 }
185
186 HANDLE RenderThemeWin::buttonTheme() const
187 {
188     if (haveTheme && !m_buttonTheme)
189         m_buttonTheme = OpenThemeData(0, L"Button");
190     return m_buttonTheme;
191 }
192
193 HANDLE RenderThemeWin::textFieldTheme() const
194 {
195     if (haveTheme && !m_textFieldTheme)
196         m_textFieldTheme = OpenThemeData(0, L"Edit");
197     return m_textFieldTheme;
198 }
199
200 HANDLE RenderThemeWin::menuListTheme() const
201 {
202     if (haveTheme && !m_menuListTheme)
203         m_menuListTheme = OpenThemeData(0, L"ComboBox");
204     return m_menuListTheme;
205 }
206
207 HANDLE RenderThemeWin::sliderTheme() const
208 {
209     if (haveTheme && !m_sliderTheme)
210         m_sliderTheme = OpenThemeData(0, L"TrackBar");
211     return m_sliderTheme;
212 }
213
214 HANDLE RenderThemeWin::spinButtonTheme() const
215 {
216     if (haveTheme && !m_spinButtonTheme)
217         m_spinButtonTheme = OpenThemeData(0, L"Spin");
218     return m_spinButtonTheme;
219 }
220
221 void RenderThemeWin::close()
222 {
223     // This method will need to be called when the OS theme changes to flush our cached themes.
224     if (m_buttonTheme)
225         CloseThemeData(m_buttonTheme);
226     if (m_textFieldTheme)
227         CloseThemeData(m_textFieldTheme);
228     if (m_menuListTheme)
229         CloseThemeData(m_menuListTheme);
230     if (m_sliderTheme)
231         CloseThemeData(m_sliderTheme);
232     if (m_spinButtonTheme)
233         CloseThemeData(m_spinButtonTheme);
234     m_buttonTheme = m_textFieldTheme = m_menuListTheme = m_sliderTheme = m_spinButtonTheme = 0;
235
236     haveTheme = uxthemeLibrary() && IsThemeActive();
237 }
238
239 void RenderThemeWin::themeChanged()
240 {
241     close();
242 }
243
244 String RenderThemeWin::extraDefaultStyleSheet()
245 {
246     return String(themeWinUserAgentStyleSheet, sizeof(themeWinUserAgentStyleSheet));
247 }
248
249 String RenderThemeWin::extraQuirksStyleSheet()
250 {
251     return String(themeWinQuirksUserAgentStyleSheet, sizeof(themeWinQuirksUserAgentStyleSheet));
252 }
253
254 bool RenderThemeWin::supportsHover(const RenderStyle*) const
255 {
256     // The Classic/2k look has no hover effects.
257     return haveTheme;
258 }
259
260 Color RenderThemeWin::platformActiveSelectionBackgroundColor() const
261 {
262     COLORREF color = GetSysColor(COLOR_HIGHLIGHT);
263     return Color(GetRValue(color), GetGValue(color), GetBValue(color));
264 }
265
266 Color RenderThemeWin::platformInactiveSelectionBackgroundColor() const
267 {
268     // This color matches Firefox.
269     return Color(176, 176, 176);
270 }
271
272 Color RenderThemeWin::platformActiveSelectionForegroundColor() const
273 {
274     COLORREF color = GetSysColor(COLOR_HIGHLIGHTTEXT);
275     return Color(GetRValue(color), GetGValue(color), GetBValue(color));
276 }
277
278 Color RenderThemeWin::platformInactiveSelectionForegroundColor() const
279 {
280     return platformActiveSelectionForegroundColor();
281 }
282
283 static void fillFontDescription(FontDescription& fontDescription, LOGFONT& logFont, float fontSize)
284 {    
285     fontDescription.setIsAbsoluteSize(true);
286     fontDescription.setGenericFamily(FontDescription::NoFamily);
287     fontDescription.firstFamily().setFamily(String(logFont.lfFaceName));
288     fontDescription.setSpecifiedSize(fontSize);
289     fontDescription.setWeight(logFont.lfWeight >= 700 ? FontWeightBold : FontWeightNormal); // FIXME: Use real weight.
290     fontDescription.setItalic(logFont.lfItalic);
291 }
292
293 static void fillFontDescription(FontDescription& fontDescription, LOGFONT& logFont)
294 {   
295     fillFontDescription(fontDescription, logFont, abs(logFont.lfHeight));
296 }
297
298 void RenderThemeWin::systemFont(int propId, FontDescription& fontDescription) const
299 {
300     static FontDescription captionFont;
301     static FontDescription controlFont;
302     static FontDescription smallCaptionFont;
303     static FontDescription menuFont;
304     static FontDescription iconFont;
305     static FontDescription messageBoxFont;
306     static FontDescription statusBarFont;
307     static FontDescription systemFont;
308     
309     static bool initialized;
310     static NONCLIENTMETRICS ncm;
311
312     if (!initialized) {
313         initialized = true;
314         ncm.cbSize = sizeof(NONCLIENTMETRICS);
315         ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0);
316     }
317  
318     switch (propId) {
319         case CSSValueIcon: {
320             if (!iconFont.isAbsoluteSize()) {
321                 LOGFONT logFont;
322                 ::SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(logFont), &logFont, 0);
323                 fillFontDescription(iconFont, logFont);
324             }
325             fontDescription = iconFont;
326             break;
327         }
328         case CSSValueMenu:
329             if (!menuFont.isAbsoluteSize())
330                 fillFontDescription(menuFont, ncm.lfMenuFont);
331             fontDescription = menuFont;
332             break;
333         case CSSValueMessageBox:
334             if (!messageBoxFont.isAbsoluteSize())
335                 fillFontDescription(messageBoxFont, ncm.lfMessageFont);
336             fontDescription = messageBoxFont;
337             break;
338         case CSSValueStatusBar:
339             if (!statusBarFont.isAbsoluteSize())
340                 fillFontDescription(statusBarFont, ncm.lfStatusFont);
341             fontDescription = statusBarFont;
342             break;
343         case CSSValueCaption:
344             if (!captionFont.isAbsoluteSize())
345                 fillFontDescription(captionFont, ncm.lfCaptionFont);
346             fontDescription = captionFont;
347             break;
348         case CSSValueSmallCaption:
349             if (!smallCaptionFont.isAbsoluteSize())
350                 fillFontDescription(smallCaptionFont, ncm.lfSmCaptionFont);
351             fontDescription = smallCaptionFont;
352             break;
353         case CSSValueWebkitSmallControl:
354         case CSSValueWebkitMiniControl: // Just map to small.
355         case CSSValueWebkitControl: // Just map to small.
356             if (!controlFont.isAbsoluteSize()) {
357                 HGDIOBJ hGDI = ::GetStockObject(DEFAULT_GUI_FONT);
358                 if (hGDI) {
359                     LOGFONT logFont;
360                     if (::GetObject(hGDI, sizeof(logFont), &logFont) > 0)
361                         fillFontDescription(controlFont, logFont, defaultControlFontPixelSize);
362                 }
363             }
364             fontDescription = controlFont;
365             break;
366         default: { // Everything else uses the stock GUI font.
367             if (!systemFont.isAbsoluteSize()) {
368                 HGDIOBJ hGDI = ::GetStockObject(DEFAULT_GUI_FONT);
369                 if (hGDI) {
370                     LOGFONT logFont;
371                     if (::GetObject(hGDI, sizeof(logFont), &logFont) > 0)
372                         fillFontDescription(systemFont, logFont);
373                 }
374             }
375             fontDescription = systemFont;
376         }
377     }
378 }
379
380 bool RenderThemeWin::supportsFocus(ControlPart appearance) const
381 {
382     switch (appearance) {
383         case PushButtonPart:
384         case ButtonPart:
385         case DefaultButtonPart:
386             return true;
387         default:
388             return false;
389     }
390 }
391
392 bool RenderThemeWin::supportsFocusRing(const RenderStyle* style) const
393 {
394     return supportsFocus(style->appearance());
395 }
396
397 unsigned RenderThemeWin::determineClassicState(RenderObject* o, ControlSubPart subPart)
398 {
399     unsigned state = 0;
400     switch (o->style()->appearance()) {
401         case PushButtonPart:
402         case ButtonPart:
403         case DefaultButtonPart:
404             state = DFCS_BUTTONPUSH;
405             if (!isEnabled(o))
406                 state |= DFCS_INACTIVE;
407             else if (isPressed(o))
408                 state |= DFCS_PUSHED;
409             break;
410         case RadioPart:
411         case CheckboxPart:
412             state = (o->style()->appearance() == RadioPart) ? DFCS_BUTTONRADIO : DFCS_BUTTONCHECK;
413             if (isChecked(o))
414                 state |= DFCS_CHECKED;
415             if (!isEnabled(o))
416                 state |= DFCS_INACTIVE;
417             else if (isPressed(o))
418                 state |= DFCS_PUSHED;
419             break;
420         case MenulistPart:
421             state = DFCS_SCROLLCOMBOBOX;
422             if (!isEnabled(o))
423                 state |= DFCS_INACTIVE;
424             else if (isPressed(o))
425                 state |= DFCS_PUSHED;
426             break;
427         case InnerSpinButtonPart: {
428             bool isUpButton = subPart == SpinButtonUp;
429             state = isUpButton ? DFCS_SCROLLUP : DFCS_SCROLLDOWN;
430             if (!isEnabled(o) || isReadOnlyControl(o))
431                 state |= DFCS_INACTIVE;
432             else if (isPressed(o) && isUpButton == isSpinUpButtonPartPressed(o))
433                 state |= DFCS_PUSHED;
434             else if (isHovered(o) && isUpButton == isSpinUpButtonPartHovered(o))
435                 state |= DFCS_HOT;
436             break;
437         }
438         default:
439             break;
440     }
441     return state;
442 }
443
444 unsigned RenderThemeWin::determineState(RenderObject* o)
445 {
446     unsigned result = TS_NORMAL;
447     ControlPart appearance = o->style()->appearance();
448     if (!isEnabled(o))
449         result = TS_DISABLED;
450     else if (isReadOnlyControl(o) && (TextFieldPart == appearance || TextAreaPart == appearance || SearchFieldPart == appearance))
451         result = TFS_READONLY; // Readonly is supported on textfields.
452     else if (isPressed(o)) // Active overrides hover and focused.
453         result = TS_ACTIVE;
454     else if (supportsFocus(appearance) && isFocused(o))
455         result = TS_FOCUSED;
456     else if (isHovered(o))
457         result = TS_HOVER;
458     if (isChecked(o))
459         result += 4; // 4 unchecked states, 4 checked states.
460     return result;
461 }
462
463 unsigned RenderThemeWin::determineSliderThumbState(RenderObject* o)
464 {
465     unsigned result = TUS_NORMAL;
466     if (!isEnabled(o->parent()))
467         result = TUS_DISABLED;
468     else if (supportsFocus(o->style()->appearance()) && isFocused(o->parent()))
469         result = TUS_FOCUSED;
470     else if (toRenderSlider(o->parent())->inDragMode())
471         result = TUS_PRESSED;
472     else if (isHovered(o))
473         result = TUS_HOT;
474     return result;
475 }
476
477 unsigned RenderThemeWin::determineButtonState(RenderObject* o)
478 {
479     unsigned result = PBS_NORMAL;
480     if (!isEnabled(o))
481         result = PBS_DISABLED;
482     else if (isPressed(o))
483         result = PBS_PRESSED;
484     else if (supportsFocus(o->style()->appearance()) && isFocused(o))
485         result = PBS_DEFAULTED;
486     else if (isHovered(o))
487         result = PBS_HOT;
488     else if (isDefault(o))
489         result = PBS_DEFAULTED;
490     return result;
491 }
492
493 unsigned RenderThemeWin::determineSpinButtonState(RenderObject* o, ControlSubPart subPart)
494 {
495     bool isUpButton = subPart == SpinButtonUp;
496     unsigned result = isUpButton ? UPS_NORMAL : DNS_NORMAL;
497     if (!isEnabled(o) || isReadOnlyControl(o))
498         result = isUpButton ? UPS_DISABLED : DNS_DISABLED;
499     else if (isPressed(o) && isUpButton == isSpinUpButtonPartPressed(o))
500         result = isUpButton ? UPS_PRESSED : DNS_PRESSED;
501     else if (isHovered(o) && isUpButton == isSpinUpButtonPartHovered(o))
502         result = isUpButton ? UPS_HOT : DNS_HOT;
503     return result;
504 }
505
506 ThemeData RenderThemeWin::getClassicThemeData(RenderObject* o, ControlSubPart subPart)
507 {
508     ThemeData result;
509     switch (o->style()->appearance()) {
510         case PushButtonPart:
511         case ButtonPart:
512         case DefaultButtonPart:
513         case CheckboxPart:
514         case RadioPart:
515             result.m_part = DFC_BUTTON;
516             result.m_state = determineClassicState(o);
517             break;
518         case MenulistPart:
519             result.m_part = DFC_SCROLL;
520             result.m_state = determineClassicState(o);
521             break;
522         case SearchFieldPart:
523         case TextFieldPart:
524         case TextAreaPart:
525             result.m_part = TFP_TEXTFIELD;
526             result.m_state = determineState(o);
527             break;
528         case SliderHorizontalPart:
529             result.m_part = TKP_TRACK;
530             result.m_state = TS_NORMAL;
531             break;
532         case SliderVerticalPart:
533             result.m_part = TKP_TRACKVERT;
534             result.m_state = TS_NORMAL;
535             break;
536         case SliderThumbHorizontalPart:
537             result.m_part = TKP_THUMBBOTTOM;
538             result.m_state = determineSliderThumbState(o);
539             break;
540         case SliderThumbVerticalPart:
541             result.m_part = TKP_THUMBRIGHT;
542             result.m_state = determineSliderThumbState(o);
543             break;
544         case InnerSpinButtonPart:
545             result.m_part = DFC_SCROLL;
546             result.m_state = determineClassicState(o, subPart);
547             break;
548         default:
549             break;
550     }
551     return result;
552 }
553
554 ThemeData RenderThemeWin::getThemeData(RenderObject* o, ControlSubPart subPart)
555 {
556     if (!haveTheme)
557         return getClassicThemeData(o, subPart);
558
559     ThemeData result;
560     switch (o->style()->appearance()) {
561         case PushButtonPart:
562         case ButtonPart:
563         case DefaultButtonPart:
564             result.m_part = BP_BUTTON;
565             result.m_state = determineButtonState(o);
566             break;
567         case CheckboxPart:
568             result.m_part = BP_CHECKBOX;
569             result.m_state = determineState(o);
570             break;
571         case MenulistPart:
572         case MenulistButtonPart: {
573             const bool isVistaOrLater = (windowsVersion() >= WindowsVista);
574             result.m_part = isVistaOrLater ? CP_DROPDOWNBUTTONRIGHT : CP_DROPDOWNBUTTON;
575             if (isVistaOrLater && documentIsInApplicationChromeMode(o->document())) {
576                 // The "readonly" look we use in application chrome mode
577                 // only uses a "normal" look for the drop down button.
578                 result.m_state = TS_NORMAL;
579             } else
580                 result.m_state = determineState(o);
581             break;
582         }
583         case RadioPart:
584             result.m_part = BP_RADIO;
585             result.m_state = determineState(o);
586             break;
587         case SearchFieldPart:
588         case TextFieldPart:
589         case TextAreaPart:
590             result.m_part = (windowsVersion() >= WindowsVista) ? EP_EDITBORDER_NOSCROLL : TFP_TEXTFIELD;
591             result.m_state = determineState(o);
592             break;
593         case SliderHorizontalPart:
594             result.m_part = TKP_TRACK;
595             result.m_state = TS_NORMAL;
596             break;
597         case SliderVerticalPart:
598             result.m_part = TKP_TRACKVERT;
599             result.m_state = TS_NORMAL;
600             break;
601         case SliderThumbHorizontalPart:
602             result.m_part = TKP_THUMBBOTTOM;
603             result.m_state = determineSliderThumbState(o);
604             break;
605         case SliderThumbVerticalPart:
606             result.m_part = TKP_THUMBRIGHT;
607             result.m_state = determineSliderThumbState(o);
608             break;
609         case InnerSpinButtonPart:
610             result.m_part = subPart == SpinButtonUp ? SPNP_UP : SPNP_DOWN;
611             result.m_state = determineSpinButtonState(o, subPart);
612             break;
613     }
614
615     return result;
616 }
617
618 static void drawControl(GraphicsContext* context, RenderObject* o, HANDLE theme, const ThemeData& themeData, const IntRect& r)
619 {
620     bool alphaBlend = false;
621     if (theme)
622         alphaBlend = IsThemeBackgroundPartiallyTransparent(theme, themeData.m_part, themeData.m_state);
623     LocalWindowsContext windowsContext(context, r, alphaBlend);
624     RECT widgetRect = r;
625     if (theme)
626         DrawThemeBackground(theme, windowsContext.hdc(), themeData.m_part, themeData.m_state, &widgetRect, 0);
627     else {
628         HDC hdc = windowsContext.hdc();
629         if (themeData.m_part == TFP_TEXTFIELD) {
630             ::DrawEdge(hdc, &widgetRect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
631             if (themeData.m_state == TS_DISABLED || themeData.m_state ==  TFS_READONLY)
632                 ::FillRect(hdc, &widgetRect, (HBRUSH)(COLOR_BTNFACE+1));
633             else
634                 ::FillRect(hdc, &widgetRect, (HBRUSH)(COLOR_WINDOW+1));
635         } else if (themeData.m_part == TKP_TRACK || themeData.m_part == TKP_TRACKVERT) {
636             ::DrawEdge(hdc, &widgetRect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
637             ::FillRect(hdc, &widgetRect, (HBRUSH)GetStockObject(GRAY_BRUSH));
638         } else if ((o->style()->appearance() == SliderThumbHorizontalPart ||
639                     o->style()->appearance() == SliderThumbVerticalPart) && 
640                    (themeData.m_part == TKP_THUMBBOTTOM || themeData.m_part == TKP_THUMBTOP || 
641                     themeData.m_part == TKP_THUMBLEFT || themeData.m_part == TKP_THUMBRIGHT)) {
642             ::DrawEdge(hdc, &widgetRect, EDGE_RAISED, BF_RECT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
643             if (themeData.m_state == TUS_DISABLED) {
644                 static WORD patternBits[8] = {0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55};
645                 HBITMAP patternBmp = ::CreateBitmap(8, 8, 1, 1, patternBits);
646                 if (patternBmp) {
647                     HBRUSH brush = (HBRUSH) ::CreatePatternBrush(patternBmp);
648                     COLORREF oldForeColor = ::SetTextColor(hdc, ::GetSysColor(COLOR_3DFACE));
649                     COLORREF oldBackColor = ::SetBkColor(hdc, ::GetSysColor(COLOR_3DHILIGHT));
650                     POINT p;
651                     ::GetViewportOrgEx(hdc, &p);
652                     ::SetBrushOrgEx(hdc, p.x + widgetRect.left, p.y + widgetRect.top, NULL);
653                     HBRUSH oldBrush = (HBRUSH) ::SelectObject(hdc, brush);
654                     ::FillRect(hdc, &widgetRect, brush);
655                     ::SetTextColor(hdc, oldForeColor);
656                     ::SetBkColor(hdc, oldBackColor);
657                     ::SelectObject(hdc, oldBrush);
658                     ::DeleteObject(brush); 
659                 } else
660                     ::FillRect(hdc, &widgetRect, (HBRUSH)COLOR_3DHILIGHT);
661                 ::DeleteObject(patternBmp);
662             }
663         } else {
664             // Push buttons, buttons, checkboxes and radios, and the dropdown arrow in menulists.
665             if (o->style()->appearance() == DefaultButtonPart) {
666                 HBRUSH brush = ::GetSysColorBrush(COLOR_3DDKSHADOW);
667                 ::FrameRect(hdc, &widgetRect, brush);
668                 ::InflateRect(&widgetRect, -1, -1);
669                 ::DrawEdge(hdc, &widgetRect, BDR_RAISEDOUTER, BF_RECT | BF_MIDDLE);
670             }
671             ::DrawFrameControl(hdc, &widgetRect, themeData.m_part, themeData.m_state);
672         }
673     }
674 }
675
676 bool RenderThemeWin::paintButton(RenderObject* o, const PaintInfo& i, const IntRect& r)
677 {  
678     drawControl(i.context,  o, buttonTheme(), getThemeData(o), r);
679     return false;
680 }
681
682 void RenderThemeWin::adjustInnerSpinButtonStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
683 {
684     int width = ::GetSystemMetrics(SM_CXVSCROLL);
685     if (width <= 0)
686         width = 17; // Vista's default.
687     style->setWidth(Length(width, Fixed));
688     style->setMinWidth(Length(width, Fixed));
689 }
690
691 bool RenderThemeWin::paintInnerSpinButton(RenderObject* o, const PaintInfo& i, const IntRect& r)
692 {
693     // We split the specified rectangle into two vertically. We can't draw a
694     // spin button of which height is less than 2px.
695     if (r.height() < 2)
696         return false;
697     IntRect upRect(r);
698     upRect.setHeight(r.height() / 2);
699     IntRect downRect(r);
700     downRect.setY(upRect.maxY());
701     downRect.setHeight(r.height() - upRect.height());
702     drawControl(i.context, o, spinButtonTheme(), getThemeData(o, SpinButtonUp), upRect);
703     drawControl(i.context, o, spinButtonTheme(), getThemeData(o, SpinButtonDown), downRect);
704     return false;
705 }
706
707 void RenderThemeWin::setCheckboxSize(RenderStyle* style) const
708 {
709     // If the width and height are both specified, then we have nothing to do.
710     if (!style->width().isIntrinsicOrAuto() && !style->height().isAuto())
711         return;
712
713     // FIXME:  A hard-coded size of 13 is used.  This is wrong but necessary for now.  It matches Firefox.
714     // At different DPI settings on Windows, querying the theme gives you a larger size that accounts for
715     // the higher DPI.  Until our entire engine honors a DPI setting other than 96, we can't rely on the theme's
716     // metrics.
717     if (style->width().isIntrinsicOrAuto())
718         style->setWidth(Length(13, Fixed));
719     if (style->height().isAuto())
720         style->setHeight(Length(13, Fixed));
721 }
722
723 bool RenderThemeWin::paintTextField(RenderObject* o, const PaintInfo& i, const IntRect& r)
724 {
725     drawControl(i.context,  o, textFieldTheme(), getThemeData(o), r);
726     return false;
727 }
728
729 bool RenderThemeWin::paintMenuList(RenderObject* o, const PaintInfo& i, const IntRect& r)
730 {
731     HANDLE theme;
732     int part;
733     if (haveTheme && (windowsVersion() >= WindowsVista)) {
734         theme = menuListTheme();
735         if (documentIsInApplicationChromeMode(o->document()))
736             part = CP_READONLY;
737         else
738             part = CP_BORDER;
739     } else {
740         theme = textFieldTheme();
741         part = TFP_TEXTFIELD;
742     }
743
744     drawControl(i.context,  o, theme, ThemeData(part, determineState(o)), r);
745     
746     return paintMenuListButton(o, i, r);
747 }
748
749 void RenderThemeWin::adjustMenuListStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
750 {
751     style->resetBorder();
752     adjustMenuListButtonStyle(selector, style, e);
753 }
754
755 void RenderThemeWin::adjustMenuListButtonStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
756 {
757     // These are the paddings needed to place the text correctly in the <select> box
758     const int dropDownBoxPaddingTop    = 2;
759     const int dropDownBoxPaddingRight  = style->direction() == LTR ? 4 + dropDownButtonWidth : 4;
760     const int dropDownBoxPaddingBottom = 2;
761     const int dropDownBoxPaddingLeft   = style->direction() == LTR ? 4 : 4 + dropDownButtonWidth;
762     // The <select> box must be at least 12px high for the button to render nicely on Windows
763     const int dropDownBoxMinHeight = 12;
764     
765     // Position the text correctly within the select box and make the box wide enough to fit the dropdown button
766     style->setPaddingTop(Length(dropDownBoxPaddingTop, Fixed));
767     style->setPaddingRight(Length(dropDownBoxPaddingRight, Fixed));
768     style->setPaddingBottom(Length(dropDownBoxPaddingBottom, Fixed));
769     style->setPaddingLeft(Length(dropDownBoxPaddingLeft, Fixed));
770
771     // Height is locked to auto
772     style->setHeight(Length(Auto));
773
774     // Calculate our min-height
775     int minHeight = style->fontMetrics().height();
776     minHeight = max(minHeight, dropDownBoxMinHeight);
777
778     style->setMinHeight(Length(minHeight, Fixed));
779     
780     // White-space is locked to pre
781     style->setWhiteSpace(PRE);
782 }
783
784 bool RenderThemeWin::paintMenuListButton(RenderObject* o, const PaintInfo& i, const IntRect& r)
785 {
786     // FIXME: Don't make hardcoded assumptions about the thickness of the textfield border.
787     int borderThickness = haveTheme ? 1 : 2;
788
789     // Paint the dropdown button on the inner edge of the text field,
790     // leaving space for the text field's 1px border
791     IntRect buttonRect(r);
792     buttonRect.inflate(-borderThickness);
793     if (o->style()->direction() == LTR)
794         buttonRect.setX(buttonRect.maxX() - dropDownButtonWidth);
795     buttonRect.setWidth(dropDownButtonWidth);
796
797     if ((windowsVersion() >= WindowsVista)) {
798         // Outset the top, right, and bottom borders of the button so that they coincide with the <select>'s border.
799         buttonRect.setY(buttonRect.y() - vistaMenuListButtonOutset);
800         buttonRect.setHeight(buttonRect.height() + 2 * vistaMenuListButtonOutset);
801         buttonRect.setWidth(buttonRect.width() + vistaMenuListButtonOutset);
802     }
803
804     drawControl(i.context, o, menuListTheme(), getThemeData(o), buttonRect);
805
806     return false;
807 }
808
809 const int trackWidth = 4;
810
811 bool RenderThemeWin::paintSliderTrack(RenderObject* o, const PaintInfo& i, const IntRect& r)
812 {
813     IntRect bounds = r;
814     
815     if (o->style()->appearance() ==  SliderHorizontalPart) {
816         bounds.setHeight(trackWidth);
817         bounds.setY(r.y() + r.height() / 2 - trackWidth / 2);
818     } else if (o->style()->appearance() == SliderVerticalPart) {
819         bounds.setWidth(trackWidth);
820         bounds.setX(r.x() + r.width() / 2 - trackWidth / 2);
821     }
822     
823     drawControl(i.context,  o, sliderTheme(), getThemeData(o), bounds);
824     return false;
825 }
826
827 bool RenderThemeWin::paintSliderThumb(RenderObject* o, const PaintInfo& i, const IntRect& r)
828 {   
829     drawControl(i.context,  o, sliderTheme(), getThemeData(o), r);
830     return false;
831 }
832
833 const int sliderThumbWidth = 7;
834 const int sliderThumbHeight = 15;
835
836 void RenderThemeWin::adjustSliderThumbSize(RenderObject* o) const
837 {
838     ControlPart part = o->style()->appearance();
839     if (part == SliderThumbVerticalPart) {
840         o->style()->setWidth(Length(sliderThumbHeight, Fixed));
841         o->style()->setHeight(Length(sliderThumbWidth, Fixed));
842     } else if (part == SliderThumbHorizontalPart) {
843         o->style()->setWidth(Length(sliderThumbWidth, Fixed));
844         o->style()->setHeight(Length(sliderThumbHeight, Fixed));
845     }
846 #if ENABLE(VIDEO)
847     else if (part == MediaSliderThumbPart || part == MediaVolumeSliderThumbPart) 
848         RenderMediaControls::adjustMediaSliderThumbSize(o);
849 #endif
850 }
851
852 bool RenderThemeWin::paintSearchField(RenderObject* o, const PaintInfo& i, const IntRect& r)
853 {
854     return paintTextField(o, i, r);
855 }
856
857 void RenderThemeWin::adjustSearchFieldStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
858 {
859     // Override paddingSize to match AppKit text positioning.
860     const int padding = 1;
861     style->setPaddingLeft(Length(padding, Fixed));
862     style->setPaddingRight(Length(padding, Fixed));
863     style->setPaddingTop(Length(padding, Fixed));
864     style->setPaddingBottom(Length(padding, Fixed));
865     if (e && e->focused() && e->document()->frame()->selection()->isFocusedAndActive())
866         style->setOutlineOffset(-2);
867 }
868
869 bool RenderThemeWin::paintSearchFieldCancelButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
870 {
871     IntRect bounds = r;
872     ASSERT(o->parent());
873     if (!o->parent() || !o->parent()->isBox())
874         return false;
875     
876     RenderBox* parentRenderBox = toRenderBox(o->parent());
877
878     IntRect parentBox = parentRenderBox->absoluteContentBox();
879     
880     // Make sure the scaled button stays square and will fit in its parent's box
881     bounds.setHeight(min(parentBox.width(), min(parentBox.height(), bounds.height())));
882     bounds.setWidth(bounds.height());
883
884     // Center the button vertically.  Round up though, so if it has to be one pixel off-center, it will
885     // be one pixel closer to the bottom of the field.  This tends to look better with the text.
886     bounds.setY(parentBox.y() + (parentBox.height() - bounds.height() + 1) / 2);
887
888     static Image* cancelImage = Image::loadPlatformResource("searchCancel").releaseRef();
889     static Image* cancelPressedImage = Image::loadPlatformResource("searchCancelPressed").releaseRef();
890     paintInfo.context->drawImage(isPressed(o) ? cancelPressedImage : cancelImage, o->style()->colorSpace(), bounds);
891     return false;
892 }
893
894 void RenderThemeWin::adjustSearchFieldCancelButtonStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
895 {
896     // Scale the button size based on the font size
897     float fontScale = style->fontSize() / defaultControlFontPixelSize;
898     int cancelButtonSize = lroundf(min(max(minCancelButtonSize, defaultCancelButtonSize * fontScale), maxCancelButtonSize));
899     style->setWidth(Length(cancelButtonSize, Fixed));
900     style->setHeight(Length(cancelButtonSize, Fixed));
901 }
902
903 void RenderThemeWin::adjustSearchFieldDecorationStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
904 {
905     IntSize emptySize(1, 11);
906     style->setWidth(Length(emptySize.width(), Fixed));
907     style->setHeight(Length(emptySize.height(), Fixed));
908 }
909
910 void RenderThemeWin::adjustSearchFieldResultsDecorationStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
911 {
912     // Scale the decoration size based on the font size
913     float fontScale = style->fontSize() / defaultControlFontPixelSize;
914     int magnifierSize = lroundf(min(max(minSearchFieldResultsDecorationSize, defaultSearchFieldResultsDecorationSize * fontScale), 
915                                      maxSearchFieldResultsDecorationSize));
916     style->setWidth(Length(magnifierSize, Fixed));
917     style->setHeight(Length(magnifierSize, Fixed));
918 }
919
920 bool RenderThemeWin::paintSearchFieldResultsDecoration(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
921 {
922     IntRect bounds = r;
923     ASSERT(o->parent());
924     if (!o->parent() || !o->parent()->isBox())
925         return false;
926     
927     RenderBox* parentRenderBox = toRenderBox(o->parent());
928     IntRect parentBox = parentRenderBox->absoluteContentBox();
929     
930     // Make sure the scaled decoration stays square and will fit in its parent's box
931     bounds.setHeight(min(parentBox.width(), min(parentBox.height(), bounds.height())));
932     bounds.setWidth(bounds.height());
933
934     // Center the decoration vertically.  Round up though, so if it has to be one pixel off-center, it will
935     // be one pixel closer to the bottom of the field.  This tends to look better with the text.
936     bounds.setY(parentBox.y() + (parentBox.height() - bounds.height() + 1) / 2);
937     
938     static Image* magnifierImage = Image::loadPlatformResource("searchMagnifier").releaseRef();
939     paintInfo.context->drawImage(magnifierImage, o->style()->colorSpace(), bounds);
940     return false;
941 }
942
943 void RenderThemeWin::adjustSearchFieldResultsButtonStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
944 {
945     // Scale the button size based on the font size
946     float fontScale = style->fontSize() / defaultControlFontPixelSize;
947     int magnifierHeight = lroundf(min(max(minSearchFieldResultsDecorationSize, defaultSearchFieldResultsDecorationSize * fontScale), 
948                                    maxSearchFieldResultsDecorationSize));
949     int magnifierWidth = lroundf(magnifierHeight * defaultSearchFieldResultsButtonWidth / defaultSearchFieldResultsDecorationSize);
950     style->setWidth(Length(magnifierWidth, Fixed));
951     style->setHeight(Length(magnifierHeight, Fixed));
952 }
953
954 bool RenderThemeWin::paintSearchFieldResultsButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
955 {
956     IntRect bounds = r;
957     ASSERT(o->parent());
958     if (!o->parent())
959         return false;
960     if (!o->parent() || !o->parent()->isBox())
961         return false;
962     
963     RenderBox* parentRenderBox = toRenderBox(o->parent());
964     IntRect parentBox = parentRenderBox->absoluteContentBox();
965     
966     // Make sure the scaled decoration will fit in its parent's box
967     bounds.setHeight(min(parentBox.height(), bounds.height()));
968     bounds.setWidth(min(parentBox.width(), static_cast<int>(bounds.height() * defaultSearchFieldResultsButtonWidth / defaultSearchFieldResultsDecorationSize)));
969
970     // Center the button vertically.  Round up though, so if it has to be one pixel off-center, it will
971     // be one pixel closer to the bottom of the field.  This tends to look better with the text.
972     bounds.setY(parentBox.y() + (parentBox.height() - bounds.height() + 1) / 2);
973
974     static Image* magnifierImage = Image::loadPlatformResource("searchMagnifierResults").releaseRef();
975     paintInfo.context->drawImage(magnifierImage, o->style()->colorSpace(), bounds);
976     return false;
977 }
978
979 // Map a CSSValue* system color to an index understood by GetSysColor
980 static int cssValueIdToSysColorIndex(int cssValueId)
981 {
982     switch (cssValueId) {
983         case CSSValueActiveborder: return COLOR_ACTIVEBORDER;
984         case CSSValueActivecaption: return COLOR_ACTIVECAPTION;
985         case CSSValueAppworkspace: return COLOR_APPWORKSPACE;
986         case CSSValueBackground: return COLOR_BACKGROUND;
987         case CSSValueButtonface: return COLOR_BTNFACE;
988         case CSSValueButtonhighlight: return COLOR_BTNHIGHLIGHT;
989         case CSSValueButtonshadow: return COLOR_BTNSHADOW;
990         case CSSValueButtontext: return COLOR_BTNTEXT;
991         case CSSValueCaptiontext: return COLOR_CAPTIONTEXT;
992         case CSSValueGraytext: return COLOR_GRAYTEXT;
993         case CSSValueHighlight: return COLOR_HIGHLIGHT;
994         case CSSValueHighlighttext: return COLOR_HIGHLIGHTTEXT;
995         case CSSValueInactiveborder: return COLOR_INACTIVEBORDER;
996         case CSSValueInactivecaption: return COLOR_INACTIVECAPTION;
997         case CSSValueInactivecaptiontext: return COLOR_INACTIVECAPTIONTEXT;
998         case CSSValueInfobackground: return COLOR_INFOBK;
999         case CSSValueInfotext: return COLOR_INFOTEXT;
1000         case CSSValueMenu: return COLOR_MENU;
1001         case CSSValueMenutext: return COLOR_MENUTEXT;
1002         case CSSValueScrollbar: return COLOR_SCROLLBAR;
1003         case CSSValueThreeddarkshadow: return COLOR_3DDKSHADOW;
1004         case CSSValueThreedface: return COLOR_3DFACE;
1005         case CSSValueThreedhighlight: return COLOR_3DHIGHLIGHT;
1006         case CSSValueThreedlightshadow: return COLOR_3DLIGHT;
1007         case CSSValueThreedshadow: return COLOR_3DSHADOW;
1008         case CSSValueWindow: return COLOR_WINDOW;
1009         case CSSValueWindowframe: return COLOR_WINDOWFRAME;
1010         case CSSValueWindowtext: return COLOR_WINDOWTEXT;
1011         default: return -1; // Unsupported CSSValue
1012     }
1013 }
1014
1015 Color RenderThemeWin::systemColor(int cssValueId) const
1016 {
1017     int sysColorIndex = cssValueIdToSysColorIndex(cssValueId);
1018     if (sysColorIndex == -1)
1019         return RenderTheme::systemColor(cssValueId);
1020
1021     COLORREF color = GetSysColor(sysColorIndex);
1022     return Color(GetRValue(color), GetGValue(color), GetBValue(color));
1023 }
1024
1025 #if ENABLE(VIDEO)
1026
1027 String RenderThemeWin::extraMediaControlsStyleSheet()
1028 {
1029     return String(mediaControlsQuickTimeUserAgentStyleSheet, sizeof(mediaControlsQuickTimeUserAgentStyleSheet));
1030 }
1031
1032 bool RenderThemeWin::shouldRenderMediaControlPart(ControlPart part, Element* element)
1033 {
1034     if (part == MediaToggleClosedCaptionsButtonPart) {
1035         // We rely on QuickTime to render captions so only enable the button for a video element.
1036 #if SAFARI_THEME_VERSION >= 4
1037         if (!element->hasTagName(videoTag))
1038             return false;
1039 #else
1040         return false;
1041 #endif
1042     }
1043
1044     return RenderTheme::shouldRenderMediaControlPart(part, element);
1045 }
1046
1047
1048 bool RenderThemeWin::paintMediaFullscreenButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1049 {
1050     return RenderMediaControls::paintMediaControlsPart(MediaFullscreenButton, o, paintInfo, r);
1051 }
1052
1053 bool RenderThemeWin::paintMediaMuteButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1054 {
1055     return RenderMediaControls::paintMediaControlsPart(MediaMuteButton, o, paintInfo, r);
1056 }
1057
1058 bool RenderThemeWin::paintMediaPlayButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1059 {
1060     return RenderMediaControls::paintMediaControlsPart(MediaPlayButton, o, paintInfo, r);
1061 }
1062
1063 bool RenderThemeWin::paintMediaRewindButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1064 {
1065     return RenderMediaControls::paintMediaControlsPart(MediaRewindButton, o, paintInfo, r);
1066 }
1067
1068 bool RenderThemeWin::paintMediaSeekBackButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1069 {
1070     return RenderMediaControls::paintMediaControlsPart(MediaSeekBackButton, o, paintInfo, r);
1071 }
1072
1073 bool RenderThemeWin::paintMediaSeekForwardButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1074 {
1075     return RenderMediaControls::paintMediaControlsPart(MediaSeekForwardButton, o, paintInfo, r);
1076 }
1077
1078 bool RenderThemeWin::paintMediaSliderTrack(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1079 {
1080     return RenderMediaControls::paintMediaControlsPart(MediaSlider, o, paintInfo, r);
1081 }
1082
1083 bool RenderThemeWin::paintMediaSliderThumb(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1084 {
1085     return RenderMediaControls::paintMediaControlsPart(MediaSliderThumb, o, paintInfo, r);
1086 }
1087
1088 bool RenderThemeWin::paintMediaToggleClosedCaptionsButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1089 {
1090     return RenderMediaControls::paintMediaControlsPart(MediaShowClosedCaptionsButton, o, paintInfo, r);
1091 }
1092
1093 bool RenderThemeWin::paintMediaControlsBackground(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1094 {
1095     return RenderMediaControls::paintMediaControlsPart(MediaTimelineContainer, o, paintInfo, r);
1096 }
1097
1098 bool RenderThemeWin::paintMediaVolumeSliderContainer(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1099 {
1100     return RenderMediaControls::paintMediaControlsPart(MediaVolumeSliderContainer, o, paintInfo, r);
1101 }
1102
1103 bool RenderThemeWin::paintMediaVolumeSliderTrack(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1104 {
1105     return RenderMediaControls::paintMediaControlsPart(MediaVolumeSlider, o, paintInfo, r);
1106 }
1107
1108 bool RenderThemeWin::paintMediaVolumeSliderThumb(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1109 {
1110     return RenderMediaControls::paintMediaControlsPart(MediaVolumeSliderThumb, o, paintInfo, r);
1111 }
1112
1113 IntPoint RenderThemeWin::volumeSliderOffsetFromMuteButton(RenderBox* muteButtonBox, const IntSize& size) const
1114 {
1115     return RenderMediaControls::volumeSliderOffsetFromMuteButton(muteButtonBox, size);
1116 }
1117
1118
1119 #endif
1120
1121 }