code.vuplus.com Git - vuplus_webkit/blob - 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))
 467         result = TUS_DISABLED;
 468     else if (supportsFocus(o->style()->appearance()) && isFocused(o))
 469         result = TUS_FOCUSED;
 470     else if (isPressed(o))
 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 #if !OS(WINCE)
 677     if (!alphaBlend && !context->isInTransparencyLayer())
 678         DIBPixelData::setRGBABitmapAlpha(windowsContext.hdc(), r, 255);
 679 #endif
 680 }
 681
 682 bool RenderThemeWin::paintButton(RenderObject* o, const PaintInfo& i, const IntRect& r)
 683 {
 684     drawControl(i.context,  o, buttonTheme(), getThemeData(o), r);
 685     return false;
 686 }
 687
 688 void RenderThemeWin::adjustInnerSpinButtonStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
 689 {
 690     int width = ::GetSystemMetrics(SM_CXVSCROLL);
 691     if (width <= 0)
 692         width = 17; // Vista's default.
 693     style->setWidth(Length(width, Fixed));
 694     style->setMinWidth(Length(width, Fixed));
 695 }
 696
 697 bool RenderThemeWin::paintInnerSpinButton(RenderObject* o, const PaintInfo& i, const IntRect& r)
 698 {
 699     // We split the specified rectangle into two vertically. We can't draw a
 700     // spin button of which height is less than 2px.
 701     if (r.height() < 2)
 702         return false;
 703     IntRect upRect(r);
 704     upRect.setHeight(r.height() / 2);
 705     IntRect downRect(r);
 706     downRect.setY(upRect.maxY());
 707     downRect.setHeight(r.height() - upRect.height());
 708     drawControl(i.context, o, spinButtonTheme(), getThemeData(o, SpinButtonUp), upRect);
 709     drawControl(i.context, o, spinButtonTheme(), getThemeData(o, SpinButtonDown), downRect);
 710     return false;
 711 }
 712
 713 void RenderThemeWin::setCheckboxSize(RenderStyle* style) const
 714 {
 715     // If the width and height are both specified, then we have nothing to do.
 716     if (!style->width().isIntrinsicOrAuto() && !style->height().isAuto())
 717         return;
 718
 719     // FIXME:  A hard-coded size of 13 is used.  This is wrong but necessary for now.  It matches Firefox.
 720     // At different DPI settings on Windows, querying the theme gives you a larger size that accounts for
 721     // the higher DPI.  Until our entire engine honors a DPI setting other than 96, we can't rely on the theme's
 722     // metrics.
 723     if (style->width().isIntrinsicOrAuto())
 724         style->setWidth(Length(13, Fixed));
 725     if (style->height().isAuto())
 726         style->setHeight(Length(13, Fixed));
 727 }
 728
 729 bool RenderThemeWin::paintTextField(RenderObject* o, const PaintInfo& i, const IntRect& r)
 730 {
 731     drawControl(i.context,  o, textFieldTheme(), getThemeData(o), r);
 732     return false;
 733 }
 734
 735 bool RenderThemeWin::paintMenuList(RenderObject* o, const PaintInfo& i, const IntRect& r)
 736 {
 737     HANDLE theme;
 738     int part;
 739     if (haveTheme && (windowsVersion() >= WindowsVista)) {
 740         theme = menuListTheme();
 741         if (documentIsInApplicationChromeMode(o->document()))
 742             part = CP_READONLY;
 743         else
 744             part = CP_BORDER;
 745     } else {
 746         theme = textFieldTheme();
 747         part = TFP_TEXTFIELD;
 748     }
 749
 750     drawControl(i.context,  o, theme, ThemeData(part, determineState(o)), r);
 751
 752     return paintMenuListButton(o, i, r);
 753 }
 754
 755 void RenderThemeWin::adjustMenuListStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
 756 {
 757     style->resetBorder();
 758     adjustMenuListButtonStyle(selector, style, e);
 759 }
 760
 761 void RenderThemeWin::adjustMenuListButtonStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
 762 {
 763     // These are the paddings needed to place the text correctly in the <select> box
 764     const int dropDownBoxPaddingTop    = 2;
 765     const int dropDownBoxPaddingRight  = style->direction() == LTR ? 4 + dropDownButtonWidth : 4;
 766     const int dropDownBoxPaddingBottom = 2;
 767     const int dropDownBoxPaddingLeft   = style->direction() == LTR ? 4 : 4 + dropDownButtonWidth;
 768     // The <select> box must be at least 12px high for the button to render nicely on Windows
 769     const int dropDownBoxMinHeight = 12;
 770
 771     // Position the text correctly within the select box and make the box wide enough to fit the dropdown button
 772     style->setPaddingTop(Length(dropDownBoxPaddingTop, Fixed));
 773     style->setPaddingRight(Length(dropDownBoxPaddingRight, Fixed));
 774     style->setPaddingBottom(Length(dropDownBoxPaddingBottom, Fixed));
 775     style->setPaddingLeft(Length(dropDownBoxPaddingLeft, Fixed));
 776
 777     // Height is locked to auto
 778     style->setHeight(Length(Auto));
 779
 780     // Calculate our min-height
 781     int minHeight = style->fontMetrics().height();
 782     minHeight = max(minHeight, dropDownBoxMinHeight);
 783
 784     style->setMinHeight(Length(minHeight, Fixed));
 785
 786     // White-space is locked to pre
 787     style->setWhiteSpace(PRE);
 788 }
 789
 790 bool RenderThemeWin::paintMenuListButton(RenderObject* o, const PaintInfo& i, const IntRect& r)
 791 {
 792     // FIXME: Don't make hardcoded assumptions about the thickness of the textfield border.
 793     int borderThickness = haveTheme ? 1 : 2;
 794
 795     // Paint the dropdown button on the inner edge of the text field,
 796     // leaving space for the text field's 1px border
 797     IntRect buttonRect(r);
 798     buttonRect.inflate(-borderThickness);
 799     if (o->style()->direction() == LTR)
 800         buttonRect.setX(buttonRect.maxX() - dropDownButtonWidth);
 801     buttonRect.setWidth(dropDownButtonWidth);
 802
 803     if ((windowsVersion() >= WindowsVista)) {
 804         // Outset the top, right, and bottom borders of the button so that they coincide with the <select>'s border.
 805         buttonRect.setY(buttonRect.y() - vistaMenuListButtonOutset);
 806         buttonRect.setHeight(buttonRect.height() + 2 * vistaMenuListButtonOutset);
 807         buttonRect.setWidth(buttonRect.width() + vistaMenuListButtonOutset);
 808     }
 809
 810     drawControl(i.context, o, menuListTheme(), getThemeData(o), buttonRect);
 811
 812     return false;
 813 }
 814
 815 const int trackWidth = 4;
 816
 817 bool RenderThemeWin::paintSliderTrack(RenderObject* o, const PaintInfo& i, const IntRect& r)
 818 {
 819     IntRect bounds = r;
 820
 821     if (o->style()->appearance() ==  SliderHorizontalPart) {
 822         bounds.setHeight(trackWidth);
 823         bounds.setY(r.y() + r.height() / 2 - trackWidth / 2);
 824     } else if (o->style()->appearance() == SliderVerticalPart) {
 825         bounds.setWidth(trackWidth);
 826         bounds.setX(r.x() + r.width() / 2 - trackWidth / 2);
 827     }
 828
 829     drawControl(i.context,  o, sliderTheme(), getThemeData(o), bounds);
 830     return false;
 831 }
 832
 833 bool RenderThemeWin::paintSliderThumb(RenderObject* o, const PaintInfo& i, const IntRect& r)
 834 {
 835     drawControl(i.context,  o, sliderTheme(), getThemeData(o), r);
 836     return false;
 837 }
 838
 839 const int sliderThumbWidth = 7;
 840 const int sliderThumbHeight = 15;
 841
 842 void RenderThemeWin::adjustSliderThumbSize(RenderStyle* style) const
 843 {
 844     ControlPart part = style->appearance();
 845     if (part == SliderThumbVerticalPart) {
 846         style->setWidth(Length(sliderThumbHeight, Fixed));
 847         style->setHeight(Length(sliderThumbWidth, Fixed));
 848     } else if (part == SliderThumbHorizontalPart) {
 849         style->setWidth(Length(sliderThumbWidth, Fixed));
 850         style->setHeight(Length(sliderThumbHeight, Fixed));
 851     }
 852 #if ENABLE(VIDEO)
 853     else if (part == MediaSliderThumbPart || part == MediaVolumeSliderThumbPart)
 854         RenderMediaControls::adjustMediaSliderThumbSize(style);
 855 #endif
 856 }
 857
 858 bool RenderThemeWin::paintSearchField(RenderObject* o, const PaintInfo& i, const IntRect& r)
 859 {
 860     return paintTextField(o, i, r);
 861 }
 862
 863 void RenderThemeWin::adjustSearchFieldStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
 864 {
 865     // Override paddingSize to match AppKit text positioning.
 866     const int padding = 1;
 867     style->setPaddingLeft(Length(padding, Fixed));
 868     style->setPaddingRight(Length(padding, Fixed));
 869     style->setPaddingTop(Length(padding, Fixed));
 870     style->setPaddingBottom(Length(padding, Fixed));
 871     if (e && e->focused() && e->document()->frame()->selection()->isFocusedAndActive())
 872         style->setOutlineOffset(-2);
 873 }
 874
 875 bool RenderThemeWin::paintSearchFieldCancelButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
 876 {
 877     IntRect bounds = r;
 878     ASSERT(o->parent());
 879     if (!o->parent() || !o->parent()->isBox())
 880         return false;
 881
 882     RenderBox* parentRenderBox = toRenderBox(o->parent());
 883
 884     IntRect parentBox = parentRenderBox->absoluteContentBox();
 885
 886     // Make sure the scaled button stays square and will fit in its parent's box
 887     bounds.setHeight(min(parentBox.width(), min(parentBox.height(), bounds.height())));
 888     bounds.setWidth(bounds.height());
 889
 890     // Center the button vertically.  Round up though, so if it has to be one pixel off-center, it will
 891     // be one pixel closer to the bottom of the field.  This tends to look better with the text.
 892     bounds.setY(parentBox.y() + (parentBox.height() - bounds.height() + 1) / 2);
 893
 894     static Image* cancelImage = Image::loadPlatformResource("searchCancel").releaseRef();
 895     static Image* cancelPressedImage = Image::loadPlatformResource("searchCancelPressed").releaseRef();
 896     paintInfo.context->drawImage(isPressed(o) ? cancelPressedImage : cancelImage, o->style()->colorSpace(), bounds);
 897     return false;
 898 }
 899
 900 void RenderThemeWin::adjustSearchFieldCancelButtonStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
 901 {
 902     // Scale the button size based on the font size
 903     float fontScale = style->fontSize() / defaultControlFontPixelSize;
 904     int cancelButtonSize = lroundf(min(max(minCancelButtonSize, defaultCancelButtonSize * fontScale), maxCancelButtonSize));
 905     style->setWidth(Length(cancelButtonSize, Fixed));
 906     style->setHeight(Length(cancelButtonSize, Fixed));
 907 }
 908
 909 void RenderThemeWin::adjustSearchFieldDecorationStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
 910 {
 911     IntSize emptySize(1, 11);
 912     style->setWidth(Length(emptySize.width(), Fixed));
 913     style->setHeight(Length(emptySize.height(), Fixed));
 914 }
 915
 916 void RenderThemeWin::adjustSearchFieldResultsDecorationStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
 917 {
 918     // Scale the decoration size based on the font size
 919     float fontScale = style->fontSize() / defaultControlFontPixelSize;
 920     int magnifierSize = lroundf(min(max(minSearchFieldResultsDecorationSize, defaultSearchFieldResultsDecorationSize * fontScale),
 921                                      maxSearchFieldResultsDecorationSize));
 922     style->setWidth(Length(magnifierSize, Fixed));
 923     style->setHeight(Length(magnifierSize, Fixed));
 924 }
 925
 926 bool RenderThemeWin::paintSearchFieldResultsDecoration(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
 927 {
 928     IntRect bounds = r;
 929     ASSERT(o->parent());
 930     if (!o->parent() || !o->parent()->isBox())
 931         return false;
 932
 933     RenderBox* parentRenderBox = toRenderBox(o->parent());
 934     IntRect parentBox = parentRenderBox->absoluteContentBox();
 935
 936     // Make sure the scaled decoration stays square and will fit in its parent's box
 937     bounds.setHeight(min(parentBox.width(), min(parentBox.height(), bounds.height())));
 938     bounds.setWidth(bounds.height());
 939
 940     // Center the decoration vertically.  Round up though, so if it has to be one pixel off-center, it will
 941     // be one pixel closer to the bottom of the field.  This tends to look better with the text.
 942     bounds.setY(parentBox.y() + (parentBox.height() - bounds.height() + 1) / 2);
 943
 944     static Image* magnifierImage = Image::loadPlatformResource("searchMagnifier").releaseRef();
 945     paintInfo.context->drawImage(magnifierImage, o->style()->colorSpace(), bounds);
 946     return false;
 947 }
 948
 949 void RenderThemeWin::adjustSearchFieldResultsButtonStyle(CSSStyleSelector* selector, RenderStyle* style, Element* e) const
 950 {
 951     // Scale the button size based on the font size
 952     float fontScale = style->fontSize() / defaultControlFontPixelSize;
 953     int magnifierHeight = lroundf(min(max(minSearchFieldResultsDecorationSize, defaultSearchFieldResultsDecorationSize * fontScale),
 954                                    maxSearchFieldResultsDecorationSize));
 955     int magnifierWidth = lroundf(magnifierHeight * defaultSearchFieldResultsButtonWidth / defaultSearchFieldResultsDecorationSize);
 956     style->setWidth(Length(magnifierWidth, Fixed));
 957     style->setHeight(Length(magnifierHeight, Fixed));
 958 }
 959
 960 bool RenderThemeWin::paintSearchFieldResultsButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
 961 {
 962     IntRect bounds = r;
 963     ASSERT(o->parent());
 964     if (!o->parent())
 965         return false;
 966     if (!o->parent() || !o->parent()->isBox())
 967         return false;
 968
 969     RenderBox* parentRenderBox = toRenderBox(o->parent());
 970     IntRect parentBox = parentRenderBox->absoluteContentBox();
 971
 972     // Make sure the scaled decoration will fit in its parent's box
 973     bounds.setHeight(min(parentBox.height(), bounds.height()));
 974     bounds.setWidth(min(parentBox.width(), static_cast<int>(bounds.height() * defaultSearchFieldResultsButtonWidth / defaultSearchFieldResultsDecorationSize)));
 975
 976     // Center the button vertically.  Round up though, so if it has to be one pixel off-center, it will
 977     // be one pixel closer to the bottom of the field.  This tends to look better with the text.
 978     bounds.setY(parentBox.y() + (parentBox.height() - bounds.height() + 1) / 2);
 979
 980     static Image* magnifierImage = Image::loadPlatformResource("searchMagnifierResults").releaseRef();
 981     paintInfo.context->drawImage(magnifierImage, o->style()->colorSpace(), bounds);
 982     return false;
 983 }
 984
 985 // Map a CSSValue* system color to an index understood by GetSysColor
 986 static int cssValueIdToSysColorIndex(int cssValueId)
 987 {
 988     switch (cssValueId) {
 989         case CSSValueActiveborder: return COLOR_ACTIVEBORDER;
 990         case CSSValueActivecaption: return COLOR_ACTIVECAPTION;
 991         case CSSValueAppworkspace: return COLOR_APPWORKSPACE;
 992         case CSSValueBackground: return COLOR_BACKGROUND;
 993         case CSSValueButtonface: return COLOR_BTNFACE;
 994         case CSSValueButtonhighlight: return COLOR_BTNHIGHLIGHT;
 995         case CSSValueButtonshadow: return COLOR_BTNSHADOW;
 996         case CSSValueButtontext: return COLOR_BTNTEXT;
 997         case CSSValueCaptiontext: return COLOR_CAPTIONTEXT;
 998         case CSSValueGraytext: return COLOR_GRAYTEXT;
 999         case CSSValueHighlight: return COLOR_HIGHLIGHT;
1000         case CSSValueHighlighttext: return COLOR_HIGHLIGHTTEXT;
1001         case CSSValueInactiveborder: return COLOR_INACTIVEBORDER;
1002         case CSSValueInactivecaption: return COLOR_INACTIVECAPTION;
1003         case CSSValueInactivecaptiontext: return COLOR_INACTIVECAPTIONTEXT;
1004         case CSSValueInfobackground: return COLOR_INFOBK;
1005         case CSSValueInfotext: return COLOR_INFOTEXT;
1006         case CSSValueMenu: return COLOR_MENU;
1007         case CSSValueMenutext: return COLOR_MENUTEXT;
1008         case CSSValueScrollbar: return COLOR_SCROLLBAR;
1009         case CSSValueThreeddarkshadow: return COLOR_3DDKSHADOW;
1010         case CSSValueThreedface: return COLOR_3DFACE;
1011         case CSSValueThreedhighlight: return COLOR_3DHIGHLIGHT;
1012         case CSSValueThreedlightshadow: return COLOR_3DLIGHT;
1013         case CSSValueThreedshadow: return COLOR_3DSHADOW;
1014         case CSSValueWindow: return COLOR_WINDOW;
1015         case CSSValueWindowframe: return COLOR_WINDOWFRAME;
1016         case CSSValueWindowtext: return COLOR_WINDOWTEXT;
1017         default: return -1; // Unsupported CSSValue
1018     }
1019 }
1020
1021 Color RenderThemeWin::systemColor(int cssValueId) const
1022 {
1023     int sysColorIndex = cssValueIdToSysColorIndex(cssValueId);
1024     if (sysColorIndex == -1)
1025         return RenderTheme::systemColor(cssValueId);
1026
1027     COLORREF color = GetSysColor(sysColorIndex);
1028     return Color(GetRValue(color), GetGValue(color), GetBValue(color));
1029 }
1030
1031 #if ENABLE(VIDEO)
1032
1033 String RenderThemeWin::extraMediaControlsStyleSheet()
1034 {
1035     return String(mediaControlsQuickTimeUserAgentStyleSheet, sizeof(mediaControlsQuickTimeUserAgentStyleSheet));
1036 }
1037
1038 #if ENABLE(FULLSCREEN_API)
1039 String RenderThemeWin::extraFullScreenStyleSheet()
1040 {
1041     return String(fullscreenQuickTimeUserAgentStyleSheet, sizeof(fullscreenQuickTimeUserAgentStyleSheet));
1042 }
1043 #endif
1044
1045 bool RenderThemeWin::supportsClosedCaptioning() const
1046 {
1047         // We rely on QuickTime to render captions so only enable the button for a video element.
1048 #if SAFARI_THEME_VERSION >= 4
1049     return true;
1050 #else
1051     return false;
1052 #endif
1053 }
1054
1055 bool RenderThemeWin::paintMediaFullscreenButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1056 {
1057     return RenderMediaControls::paintMediaControlsPart(MediaFullscreenButton, o, paintInfo, r);
1058 }
1059
1060 bool RenderThemeWin::paintMediaMuteButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1061 {
1062     return RenderMediaControls::paintMediaControlsPart(MediaMuteButton, o, paintInfo, r);
1063 }
1064
1065 bool RenderThemeWin::paintMediaPlayButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1066 {
1067     return RenderMediaControls::paintMediaControlsPart(MediaPlayButton, o, paintInfo, r);
1068 }
1069
1070 bool RenderThemeWin::paintMediaRewindButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1071 {
1072     return RenderMediaControls::paintMediaControlsPart(MediaRewindButton, o, paintInfo, r);
1073 }
1074
1075 bool RenderThemeWin::paintMediaSeekBackButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1076 {
1077     return RenderMediaControls::paintMediaControlsPart(MediaSeekBackButton, o, paintInfo, r);
1078 }
1079
1080 bool RenderThemeWin::paintMediaSeekForwardButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1081 {
1082     return RenderMediaControls::paintMediaControlsPart(MediaSeekForwardButton, o, paintInfo, r);
1083 }
1084
1085 bool RenderThemeWin::paintMediaSliderTrack(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1086 {
1087     return RenderMediaControls::paintMediaControlsPart(MediaSlider, o, paintInfo, r);
1088 }
1089
1090 bool RenderThemeWin::paintMediaSliderThumb(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1091 {
1092     return RenderMediaControls::paintMediaControlsPart(MediaSliderThumb, o, paintInfo, r);
1093 }
1094
1095 bool RenderThemeWin::paintMediaToggleClosedCaptionsButton(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1096 {
1097     return RenderMediaControls::paintMediaControlsPart(MediaShowClosedCaptionsButton, o, paintInfo, r);
1098 }
1099
1100 bool RenderThemeWin::paintMediaControlsBackground(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1101 {
1102     return RenderMediaControls::paintMediaControlsPart(MediaTimelineContainer, o, paintInfo, r);
1103 }
1104
1105 bool RenderThemeWin::paintMediaVolumeSliderContainer(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1106 {
1107     return RenderMediaControls::paintMediaControlsPart(MediaVolumeSliderContainer, o, paintInfo, r);
1108 }
1109
1110 bool RenderThemeWin::paintMediaVolumeSliderTrack(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1111 {
1112     return RenderMediaControls::paintMediaControlsPart(MediaVolumeSlider, o, paintInfo, r);
1113 }
1114
1115 bool RenderThemeWin::paintMediaVolumeSliderThumb(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
1116 {
1117     return RenderMediaControls::paintMediaControlsPart(MediaVolumeSliderThumb, o, paintInfo, r);
1118 }
1119
1120 IntPoint RenderThemeWin::volumeSliderOffsetFromMuteButton(RenderBox* muteButtonBox, const IntSize& size) const
1121 {
1122     return RenderMediaControls::volumeSliderOffsetFromMuteButton(muteButtonBox, size);
1123 }
1124
1125
1126 #endif
1127
1128 }