The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 40; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include "nsNativeThemeWin.h"

 #include "mozilla/EventStates.h"

 #include "mozilla/WindowsVersion.h"

 #include "nsRenderingContext.h"

 #include "nsRect.h"

 #include "nsSize.h"

 #include "nsTransform2D.h"

 #include "nsThemeConstants.h"

 #include "nsIPresShell.h"

 #include "nsPresContext.h"

 #include "nsIContent.h"

 #include "nsIFrame.h"

 #include "nsNameSpaceManager.h"

 #include "nsIDOMHTMLInputElement.h"

 #include "nsLookAndFeel.h"

 #include "nsMenuFrame.h"

 #include "nsGkAtoms.h"

 #include <malloc.h>

 #include "nsWindow.h"

 #include "nsIComboboxControlFrame.h"

 #include "prinrval.h"

 #include "WinUtils.h"

 #include "gfxPlatform.h"

 #include "gfxContext.h"

 #include "gfxWindowsPlatform.h"

 #include "gfxWindowsSurface.h"

 #include "gfxWindowsNativeDrawing.h"

 #include "nsUXThemeData.h"

 #include "nsUXThemeConstants.h"

 #include <algorithm>

 using mozilla::IsVistaOrLater;

 using namespace mozilla;

 using namespace mozilla::widget;

 #ifdef PR_LOGGING

 extern PRLogModuleInfo* gWindowsLog;

 #endif

 NS_IMPL_ISUPPORTS_INHERITED(nsNativeThemeWin, nsNativeTheme, nsITheme)

 nsNativeThemeWin::nsNativeThemeWin() :

   mProgressDeterminateTimeStamp(TimeStamp::Now()),

   mProgressIndeterminateTimeStamp(TimeStamp::Now())

 {

   // If there is a relevant change in forms.css for windows platform,

   // static widget style variables (e.g. sButtonBorderSize) should be 

   // reinitialized here.

 }

 nsNativeThemeWin::~nsNativeThemeWin()

 {

   nsUXThemeData::Invalidate();

 }

 static int32_t

 GetTopLevelWindowActiveState(nsIFrame *aFrame)

 {

   // Get the widget. nsIFrame's GetNearestWidget walks up the view chain

   // until it finds a real window.

   nsIWidget* widget = aFrame->GetNearestWidget();

   nsWindowBase * window = static_cast<nsWindowBase*>(widget);

   if (!window)

     return mozilla::widget::themeconst::FS_INACTIVE;

   if (widget && !window->IsTopLevelWidget() &&

       !(window = window->GetParentWindowBase(false)))

     return mozilla::widget::themeconst::FS_INACTIVE;

   if (window->GetWindowHandle() == ::GetActiveWindow())

     return mozilla::widget::themeconst::FS_ACTIVE;

   return mozilla::widget::themeconst::FS_INACTIVE;

 }

 static int32_t

 GetWindowFrameButtonState(nsIFrame* aFrame, EventStates eventState)

 {

   if (GetTopLevelWindowActiveState(aFrame) ==

       mozilla::widget::themeconst::FS_INACTIVE) {

     if (eventState.HasState(NS_EVENT_STATE_HOVER))

       return mozilla::widget::themeconst::BS_HOT;

     return mozilla::widget::themeconst::BS_INACTIVE;

   }

   if (eventState.HasState(NS_EVENT_STATE_HOVER)) {

     if (eventState.HasState(NS_EVENT_STATE_ACTIVE))

       return mozilla::widget::themeconst::BS_PUSHED;

     return mozilla::widget::themeconst::BS_HOT;

   }

   return mozilla::widget::themeconst::BS_NORMAL;

 }

 static int32_t

 GetClassicWindowFrameButtonState(EventStates eventState)

 {

   if (eventState.HasState(NS_EVENT_STATE_ACTIVE) &&

       eventState.HasState(NS_EVENT_STATE_HOVER))

     return DFCS_BUTTONPUSH|DFCS_PUSHED;

   return DFCS_BUTTONPUSH;

 }

 static bool

 IsTopLevelMenu(nsIFrame *aFrame)

 {

   bool isTopLevel(false);

   nsMenuFrame *menuFrame = do_QueryFrame(aFrame);

   if (menuFrame) {

     isTopLevel = menuFrame->IsOnMenuBar();

   }

   return isTopLevel;

 }

 static MARGINS

 GetCheckboxMargins(HANDLE theme, HDC hdc)

 {

     MARGINS checkboxContent = {0};

     GetThemeMargins(theme, hdc, MENU_POPUPCHECK, MCB_NORMAL,

                     TMT_CONTENTMARGINS, nullptr, &checkboxContent);

     return checkboxContent;

 }

 static SIZE

 GetCheckboxBGSize(HANDLE theme, HDC hdc)

 {

     SIZE checkboxSize;

     GetThemePartSize(theme, hdc, MENU_POPUPCHECK, MC_CHECKMARKNORMAL,

                      nullptr, TS_TRUE, &checkboxSize);

     MARGINS checkboxMargins = GetCheckboxMargins(theme, hdc);

     int leftMargin = checkboxMargins.cxLeftWidth;

     int rightMargin = checkboxMargins.cxRightWidth;

     int topMargin = checkboxMargins.cyTopHeight;

     int bottomMargin = checkboxMargins.cyBottomHeight;

     int width = leftMargin + checkboxSize.cx + rightMargin;

     int height = topMargin + checkboxSize.cy + bottomMargin;

     SIZE ret;

     ret.cx = width;

     ret.cy = height;

     return ret;

 }

 static SIZE

 GetCheckboxBGBounds(HANDLE theme, HDC hdc)

 {

     MARGINS checkboxBGSizing = {0};

     MARGINS checkboxBGContent = {0};

     GetThemeMargins(theme, hdc, MENU_POPUPCHECKBACKGROUND, MCB_NORMAL,

                     TMT_SIZINGMARGINS, nullptr, &checkboxBGSizing);

     GetThemeMargins(theme, hdc, MENU_POPUPCHECKBACKGROUND, MCB_NORMAL,

                     TMT_CONTENTMARGINS, nullptr, &checkboxBGContent);

 #define posdx(d) ((d) > 0 ? d : 0)

     int dx = posdx(checkboxBGContent.cxRightWidth -

                    checkboxBGSizing.cxRightWidth) +

              posdx(checkboxBGContent.cxLeftWidth -

                    checkboxBGSizing.cxLeftWidth);

     int dy = posdx(checkboxBGContent.cyTopHeight -

                    checkboxBGSizing.cyTopHeight) +

              posdx(checkboxBGContent.cyBottomHeight -

                    checkboxBGSizing.cyBottomHeight);

 #undef posdx

     SIZE ret(GetCheckboxBGSize(theme, hdc));

     ret.cx += dx;

     ret.cy += dy;

     return ret;

 }

 static SIZE

 GetGutterSize(HANDLE theme, HDC hdc)

 {

     SIZE gutterSize;

     GetThemePartSize(theme, hdc, MENU_POPUPGUTTER, 0, nullptr, TS_TRUE, &gutterSize);

     SIZE checkboxBGSize(GetCheckboxBGBounds(theme, hdc));

     SIZE itemSize;

     GetThemePartSize(theme, hdc, MENU_POPUPITEM, MPI_NORMAL, nullptr, TS_TRUE, &itemSize);

     // Figure out how big the menuitem's icon will be (if present) at current DPI

     double scaleFactor = nsIWidget::DefaultScaleOverride();

     if (scaleFactor <= 0.0) {

       scaleFactor = gfxWindowsPlatform::GetPlatform()->GetDPIScale();

     }

     int iconDevicePixels = NSToIntRound(16 * scaleFactor);

     SIZE iconSize = {

       iconDevicePixels, iconDevicePixels

     };

     // Not really sure what margins should be used here, but this seems to work in practice...

     MARGINS margins = {0};

     GetThemeMargins(theme, hdc, MENU_POPUPCHECKBACKGROUND, MCB_NORMAL,

                     TMT_CONTENTMARGINS, nullptr, &margins);

     iconSize.cx += margins.cxLeftWidth + margins.cxRightWidth;

     iconSize.cy += margins.cyTopHeight + margins.cyBottomHeight;

     int width = std::max(itemSize.cx, std::max(iconSize.cx, checkboxBGSize.cx) + gutterSize.cx);

     int height = std::max(itemSize.cy, std::max(iconSize.cy, checkboxBGSize.cy));

     SIZE ret;

     ret.cx = width;

     ret.cy = height;

     return ret;

 }

 /* DrawThemeBGRTLAware - render a theme part based on rtl state.

  * Some widgets are not direction-neutral and need to be drawn reversed for

  * RTL.  Windows provides a way to do this with SetLayout, but this reverses

  * the entire drawing area of a given device context, which means that its

  * use will also affect the positioning of the widget.  There are two ways

  * to work around this:

  *

  * Option 1: Alter the position of the rect that we send so that we cancel

  *           out the positioning effects of SetLayout

  * Option 2: Create a memory DC with the widgetRect's dimensions, draw onto

  *           that, and then transfer the results back to our DC

  *

  * This function tries to implement option 1, under the assumption that the

  * correct way to reverse the effects of SetLayout is to translate the rect

  * such that the offset from the DC bitmap's left edge to the old rect's

  * left edge is equal to the offset from the DC bitmap's right edge to the

  * new rect's right edge.  In other words,

  * (oldRect.left + vpOrg.x) == ((dcBMP.width - vpOrg.x) - newRect.right)

  */

 static HRESULT

 DrawThemeBGRTLAware(HANDLE aTheme, HDC aHdc, int aPart, int aState,

                     const RECT *aWidgetRect, const RECT *aClipRect,

                     bool aIsRtl)

 {

   NS_ASSERTION(aTheme, "Bad theme handle.");

   NS_ASSERTION(aHdc, "Bad hdc.");

   NS_ASSERTION(aWidgetRect, "Bad rect.");

   NS_ASSERTION(aClipRect, "Bad clip rect.");

   if (!aIsRtl) {

     return DrawThemeBackground(aTheme, aHdc, aPart, aState,

                                aWidgetRect, aClipRect);

   }

   HGDIOBJ hObj = GetCurrentObject(aHdc, OBJ_BITMAP);

   BITMAP bitmap;

   POINT vpOrg;

   if (hObj && GetObject(hObj, sizeof(bitmap), &bitmap) &&

       GetViewportOrgEx(aHdc, &vpOrg)) {

     RECT newWRect(*aWidgetRect);

     newWRect.left = bitmap.bmWidth - (aWidgetRect->right + 2*vpOrg.x);

     newWRect.right = bitmap.bmWidth - (aWidgetRect->left + 2*vpOrg.x);

     RECT newCRect;

     RECT *newCRectPtr = nullptr;

     if (aClipRect) {

       newCRect.top = aClipRect->top;

       newCRect.bottom = aClipRect->bottom;

       newCRect.left = bitmap.bmWidth - (aClipRect->right + 2*vpOrg.x);

       newCRect.right = bitmap.bmWidth - (aClipRect->left + 2*vpOrg.x);

       newCRectPtr = &newCRect;

     }

     SetLayout(aHdc, LAYOUT_RTL);

     HRESULT hr = DrawThemeBackground(aTheme, aHdc, aPart, aState, &newWRect,

                                      newCRectPtr);

     SetLayout(aHdc, 0);

     if (SUCCEEDED(hr)) {

       return hr;

     }

   }

   return DrawThemeBackground(aTheme, aHdc, aPart, aState,

                              aWidgetRect, aClipRect);

 }

 /*

  *  Caption button padding data - 'hot' button padding.

  *  These areas are considered hot, in that they activate

  *  a button when hovered or clicked. The button graphic

  *  is drawn inside the padding border. Unrecognized themes

  *  are treated as their recognized counterparts for now.

  *                       left      top    right   bottom

  *  classic min             1        2        0        1

  *  classic max             0        2        1        1

  *  classic close           1        2        2        1

  *

  *  aero basic min          1        2        0        2

  *  aero basic max          0        2        1        2

  *  aero basic close        1        2        1        2

  *

  *  xp theme min            0        2        0        2

  *  xp theme max            0        2        1        2

  *  xp theme close          1        2        2        2

  *

  *  'cold' button padding - generic button padding, should

  *  be handled in css.

  *                       left      top    right   bottom

  *  classic min             0        0        0        0

  *  classic max             0        0        0        0

  *  classic close           0        0        0        0

  *

  *  aero basic min          0        0        1        0

  *  aero basic max          1        0        0        0

  *  aero basic close        0        0        0        0

  *

  *  xp theme min            0        0        1        0

  *  xp theme max            1        0        0        0

  *  xp theme close          0        0        0        0

  */

 enum CaptionDesktopTheme {

   CAPTION_CLASSIC = 0,

   CAPTION_BASIC,

   CAPTION_XPTHEME,

 };

 enum CaptionButton {

   CAPTIONBUTTON_MINIMIZE = 0,

   CAPTIONBUTTON_RESTORE,

   CAPTIONBUTTON_CLOSE,

 };

 struct CaptionButtonPadding {

   RECT hotPadding[3];

 };

 // RECT: left, top, right, bottom

 static CaptionButtonPadding buttonData[3] = {

   { 

     { { 1, 2, 0, 1 }, { 0, 2, 1, 1 }, { 1, 2, 2, 1 } }

   },

   { 

     { { 1, 2, 0, 2 }, { 0, 2, 1, 2 }, { 1, 2, 2, 2 } }

   },

   { 

     { { 0, 2, 0, 2 }, { 0, 2, 1, 2 }, { 1, 2, 2, 2 } }

   }

 };

 // Adds "hot" caption button padding to minimum widget size.

 static void

 AddPaddingRect(nsIntSize* aSize, CaptionButton button) {

   if (!aSize)

     return;

   RECT offset;

   if (!IsAppThemed())

     offset = buttonData[CAPTION_CLASSIC].hotPadding[button];

   else if (!IsVistaOrLater())

     offset = buttonData[CAPTION_XPTHEME].hotPadding[button];

   else

     offset = buttonData[CAPTION_BASIC].hotPadding[button];

   aSize->width += offset.left + offset.right;

   aSize->height += offset.top + offset.bottom;

 }

 // If we've added padding to the minimum widget size, offset

 // the area we draw into to compensate.

 static void

 OffsetBackgroundRect(RECT& rect, CaptionButton button) {

   RECT offset;

   if (!IsAppThemed())

     offset = buttonData[CAPTION_CLASSIC].hotPadding[button];

   else if (!IsVistaOrLater())

     offset = buttonData[CAPTION_XPTHEME].hotPadding[button];

   else

     offset = buttonData[CAPTION_BASIC].hotPadding[button];

   rect.left += offset.left;

   rect.top += offset.top;

   rect.right -= offset.right;

   rect.bottom -= offset.bottom;

 }

 /*

  * Notes on progress track and meter part constants:

  * xp and up:

  * PP_BAR(_VERT)            - base progress track

  * PP_TRANSPARENTBAR(_VERT) - transparent progress track. this only works if

  *                            the underlying surface supports alpha. otherwise

  *                            theme lib's DrawThemeBackground falls back on

  *                            opaque PP_BAR. we currently don't use this.

  * PP_CHUNK(_VERT)          - xp progress meter. this does not draw an xp style

  *                            progress w/chunks, it draws fill using the chunk

  *                            graphic.

  * vista and up:

  * PP_FILL(_VERT)           - progress meter. these have four states/colors.

  * PP_PULSEOVERLAY(_VERT)   - white reflection - an overlay, not sure what this

  *                            is used for.

  * PP_MOVEOVERLAY(_VERT)    - green pulse - the pulse effect overlay on

  *                            determined progress bars. we also use this for

  *                            indeterminate chunk.

  *

  * Notes on state constants:

  * PBBS_NORMAL               - green progress

  * PBBVS_PARTIAL/PBFVS_ERROR - red error progress

  * PBFS_PAUSED               - yellow paused progress

  *

  * There is no common controls style indeterminate part on vista and up.

  */

 /*

  * Progress bar related constants. These values are found by experimenting and

  * comparing against native widgets used by the system. They are very unlikely

  * exact but try to not be too wrong.

  */

 // The amount of time we animate progress meters parts across the frame.

 static const double kProgressDeterminateTimeSpan = 3.0;

 static const double kProgressIndeterminateTimeSpan = 5.0;

 // The width of the overlay used to animate the horizontal progress bar (Vista and later).

 static const int32_t kProgressHorizontalVistaOverlaySize = 120;

 // The width of the overlay used for the horizontal indeterminate progress bars on XP.

 static const int32_t kProgressHorizontalXPOverlaySize = 55;

 // The height of the overlay used to animate the vertical progress bar (Vista and later).

 static const int32_t kProgressVerticalOverlaySize = 45;

 // The height of the overlay used for the vertical indeterminate progress bar (Vista and later).

 static const int32_t kProgressVerticalIndeterminateOverlaySize = 60;

 // The width of the overlay used to animate the indeterminate progress bar (Windows Classic).

 static const int32_t kProgressClassicOverlaySize = 40;

 /*

  * GetProgressOverlayStyle - returns the proper overlay part for themed

  * progress bars based on os and orientation.

  */

 static int32_t

 GetProgressOverlayStyle(bool aIsVertical)

 { 

   if (aIsVertical) {

     if (IsVistaOrLater()) {

       return PP_MOVEOVERLAYVERT;

     }

     return PP_CHUNKVERT;

   } else {

     if (IsVistaOrLater()) {

       return PP_MOVEOVERLAY;

     }

     return PP_CHUNK;

   }

 }

 /*

  * GetProgressOverlaySize - returns the minimum width or height for themed

  * progress bar overlays. This includes the width of indeterminate chunks

  * and vista pulse overlays.

  */

 static int32_t

 GetProgressOverlaySize(bool aIsVertical, bool aIsIndeterminate)

 {

   if (IsVistaOrLater()) {

     if (aIsVertical) {

       return aIsIndeterminate ? kProgressVerticalIndeterminateOverlaySize

                               : kProgressVerticalOverlaySize;

     }

     return kProgressHorizontalVistaOverlaySize;

   }

   return kProgressHorizontalXPOverlaySize;

 }

 /*

  * IsProgressMeterFilled - Determines if a progress meter is at 100% fill based

  * on a comparison of the current value and maximum.

  */

 static bool

 IsProgressMeterFilled(nsIFrame* aFrame)

 {

   NS_ENSURE_TRUE(aFrame, false);

   nsIFrame* parentFrame = aFrame->GetParent();

   NS_ENSURE_TRUE(parentFrame, false);

   return nsNativeTheme::GetProgressValue(parentFrame) ==

          nsNativeTheme::GetProgressMaxValue(parentFrame);

 }

 /*

  * CalculateProgressOverlayRect - returns the padded overlay animation rect

  * used in rendering progress bars. Resulting rects are used in rendering

  * vista+ pulse overlays and indeterminate progress meters. Graphics should

  * be rendered at the origin.

  */

 RECT

 nsNativeThemeWin::CalculateProgressOverlayRect(nsIFrame* aFrame,

                                                RECT* aWidgetRect,

                                                bool aIsVertical,

                                                bool aIsIndeterminate,

                                                bool aIsClassic)

 {

   NS_ASSERTION(aFrame, "bad frame pointer");

   NS_ASSERTION(aWidgetRect, "bad rect pointer");

   int32_t frameSize = aIsVertical ? aWidgetRect->bottom - aWidgetRect->top

                                   : aWidgetRect->right - aWidgetRect->left;

   // Recycle a set of progress pulse timers - these timers control the position

   // of all progress overlays and indeterminate chunks that get rendered.

   double span = aIsIndeterminate ? kProgressIndeterminateTimeSpan

                                  : kProgressDeterminateTimeSpan;

   TimeDuration period;

   if (!aIsIndeterminate) {

     if (TimeStamp::Now() > (mProgressDeterminateTimeStamp +

                             TimeDuration::FromSeconds(span))) {

       mProgressDeterminateTimeStamp = TimeStamp::Now();

     }

     period = TimeStamp::Now() - mProgressDeterminateTimeStamp;

   } else {

     if (TimeStamp::Now() > (mProgressIndeterminateTimeStamp +

                             TimeDuration::FromSeconds(span))) {

       mProgressIndeterminateTimeStamp = TimeStamp::Now();

     }

     period = TimeStamp::Now() - mProgressIndeterminateTimeStamp;

   }

   double percent = period / TimeDuration::FromSeconds(span);

   if (!aIsVertical && IsFrameRTL(aFrame))

     percent = 1 - percent;

   RECT overlayRect = *aWidgetRect;

   int32_t overlaySize;

   if (!aIsClassic) {

     overlaySize = GetProgressOverlaySize(aIsVertical, aIsIndeterminate);

   } else {

     overlaySize = kProgressClassicOverlaySize;

   } 

   // Calculate a bounds that is larger than the meters frame such that the

   // overlay starts and ends completely off the edge of the frame:

   // [overlay][frame][overlay]

   // This also yields a nice delay on rotation. Use overlaySize as the minimum

   // size for [overlay] based on the graphics dims. If [frame] is larger, use

   // the frame size instead.

   int trackWidth = frameSize > overlaySize ? frameSize : overlaySize;

   if (!aIsVertical) {

     int xPos = aWidgetRect->left - trackWidth;

     xPos += (int)ceil(((double)(trackWidth*2) * percent));

     overlayRect.left = xPos;

     overlayRect.right = xPos + overlaySize;

   } else {

     int yPos = aWidgetRect->bottom + trackWidth;

     yPos -= (int)ceil(((double)(trackWidth*2) * percent));

     overlayRect.bottom = yPos;

     overlayRect.top = yPos - overlaySize;

   }

   return overlayRect;

 }

 /*

  * DrawChunkProgressMeter - renders an xp style chunked progress meter. Called

  * by DrawProgressMeter.

  *

  * @param aTheme       progress theme handle

  * @param aHdc         hdc returned by gfxWindowsNativeDrawing

  * @param aPart        the PP_X progress part

  * @param aState       the theme state

  * @param aFrame       the elements frame

  * @param aWidgetRect  bounding rect for the widget

  * @param aClipRect    dirty rect that needs drawing.

  * @param aAppUnits    app units per device pixel

  * @param aIsIndeterm  is an indeterminate progress?

  * @param aIsVertical  render a vertical progress?

  * @param aIsRtl       direction is rtl

  */

 static void

 DrawChunkProgressMeter(HTHEME aTheme, HDC aHdc, int aPart,

                        int aState, nsIFrame* aFrame, RECT* aWidgetRect,

                        RECT* aClipRect, gfxFloat aAppUnits, bool aIsIndeterm,

                        bool aIsVertical, bool aIsRtl)

 {

   NS_ASSERTION(aTheme, "Bad theme.");

   NS_ASSERTION(aHdc, "Bad hdc.");

   NS_ASSERTION(aWidgetRect, "Bad rect.");

   NS_ASSERTION(aClipRect, "Bad clip rect.");

   NS_ASSERTION(aFrame, "Bad frame.");

   // For horizontal meters, the theme lib paints the right graphic but doesn't

   // paint the chunks, so we do that manually. For vertical meters, the theme

   // library draws everything correctly.

   if (aIsVertical) {

     DrawThemeBackground(aTheme, aHdc, aPart, aState, aWidgetRect, aClipRect);

     return;

   }

   // query for the proper chunk metrics

   int chunkSize, spaceSize;

   if (FAILED(GetThemeMetric(aTheme, aHdc, aPart, aState,

                             TMT_PROGRESSCHUNKSIZE, &chunkSize)) ||

       FAILED(GetThemeMetric(aTheme, aHdc, aPart, aState,

                             TMT_PROGRESSSPACESIZE, &spaceSize))) {

     DrawThemeBackground(aTheme, aHdc, aPart, aState, aWidgetRect, aClipRect);

     return;

   }

   // render chunks

   if (!aIsRtl || aIsIndeterm) {

     for (int chunk = aWidgetRect->left; chunk <= aWidgetRect->right;

          chunk += (chunkSize+spaceSize)) {

       if (!aIsIndeterm && ((chunk + chunkSize) > aWidgetRect->right)) {

         // aWidgetRect->right represents the end of the meter. Partial blocks

         // don't get rendered with one exception, so exit here if we don't have

         // a full chunk to draw.

         // The above is true *except* when the meter is at 100% fill, in which

         // case Windows renders any remaining partial block. Query the parent

         // frame to find out if we're at 100%.

         if (!IsProgressMeterFilled(aFrame)) {

           break;

         }

       }

       RECT bounds =

         { chunk, aWidgetRect->top, chunk + chunkSize, aWidgetRect->bottom };

       DrawThemeBackground(aTheme, aHdc, aPart, aState, &bounds, aClipRect);

     }

   } else {

     // rtl needs to grow in the opposite direction to look right.

     for (int chunk = aWidgetRect->right; chunk >= aWidgetRect->left;

          chunk -= (chunkSize+spaceSize)) {

       if ((chunk - chunkSize) < aWidgetRect->left) {

         if (!IsProgressMeterFilled(aFrame)) {

           break;

         }

       }

       RECT bounds =

         { chunk - chunkSize, aWidgetRect->top, chunk, aWidgetRect->bottom };

       DrawThemeBackground(aTheme, aHdc, aPart, aState, &bounds, aClipRect);

     }

   }

 }

 /*

  * DrawProgressMeter - render an appropriate progress meter based on progress

  * meter style, orientation, and os. Note, this does not render the underlying

  * progress track.

  *

  * @param aFrame       the widget frame

  * @param aWidgetType  type of widget

  * @param aTheme       progress theme handle

  * @param aHdc         hdc returned by gfxWindowsNativeDrawing

  * @param aPart        the PP_X progress part

  * @param aState       the theme state

  * @param aWidgetRect  bounding rect for the widget

  * @param aClipRect    dirty rect that needs drawing.

  * @param aAppUnits    app units per device pixel

  */

 void

 nsNativeThemeWin::DrawThemedProgressMeter(nsIFrame* aFrame, int aWidgetType,

                                           HANDLE aTheme, HDC aHdc,

                                           int aPart, int aState,

                                           RECT* aWidgetRect, RECT* aClipRect,

                                           gfxFloat aAppUnits)

 {

   if (!aFrame || !aTheme || !aHdc)

     return;

   NS_ASSERTION(aWidgetRect, "bad rect pointer");

   NS_ASSERTION(aClipRect, "bad clip rect pointer");

   RECT adjWidgetRect, adjClipRect;

   adjWidgetRect = *aWidgetRect;

   adjClipRect = *aClipRect;

   if (!IsVistaOrLater()) {

     // Adjust clipping out by one pixel. XP progress meters are inset,

     // Vista+ are not.

     InflateRect(&adjWidgetRect, 1, 1);

     InflateRect(&adjClipRect, 1, 1);

   }

   nsIFrame* parentFrame = aFrame->GetParent();

   if (!parentFrame) {

     // We have no parent to work with, just bail.

     NS_WARNING("No parent frame for progress rendering. Can't paint.");

     return;

   }

   EventStates eventStates = GetContentState(parentFrame, aWidgetType);

   bool vertical = IsVerticalProgress(parentFrame) ||

                   aWidgetType == NS_THEME_PROGRESSBAR_CHUNK_VERTICAL;

   bool indeterminate = IsIndeterminateProgress(parentFrame, eventStates);

   bool animate = indeterminate;

   if (IsVistaOrLater()) {

     // Vista and up progress meter is fill style, rendered here. We render

     // the pulse overlay in the follow up section below.

     DrawThemeBackground(aTheme, aHdc, aPart, aState,

                         &adjWidgetRect, &adjClipRect);

     if (!IsProgressMeterFilled(aFrame)) {

       animate = true;

     }

   } else if (!indeterminate) {

     // XP progress meters are 'chunk' style.

     DrawChunkProgressMeter(aTheme, aHdc, aPart, aState, aFrame,

                            &adjWidgetRect, &adjClipRect, aAppUnits,

                            indeterminate, vertical, IsFrameRTL(aFrame));

   }    

   if (animate) {

     // Indeterminate rendering

     int32_t overlayPart = GetProgressOverlayStyle(vertical);

     RECT overlayRect =

       CalculateProgressOverlayRect(aFrame, &adjWidgetRect, vertical,

                                    indeterminate, false);

     if (IsVistaOrLater()) {

       DrawThemeBackground(aTheme, aHdc, overlayPart, aState, &overlayRect,

                           &adjClipRect);

     } else {

       DrawChunkProgressMeter(aTheme, aHdc, overlayPart, aState, aFrame,

                              &overlayRect, &adjClipRect, aAppUnits,

                              indeterminate, vertical, IsFrameRTL(aFrame));

     }

     if (!QueueAnimatedContentForRefresh(aFrame->GetContent(), 60)) {

       NS_WARNING("unable to animate progress widget!");

     }

   }

 }

 HANDLE

 nsNativeThemeWin::GetTheme(uint8_t aWidgetType)

 { 

   if (!IsVistaOrLater()) {

     // On XP or earlier, render dropdowns as textfields;

     // doing it the right way works fine with the MS themes,

     // but breaks on a lot of custom themes (presumably because MS

     // apps do the textfield border business as well).

     if (aWidgetType == NS_THEME_DROPDOWN)

       aWidgetType = NS_THEME_TEXTFIELD;

   }

   switch (aWidgetType) {

     case NS_THEME_BUTTON:

     case NS_THEME_RADIO:

     case NS_THEME_CHECKBOX:

     case NS_THEME_GROUPBOX:

       return nsUXThemeData::GetTheme(eUXButton);

     case NS_THEME_NUMBER_INPUT:

     case NS_THEME_TEXTFIELD:

     case NS_THEME_TEXTFIELD_MULTILINE:

       return nsUXThemeData::GetTheme(eUXEdit);

     case NS_THEME_TOOLTIP:

       // XP/2K3 should force a classic treatment of tooltips

       return !IsVistaOrLater() ?

         nullptr : nsUXThemeData::GetTheme(eUXTooltip);

     case NS_THEME_TOOLBOX:

       return nsUXThemeData::GetTheme(eUXRebar);

     case NS_THEME_WIN_MEDIA_TOOLBOX:

       return nsUXThemeData::GetTheme(eUXMediaRebar);

     case NS_THEME_WIN_COMMUNICATIONS_TOOLBOX:

       return nsUXThemeData::GetTheme(eUXCommunicationsRebar);

     case NS_THEME_WIN_BROWSER_TAB_BAR_TOOLBOX:

       return nsUXThemeData::GetTheme(eUXBrowserTabBarRebar);

     case NS_THEME_TOOLBAR:

     case NS_THEME_TOOLBAR_BUTTON:

     case NS_THEME_TOOLBAR_SEPARATOR:

       return nsUXThemeData::GetTheme(eUXToolbar);

     case NS_THEME_PROGRESSBAR:

     case NS_THEME_PROGRESSBAR_VERTICAL:

     case NS_THEME_PROGRESSBAR_CHUNK:

     case NS_THEME_PROGRESSBAR_CHUNK_VERTICAL:

       return nsUXThemeData::GetTheme(eUXProgress);

     case NS_THEME_TAB:

     case NS_THEME_TAB_PANEL:

     case NS_THEME_TAB_PANELS:

       return nsUXThemeData::GetTheme(eUXTab);

     case NS_THEME_SCROLLBAR:

     case NS_THEME_SCROLLBAR_SMALL:

     case NS_THEME_SCROLLBAR_TRACK_VERTICAL:

     case NS_THEME_SCROLLBAR_TRACK_HORIZONTAL:

     case NS_THEME_SCROLLBAR_BUTTON_UP:

     case NS_THEME_SCROLLBAR_BUTTON_DOWN:

     case NS_THEME_SCROLLBAR_BUTTON_LEFT:

     case NS_THEME_SCROLLBAR_BUTTON_RIGHT:

     case NS_THEME_SCROLLBAR_THUMB_VERTICAL:

     case NS_THEME_SCROLLBAR_THUMB_HORIZONTAL:

       return nsUXThemeData::GetTheme(eUXScrollbar);

     case NS_THEME_RANGE:

     case NS_THEME_RANGE_THUMB:

     case NS_THEME_SCALE_HORIZONTAL:

     case NS_THEME_SCALE_VERTICAL:

     case NS_THEME_SCALE_THUMB_HORIZONTAL:

     case NS_THEME_SCALE_THUMB_VERTICAL:

       return nsUXThemeData::GetTheme(eUXTrackbar);

     case NS_THEME_SPINNER_UP_BUTTON:

     case NS_THEME_SPINNER_DOWN_BUTTON:

       return nsUXThemeData::GetTheme(eUXSpin);

     case NS_THEME_STATUSBAR:

     case NS_THEME_STATUSBAR_PANEL:

     case NS_THEME_STATUSBAR_RESIZER_PANEL:

     case NS_THEME_RESIZER:

       return nsUXThemeData::GetTheme(eUXStatus);

     case NS_THEME_DROPDOWN:

     case NS_THEME_DROPDOWN_BUTTON:

       return nsUXThemeData::GetTheme(eUXCombobox);

     case NS_THEME_TREEVIEW_HEADER_CELL:

     case NS_THEME_TREEVIEW_HEADER_SORTARROW:

       return nsUXThemeData::GetTheme(eUXHeader);

     case NS_THEME_LISTBOX:

     case NS_THEME_LISTBOX_LISTITEM:

     case NS_THEME_TREEVIEW:

     case NS_THEME_TREEVIEW_TWISTY_OPEN:

     case NS_THEME_TREEVIEW_TREEITEM:

       return nsUXThemeData::GetTheme(eUXListview);

     case NS_THEME_MENUBAR:

     case NS_THEME_MENUPOPUP:

     case NS_THEME_MENUITEM:

     case NS_THEME_CHECKMENUITEM:

     case NS_THEME_RADIOMENUITEM:

     case NS_THEME_MENUCHECKBOX:

     case NS_THEME_MENURADIO:

     case NS_THEME_MENUSEPARATOR:

     case NS_THEME_MENUARROW:

     case NS_THEME_MENUIMAGE:

     case NS_THEME_MENUITEMTEXT:

       return nsUXThemeData::GetTheme(eUXMenu);

     case NS_THEME_WINDOW_TITLEBAR:

     case NS_THEME_WINDOW_TITLEBAR_MAXIMIZED:

     case NS_THEME_WINDOW_FRAME_LEFT:

     case NS_THEME_WINDOW_FRAME_RIGHT:

     case NS_THEME_WINDOW_FRAME_BOTTOM:

     case NS_THEME_WINDOW_BUTTON_CLOSE:

     case NS_THEME_WINDOW_BUTTON_MINIMIZE:

     case NS_THEME_WINDOW_BUTTON_MAXIMIZE:

     case NS_THEME_WINDOW_BUTTON_RESTORE:

     case NS_THEME_WINDOW_BUTTON_BOX:

     case NS_THEME_WINDOW_BUTTON_BOX_MAXIMIZED:

     case NS_THEME_WIN_GLASS:

     case NS_THEME_WIN_BORDERLESS_GLASS:

       return nsUXThemeData::GetTheme(eUXWindowFrame);

   }

   return nullptr;

 }

 int32_t

 nsNativeThemeWin::StandardGetState(nsIFrame* aFrame, uint8_t aWidgetType,

                                    bool wantFocused)

 {

   EventStates eventState = GetContentState(aFrame, aWidgetType);

   if (eventState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE))

     return TS_ACTIVE;

   if (eventState.HasState(NS_EVENT_STATE_HOVER))

     return TS_HOVER;

   if (wantFocused && eventState.HasState(NS_EVENT_STATE_FOCUS))

     return TS_FOCUSED;

   return TS_NORMAL;

 }

 bool

 nsNativeThemeWin::IsMenuActive(nsIFrame *aFrame, uint8_t aWidgetType)

 {

   nsIContent* content = aFrame->GetContent();

   if (content->IsXUL() &&

       content->NodeInfo()->Equals(nsGkAtoms::richlistitem))

     return CheckBooleanAttr(aFrame, nsGkAtoms::selected);

   return CheckBooleanAttr(aFrame, nsGkAtoms::menuactive);

 }

 /**

  * aPart is filled in with the UXTheme part code. On return, values > 0

  * are the actual UXTheme part code; -1 means the widget will be drawn by

  * us; 0 means that we should use part code 0, which isn't a real part code

  * but elicits some kind of default behaviour from UXTheme when drawing

  * (but isThemeBackgroundPartiallyTransparent may not work).

  */

 nsresult 

 nsNativeThemeWin::GetThemePartAndState(nsIFrame* aFrame, uint8_t aWidgetType, 

                                        int32_t& aPart, int32_t& aState)

 {

   if (!IsVistaOrLater()) {

     // See GetTheme

     if (aWidgetType == NS_THEME_DROPDOWN)

       aWidgetType = NS_THEME_TEXTFIELD;

   }

   switch (aWidgetType) {

     case NS_THEME_BUTTON: {

       aPart = BP_BUTTON;

       if (!aFrame) {

         aState = TS_NORMAL;

         return NS_OK;

       }

       EventStates eventState = GetContentState(aFrame, aWidgetType);

       if (IsDisabled(aFrame, eventState)) {

         aState = TS_DISABLED;

         return NS_OK;

       } else if (IsOpenButton(aFrame) ||

                  IsCheckedButton(aFrame)) {

         aState = TS_ACTIVE;

         return NS_OK;

       }

       aState = StandardGetState(aFrame, aWidgetType, true);

       // Check for default dialog buttons.  These buttons should always look

       // focused.

       if (aState == TS_NORMAL && IsDefaultButton(aFrame))

         aState = TS_FOCUSED;

       return NS_OK;

     }

     case NS_THEME_CHECKBOX:

     case NS_THEME_RADIO: {

       bool isCheckbox = (aWidgetType == NS_THEME_CHECKBOX);

       aPart = isCheckbox ? BP_CHECKBOX : BP_RADIO;

       enum InputState {

         UNCHECKED = 0, CHECKED, INDETERMINATE

       };

       InputState inputState = UNCHECKED;

       bool isXULCheckboxRadio = false;

       if (!aFrame) {

         aState = TS_NORMAL;

       } else {

         if (GetCheckedOrSelected(aFrame, !isCheckbox)) {

           inputState = CHECKED;

         } if (isCheckbox && GetIndeterminate(aFrame)) {

           inputState = INDETERMINATE;

         }

         EventStates eventState =

           GetContentState(isXULCheckboxRadio ? aFrame->GetParent() : aFrame,

                           aWidgetType);

         if (IsDisabled(aFrame, eventState)) {

           aState = TS_DISABLED;

         } else {

           aState = StandardGetState(aFrame, aWidgetType, false);

         }

       }

       // 4 unchecked states, 4 checked states, 4 indeterminate states.

       aState += inputState * 4;

       return NS_OK;

     }

     case NS_THEME_GROUPBOX: {

       aPart = BP_GROUPBOX;

       aState = TS_NORMAL;

       // Since we don't support groupbox disabled and GBS_DISABLED looks the

       // same as GBS_NORMAL don't bother supporting GBS_DISABLED.

       return NS_OK;

     }

     case NS_THEME_NUMBER_INPUT:

     case NS_THEME_TEXTFIELD:

     case NS_THEME_TEXTFIELD_MULTILINE: {

       EventStates eventState = GetContentState(aFrame, aWidgetType);

       if (IsVistaOrLater()) {

         /* Note: the NOSCROLL type has a rounded corner in each

          * corner.  The more specific HSCROLL, VSCROLL, HVSCROLL types

          * have side and/or top/bottom edges rendered as straight

          * horizontal lines with sharp corners to accommodate a

          * scrollbar.  However, the scrollbar gets rendered on top of

          * this for us, so we don't care, and can just use NOSCROLL

          * here.

          */

         aPart = TFP_EDITBORDER_NOSCROLL;

         if (!aFrame) {

           aState = TFS_EDITBORDER_NORMAL;

         } else if (IsDisabled(aFrame, eventState)) {

           aState = TFS_EDITBORDER_DISABLED;

         } else if (IsReadOnly(aFrame)) {

           /* no special read-only state */

           aState = TFS_EDITBORDER_NORMAL;

         } else {

           nsIContent* content = aFrame->GetContent();

           /* XUL textboxes don't get focused themselves, because they have child

            * html:input.. but we can check the XUL focused attributes on them

            */

           if (content && content->IsXUL() && IsFocused(aFrame))

             aState = TFS_EDITBORDER_FOCUSED;

           else if (eventState.HasAtLeastOneOfStates(NS_EVENT_STATE_ACTIVE | NS_EVENT_STATE_FOCUS))

             aState = TFS_EDITBORDER_FOCUSED;

           else if (eventState.HasState(NS_EVENT_STATE_HOVER))

             aState = TFS_EDITBORDER_HOVER;

           else

             aState = TFS_EDITBORDER_NORMAL;

         }

       } else {

         aPart = TFP_TEXTFIELD;

         if (!aFrame)

           aState = TS_NORMAL;

         else if (IsDisabled(aFrame, eventState))

           aState = TS_DISABLED;

         else if (IsReadOnly(aFrame))

           aState = TFS_READONLY;

         else

           aState = StandardGetState(aFrame, aWidgetType, true);

       }

       return NS_OK;

     }

     case NS_THEME_TOOLTIP: {

       aPart = TTP_STANDARD;

       aState = TS_NORMAL;

       return NS_OK;

     }

     case NS_THEME_PROGRESSBAR:

     case NS_THEME_PROGRESSBAR_VERTICAL: {

       // Note IsVerticalProgress only tests for orient css attrribute,

       // NS_THEME_PROGRESSBAR_VERTICAL is dedicated to -moz-appearance:

       // progressbar-vertical.

       bool vertical = IsVerticalProgress(aFrame) ||

                       aWidgetType == NS_THEME_PROGRESSBAR_VERTICAL;

       aPart = vertical ? PP_BARVERT : PP_BAR;

       aState = PBBS_NORMAL;

       return NS_OK;

     }

     case NS_THEME_PROGRESSBAR_CHUNK:

     case NS_THEME_PROGRESSBAR_CHUNK_VERTICAL: {

       nsIFrame* parentFrame = aFrame->GetParent();

       EventStates eventStates = GetContentState(parentFrame, aWidgetType);

       if (aWidgetType == NS_THEME_PROGRESSBAR_CHUNK_VERTICAL ||

           IsVerticalProgress(parentFrame)) {

         aPart = IsVistaOrLater() ?

           PP_FILLVERT : PP_CHUNKVERT;

       } else {

         aPart = IsVistaOrLater() ?

           PP_FILL : PP_CHUNK;

       }

       aState = PBBVS_NORMAL;

       return NS_OK;

     }

     case NS_THEME_TOOLBAR_BUTTON: {

       aPart = BP_BUTTON;

       if (!aFrame) {

         aState = TS_NORMAL;

         return NS_OK;

       }

       EventStates eventState = GetContentState(aFrame, aWidgetType);

       if (IsDisabled(aFrame, eventState)) {

         aState = TS_DISABLED;

         return NS_OK;

       }

       if (IsOpenButton(aFrame)) {

         aState = TS_ACTIVE;

         return NS_OK;

       }

       if (eventState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE))

         aState = TS_ACTIVE;

       else if (eventState.HasState(NS_EVENT_STATE_HOVER)) {

         if (IsCheckedButton(aFrame))

           aState = TB_HOVER_CHECKED;

         else

           aState = TS_HOVER;

       }

       else {

         if (IsCheckedButton(aFrame))

           aState = TB_CHECKED;

         else

           aState = TS_NORMAL;

       }

       return NS_OK;

     }

     case NS_THEME_TOOLBAR_SEPARATOR: {

       aPart = TP_SEPARATOR;

       aState = TS_NORMAL;

       return NS_OK;

     }

     case NS_THEME_SCROLLBAR_BUTTON_UP:

     case NS_THEME_SCROLLBAR_BUTTON_DOWN:

     case NS_THEME_SCROLLBAR_BUTTON_LEFT:

     case NS_THEME_SCROLLBAR_BUTTON_RIGHT: {

       aPart = SP_BUTTON;

       aState = (aWidgetType - NS_THEME_SCROLLBAR_BUTTON_UP)*4;

       EventStates eventState = GetContentState(aFrame, aWidgetType);

       if (!aFrame)

         aState += TS_NORMAL;

       else if (IsDisabled(aFrame, eventState))

         aState += TS_DISABLED;

       else {

         nsIFrame *parent = aFrame->GetParent();

         EventStates parentState =

           GetContentState(parent, parent->StyleDisplay()->mAppearance);

         if (eventState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE))

           aState += TS_ACTIVE;

         else if (eventState.HasState(NS_EVENT_STATE_HOVER))

           aState += TS_HOVER;

         else if (IsVistaOrLater() &&

                  parentState.HasState(NS_EVENT_STATE_HOVER))

           aState = (aWidgetType - NS_THEME_SCROLLBAR_BUTTON_UP) + SP_BUTTON_IMPLICIT_HOVER_BASE;

         else

           aState += TS_NORMAL;

       }

       return NS_OK;

     }

     case NS_THEME_SCROLLBAR_TRACK_HORIZONTAL:

     case NS_THEME_SCROLLBAR_TRACK_VERTICAL: {

       aPart = (aWidgetType == NS_THEME_SCROLLBAR_TRACK_HORIZONTAL) ?

               SP_TRACKSTARTHOR : SP_TRACKSTARTVERT;

       aState = TS_NORMAL;

       return NS_OK;

     }

     case NS_THEME_SCROLLBAR_THUMB_HORIZONTAL:

     case NS_THEME_SCROLLBAR_THUMB_VERTICAL: {

       aPart = (aWidgetType == NS_THEME_SCROLLBAR_THUMB_HORIZONTAL) ?

               SP_THUMBHOR : SP_THUMBVERT;

       EventStates eventState = GetContentState(aFrame, aWidgetType);

       if (!aFrame)

         aState = TS_NORMAL;

       else if (IsDisabled(aFrame, eventState))

         aState = TS_DISABLED;

       else {

         if (eventState.HasState(NS_EVENT_STATE_ACTIVE)) // Hover is not also a requirement for

                                                         // the thumb, since the drag is not canceled

                                                         // when you move outside the thumb.

           aState = TS_ACTIVE;

         else if (eventState.HasState(NS_EVENT_STATE_HOVER))

           aState = TS_HOVER;

         else 

           aState = TS_NORMAL;

       }

       return NS_OK;

     }

     case NS_THEME_RANGE:

     case NS_THEME_SCALE_HORIZONTAL:

     case NS_THEME_SCALE_VERTICAL: {

       if (aWidgetType == NS_THEME_SCALE_HORIZONTAL ||

           (aWidgetType == NS_THEME_RANGE &&

            IsRangeHorizontal(aFrame))) {

         aPart = TKP_TRACK;

         aState = TRS_NORMAL;

       } else {

         aPart = TKP_TRACKVERT;

         aState = TRVS_NORMAL;

       }

       return NS_OK;

     }

     case NS_THEME_RANGE_THUMB:

     case NS_THEME_SCALE_THUMB_HORIZONTAL:

     case NS_THEME_SCALE_THUMB_VERTICAL: {

       if (aWidgetType == NS_THEME_RANGE_THUMB) {

         if (IsRangeHorizontal(aFrame)) {

           aPart = TKP_THUMBBOTTOM;

         } else {

           aPart = IsFrameRTL(aFrame) ? TKP_THUMBLEFT : TKP_THUMBRIGHT;

         }

       } else {

         aPart = (aWidgetType == NS_THEME_SCALE_THUMB_HORIZONTAL) ?

                 TKP_THUMB : TKP_THUMBVERT;

       }

       EventStates eventState = GetContentState(aFrame, aWidgetType);

       if (!aFrame)

         aState = TS_NORMAL;

       else if (IsDisabled(aFrame, eventState)) {

         aState = TKP_DISABLED;

       }

       else {

         if (eventState.HasState(NS_EVENT_STATE_ACTIVE)) // Hover is not also a requirement for

                                                         // the thumb, since the drag is not canceled

                                                         // when you move outside the thumb.

           aState = TS_ACTIVE;

         else if (eventState.HasState(NS_EVENT_STATE_FOCUS))

           aState = TKP_FOCUSED;

         else if (eventState.HasState(NS_EVENT_STATE_HOVER))

           aState = TS_HOVER;

         else

           aState = TS_NORMAL;

       }

       return NS_OK;

     }

     case NS_THEME_SPINNER_UP_BUTTON:

     case NS_THEME_SPINNER_DOWN_BUTTON: {

       aPart = (aWidgetType == NS_THEME_SPINNER_UP_BUTTON) ?

               SPNP_UP : SPNP_DOWN;

       EventStates eventState = GetContentState(aFrame, aWidgetType);

       if (!aFrame)

         aState = TS_NORMAL;

       else if (IsDisabled(aFrame, eventState))

         aState = TS_DISABLED;

       else

         aState = StandardGetState(aFrame, aWidgetType, false);

       return NS_OK;    

     }

     case NS_THEME_TOOLBOX:

     case NS_THEME_WIN_MEDIA_TOOLBOX:

     case NS_THEME_WIN_COMMUNICATIONS_TOOLBOX:

     case NS_THEME_WIN_BROWSER_TAB_BAR_TOOLBOX:

     case NS_THEME_STATUSBAR:

     case NS_THEME_SCROLLBAR:

     case NS_THEME_SCROLLBAR_SMALL: {

       aState = 0;

       if (IsVistaOrLater()) {

         // On vista, they have a part

         aPart = RP_BACKGROUND;

       } else {

         // Otherwise, they don't.  (But I bet

         // RP_BACKGROUND would work here, too);

         aPart = 0;

       }

       return NS_OK;

     }

     case NS_THEME_TOOLBAR: {

       // Use -1 to indicate we don't wish to have the theme background drawn

       // for this item. We will pass any nessessary information via aState,

       // and will render the item using separate code.

       aPart = -1;

       aState = 0;

       if (aFrame) {

         nsIContent* content = aFrame->GetContent();

         nsIContent* parent = content->GetParent();

         // XXXzeniko hiding the first toolbar will result in an unwanted margin

         if (parent && parent->GetFirstChild() == content) {

           aState = 1;

         }

       }

       return NS_OK;

     }

     case NS_THEME_STATUSBAR_PANEL:

     case NS_THEME_STATUSBAR_RESIZER_PANEL:

     case NS_THEME_RESIZER: {

       aPart = (aWidgetType - NS_THEME_STATUSBAR_PANEL) + 1;

       aState = TS_NORMAL;

       return NS_OK;

     }

     case NS_THEME_TREEVIEW:

     case NS_THEME_LISTBOX: {

       aPart = TREEVIEW_BODY;

       aState = TS_NORMAL;

       return NS_OK;

     }

     case NS_THEME_TAB_PANELS: {

       aPart = TABP_PANELS;

       aState = TS_NORMAL;

       return NS_OK;

     }

     case NS_THEME_TAB_PANEL: {

       aPart = TABP_PANEL;

       aState = TS_NORMAL;

       return NS_OK;

     }

     case NS_THEME_TAB: {

       aPart = TABP_TAB;

       if (!aFrame) {

         aState = TS_NORMAL;

         return NS_OK;

       }

       EventStates eventState = GetContentState(aFrame, aWidgetType);

       if (IsDisabled(aFrame, eventState)) {

         aState = TS_DISABLED;

         return NS_OK;

       }

       if (IsSelectedTab(aFrame)) {

         aPart = TABP_TAB_SELECTED;

         aState = TS_ACTIVE; // The selected tab is always "pressed".

       }

       else

         aState = StandardGetState(aFrame, aWidgetType, true);

       return NS_OK;

     }

     case NS_THEME_TREEVIEW_HEADER_SORTARROW: {

       // XXX Probably will never work due to a bug in the Luna theme.

       aPart = 4;

       aState = 1;

       return NS_OK;

     }

     case NS_THEME_TREEVIEW_HEADER_CELL: {

       aPart = 1;

       if (!aFrame) {

         aState = TS_NORMAL;

         return NS_OK;

       }

       aState = StandardGetState(aFrame, aWidgetType, true);

       return NS_OK;

     }

     case NS_THEME_DROPDOWN: {

       nsIContent* content = aFrame->GetContent();

       bool isHTML = content && content->IsHTML();

       bool useDropBorder = isHTML || IsMenuListEditable(aFrame);

       EventStates eventState = GetContentState(aFrame, aWidgetType);

       /* On Vista/Win7, we use CBP_DROPBORDER instead of DROPFRAME for HTML

        * content or for editable menulists; this gives us the thin outline,

        * instead of the gradient-filled background */

       if (useDropBorder)

         aPart = CBP_DROPBORDER;

       else

         aPart = CBP_DROPFRAME;

       if (IsDisabled(aFrame, eventState)) {

         aState = TS_DISABLED;

       } else if (IsReadOnly(aFrame)) {

         aState = TS_NORMAL;

       } else if (IsOpenButton(aFrame)) {

         aState = TS_ACTIVE;

       } else {

         if (useDropBorder && (eventState.HasState(NS_EVENT_STATE_FOCUS) || IsFocused(aFrame)))

           aState = TS_ACTIVE;

         else if (eventState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE))

           aState = TS_ACTIVE;

         else if (eventState.HasState(NS_EVENT_STATE_HOVER))

           aState = TS_HOVER;

         else

           aState = TS_NORMAL;

       }

       return NS_OK;

     }

     case NS_THEME_DROPDOWN_BUTTON: {

       bool isHTML = IsHTMLContent(aFrame);

       nsIFrame* parentFrame = aFrame->GetParent();

       bool isMenulist = !isHTML && parentFrame->GetType() == nsGkAtoms::menuFrame;

       bool isOpen = false;

       // HTML select and XUL menulist dropdown buttons get state from the parent.

       if (isHTML || isMenulist)

         aFrame = parentFrame;

       EventStates eventState = GetContentState(aFrame, aWidgetType);

       aPart = IsVistaOrLater() ?

         CBP_DROPMARKER_VISTA : CBP_DROPMARKER;

       // For HTML controls with author styling, we should fall

       // back to the old dropmarker style to avoid clashes with

       // author-specified backgrounds and borders (bug #441034)

       if (isHTML && IsWidgetStyled(aFrame->PresContext(), aFrame, NS_THEME_DROPDOWN))

         aPart = CBP_DROPMARKER;

       if (IsDisabled(aFrame, eventState)) {

         aState = TS_DISABLED;

         return NS_OK;

       }

       if (isHTML) {

         nsIComboboxControlFrame* ccf = do_QueryFrame(aFrame);

         isOpen = (ccf && ccf->IsDroppedDown());

       }

       else

         isOpen = IsOpenButton(aFrame);

       if (IsVistaOrLater()) {

         if (isHTML || IsMenuListEditable(aFrame)) {

           if (isOpen) {

             /* Hover is propagated, but we need to know whether we're

              * hovering just the combobox frame, not the dropdown frame.

              * But, we can't get that information, since hover is on the

              * content node, and they share the same content node.  So,

              * instead, we cheat -- if the dropdown is open, we always

              * show the hover state.  This looks fine in practice.

              */

             aState = TS_HOVER;

             return NS_OK;

           }

         } else {

           /* On Vista, the dropdown indicator on a menulist button in  

            * chrome is not given a hover effect. When the frame isn't

            * isn't HTML content, we cheat and force the dropdown state

            * to be normal. (Bug 430434)

            */

           aState = TS_NORMAL;

           return NS_OK;

         }

       }

       aState = TS_NORMAL;

       // Dropdown button active state doesn't need :hover.

       if (eventState.HasState(NS_EVENT_STATE_ACTIVE)) {

         if (isOpen && (isHTML || isMenulist)) {

           // XXX Button should look active until the mouse is released, but

           //     without making it look active when the popup is clicked.

           return NS_OK;

         }

         aState = TS_ACTIVE;

       }

       else if (eventState.HasState(NS_EVENT_STATE_HOVER)) {

         // No hover effect for XUL menulists and autocomplete dropdown buttons

         // while the dropdown menu is open.

         if (isOpen) {

           // XXX HTML select dropdown buttons should have the hover effect when

           //     hovering the combobox frame, but not the popup frame.

           return NS_OK;

         }

         aState = TS_HOVER;

       }

       return NS_OK;

     }

     case NS_THEME_MENUPOPUP: {

       aPart = MENU_POPUPBACKGROUND;

       aState = MB_ACTIVE;

       return NS_OK;

     }

     case NS_THEME_MENUITEM:

     case NS_THEME_CHECKMENUITEM: 

     case NS_THEME_RADIOMENUITEM: {

       bool isTopLevel = false;

       bool isOpen = false;

       bool isHover = false;

       nsMenuFrame *menuFrame = do_QueryFrame(aFrame);

       EventStates eventState = GetContentState(aFrame, aWidgetType);

       isTopLevel = IsTopLevelMenu(aFrame);

       if (menuFrame)

         isOpen = menuFrame->IsOpen();

       isHover = IsMenuActive(aFrame, aWidgetType);

       if (isTopLevel) {

         aPart = MENU_BARITEM;

         if (isOpen)

           aState = MBI_PUSHED;

         else if (isHover)

           aState = MBI_HOT;

         else

           aState = MBI_NORMAL;

         // the disabled states are offset by 3

         if (IsDisabled(aFrame, eventState))

           aState += 3;

       } else {

         aPart = MENU_POPUPITEM;

         if (isHover)

           aState = MPI_HOT;

         else

           aState = MPI_NORMAL;

         // the disabled states are offset by 2

         if (IsDisabled(aFrame, eventState))

           aState += 2;

       }

       return NS_OK;

     }

     case NS_THEME_MENUSEPARATOR:

       aPart = MENU_POPUPSEPARATOR;

       aState = 0;

       return NS_OK;

     case NS_THEME_MENUARROW:

       {

         aPart = MENU_POPUPSUBMENU;

         EventStates eventState = GetContentState(aFrame, aWidgetType);

         aState = IsDisabled(aFrame, eventState) ? MSM_DISABLED : MSM_NORMAL;

         return NS_OK;

       }

     case NS_THEME_MENUCHECKBOX:

     case NS_THEME_MENURADIO:

       {

         bool isChecked;

         EventStates eventState = GetContentState(aFrame, aWidgetType);

         // NOTE: we can probably use NS_EVENT_STATE_CHECKED

         isChecked = CheckBooleanAttr(aFrame, nsGkAtoms::checked);

         aPart = MENU_POPUPCHECK;

         aState = MC_CHECKMARKNORMAL;

         // Radio states are offset by 2

         if (aWidgetType == NS_THEME_MENURADIO)

           aState += 2;

         // the disabled states are offset by 1

         if (IsDisabled(aFrame, eventState))

           aState += 1;

         return NS_OK;

       }

     case NS_THEME_MENUITEMTEXT:

     case NS_THEME_MENUIMAGE:

       aPart = -1;

       aState = 0;

       return NS_OK;

     case NS_THEME_WINDOW_TITLEBAR:

       aPart = mozilla::widget::themeconst::WP_CAPTION;

       aState = GetTopLevelWindowActiveState(aFrame);

       return NS_OK;

     case NS_THEME_WINDOW_TITLEBAR_MAXIMIZED:

       aPart = mozilla::widget::themeconst::WP_MAXCAPTION;

       aState = GetTopLevelWindowActiveState(aFrame);

       return NS_OK;

     case NS_THEME_WINDOW_FRAME_LEFT:

       aPart = mozilla::widget::themeconst::WP_FRAMELEFT;

       aState = GetTopLevelWindowActiveState(aFrame);

       return NS_OK;

     case NS_THEME_WINDOW_FRAME_RIGHT:

       aPart = mozilla::widget::themeconst::WP_FRAMERIGHT;

       aState = GetTopLevelWindowActiveState(aFrame);

       return NS_OK;

     case NS_THEME_WINDOW_FRAME_BOTTOM:

       aPart = mozilla::widget::themeconst::WP_FRAMEBOTTOM;

       aState = GetTopLevelWindowActiveState(aFrame);

       return NS_OK;

     case NS_THEME_WINDOW_BUTTON_CLOSE:

       aPart = mozilla::widget::themeconst::WP_CLOSEBUTTON;

       aState = GetWindowFrameButtonState(aFrame, GetContentState(aFrame, aWidgetType));

       return NS_OK;

     case NS_THEME_WINDOW_BUTTON_MINIMIZE:

       aPart = mozilla::widget::themeconst::WP_MINBUTTON;

       aState = GetWindowFrameButtonState(aFrame, GetContentState(aFrame, aWidgetType));

       return NS_OK;

     case NS_THEME_WINDOW_BUTTON_MAXIMIZE:

       aPart = mozilla::widget::themeconst::WP_MAXBUTTON;

       aState = GetWindowFrameButtonState(aFrame, GetContentState(aFrame, aWidgetType));

       return NS_OK;

     case NS_THEME_WINDOW_BUTTON_RESTORE:

       aPart = mozilla::widget::themeconst::WP_RESTOREBUTTON;

       aState = GetWindowFrameButtonState(aFrame, GetContentState(aFrame, aWidgetType));

       return NS_OK;

     case NS_THEME_WINDOW_BUTTON_BOX:

     case NS_THEME_WINDOW_BUTTON_BOX_MAXIMIZED:

     case NS_THEME_WIN_GLASS:

     case NS_THEME_WIN_BORDERLESS_GLASS:

       aPart = -1;

       aState = 0;

       return NS_OK;

   }

   aPart = 0;

   aState = 0;

   return NS_ERROR_FAILURE;

 }

 static bool

 AssumeThemePartAndStateAreTransparent(int32_t aPart, int32_t aState)

 {

   if (aPart == MENU_POPUPITEM && aState == MBI_NORMAL) {

     return true;

   }

   return false;

 }

 NS_IMETHODIMP

 nsNativeThemeWin::DrawWidgetBackground(nsRenderingContext* aContext,

                                        nsIFrame* aFrame,

                                        uint8_t aWidgetType,

                                        const nsRect& aRect,

                                        const nsRect& aDirtyRect)

 {

   HANDLE theme = GetTheme(aWidgetType);

   if (!theme)

     return ClassicDrawWidgetBackground(aContext, aFrame, aWidgetType, aRect, aDirtyRect); 

   // ^^ without the right sdk, assume xp theming and fall through.

   if (nsUXThemeData::CheckForCompositor()) {

     switch (aWidgetType) {

       case NS_THEME_WINDOW_TITLEBAR:

       case NS_THEME_WINDOW_TITLEBAR_MAXIMIZED:

       case NS_THEME_WINDOW_FRAME_LEFT:

       case NS_THEME_WINDOW_FRAME_RIGHT:

       case NS_THEME_WINDOW_FRAME_BOTTOM:

         // Nothing to draw, these areas are glass. Minimum dimensions

         // should be set, so xul content should be layed out correctly.

         return NS_OK;

       break;

       case NS_THEME_WINDOW_BUTTON_CLOSE:

       case NS_THEME_WINDOW_BUTTON_MINIMIZE:

       case NS_THEME_WINDOW_BUTTON_MAXIMIZE:

       case NS_THEME_WINDOW_BUTTON_RESTORE:

         // Not conventional bitmaps, can't be retrieved. If we fall

         // through here and call the theme library we'll get aero

         // basic bitmaps. 

         return NS_OK;

       break;

       case NS_THEME_WIN_GLASS:

       case NS_THEME_WIN_BORDERLESS_GLASS:

         // Nothing to draw, this is the glass background.

         return NS_OK;

       case NS_THEME_WINDOW_BUTTON_BOX:

       case NS_THEME_WINDOW_BUTTON_BOX_MAXIMIZED:

         // We handle these through nsIWidget::UpdateThemeGeometries

         return NS_OK;

       break;

     }

   }

   int32_t part, state;

   nsresult rv = GetThemePartAndState(aFrame, aWidgetType, part, state);

   if (NS_FAILED(rv))

     return rv;

   if (AssumeThemePartAndStateAreTransparent(part, state)) {

     return NS_OK;

   }

   gfxFloat p2a = gfxFloat(aContext->AppUnitsPerDevPixel());

   RECT widgetRect;

   RECT clipRect;

   gfxRect tr(aRect.x, aRect.y, aRect.width, aRect.height),

           dr(aDirtyRect.x, aDirtyRect.y, aDirtyRect.width, aDirtyRect.height);

   tr.ScaleInverse(p2a);

   dr.ScaleInverse(p2a);

   nsRefPtr<gfxContext> ctx = aContext->ThebesContext();

   gfxWindowsNativeDrawing nativeDrawing(ctx, dr, GetWidgetNativeDrawingFlags(aWidgetType));

 RENDER_AGAIN:

   HDC hdc = nativeDrawing.BeginNativeDrawing();

   if (!hdc)

     return NS_ERROR_FAILURE;

   nativeDrawing.TransformToNativeRect(tr, widgetRect);

   nativeDrawing.TransformToNativeRect(dr, clipRect);

 #if 0

   {

     PR_LOG(gWindowsLog, PR_LOG_ERROR,

            (stderr, "xform: %f %f %f %f [%f %f]\n", m.xx, m.yx, m.xy, m.yy, 

             m.x0, m.y0));

     PR_LOG(gWindowsLog, PR_LOG_ERROR,

            (stderr, "tr: [%d %d %d %d]\ndr: [%d %d %d %d]\noff: [%f %f]\n",

             tr.x, tr.y, tr.width, tr.height, dr.x, dr.y, dr.width, dr.height,

             offset.x, offset.y));

   }

 #endif

   if (aWidgetType == NS_THEME_WINDOW_TITLEBAR) {

     // Clip out the left and right corners of the frame, all we want in

     // is the middle section.

     widgetRect.left -= GetSystemMetrics(SM_CXFRAME);

     widgetRect.right += GetSystemMetrics(SM_CXFRAME);

   } else if (aWidgetType == NS_THEME_WINDOW_TITLEBAR_MAXIMIZED) {

     // The origin of the window is off screen when maximized and windows

     // doesn't compensate for this in rendering the background. Push the

     // top of the bitmap down by SM_CYFRAME so we get the full graphic.

     widgetRect.top += GetSystemMetrics(SM_CYFRAME);

   } else if (aWidgetType == NS_THEME_TAB) {

     // For left edge and right edge tabs, we need to adjust the widget

     // rects and clip rects so that the edges don't get drawn.

     bool isLeft = IsLeftToSelectedTab(aFrame);

     bool isRight = !isLeft && IsRightToSelectedTab(aFrame);

     if (isLeft || isRight) {

       // HACK ALERT: There appears to be no way to really obtain this value, so we're forced

       // to just use the default value for Luna (which also happens to be correct for

       // all the other skins I've tried).

       int32_t edgeSize = 2;

       // Armed with the size of the edge, we now need to either shift to the left or to the

       // right.  The clip rect won't include this extra area, so we know that we're

       // effectively shifting the edge out of view (such that it won't be painted).

       if (isLeft)

         // The right edge should not be drawn.  Extend our rect by the edge size.

         widgetRect.right += edgeSize;

       else

         // The left edge should not be drawn.  Move the widget rect's left coord back.

         widgetRect.left -= edgeSize;

     }

   }

   else if (aWidgetType == NS_THEME_WINDOW_BUTTON_MINIMIZE) {

     OffsetBackgroundRect(widgetRect, CAPTIONBUTTON_MINIMIZE);

   }

   else if (aWidgetType == NS_THEME_WINDOW_BUTTON_MAXIMIZE ||

            aWidgetType == NS_THEME_WINDOW_BUTTON_RESTORE) {

     OffsetBackgroundRect(widgetRect, CAPTIONBUTTON_RESTORE);

   }

   else if (aWidgetType == NS_THEME_WINDOW_BUTTON_CLOSE) {

     OffsetBackgroundRect(widgetRect, CAPTIONBUTTON_CLOSE);

   }

   // widgetRect is the bounding box for a widget, yet the scale track is only

   // a small portion of this size, so the edges of the scale need to be

   // adjusted to the real size of the track.

   if (aWidgetType == NS_THEME_RANGE ||

       aWidgetType == NS_THEME_SCALE_HORIZONTAL ||

       aWidgetType == NS_THEME_SCALE_VERTICAL) {

     RECT contentRect;

     GetThemeBackgroundContentRect(theme, hdc, part, state, &widgetRect, &contentRect);

     SIZE siz;

     GetThemePartSize(theme, hdc, part, state, &widgetRect, TS_TRUE, &siz);

     // When rounding is necessary, we round the position of the track

     // away from the chevron of the thumb to make it look better.

     if (aWidgetType == NS_THEME_SCALE_HORIZONTAL ||

         (aWidgetType == NS_THEME_RANGE && IsRangeHorizontal(aFrame))) {

       contentRect.top += (contentRect.bottom - contentRect.top - siz.cy) / 2;

       contentRect.bottom = contentRect.top + siz.cy;

     }

     else {

       if (!IsFrameRTL(aFrame)) {

         contentRect.left += (contentRect.right - contentRect.left - siz.cx) / 2;

         contentRect.right = contentRect.left + siz.cx;

       } else {

         contentRect.right -= (contentRect.right - contentRect.left - siz.cx) / 2;

         contentRect.left = contentRect.right - siz.cx;

       }

     }

     DrawThemeBackground(theme, hdc, part, state, &contentRect, &clipRect);

   }

   else if (aWidgetType == NS_THEME_MENUCHECKBOX || aWidgetType == NS_THEME_MENURADIO)

   {

       bool isChecked = false;

       isChecked = CheckBooleanAttr(aFrame, nsGkAtoms::checked);

       if (isChecked)

       {

         int bgState = MCB_NORMAL;

         EventStates eventState = GetContentState(aFrame, aWidgetType);

         // the disabled states are offset by 1

         if (IsDisabled(aFrame, eventState))

           bgState += 1;

         SIZE checkboxBGSize(GetCheckboxBGSize(theme, hdc));

         RECT checkBGRect = widgetRect;

         if (IsFrameRTL(aFrame)) {

           checkBGRect.left = checkBGRect.right-checkboxBGSize.cx;

         } else {

           checkBGRect.right = checkBGRect.left+checkboxBGSize.cx;

         }

         // Center the checkbox background vertically in the menuitem

         checkBGRect.top += (checkBGRect.bottom - checkBGRect.top)/2 - checkboxBGSize.cy/2;

         checkBGRect.bottom = checkBGRect.top + checkboxBGSize.cy;

         DrawThemeBackground(theme, hdc, MENU_POPUPCHECKBACKGROUND, bgState, &checkBGRect, &clipRect);

         MARGINS checkMargins = GetCheckboxMargins(theme, hdc);

         RECT checkRect = checkBGRect;

         checkRect.left += checkMargins.cxLeftWidth;

         checkRect.right -= checkMargins.cxRightWidth;

         checkRect.top += checkMargins.cyTopHeight;

         checkRect.bottom -= checkMargins.cyBottomHeight;

         DrawThemeBackground(theme, hdc, MENU_POPUPCHECK, state, &checkRect, &clipRect);

       }

   }

   else if (aWidgetType == NS_THEME_MENUPOPUP)

   {

     DrawThemeBackground(theme, hdc, MENU_POPUPBORDERS, /* state */ 0, &widgetRect, &clipRect);

     SIZE borderSize;

     GetThemePartSize(theme, hdc, MENU_POPUPBORDERS, 0, nullptr, TS_TRUE, &borderSize);

     RECT bgRect = widgetRect;

     bgRect.top += borderSize.cy;

     bgRect.bottom -= borderSize.cy;

     bgRect.left += borderSize.cx;

     bgRect.right -= borderSize.cx;

     DrawThemeBackground(theme, hdc, MENU_POPUPBACKGROUND, /* state */ 0, &bgRect, &clipRect);

     SIZE gutterSize(GetGutterSize(theme, hdc));

     RECT gutterRect;

     gutterRect.top = bgRect.top;

     gutterRect.bottom = bgRect.bottom;

     if (IsFrameRTL(aFrame)) {

       gutterRect.right = bgRect.right;

       gutterRect.left = gutterRect.right-gutterSize.cx;

     } else {

       gutterRect.left = bgRect.left;

       gutterRect.right = gutterRect.left+gutterSize.cx;

     }

     DrawThemeBGRTLAware(theme, hdc, MENU_POPUPGUTTER, /* state */ 0,

                         &gutterRect, &clipRect, IsFrameRTL(aFrame));

   }

   else if (aWidgetType == NS_THEME_MENUSEPARATOR)

   {

     SIZE gutterSize(GetGutterSize(theme,hdc));

     RECT sepRect = widgetRect;

     if (IsFrameRTL(aFrame))

       sepRect.right -= gutterSize.cx;

     else

       sepRect.left += gutterSize.cx;

     DrawThemeBackground(theme, hdc, MENU_POPUPSEPARATOR, /* state */ 0, &sepRect, &clipRect);

   }

   else if (aWidgetType == NS_THEME_MENUARROW)

   {

     // We're dpi aware and as such on systems that have dpi > 96 set, the

     // theme library expects us to do proper positioning and scaling of glyphs.

     // For NS_THEME_MENUARROW, layout may hand us a widget rect larger than the

     // glyph rect we request in GetMinimumWidgetSize. To prevent distortion we

     // have to position and scale what we draw.

     SIZE glyphSize;

     GetThemePartSize(theme, hdc, part, state, nullptr, TS_TRUE, &glyphSize);

     int32_t widgetHeight = widgetRect.bottom - widgetRect.top;

     RECT renderRect = widgetRect;

     // We request (glyph width * 2, glyph height) in GetMinimumWidgetSize. In

     // Firefox some menu items provide the full height of the item to us, in

     // others our widget rect is the exact dims of our arrow glyph. Adjust the

     // vertical position by the added space, if any exists.

     renderRect.top += ((widgetHeight - glyphSize.cy) / 2);

     renderRect.bottom = renderRect.top + glyphSize.cy;

     // I'm using the width of the arrow glyph for the arrow-side padding.

     // AFAICT there doesn't appear to be a theme constant we can query

     // for this value. Generally this looks correct, and has the added

     // benefit of being a dpi adjusted value.

     if (!IsFrameRTL(aFrame)) {

       renderRect.right = widgetRect.right - glyphSize.cx;

       renderRect.left = renderRect.right - glyphSize.cx;

     } else {

       renderRect.left = glyphSize.cx;

       renderRect.right = renderRect.left + glyphSize.cx;

     }

     DrawThemeBGRTLAware(theme, hdc, part, state, &renderRect, &clipRect,

                         IsFrameRTL(aFrame));

   }

   // The following widgets need to be RTL-aware

   else if (aWidgetType == NS_THEME_RESIZER ||

            aWidgetType == NS_THEME_DROPDOWN_BUTTON)

   {

     DrawThemeBGRTLAware(theme, hdc, part, state,

                         &widgetRect, &clipRect, IsFrameRTL(aFrame));

   }

   else if (aWidgetType == NS_THEME_PROGRESSBAR ||

            aWidgetType == NS_THEME_PROGRESSBAR_VERTICAL) {

     // DrawThemeBackground renders each corner with a solid white pixel.

     // Restore these pixels to the underlying color. Tracks are rendered

     // using alpha recovery, so this makes the corners transparent.

     COLORREF color;

     color = GetPixel(hdc, widgetRect.left, widgetRect.top);

     DrawThemeBackground(theme, hdc, part, state, &widgetRect, &clipRect);

     SetPixel(hdc, widgetRect.left, widgetRect.top, color);

     SetPixel(hdc, widgetRect.right-1, widgetRect.top, color);

     SetPixel(hdc, widgetRect.right-1, widgetRect.bottom-1, color);

     SetPixel(hdc, widgetRect.left, widgetRect.bottom-1, color);

   }

   else if (aWidgetType == NS_THEME_PROGRESSBAR_CHUNK ||

            aWidgetType == NS_THEME_PROGRESSBAR_CHUNK_VERTICAL) {

     DrawThemedProgressMeter(aFrame, aWidgetType, theme, hdc, part, state,

                             &widgetRect, &clipRect, p2a);

   }

   // If part is negative, the element wishes us to not render a themed

   // background, instead opting to be drawn specially below.

   else if (part >= 0) {

     DrawThemeBackground(theme, hdc, part, state, &widgetRect, &clipRect);

   }

   // Draw focus rectangles for XP HTML checkboxes and radio buttons

   // XXX it'd be nice to draw these outside of the frame

   if (((aWidgetType == NS_THEME_CHECKBOX || aWidgetType == NS_THEME_RADIO) &&

         aFrame->GetContent()->IsHTML()) ||

       aWidgetType == NS_THEME_RANGE ||

       aWidgetType == NS_THEME_SCALE_HORIZONTAL ||

       aWidgetType == NS_THEME_SCALE_VERTICAL) {

       EventStates contentState = GetContentState(aFrame, aWidgetType);

       if (contentState.HasState(NS_EVENT_STATE_FOCUS)) {

         POINT vpOrg;

         HPEN hPen = nullptr;

         uint8_t id = SaveDC(hdc);

         ::SelectClipRgn(hdc, nullptr);

         ::GetViewportOrgEx(hdc, &vpOrg);

         ::SetBrushOrgEx(hdc, vpOrg.x + widgetRect.left, vpOrg.y + widgetRect.top, nullptr);

         // On vista, choose our own colors and draw an XP style half focus rect

         // for focused checkboxes and a full rect when active.

         if (IsVistaOrLater() &&

             aWidgetType == NS_THEME_CHECKBOX) {

           LOGBRUSH lb;

           lb.lbStyle = BS_SOLID;

           lb.lbColor = RGB(255,255,255);

           lb.lbHatch = 0;

           hPen = ::ExtCreatePen(PS_COSMETIC|PS_ALTERNATE, 1, &lb, 0, nullptr);

           ::SelectObject(hdc, hPen);

           // If pressed, draw the upper left corner of the dotted rect.

           if (contentState.HasState(NS_EVENT_STATE_ACTIVE)) {

             ::MoveToEx(hdc, widgetRect.left, widgetRect.bottom-1, nullptr);

             ::LineTo(hdc, widgetRect.left, widgetRect.top);

             ::LineTo(hdc, widgetRect.right-1, widgetRect.top);

           }

           // Draw the lower right corner of the dotted rect.

           ::MoveToEx(hdc, widgetRect.right-1, widgetRect.top, nullptr);

           ::LineTo(hdc, widgetRect.right-1, widgetRect.bottom-1);

           ::LineTo(hdc, widgetRect.left, widgetRect.bottom-1);

         } else {

           ::SetTextColor(hdc, 0);

           ::DrawFocusRect(hdc, &widgetRect);

         }

         ::RestoreDC(hdc, id);

         if (hPen) {

           ::DeleteObject(hPen);

         }

       }

   }

   else if (aWidgetType == NS_THEME_TOOLBAR && state == 0) {

     // Draw toolbar separator lines above all toolbars except the first one.

     // The lines are part of the Rebar theme, which is loaded for NS_THEME_TOOLBOX.

     theme = GetTheme(NS_THEME_TOOLBOX);

     if (!theme)

       return NS_ERROR_FAILURE;

     widgetRect.bottom = widgetRect.top + TB_SEPARATOR_HEIGHT;

     DrawThemeEdge(theme, hdc, RP_BAND, 0, &widgetRect, EDGE_ETCHED, BF_TOP, nullptr);

   }

   else if (aWidgetType == NS_THEME_SCROLLBAR_THUMB_HORIZONTAL ||

            aWidgetType == NS_THEME_SCROLLBAR_THUMB_VERTICAL)

   {

     // Draw the decorative gripper for the scrollbar thumb button, if it fits

     SIZE gripSize;

     MARGINS thumbMgns;

     int gripPart = (aWidgetType == NS_THEME_SCROLLBAR_THUMB_HORIZONTAL) ?

                    SP_GRIPPERHOR : SP_GRIPPERVERT;

     if (GetThemePartSize(theme, hdc, gripPart, state, nullptr, TS_TRUE, &gripSize) == S_OK &&

         GetThemeMargins(theme, hdc, part, state, TMT_CONTENTMARGINS, nullptr, &thumbMgns) == S_OK &&

         gripSize.cx + thumbMgns.cxLeftWidth + thumbMgns.cxRightWidth <= widgetRect.right - widgetRect.left &&

         gripSize.cy + thumbMgns.cyTopHeight + thumbMgns.cyBottomHeight <= widgetRect.bottom - widgetRect.top)

     {

       DrawThemeBackground(theme, hdc, gripPart, state, &widgetRect, &clipRect);

     }

   }

   nativeDrawing.EndNativeDrawing();

   if (nativeDrawing.ShouldRenderAgain())

     goto RENDER_AGAIN;

   nativeDrawing.PaintToContext();

   return NS_OK;

 }

 NS_IMETHODIMP

 nsNativeThemeWin::GetWidgetBorder(nsDeviceContext* aContext, 

                                   nsIFrame* aFrame,

                                   uint8_t aWidgetType,

                                   nsIntMargin* aResult)

 {

   HANDLE theme = GetTheme(aWidgetType);

   if (!theme)

     return ClassicGetWidgetBorder(aContext, aFrame, aWidgetType, aResult); 

   (*aResult).top = (*aResult).bottom = (*aResult).left = (*aResult).right = 0;

   if (!WidgetIsContainer(aWidgetType) ||

       aWidgetType == NS_THEME_TOOLBOX || 

       aWidgetType == NS_THEME_WIN_MEDIA_TOOLBOX ||

       aWidgetType == NS_THEME_WIN_COMMUNICATIONS_TOOLBOX ||

       aWidgetType == NS_THEME_WIN_BROWSER_TAB_BAR_TOOLBOX ||

       aWidgetType == NS_THEME_STATUSBAR || 

       aWidgetType == NS_THEME_RESIZER || aWidgetType == NS_THEME_TAB_PANEL ||

       aWidgetType == NS_THEME_SCROLLBAR_TRACK_HORIZONTAL ||

       aWidgetType == NS_THEME_SCROLLBAR_TRACK_VERTICAL ||

       aWidgetType == NS_THEME_MENUITEM || aWidgetType == NS_THEME_CHECKMENUITEM ||

       aWidgetType == NS_THEME_RADIOMENUITEM || aWidgetType == NS_THEME_MENUPOPUP ||

       aWidgetType == NS_THEME_MENUIMAGE || aWidgetType == NS_THEME_MENUITEMTEXT ||

       aWidgetType == NS_THEME_TOOLBAR_SEPARATOR ||

       aWidgetType == NS_THEME_WINDOW_TITLEBAR ||

       aWidgetType == NS_THEME_WINDOW_TITLEBAR_MAXIMIZED ||

       aWidgetType == NS_THEME_WIN_GLASS || aWidgetType == NS_THEME_WIN_BORDERLESS_GLASS)

     return NS_OK; // Don't worry about it.

   int32_t part, state;

   nsresult rv = GetThemePartAndState(aFrame, aWidgetType, part, state);

   if (NS_FAILED(rv))

     return rv;

   if (aWidgetType == NS_THEME_TOOLBAR) {

     // make space for the separator line above all toolbars but the first

     if (state == 0)

       aResult->top = TB_SEPARATOR_HEIGHT;

     return NS_OK;

   }

   // Get our info.

   RECT outerRect; // Create a fake outer rect.

   outerRect.top = outerRect.left = 100;

   outerRect.right = outerRect.bottom = 200;

   RECT contentRect(outerRect);

   HRESULT res = GetThemeBackgroundContentRect(theme, nullptr, part, state, &outerRect, &contentRect);

   if (FAILED(res))

     return NS_ERROR_FAILURE;

   // Now compute the delta in each direction and place it in our

   // nsIntMargin struct.

   aResult->top = contentRect.top - outerRect.top;

   aResult->bottom = outerRect.bottom - contentRect.bottom;

   aResult->left = contentRect.left - outerRect.left;

   aResult->right = outerRect.right - contentRect.right;

   // Remove the edges for tabs that are before or after the selected tab,

   if (aWidgetType == NS_THEME_TAB) {

     if (IsLeftToSelectedTab(aFrame))

       // Remove the right edge, since we won't be drawing it.

       aResult->right = 0;

     else if (IsRightToSelectedTab(aFrame))

       // Remove the left edge, since we won't be drawing it.

       aResult->left = 0;

   }

   if (aFrame && (aWidgetType == NS_THEME_NUMBER_INPUT ||

                  aWidgetType == NS_THEME_TEXTFIELD ||

                  aWidgetType == NS_THEME_TEXTFIELD_MULTILINE)) {

     nsIContent* content = aFrame->GetContent();

     if (content && content->IsHTML()) {

       // We need to pad textfields by 1 pixel, since the caret will draw

       // flush against the edge by default if we don't.

       aResult->top++;

       aResult->left++;

       aResult->bottom++;

       aResult->right++;

     }

   }

   return NS_OK;

 }

 bool

 nsNativeThemeWin::GetWidgetPadding(nsDeviceContext* aContext, 

                                    nsIFrame* aFrame,

                                    uint8_t aWidgetType,

                                    nsIntMargin* aResult)

 {

   switch (aWidgetType) {

     // Radios and checkboxes return a fixed size in GetMinimumWidgetSize

     // and have a meaningful baseline, so they can't have

     // author-specified padding.

     case NS_THEME_CHECKBOX:

     case NS_THEME_RADIO:

       aResult->SizeTo(0, 0, 0, 0);

       return true;

   }

   HANDLE theme = GetTheme(aWidgetType);

   if (aWidgetType == NS_THEME_WINDOW_BUTTON_BOX ||

       aWidgetType == NS_THEME_WINDOW_BUTTON_BOX_MAXIMIZED) {

     aResult->SizeTo(0, 0, 0, 0);

     // aero glass doesn't display custom buttons

     if (nsUXThemeData::CheckForCompositor())

       return true;

     // button padding for standard windows

     if (aWidgetType == NS_THEME_WINDOW_BUTTON_BOX) {

       aResult->top = GetSystemMetrics(SM_CXFRAME);

     }

     return true;

   }

   // Content padding

   if (aWidgetType == NS_THEME_WINDOW_TITLEBAR ||

       aWidgetType == NS_THEME_WINDOW_TITLEBAR_MAXIMIZED) {

     aResult->SizeTo(0, 0, 0, 0);

     // XXX Maximized windows have an offscreen offset equal to

     // the border padding. This should be addressed in nsWindow,

     // but currently can't be, see UpdateNonClientMargins.

     if (aWidgetType == NS_THEME_WINDOW_TITLEBAR_MAXIMIZED)

       aResult->top = GetSystemMetrics(SM_CXFRAME)

                    + GetSystemMetrics(SM_CXPADDEDBORDER);

     return true;

   }

   if (!theme)

     return ClassicGetWidgetPadding(aContext, aFrame, aWidgetType, aResult);

   if (aWidgetType == NS_THEME_MENUPOPUP)

   {

     SIZE popupSize;

     GetThemePartSize(theme, nullptr, MENU_POPUPBORDERS, /* state */ 0, nullptr, TS_TRUE, &popupSize);

     aResult->top = aResult->bottom = popupSize.cy;

     aResult->left = aResult->right = popupSize.cx;

     return true;

   }

   if (IsVistaOrLater()) {

     if (aWidgetType == NS_THEME_NUMBER_INPUT ||

         aWidgetType == NS_THEME_TEXTFIELD ||

         aWidgetType == NS_THEME_TEXTFIELD_MULTILINE ||

         aWidgetType == NS_THEME_DROPDOWN)

     {

       /* If we have author-specified padding for these elements, don't do the fixups below */

       if (aFrame->PresContext()->HasAuthorSpecifiedRules(aFrame, NS_AUTHOR_SPECIFIED_PADDING))

         return false;

     }

     /* textfields need extra pixels on all sides, otherwise they

      * wrap their content too tightly.  The actual border is drawn 1px

      * inside the specified rectangle, so Gecko will end up making the

      * contents look too small.  Instead, we add 2px padding for the

      * contents and fix this. (Used to be 1px added, see bug 430212)

      */

     if (aWidgetType == NS_THEME_NUMBER_INPUT ||

         aWidgetType == NS_THEME_TEXTFIELD ||

         aWidgetType == NS_THEME_TEXTFIELD_MULTILINE) {

       aResult->top = aResult->bottom = 2;

       aResult->left = aResult->right = 2;

       return true;

     } else if (IsHTMLContent(aFrame) && aWidgetType == NS_THEME_DROPDOWN) {

       /* For content menulist controls, we need an extra pixel so

        * that we have room to draw our focus rectangle stuff.

        * Otherwise, the focus rect might overlap the control's

        * border.

        */

       aResult->top = aResult->bottom = 1;

       aResult->left = aResult->right = 1;

       return true;

     }

   }

   int32_t right, left, top, bottom;

   right = left = top = bottom = 0;

   switch (aWidgetType)

   {

     case NS_THEME_MENUIMAGE:

         right = 8;

         left = 3;

         break;

     case NS_THEME_MENUCHECKBOX:

     case NS_THEME_MENURADIO:

         right = 8;

         left = 0;

         break;

     case NS_THEME_MENUITEMTEXT:

         // There seem to be exactly 4 pixels from the edge

         // of the gutter to the text: 2px margin (CSS) + 2px padding (here)

         {

           SIZE size(GetGutterSize(theme, nullptr));

           left = size.cx + 2;

         }

         break;

     case NS_THEME_MENUSEPARATOR:

         {

           SIZE size(GetGutterSize(theme, nullptr));

           left = size.cx + 5;

           top = 10;

           bottom = 7;

         }

         break;

     default:

         return false;

   }

   if (IsFrameRTL(aFrame))

   {

     aResult->right = left;

     aResult->left = right;

   }

   else

   {

     aResult->right = right;

     aResult->left = left;

   }

   return true;

 }

 bool

 nsNativeThemeWin::GetWidgetOverflow(nsDeviceContext* aContext, 

                                     nsIFrame* aFrame,

                                     uint8_t aOverflowRect,

                                     nsRect* aResult)

 {

   /* This is disabled for now, because it causes invalidation problems --

    * see bug 420381.  The effect of not updating the overflow area is that

    * for dropdown buttons in content areas, there is a 1px border on 3 sides

    * where, if invalidated, the dropdown control probably won't be repainted.

    * This is fairly minor, as by default there is nothing in that area, and

    * a border only shows up if the widget is being hovered.

    */

 #if 0

   if (IsVistaOrLater()) {

     /* We explicitly draw dropdown buttons in HTML content 1px bigger

      * up, right, and bottom so that they overlap the dropdown's border

      * like they're supposed to.

      */

     if (aWidgetType == NS_THEME_DROPDOWN_BUTTON &&

         IsHTMLContent(aFrame) &&

         !IsWidgetStyled(aFrame->GetParent()->PresContext(),

                         aFrame->GetParent(),

                         NS_THEME_DROPDOWN))

     {

       int32_t p2a = aContext->AppUnitsPerDevPixel();

       /* Note: no overflow on the left */

       nsMargin m(p2a, p2a, p2a, 0);

       aOverflowRect->Inflate (m);

       return true;

     }

   }

 #endif

   return false;

 }

 NS_IMETHODIMP

 nsNativeThemeWin::GetMinimumWidgetSize(nsRenderingContext* aContext, nsIFrame* aFrame,

                                        uint8_t aWidgetType,

                                        nsIntSize* aResult, bool* aIsOverridable)

 {

   (*aResult).width = (*aResult).height = 0;

   *aIsOverridable = true;

   HANDLE theme = GetTheme(aWidgetType);

   if (!theme)

     return ClassicGetMinimumWidgetSize(aContext, aFrame, aWidgetType, aResult, aIsOverridable);

   switch (aWidgetType) {

     case NS_THEME_GROUPBOX:

     case NS_THEME_NUMBER_INPUT:

     case NS_THEME_TEXTFIELD:

     case NS_THEME_TOOLBOX:

     case NS_THEME_WIN_MEDIA_TOOLBOX:

     case NS_THEME_WIN_COMMUNICATIONS_TOOLBOX:

     case NS_THEME_WIN_BROWSER_TAB_BAR_TOOLBOX:

     case NS_THEME_TOOLBAR:

     case NS_THEME_STATUSBAR:

     case NS_THEME_PROGRESSBAR_CHUNK:

     case NS_THEME_PROGRESSBAR_CHUNK_VERTICAL:

     case NS_THEME_TAB_PANELS:

     case NS_THEME_TAB_PANEL:

     case NS_THEME_LISTBOX:

     case NS_THEME_TREEVIEW:

     case NS_THEME_MENUITEMTEXT:

     case NS_THEME_WIN_GLASS:

     case NS_THEME_WIN_BORDERLESS_GLASS:

       return NS_OK; // Don't worry about it.

   }

   if (aWidgetType == NS_THEME_MENUITEM && IsTopLevelMenu(aFrame))

       return NS_OK; // Don't worry about it for top level menus

   // Call GetSystemMetrics to determine size for WinXP scrollbars

   // (GetThemeSysSize API returns the optimal size for the theme, but 

   //  Windows appears to always use metrics when drawing standard scrollbars)

   THEMESIZE sizeReq = TS_TRUE; // Best-fit size

   switch (aWidgetType) {

     case NS_THEME_SCROLLBAR_THUMB_VERTICAL:

     case NS_THEME_SCROLLBAR_THUMB_HORIZONTAL:

     case NS_THEME_SCROLLBAR_BUTTON_UP:

     case NS_THEME_SCROLLBAR_BUTTON_DOWN:

     case NS_THEME_SCROLLBAR_BUTTON_LEFT:

     case NS_THEME_SCROLLBAR_BUTTON_RIGHT:

     case NS_THEME_SCROLLBAR_TRACK_HORIZONTAL:

     case NS_THEME_SCROLLBAR_TRACK_VERTICAL:

     case NS_THEME_DROPDOWN_BUTTON:

       return ClassicGetMinimumWidgetSize(aContext, aFrame, aWidgetType, aResult, aIsOverridable);

     case NS_THEME_MENUITEM:

     case NS_THEME_CHECKMENUITEM:

     case NS_THEME_RADIOMENUITEM:

       if(!IsTopLevelMenu(aFrame))

       {

         SIZE gutterSize(GetGutterSize(theme, nullptr));

         aResult->width = gutterSize.cx;

         aResult->height = gutterSize.cy;

         return NS_OK;

       }

       break;

     case NS_THEME_MENUIMAGE:

     case NS_THEME_MENUCHECKBOX:

     case NS_THEME_MENURADIO:

       {

         SIZE boxSize(GetGutterSize(theme, nullptr));

         aResult->width = boxSize.cx+2;

         aResult->height = boxSize.cy;

         *aIsOverridable = false;

       }

     case NS_THEME_MENUITEMTEXT:

       return NS_OK;

     case NS_THEME_PROGRESSBAR:

     case NS_THEME_PROGRESSBAR_VERTICAL:

       // Best-fit size for progress meters is too large for most 

       // themes. We want these widgets to be able to really shrink

       // down, so use the min-size request value (of 0).

       sizeReq = TS_MIN; 

       break;

     case NS_THEME_RESIZER:

       *aIsOverridable = false;

       break;

     case NS_THEME_RANGE_THUMB:

     case NS_THEME_SCALE_THUMB_HORIZONTAL:

     case NS_THEME_SCALE_THUMB_VERTICAL:

     {

       *aIsOverridable = false;

       // on Vista, GetThemePartAndState returns odd values for

       // scale thumbs, so use a hardcoded size instead.

       if (IsVistaOrLater()) {

         if (aWidgetType == NS_THEME_SCALE_THUMB_HORIZONTAL ||

             (aWidgetType == NS_THEME_RANGE_THUMB && IsRangeHorizontal(aFrame))) {

           aResult->width = 12;

           aResult->height = 20;

         }

         else {

           aResult->width = 20;

           aResult->height = 12;

         }

         return NS_OK;

       }

       break;

     }

     case NS_THEME_SCROLLBAR:

     {

       if (nsLookAndFeel::GetInt(

             nsLookAndFeel::eIntID_UseOverlayScrollbars) != 0) {

         aResult->SizeTo(::GetSystemMetrics(SM_CXHSCROLL),

                         ::GetSystemMetrics(SM_CYVSCROLL));

         return NS_OK;

       }

       break;

     }

     case NS_THEME_TOOLBAR_SEPARATOR:

       // that's 2px left margin, 2px right margin and 2px separator

       // (the margin is drawn as part of the separator, though)

       aResult->width = 6;

       return NS_OK;

     case NS_THEME_BUTTON:

       // We should let HTML buttons shrink to their min size.

       // FIXME bug 403934: We should probably really separate

       // GetPreferredWidgetSize from GetMinimumWidgetSize, so callers can

       // use the one they want.

       if (aFrame->GetContent()->IsHTML()) {

         sizeReq = TS_MIN;

       }

       break;

     case NS_THEME_WINDOW_BUTTON_MAXIMIZE:

     case NS_THEME_WINDOW_BUTTON_RESTORE:

       // The only way to get accurate titlebar button info is to query a

       // window w/buttons when it's visible. nsWindow takes care of this and

       // stores that info in nsUXThemeData.

       aResult->width = nsUXThemeData::sCommandButtons[CMDBUTTONIDX_RESTORE].cx;

       aResult->height = nsUXThemeData::sCommandButtons[CMDBUTTONIDX_RESTORE].cy;

       // For XP, subtract 4 from system metrics dimensions.

       if (!IsVistaOrLater()) {

         aResult->width -= 4;

         aResult->height -= 4;

       }

       AddPaddingRect(aResult, CAPTIONBUTTON_RESTORE);

       *aIsOverridable = false;

       return NS_OK;

     case NS_THEME_WINDOW_BUTTON_MINIMIZE:

       aResult->width = nsUXThemeData::sCommandButtons[CMDBUTTONIDX_MINIMIZE].cx;

       aResult->height = nsUXThemeData::sCommandButtons[CMDBUTTONIDX_MINIMIZE].cy;

       if (!IsVistaOrLater()) {

         aResult->width -= 4;

         aResult->height -= 4;

       }

       AddPaddingRect(aResult, CAPTIONBUTTON_MINIMIZE);

       *aIsOverridable = false;

       return NS_OK;

     case NS_THEME_WINDOW_BUTTON_CLOSE:

       aResult->width = nsUXThemeData::sCommandButtons[CMDBUTTONIDX_CLOSE].cx;

       aResult->height = nsUXThemeData::sCommandButtons[CMDBUTTONIDX_CLOSE].cy;

       if (!IsVistaOrLater()) {

         aResult->width -= 4;

         aResult->height -= 4;

       }

       AddPaddingRect(aResult, CAPTIONBUTTON_CLOSE);

       *aIsOverridable = false;

       return NS_OK;

     case NS_THEME_WINDOW_TITLEBAR:

     case NS_THEME_WINDOW_TITLEBAR_MAXIMIZED:

       aResult->height = GetSystemMetrics(SM_CYCAPTION);

       aResult->height += GetSystemMetrics(SM_CYFRAME);

       aResult->height += GetSystemMetrics(SM_CXPADDEDBORDER);

       *aIsOverridable = false;

       return NS_OK;

     case NS_THEME_WINDOW_BUTTON_BOX:

     case NS_THEME_WINDOW_BUTTON_BOX_MAXIMIZED:

       if (nsUXThemeData::CheckForCompositor()) {

         aResult->width = nsUXThemeData::sCommandButtons[CMDBUTTONIDX_BUTTONBOX].cx;

         aResult->height = nsUXThemeData::sCommandButtons[CMDBUTTONIDX_BUTTONBOX].cy

                           - GetSystemMetrics(SM_CYFRAME)

                           - GetSystemMetrics(SM_CXPADDEDBORDER);

         if (aWidgetType == NS_THEME_WINDOW_BUTTON_BOX_MAXIMIZED) {

           aResult->width += 1;

           aResult->height -= 2;

         }

         *aIsOverridable = false;

         return NS_OK;

       }

       break;

     case NS_THEME_WINDOW_FRAME_LEFT:

     case NS_THEME_WINDOW_FRAME_RIGHT:

     case NS_THEME_WINDOW_FRAME_BOTTOM:

       aResult->width = GetSystemMetrics(SM_CXFRAME);

       aResult->height = GetSystemMetrics(SM_CYFRAME);

       *aIsOverridable = false;

       return NS_OK;

   }

   int32_t part, state;

   nsresult rv = GetThemePartAndState(aFrame, aWidgetType, part, state);

   if (NS_FAILED(rv))

     return rv;

   HDC hdc = ::GetDC(nullptr);

   if (!hdc)

     return NS_ERROR_FAILURE;

   SIZE sz;

   GetThemePartSize(theme, hdc, part, state, nullptr, sizeReq, &sz);

   aResult->width = sz.cx;

   aResult->height = sz.cy;

   switch(aWidgetType) {

     case NS_THEME_SPINNER_UP_BUTTON:

     case NS_THEME_SPINNER_DOWN_BUTTON:

       aResult->width++;

       aResult->height = aResult->height / 2 + 1;

       break;

     case NS_THEME_MENUSEPARATOR:

     {

       SIZE gutterSize(GetGutterSize(theme, hdc));

       aResult->width += gutterSize.cx;

       break;

     }

     case NS_THEME_MENUARROW:

     {

       // Use the width of the arrow glyph as padding. See the drawing

       // code for details.

       aResult->width *= 2;

       break;

     }

   }

   ::ReleaseDC(nullptr, hdc);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsNativeThemeWin::WidgetStateChanged(nsIFrame* aFrame, uint8_t aWidgetType, 

                                      nsIAtom* aAttribute, bool* aShouldRepaint)

 {

   // Some widget types just never change state.

   if (aWidgetType == NS_THEME_TOOLBOX ||

       aWidgetType == NS_THEME_WIN_MEDIA_TOOLBOX ||

       aWidgetType == NS_THEME_WIN_COMMUNICATIONS_TOOLBOX ||

       aWidgetType == NS_THEME_WIN_BROWSER_TAB_BAR_TOOLBOX ||

       aWidgetType == NS_THEME_TOOLBAR ||

       aWidgetType == NS_THEME_STATUSBAR || aWidgetType == NS_THEME_STATUSBAR_PANEL ||

       aWidgetType == NS_THEME_STATUSBAR_RESIZER_PANEL ||

       aWidgetType == NS_THEME_PROGRESSBAR_CHUNK ||

       aWidgetType == NS_THEME_PROGRESSBAR_CHUNK_VERTICAL ||

       aWidgetType == NS_THEME_PROGRESSBAR ||

       aWidgetType == NS_THEME_PROGRESSBAR_VERTICAL ||

       aWidgetType == NS_THEME_TOOLTIP ||

       aWidgetType == NS_THEME_TAB_PANELS ||

       aWidgetType == NS_THEME_TAB_PANEL ||

       aWidgetType == NS_THEME_TOOLBAR_SEPARATOR ||

       aWidgetType == NS_THEME_WIN_GLASS ||

       aWidgetType == NS_THEME_WIN_BORDERLESS_GLASS) {

     *aShouldRepaint = false;

     return NS_OK;

   }

   if (aWidgetType == NS_THEME_WINDOW_TITLEBAR ||

       aWidgetType == NS_THEME_WINDOW_TITLEBAR_MAXIMIZED ||

       aWidgetType == NS_THEME_WINDOW_FRAME_LEFT ||

       aWidgetType == NS_THEME_WINDOW_FRAME_RIGHT ||

       aWidgetType == NS_THEME_WINDOW_FRAME_BOTTOM ||

       aWidgetType == NS_THEME_WINDOW_BUTTON_CLOSE ||

       aWidgetType == NS_THEME_WINDOW_BUTTON_MINIMIZE ||

       aWidgetType == NS_THEME_WINDOW_BUTTON_MINIMIZE ||

       aWidgetType == NS_THEME_WINDOW_BUTTON_RESTORE) {

     *aShouldRepaint = true;

     return NS_OK;

   }

   // On Vista, the scrollbar buttons need to change state when the track has/doesn't have hover

   if (!IsVistaOrLater() &&

       (aWidgetType == NS_THEME_SCROLLBAR_TRACK_VERTICAL || 

       aWidgetType == NS_THEME_SCROLLBAR_TRACK_HORIZONTAL)) {

     *aShouldRepaint = false;

     return NS_OK;

   }

   // We need to repaint the dropdown arrow in vista HTML combobox controls when

   // the control is closed to get rid of the hover effect.

   if (IsVistaOrLater() &&

       (aWidgetType == NS_THEME_DROPDOWN || aWidgetType == NS_THEME_DROPDOWN_BUTTON) &&

       IsHTMLContent(aFrame))

   {

     *aShouldRepaint = true;

     return NS_OK;

   }

   // XXXdwh Not sure what can really be done here.  Can at least guess for

   // specific widgets that they're highly unlikely to have certain states.

   // For example, a toolbar doesn't care about any states.

   if (!aAttribute) {

     // Hover/focus/active changed.  Always repaint.

     *aShouldRepaint = true;

   }

   else {

     // Check the attribute to see if it's relevant.  

     // disabled, checked, dlgtype, default, etc.

     *aShouldRepaint = false;

     if (aAttribute == nsGkAtoms::disabled ||

         aAttribute == nsGkAtoms::checked ||

         aAttribute == nsGkAtoms::selected ||

         aAttribute == nsGkAtoms::readonly ||

         aAttribute == nsGkAtoms::open ||

         aAttribute == nsGkAtoms::menuactive ||

         aAttribute == nsGkAtoms::focused)

       *aShouldRepaint = true;

   }

   return NS_OK;

 }

 NS_IMETHODIMP

 nsNativeThemeWin::ThemeChanged()

 {

   nsUXThemeData::Invalidate();

   return NS_OK;

 }

 bool 

 nsNativeThemeWin::ThemeSupportsWidget(nsPresContext* aPresContext,

                                       nsIFrame* aFrame,

                                       uint8_t aWidgetType)

 {

   // XXXdwh We can go even further and call the API to ask if support exists for

   // specific widgets.

   if (aPresContext && !aPresContext->PresShell()->IsThemeSupportEnabled())

     return false;

   HANDLE theme = nullptr;

   if (aWidgetType == NS_THEME_CHECKBOX_CONTAINER)

     theme = GetTheme(NS_THEME_CHECKBOX);

   else if (aWidgetType == NS_THEME_RADIO_CONTAINER)

     theme = GetTheme(NS_THEME_RADIO);

   else

     theme = GetTheme(aWidgetType);

   if ((theme) || (!theme && ClassicThemeSupportsWidget(aPresContext, aFrame, aWidgetType)))

     // turn off theming for some HTML widgets styled by the page

     return (!IsWidgetStyled(aPresContext, aFrame, aWidgetType));

   return false;

 }

 bool 

 nsNativeThemeWin::WidgetIsContainer(uint8_t aWidgetType)

 {

   // XXXdwh At some point flesh all of this out.

   if (aWidgetType == NS_THEME_DROPDOWN_BUTTON || 

       aWidgetType == NS_THEME_RADIO ||

       aWidgetType == NS_THEME_CHECKBOX)

     return false;

   return true;

 }

 bool

 nsNativeThemeWin::ThemeDrawsFocusForWidget(uint8_t aWidgetType)

 {

   return false;

 }

 bool

 nsNativeThemeWin::ThemeNeedsComboboxDropmarker()

 {

   return true;

 }

 bool

 nsNativeThemeWin::WidgetAppearanceDependsOnWindowFocus(uint8_t aWidgetType)

 {

   switch (aWidgetType) {

     case NS_THEME_WINDOW_TITLEBAR:

     case NS_THEME_WINDOW_TITLEBAR_MAXIMIZED:

     case NS_THEME_WINDOW_FRAME_LEFT:

     case NS_THEME_WINDOW_FRAME_RIGHT:

     case NS_THEME_WINDOW_FRAME_BOTTOM:

     case NS_THEME_WINDOW_BUTTON_CLOSE:

     case NS_THEME_WINDOW_BUTTON_MINIMIZE:

     case NS_THEME_WINDOW_BUTTON_MAXIMIZE:

     case NS_THEME_WINDOW_BUTTON_RESTORE:

       return true;

     default:

       return false;

   }

 }

 bool

 nsNativeThemeWin::ShouldHideScrollbars()

 {

   return WinUtils::ShouldHideScrollbars();

 }

 nsITheme::Transparency

 nsNativeThemeWin::GetWidgetTransparency(nsIFrame* aFrame, uint8_t aWidgetType)

 {

   switch (aWidgetType) {

   case NS_THEME_SCROLLBAR_SMALL:

   case NS_THEME_SCROLLBAR:

   case NS_THEME_STATUSBAR:

     // Knowing that scrollbars and statusbars are opaque improves

     // performance, because we create layers for them. This better be

     // true across all Windows themes! If it's not true, we should

     // paint an opaque background for them to make it true!

     return eOpaque;

   case NS_THEME_WIN_GLASS:

   case NS_THEME_WIN_BORDERLESS_GLASS:

   case NS_THEME_SCALE_HORIZONTAL:

   case NS_THEME_SCALE_VERTICAL:

   case NS_THEME_PROGRESSBAR:

   case NS_THEME_PROGRESSBAR_VERTICAL:

   case NS_THEME_PROGRESSBAR_CHUNK:

   case NS_THEME_PROGRESSBAR_CHUNK_VERTICAL:

   case NS_THEME_RANGE:

     return eTransparent;

   }

   HANDLE theme = GetTheme(aWidgetType);

   // For the classic theme we don't really have a way of knowing

   if (!theme) {

     // menu backgrounds and tooltips which can't be themed are opaque

     if (aWidgetType == NS_THEME_MENUPOPUP || aWidgetType == NS_THEME_TOOLTIP) {

       return eOpaque;

     }

     return eUnknownTransparency;

   }

   int32_t part, state;

   nsresult rv = GetThemePartAndState(aFrame, aWidgetType, part, state);

   // Fail conservatively