From 99a3719f8ed1764fd21c54373fedd27821efc38d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Wed, 5 Oct 2022 19:09:29 +0000 Subject: [PATCH] Bug 1793689 - Make GetMinimumWidgetSize work properly on non-XUL flexbox. r=TYLin,layout-reviewers The XUL behavior in nsBox.cpp is fairly different to what the non-XUL layout code paths do. In particular, canOverride=false means that the min-{width,height} properties cannot go under the min widget size of the widget, but that doesn't mean that intrinsic sizes don't affect the final size of the widget. This is very visible if you turn on flex emulation on Windows or macOS, where the toolbar has an appearance that returns width=0,height=N,canOverride=false. With flex emulation we'd collapse the item to be zero-width, which is not good at all. The good thing is that this is no longer exposed to the web (non-native-theme always returns canOverride=true), and our front-end code doesn't seem to rely on this, so we can just remove support for canOverride=false. Differential Revision: https://phabricator.services.mozilla.com/D158608 --- gfx/src/nsITheme.h | 12 +- layout/base/nsLayoutUtils.cpp | 8 +- layout/forms/nsComboboxControlFrame.cpp | 12 +- layout/forms/nsRangeFrame.cpp | 19 +- layout/generic/nsFlexContainerFrame.cpp | 40 ++-- layout/generic/nsIFrame.cpp | 17 +- layout/xul/nsBox.cpp | 10 +- layout/xul/tree/nsTreeBodyFrame.cpp | 9 +- widget/Theme.cpp | 32 ++-- widget/Theme.h | 5 +- widget/ThemeCocoa.cpp | 17 +- widget/ThemeCocoa.h | 7 +- widget/cocoa/nsNativeThemeCocoa.h | 5 +- widget/cocoa/nsNativeThemeCocoa.mm | 68 +++---- widget/gtk/nsNativeThemeGTK.cpp | 109 ++++------- widget/gtk/nsNativeThemeGTK.h | 7 +- widget/windows/nsNativeThemeWin.cpp | 238 ++++++++++-------------- widget/windows/nsNativeThemeWin.h | 13 +- 18 files changed, 245 insertions(+), 383 deletions(-) diff --git a/gfx/src/nsITheme.h b/gfx/src/nsITheme.h index 8384f0f728a3..84baccea3cfd 100644 --- a/gfx/src/nsITheme.h +++ b/gfx/src/nsITheme.h @@ -166,15 +166,11 @@ class nsITheme : public nsISupports { } /** - * Get the minimum border-box size of a widget, in *pixels* (in - * |aResult|). If |aIsOverridable| is set to true, this size is a - * minimum size; if false, this size is the only valid size for the - * widget. + * Get the minimum border-box size of a widget, in device pixels. */ - NS_IMETHOD GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* aFrame, - StyleAppearance aWidgetType, - mozilla::LayoutDeviceIntSize* aResult, - bool* aIsOverridable) = 0; + virtual mozilla::LayoutDeviceIntSize GetMinimumWidgetSize( + nsPresContext* aPresContext, nsIFrame* aFrame, + StyleAppearance aWidgetType) = 0; enum Transparency { eOpaque = 0, eTransparent, eUnknownTransparency }; diff --git a/layout/base/nsLayoutUtils.cpp b/layout/base/nsLayoutUtils.cpp index a565544363f5..220b1cfcb35e 100644 --- a/layout/base/nsLayoutUtils.cpp +++ b/layout/base/nsLayoutUtils.cpp @@ -4748,16 +4748,14 @@ static nscoord AddIntrinsicSizeOffset( const nsStyleDisplay* disp = aFrame->StyleDisplay(); if (aFrame->IsThemed(disp)) { - LayoutDeviceIntSize devSize; - bool canOverride = true; nsPresContext* pc = aFrame->PresContext(); - pc->Theme()->GetMinimumWidgetSize(pc, aFrame, disp->EffectiveAppearance(), - &devSize, &canOverride); + LayoutDeviceIntSize devSize = pc->Theme()->GetMinimumWidgetSize( + pc, aFrame, disp->EffectiveAppearance()); nscoord themeSize = pc->DevPixelsToAppUnits( aAxis == eAxisVertical ? devSize.height : devSize.width); // GetMinimumWidgetSize() returns a border-box width. themeSize += aOffsets.margin; - if (themeSize > result || !canOverride) { + if (themeSize > result) { result = themeSize; } } diff --git a/layout/forms/nsComboboxControlFrame.cpp b/layout/forms/nsComboboxControlFrame.cpp index 48d3419fc2d9..6583fe7d3911 100644 --- a/layout/forms/nsComboboxControlFrame.cpp +++ b/layout/forms/nsComboboxControlFrame.cpp @@ -291,14 +291,10 @@ nscoord nsComboboxControlFrame::DropDownButtonISize() { return 0; } - LayoutDeviceIntSize dropdownButtonSize; - bool canOverride = true; - nsPresContext* presContext = PresContext(); - presContext->Theme()->GetMinimumWidgetSize( - presContext, this, StyleAppearance::MozMenulistArrowButton, - &dropdownButtonSize, &canOverride); - - return presContext->DevPixelsToAppUnits(dropdownButtonSize.width); + nsPresContext* pc = PresContext(); + LayoutDeviceIntSize dropdownButtonSize = pc->Theme()->GetMinimumWidgetSize( + pc, this, StyleAppearance::MozMenulistArrowButton); + return pc->DevPixelsToAppUnits(dropdownButtonSize.width); } int32_t nsComboboxControlFrame::CharCountOfLargestOptionForInflation() const { diff --git a/layout/forms/nsRangeFrame.cpp b/layout/forms/nsRangeFrame.cpp index ca3f3b3b3529..51dc07ba97a8 100644 --- a/layout/forms/nsRangeFrame.cpp +++ b/layout/forms/nsRangeFrame.cpp @@ -373,14 +373,11 @@ Decimal nsRangeFrame::GetValueAtEventPoint(WidgetGUIEvent* aEvent) { if (IsThemed()) { // We need to get the size of the thumb from the theme. - nsPresContext* presContext = PresContext(); - bool notUsedCanOverride; - LayoutDeviceIntSize size; - presContext->Theme()->GetMinimumWidgetSize(presContext, this, - StyleAppearance::RangeThumb, - &size, ¬UsedCanOverride); - thumbSize.width = presContext->DevPixelsToAppUnits(size.width); - thumbSize.height = presContext->DevPixelsToAppUnits(size.height); + nsPresContext* pc = PresContext(); + LayoutDeviceIntSize size = pc->Theme()->GetMinimumWidgetSize( + pc, this, StyleAppearance::RangeThumb); + thumbSize = + LayoutDeviceIntSize::ToAppUnits(size, pc->AppUnitsPerDevPixel()); // For GTK, GetMinimumWidgetSize returns zero for the thumb dimension // perpendicular to the orientation of the slider. That's okay since we // only care about the dimension in the direction of the slider when using @@ -582,11 +579,9 @@ nsresult nsRangeFrame::AttributeChanged(int32_t aNameSpaceID, nscoord nsRangeFrame::AutoCrossSize(Length aEm) { nscoord minCrossSize(0); if (IsThemed()) { - bool unused; - LayoutDeviceIntSize size; nsPresContext* pc = PresContext(); - pc->Theme()->GetMinimumWidgetSize(pc, this, StyleAppearance::RangeThumb, - &size, &unused); + LayoutDeviceIntSize size = pc->Theme()->GetMinimumWidgetSize( + pc, this, StyleAppearance::RangeThumb); minCrossSize = pc->DevPixelsToAppUnits(IsHorizontal() ? size.height : size.width); } diff --git a/layout/generic/nsFlexContainerFrame.cpp b/layout/generic/nsFlexContainerFrame.cpp index 1f494bd22579..3a264374fc37 100644 --- a/layout/generic/nsFlexContainerFrame.cpp +++ b/layout/generic/nsFlexContainerFrame.cpp @@ -1441,14 +1441,11 @@ FlexItem* nsFlexContainerFrame::GenerateFlexItemForChild( // Check if we're a themed widget, in which case we might have a minimum // main & cross size imposed by our widget (which we can't go below), or // (more severe) our widget might have only a single valid size. - bool isFixedSizeWidget = false; const nsStyleDisplay* disp = aChildFrame->StyleDisplay(); if (aChildFrame->IsThemed(disp)) { - LayoutDeviceIntSize widgetMinSize; - bool canOverride = true; - PresContext()->Theme()->GetMinimumWidgetSize(PresContext(), aChildFrame, - disp->EffectiveAppearance(), - &widgetMinSize, &canOverride); + LayoutDeviceIntSize widgetMinSize = + PresContext()->Theme()->GetMinimumWidgetSize( + PresContext(), aChildFrame, disp->EffectiveAppearance()); nscoord widgetMainMinSize = PresContext()->DevPixelsToAppUnits( aAxisTracker.MainComponent(widgetMinSize)); @@ -1464,26 +1461,16 @@ FlexItem* nsFlexContainerFrame::GenerateFlexItemForChild( // ... (but don't let that push these min sizes below 0). widgetMainMinSize = std::max(0, widgetMainMinSize); widgetCrossMinSize = std::max(0, widgetCrossMinSize); + // Ensure our min/max sizes are at least as large as the widget's mandated + // minimum size, so we don't flex below that. + mainMinSize = std::max(mainMinSize, widgetMainMinSize); + mainMaxSize = std::max(mainMaxSize, widgetMainMinSize); - if (!canOverride) { - // Fixed-size widget: freeze our main-size at the widget's mandated size. - // (Set min and max main-sizes to that size, too, to keep us from - // clamping to any other size later on.) - flexBaseSize = mainMinSize = mainMaxSize = widgetMainMinSize; - tentativeCrossSize = crossMinSize = crossMaxSize = widgetCrossMinSize; - isFixedSizeWidget = true; - } else { - // Variable-size widget: ensure our min/max sizes are at least as large - // as the widget's mandated minimum size, so we don't flex below that. - mainMinSize = std::max(mainMinSize, widgetMainMinSize); - mainMaxSize = std::max(mainMaxSize, widgetMainMinSize); - - if (tentativeCrossSize != NS_UNCONSTRAINEDSIZE) { - tentativeCrossSize = std::max(tentativeCrossSize, widgetCrossMinSize); - } - crossMinSize = std::max(crossMinSize, widgetCrossMinSize); - crossMaxSize = std::max(crossMaxSize, widgetCrossMinSize); + if (tentativeCrossSize != NS_UNCONSTRAINEDSIZE) { + tentativeCrossSize = std::max(tentativeCrossSize, widgetCrossMinSize); } + crossMinSize = std::max(crossMinSize, widgetCrossMinSize); + crossMaxSize = std::max(crossMaxSize, widgetCrossMinSize); } // Construct the flex item! @@ -1523,9 +1510,8 @@ FlexItem* nsFlexContainerFrame::GenerateFlexItemForChild( item->ResolveFlexBaseSizeFromAspectRatio(childRI); // If we're inflexible, we can just freeze to our hypothetical main-size - // up-front. Similarly, if we're a fixed-size widget, we only have one - // valid size, so we freeze to keep ourselves from flexing. - if (isFixedSizeWidget || (flexGrow == 0.0f && flexShrink == 0.0f)) { + // up-front. + if (flexGrow == 0.0f && flexShrink == 0.0f) { item->Freeze(); if (flexBaseSize < mainMinSize) { item->SetWasMinClamped(); diff --git a/layout/generic/nsIFrame.cpp b/layout/generic/nsIFrame.cpp index b61cb42fa1cc..1312b79cf711 100644 --- a/layout/generic/nsIFrame.cpp +++ b/layout/generic/nsIFrame.cpp @@ -6524,24 +6524,21 @@ nsIFrame::SizeComputationResult nsIFrame::ComputeSize( } if (IsThemed(disp)) { - LayoutDeviceIntSize widget; - bool canOverride = true; - nsPresContext* presContext = PresContext(); - presContext->Theme()->GetMinimumWidgetSize( - presContext, this, disp->EffectiveAppearance(), &widget, &canOverride); + nsPresContext* pc = PresContext(); + LayoutDeviceIntSize widget = pc->Theme()->GetMinimumWidgetSize( + pc, this, disp->EffectiveAppearance()); // Convert themed widget's physical dimensions to logical coords - LogicalSize size(aWM, - nsSize(presContext->DevPixelsToAppUnits(widget.width), - presContext->DevPixelsToAppUnits(widget.height))); + LogicalSize size(aWM, LayoutDeviceIntSize::ToAppUnits( + widget, pc->AppUnitsPerDevPixel())); // GetMinimumWidgetSize() returns border-box; we need content-box. size -= aBorderPadding; - if (size.BSize(aWM) > result.BSize(aWM) || !canOverride) { + if (size.BSize(aWM) > result.BSize(aWM)) { result.BSize(aWM) = size.BSize(aWM); } - if (size.ISize(aWM) > result.ISize(aWM) || !canOverride) { + if (size.ISize(aWM) > result.ISize(aWM)) { result.ISize(aWM) = size.ISize(aWM); } } diff --git a/layout/xul/nsBox.cpp b/layout/xul/nsBox.cpp index d8cbd1a3a97c..3dd11d8a3fd2 100644 --- a/layout/xul/nsBox.cpp +++ b/layout/xul/nsBox.cpp @@ -373,8 +373,6 @@ bool nsIFrame::AddXULMinSize(nsIFrame* aBox, nsSize& aSize, bool& aWidthSet, aWidthSet = false; aHeightSet = false; - bool canOverride = true; - nsPresContext* pc = aBox->PresContext(); // See if a native theme wants to supply a minimum size. @@ -383,8 +381,8 @@ bool nsIFrame::AddXULMinSize(nsIFrame* aBox, nsSize& aSize, bool& aWidthSet, nsITheme* theme = pc->Theme(); StyleAppearance appearance = display->EffectiveAppearance(); if (theme->ThemeSupportsWidget(pc, aBox, appearance)) { - LayoutDeviceIntSize size; - theme->GetMinimumWidgetSize(pc, aBox, appearance, &size, &canOverride); + LayoutDeviceIntSize size = + theme->GetMinimumWidgetSize(pc, aBox, appearance); if (size.width) { aSize.width = pc->DevPixelsToAppUnits(size.width); aWidthSet = true; @@ -421,7 +419,7 @@ bool nsIFrame::AddXULMinSize(nsIFrame* aBox, nsSize& aSize, bool& aWidthSet, const auto& minWidth = position->mMinWidth; if (minWidth.ConvertsToLength()) { nscoord min = minWidth.ToLength(); - if (!aWidthSet || (min > aSize.width && canOverride)) { + if (!aWidthSet || min > aSize.width) { aSize.width = min; aWidthSet = true; } @@ -440,7 +438,7 @@ bool nsIFrame::AddXULMinSize(nsIFrame* aBox, nsSize& aSize, bool& aWidthSet, const auto& minHeight = position->mMinHeight; if (minHeight.ConvertsToLength()) { nscoord min = minHeight.ToLength(); - if (!aHeightSet || (min > aSize.height && canOverride)) { + if (!aHeightSet || min > aSize.height) { aSize.height = min; aHeightSet = true; } diff --git a/layout/xul/tree/nsTreeBodyFrame.cpp b/layout/xul/tree/nsTreeBodyFrame.cpp index 5477eeea38fb..104110e07321 100644 --- a/layout/xul/tree/nsTreeBodyFrame.cpp +++ b/layout/xul/tree/nsTreeBodyFrame.cpp @@ -1827,10 +1827,8 @@ nsITheme* nsTreeBodyFrame::GetTwistyRect(int32_t aRowIndex, } if (useTheme) { - LayoutDeviceIntSize minTwistySizePx; - bool canOverride = true; - theme->GetMinimumWidgetSize(aPresContext, this, appearance, - &minTwistySizePx, &canOverride); + LayoutDeviceIntSize minTwistySizePx = + theme->GetMinimumWidgetSize(aPresContext, this, appearance); // GMWS() returns size in pixels, we need to convert it back to app units nsSize minTwistySize; @@ -1839,8 +1837,9 @@ nsITheme* nsTreeBodyFrame::GetTwistyRect(int32_t aRowIndex, minTwistySize.height = aPresContext->DevPixelsToAppUnits(minTwistySizePx.height); - if (aTwistyRect.width < minTwistySize.width || !canOverride) + if (aTwistyRect.width < minTwistySize.width) { aTwistyRect.width = minTwistySize.width; + } } return useTheme ? theme : nullptr; diff --git a/widget/Theme.cpp b/widget/Theme.cpp index 792c3994745d..3284ce89608d 100644 --- a/widget/Theme.cpp +++ b/widget/Theme.cpp @@ -1504,45 +1504,39 @@ UniquePtr Theme::ScrollbarStyle() { #endif } -NS_IMETHODIMP -Theme::GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* aFrame, - StyleAppearance aAppearance, - LayoutDeviceIntSize* aResult, - bool* aIsOverridable) { +LayoutDeviceIntSize Theme::GetMinimumWidgetSize(nsPresContext* aPresContext, + nsIFrame* aFrame, + StyleAppearance aAppearance) { DPIRatio dpiRatio = GetDPIRatio(aFrame, aAppearance); - aResult->width = aResult->height = 0; - *aIsOverridable = true; - if (IsWidgetScrollbarPart(aAppearance)) { - *aResult = GetScrollbarDrawing().GetMinimumWidgetSize(aPresContext, - aAppearance, aFrame); - return NS_OK; + return GetScrollbarDrawing().GetMinimumWidgetSize(aPresContext, aAppearance, + aFrame); } + LayoutDeviceIntSize result; switch (aAppearance) { case StyleAppearance::Button: if (aFrame->IsColorControlFrame()) { - aResult->height = (kMinimumColorPickerHeight * dpiRatio).Rounded(); + result.height = (kMinimumColorPickerHeight * dpiRatio).Rounded(); } break; case StyleAppearance::RangeThumb: - aResult->SizeTo((kMinimumRangeThumbSize * dpiRatio).Rounded(), - (kMinimumRangeThumbSize * dpiRatio).Rounded()); + result.SizeTo((kMinimumRangeThumbSize * dpiRatio).Rounded(), + (kMinimumRangeThumbSize * dpiRatio).Rounded()); break; case StyleAppearance::MozMenulistArrowButton: - aResult->width = (kMinimumDropdownArrowButtonWidth * dpiRatio).Rounded(); + result.width = (kMinimumDropdownArrowButtonWidth * dpiRatio).Rounded(); break; case StyleAppearance::SpinnerUpbutton: case StyleAppearance::SpinnerDownbutton: - aResult->width = (kMinimumSpinnerButtonWidth * dpiRatio).Rounded(); - aResult->height = (kMinimumSpinnerButtonHeight * dpiRatio).Rounded(); + result.width = (kMinimumSpinnerButtonWidth * dpiRatio).Rounded(); + result.height = (kMinimumSpinnerButtonHeight * dpiRatio).Rounded(); break; default: break; } - - return NS_OK; + return result; } nsITheme::Transparency Theme::GetWidgetTransparency( diff --git a/widget/Theme.h b/widget/Theme.h index cda6a0db8ae0..82508301464d 100644 --- a/widget/Theme.h +++ b/widget/Theme.h @@ -74,9 +74,8 @@ class Theme : protected nsNativeTheme, public nsITheme { LayoutDeviceIntMargin* aResult) override; bool GetWidgetOverflow(nsDeviceContext* aContext, nsIFrame*, StyleAppearance, nsRect* aOverflowRect) override; - NS_IMETHOD GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame*, - StyleAppearance, LayoutDeviceIntSize* aResult, - bool* aIsOverridable) override; + LayoutDeviceIntSize GetMinimumWidgetSize(nsPresContext*, nsIFrame*, + StyleAppearance) override; Transparency GetWidgetTransparency(nsIFrame*, StyleAppearance) override; NS_IMETHOD WidgetStateChanged(nsIFrame*, StyleAppearance, nsAtom* aAttribute, bool* aShouldRepaint, diff --git a/widget/ThemeCocoa.cpp b/widget/ThemeCocoa.cpp index d29e76123dc0..dd8655454f02 100644 --- a/widget/ThemeCocoa.cpp +++ b/widget/ThemeCocoa.cpp @@ -14,21 +14,16 @@ namespace mozilla::widget { -NS_IMETHODIMP -ThemeCocoa::GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* aFrame, - StyleAppearance aAppearance, - LayoutDeviceIntSize* aResult, - bool* aIsOverridable) { +LayoutDeviceIntSize ThemeCocoa::GetMinimumWidgetSize( + nsPresContext* aPresContext, nsIFrame* aFrame, + StyleAppearance aAppearance) { if (aAppearance == StyleAppearance::MozMenulistArrowButton) { - auto size = ScrollbarDrawingCocoa::GetScrollbarSize( + LayoutDeviceIntCoord size = ScrollbarDrawingCocoa::GetScrollbarSize( StyleScrollbarWidth::Auto, /* aOverlay = */ false, GetDPIRatio(aFrame, aAppearance)); - aResult->SizeTo(size, size); - return NS_OK; + return {size, size}; } - - return Theme::GetMinimumWidgetSize(aPresContext, aFrame, aAppearance, aResult, - aIsOverridable); + return Theme::GetMinimumWidgetSize(aPresContext, aFrame, aAppearance); } nsITheme::ThemeGeometryType ThemeCocoa::ThemeGeometryTypeForWidget( diff --git a/widget/ThemeCocoa.h b/widget/ThemeCocoa.h index bb19267bb14d..44b00425bccf 100644 --- a/widget/ThemeCocoa.h +++ b/widget/ThemeCocoa.h @@ -18,10 +18,9 @@ class ThemeCocoa : public Theme { explicit ThemeCocoa(UniquePtr&& aScrollbarDrawing) : Theme(std::move(aScrollbarDrawing)) {} - NS_IMETHOD GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* aFrame, - StyleAppearance aAppearance, - mozilla::LayoutDeviceIntSize* aResult, - bool* aIsOverridable) override; + LayoutDeviceIntSize GetMinimumWidgetSize( + nsPresContext* aPresContext, nsIFrame* aFrame, + StyleAppearance aAppearance) override; ThemeGeometryType ThemeGeometryTypeForWidget(nsIFrame*, StyleAppearance) override; diff --git a/widget/cocoa/nsNativeThemeCocoa.h b/widget/cocoa/nsNativeThemeCocoa.h index 993df5b763ea..b7557860d962 100644 --- a/widget/cocoa/nsNativeThemeCocoa.h +++ b/widget/cocoa/nsNativeThemeCocoa.h @@ -314,10 +314,7 @@ class nsNativeThemeCocoa : public mozilla::widget::ThemeCocoa { virtual bool GetWidgetOverflow(nsDeviceContext* aContext, nsIFrame* aFrame, StyleAppearance aAppearance, nsRect* aOverflowRect) override; - NS_IMETHOD GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* aFrame, - StyleAppearance aAppearance, - mozilla::LayoutDeviceIntSize* aResult, - bool* aIsOverridable) override; + LayoutDeviceIntSize GetMinimumWidgetSize(nsPresContext*, nsIFrame*, StyleAppearance) override; NS_IMETHOD WidgetStateChanged(nsIFrame* aFrame, StyleAppearance aAppearance, nsAtom* aAttribute, bool* aShouldRepaint, const nsAttrValue* aOldValue) override; NS_IMETHOD ThemeChanged() override; diff --git a/widget/cocoa/nsNativeThemeCocoa.mm b/widget/cocoa/nsNativeThemeCocoa.mm index 1731d9ef2551..c31e5af46335 100644 --- a/widget/cocoa/nsNativeThemeCocoa.mm +++ b/widget/cocoa/nsNativeThemeCocoa.mm @@ -3035,55 +3035,47 @@ bool nsNativeThemeCocoa::GetWidgetOverflow(nsDeviceContext* aContext, nsIFrame* return false; } -NS_IMETHODIMP -nsNativeThemeCocoa::GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* aFrame, - StyleAppearance aAppearance, LayoutDeviceIntSize* aResult, - bool* aIsOverridable) { +LayoutDeviceIntSize nsNativeThemeCocoa::GetMinimumWidgetSize(nsPresContext* aPresContext, + nsIFrame* aFrame, + StyleAppearance aAppearance) { NS_OBJC_BEGIN_TRY_BLOCK_RETURN; - aResult->SizeTo(0, 0); - *aIsOverridable = true; - if (IsWidgetScrollbarPart(aAppearance)) { - return ThemeCocoa::GetMinimumWidgetSize(aPresContext, aFrame, aAppearance, aResult, - aIsOverridable); + return ThemeCocoa::GetMinimumWidgetSize(aPresContext, aFrame, aAppearance); } + LayoutDeviceIntSize result; switch (aAppearance) { case StyleAppearance::Button: { - aResult->SizeTo(pushButtonSettings.minimumSizes[miniControlSize].width, - pushButtonSettings.naturalSizes[miniControlSize].height); + result.SizeTo(pushButtonSettings.minimumSizes[miniControlSize].width, + pushButtonSettings.naturalSizes[miniControlSize].height); break; } case StyleAppearance::ButtonArrowUp: case StyleAppearance::ButtonArrowDown: { - aResult->SizeTo(kMenuScrollArrowSize.width, kMenuScrollArrowSize.height); - *aIsOverridable = false; + result.SizeTo(kMenuScrollArrowSize.width, kMenuScrollArrowSize.height); break; } case StyleAppearance::Menuarrow: { - aResult->SizeTo(kMenuarrowSize.width, kMenuarrowSize.height); - *aIsOverridable = false; + result.SizeTo(kMenuarrowSize.width, kMenuarrowSize.height); break; } case StyleAppearance::MozMacDisclosureButtonOpen: case StyleAppearance::MozMacDisclosureButtonClosed: { - aResult->SizeTo(kDisclosureButtonSize.width, kDisclosureButtonSize.height); - *aIsOverridable = false; + result.SizeTo(kDisclosureButtonSize.width, kDisclosureButtonSize.height); break; } case StyleAppearance::MozMacHelpButton: { - aResult->SizeTo(kHelpButtonSize.width, kHelpButtonSize.height); - *aIsOverridable = false; + result.SizeTo(kHelpButtonSize.width, kHelpButtonSize.height); break; } case StyleAppearance::Toolbarbutton: { - aResult->SizeTo(0, toolbarButtonHeights[miniControlSize]); + result.SizeTo(0, toolbarButtonHeights[miniControlSize]); break; } @@ -3103,8 +3095,7 @@ nsNativeThemeCocoa::GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* buttonHeight /= 2; } } - aResult->SizeTo(buttonWidth, buttonHeight); - *aIsOverridable = true; + result.SizeTo(buttonWidth, buttonHeight); break; } @@ -3112,7 +3103,7 @@ nsNativeThemeCocoa::GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* case StyleAppearance::MenulistButton: { SInt32 popupHeight = 0; ::GetThemeMetric(kThemeMetricPopupButtonHeight, &popupHeight); - aResult->SizeTo(0, popupHeight); + result.SizeTo(0, popupHeight); break; } @@ -3123,26 +3114,25 @@ nsNativeThemeCocoa::GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* // at minimum, we should be tall enough for 9pt text. // I'm using hardcoded values here because the appearance manager // values for the frame size are incorrect. - aResult->SizeTo(0, (2 + 2) /* top */ + 9 + (1 + 1) /* bottom */); + result.SizeTo(0, (2 + 2) /* top */ + 9 + (1 + 1) /* bottom */); break; } case StyleAppearance::MozWindowButtonBox: { NSSize size = WindowButtonsSize(aFrame); - aResult->SizeTo(size.width, size.height); - *aIsOverridable = false; + result.SizeTo(size.width, size.height); break; } case StyleAppearance::ProgressBar: { SInt32 barHeight = 0; ::GetThemeMetric(kThemeMetricNormalProgressBarThickness, &barHeight); - aResult->SizeTo(0, barHeight); + result.SizeTo(0, barHeight); break; } case StyleAppearance::Separator: { - aResult->SizeTo(1, 1); + result.SizeTo(1, 1); break; } @@ -3151,8 +3141,7 @@ nsNativeThemeCocoa::GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* SInt32 twistyHeight = 0, twistyWidth = 0; ::GetThemeMetric(kThemeMetricDisclosureButtonWidth, &twistyWidth); ::GetThemeMetric(kThemeMetricDisclosureButtonHeight, &twistyHeight); - aResult->SizeTo(twistyWidth, twistyHeight); - *aIsOverridable = false; + result.SizeTo(twistyWidth, twistyHeight); break; } @@ -3160,12 +3149,12 @@ nsNativeThemeCocoa::GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* case StyleAppearance::Treeheadercell: { SInt32 headerHeight = 0; ::GetThemeMetric(kThemeMetricListHeaderHeight, &headerHeight); - aResult->SizeTo(0, headerHeight); + result.SizeTo(0, headerHeight); break; } case StyleAppearance::Tab: { - aResult->SizeTo(0, tabHeights[miniControlSize]); + result.SizeTo(0, tabHeights[miniControlSize]); break; } @@ -3174,14 +3163,12 @@ nsNativeThemeCocoa::GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* SInt32 height = 0; ::GetThemeMetric(kThemeMetricSliderMinThumbWidth, &width); ::GetThemeMetric(kThemeMetricSliderMinThumbHeight, &height); - aResult->SizeTo(width, height); - *aIsOverridable = false; + result.SizeTo(width, height); break; } case StyleAppearance::MozMenulistArrowButton: - return ThemeCocoa::GetMinimumWidgetSize(aPresContext, aFrame, aAppearance, aResult, - aIsOverridable); + return ThemeCocoa::GetMinimumWidgetSize(aPresContext, aFrame, aAppearance); case StyleAppearance::Resizer: { HIThemeGrowBoxDrawInfo drawInfo; @@ -3193,8 +3180,7 @@ nsNativeThemeCocoa::GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* HIPoint pnt = {0, 0}; HIRect bounds; HIThemeGetGrowBoxBounds(&pnt, &drawInfo, &bounds); - aResult->SizeTo(bounds.size.width, bounds.size.height); - *aIsOverridable = false; + result.SizeTo(bounds.size.width, bounds.size.height); break; } default: @@ -3202,12 +3188,12 @@ nsNativeThemeCocoa::GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* } if (IsHiDPIContext(aPresContext->DeviceContext())) { - *aResult = *aResult * 2; + result = result * 2; } - return NS_OK; + return result; - NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE); + NS_OBJC_END_TRY_BLOCK_RETURN(LayoutDeviceIntSize()); } NS_IMETHODIMP diff --git a/widget/gtk/nsNativeThemeGTK.cpp b/widget/gtk/nsNativeThemeGTK.cpp index 8705e8c7eaeb..98d1c2c7292d 100644 --- a/widget/gtk/nsNativeThemeGTK.cpp +++ b/widget/gtk/nsNativeThemeGTK.cpp @@ -1216,104 +1216,77 @@ auto nsNativeThemeGTK::IsWidgetNonNative(nsIFrame* aFrame, return NonNative::No; } -NS_IMETHODIMP -nsNativeThemeGTK::GetMinimumWidgetSize(nsPresContext* aPresContext, - nsIFrame* aFrame, - StyleAppearance aAppearance, - LayoutDeviceIntSize* aResult, - bool* aIsOverridable) { +LayoutDeviceIntSize nsNativeThemeGTK::GetMinimumWidgetSize( + nsPresContext* aPresContext, nsIFrame* aFrame, + StyleAppearance aAppearance) { if (IsWidgetNonNative(aFrame, aAppearance) == NonNative::Always) { - return Theme::GetMinimumWidgetSize(aPresContext, aFrame, aAppearance, - aResult, aIsOverridable); + return Theme::GetMinimumWidgetSize(aPresContext, aFrame, aAppearance); } - aResult->width = aResult->height = 0; - *aIsOverridable = true; - + LayoutDeviceIntSize result; switch (aAppearance) { case StyleAppearance::Splitter: { - gint metrics; if (IsHorizontal(aFrame)) { - moz_gtk_splitter_get_metrics(GTK_ORIENTATION_HORIZONTAL, &metrics); - aResult->width = metrics; - aResult->height = 0; + moz_gtk_splitter_get_metrics(GTK_ORIENTATION_HORIZONTAL, &result.width); } else { - moz_gtk_splitter_get_metrics(GTK_ORIENTATION_VERTICAL, &metrics); - aResult->width = 0; - aResult->height = metrics; + moz_gtk_splitter_get_metrics(GTK_ORIENTATION_VERTICAL, &result.height); } - *aIsOverridable = false; } break; case StyleAppearance::RangeThumb: { - gint thumb_length, thumb_height; - if (IsRangeHorizontal(aFrame)) { moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_HORIZONTAL, - &thumb_length, &thumb_height); + &result.width, &result.height); } else { - moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_VERTICAL, &thumb_height, - &thumb_length); + moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_VERTICAL, &result.width, + &result.width); } - aResult->width = thumb_length; - aResult->height = thumb_height; - - *aIsOverridable = false; } break; case StyleAppearance::TabScrollArrowBack: case StyleAppearance::TabScrollArrowForward: { - moz_gtk_get_tab_scroll_arrow_size(&aResult->width, &aResult->height); - *aIsOverridable = false; + moz_gtk_get_tab_scroll_arrow_size(&result.width, &result.height); } break; case StyleAppearance::MozMenulistArrowButton: { - moz_gtk_get_combo_box_entry_button_size(&aResult->width, - &aResult->height); - *aIsOverridable = false; + moz_gtk_get_combo_box_entry_button_size(&result.width, &result.height); } break; case StyleAppearance::Menuseparator: { - gint separator_height; - - moz_gtk_get_menu_separator_height(&separator_height); - aResult->height = separator_height; - - *aIsOverridable = false; + moz_gtk_get_menu_separator_height(&result.height); } break; case StyleAppearance::Checkbox: case StyleAppearance::Radio: { const ToggleGTKMetrics* metrics = GetToggleMetrics( aAppearance == StyleAppearance::Radio ? MOZ_GTK_RADIOBUTTON : MOZ_GTK_CHECKBUTTON); - aResult->width = metrics->minSizeWithBorder.width; - aResult->height = metrics->minSizeWithBorder.height; + result.width = metrics->minSizeWithBorder.width; + result.height = metrics->minSizeWithBorder.height; } break; case StyleAppearance::ToolbarbuttonDropdown: case StyleAppearance::ButtonArrowUp: case StyleAppearance::ButtonArrowDown: case StyleAppearance::ButtonArrowNext: case StyleAppearance::ButtonArrowPrevious: { - moz_gtk_get_arrow_size(MOZ_GTK_TOOLBARBUTTON_ARROW, &aResult->width, - &aResult->height); - *aIsOverridable = false; + moz_gtk_get_arrow_size(MOZ_GTK_TOOLBARBUTTON_ARROW, &result.width, + &result.height); } break; case StyleAppearance::MozWindowButtonClose: { const ToolbarButtonGTKMetrics* metrics = GetToolbarButtonMetrics(MOZ_GTK_HEADER_BAR_BUTTON_CLOSE); - aResult->width = metrics->minSizeWithBorderMargin.width; - aResult->height = metrics->minSizeWithBorderMargin.height; + result.width = metrics->minSizeWithBorderMargin.width; + result.height = metrics->minSizeWithBorderMargin.height; break; } case StyleAppearance::MozWindowButtonMinimize: { const ToolbarButtonGTKMetrics* metrics = GetToolbarButtonMetrics(MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE); - aResult->width = metrics->minSizeWithBorderMargin.width; - aResult->height = metrics->minSizeWithBorderMargin.height; + result.width = metrics->minSizeWithBorderMargin.width; + result.height = metrics->minSizeWithBorderMargin.height; break; } case StyleAppearance::MozWindowButtonMaximize: case StyleAppearance::MozWindowButtonRestore: { const ToolbarButtonGTKMetrics* metrics = GetToolbarButtonMetrics(MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE); - aResult->width = metrics->minSizeWithBorderMargin.width; - aResult->height = metrics->minSizeWithBorderMargin.height; + result.width = metrics->minSizeWithBorderMargin.width; + result.height = metrics->minSizeWithBorderMargin.height; break; } case StyleAppearance::CheckboxContainer: @@ -1328,8 +1301,7 @@ nsNativeThemeGTK::GetMinimumWidgetSize(nsPresContext* aPresContext, if (aAppearance == StyleAppearance::Menulist || aAppearance == StyleAppearance::MenulistButton) { // Include the arrow size. - moz_gtk_get_arrow_size(MOZ_GTK_DROPDOWN, &aResult->width, - &aResult->height); + moz_gtk_get_arrow_size(MOZ_GTK_DROPDOWN, &result.width, &result.height); } // else the minimum size is missing consideration of container // descendants; the value returned here will not be helpful, but the @@ -1338,8 +1310,8 @@ nsNativeThemeGTK::GetMinimumWidgetSize(nsPresContext* aPresContext, LayoutDeviceIntMargin border; GetCachedWidgetBorder(aFrame, aAppearance, GetTextDirection(aFrame), &border); - aResult->width += border.left + border.right; - aResult->height += border.top + border.bottom; + result.width += border.LeftRight(); + result.height += border.TopBottom(); } break; case StyleAppearance::NumberInput: case StyleAppearance::Textfield: { @@ -1370,50 +1342,41 @@ nsNativeThemeGTK::GetMinimumWidgetSize(nsPresContext* aPresContext, gint height = contentHeight + borderPaddingHeight; if (aFrame->GetWritingMode().IsVertical()) { - aResult->width = height; + result.width = height; } else { - aResult->height = height; + result.height = height; } } break; case StyleAppearance::Separator: { - gint separator_width; - - moz_gtk_get_toolbar_separator_width(&separator_width); - - aResult->width = separator_width; + moz_gtk_get_toolbar_separator_width(&result.width); } break; case StyleAppearance::Spinner: // hard code these sizes - aResult->width = 14; - aResult->height = 26; + result.width = 14; + result.height = 26; break; case StyleAppearance::Treeheadersortarrow: case StyleAppearance::SpinnerUpbutton: case StyleAppearance::SpinnerDownbutton: // hard code these sizes - aResult->width = 14; - aResult->height = 13; + result.width = 14; + result.height = 13; break; case StyleAppearance::Resizer: // same as Windows to make our lives easier - aResult->width = aResult->height = 15; - *aIsOverridable = false; + result.width = result.height = 15; break; case StyleAppearance::Treetwisty: case StyleAppearance::Treetwistyopen: { gint expander_size; - moz_gtk_get_treeview_expander_size(&expander_size); - aResult->width = aResult->height = expander_size; - *aIsOverridable = false; + result.width = result.height = expander_size; } break; default: break; } - *aResult = *aResult * GetMonitorScaleFactor(aFrame); - - return NS_OK; + return result * GetMonitorScaleFactor(aFrame); } NS_IMETHODIMP diff --git a/widget/gtk/nsNativeThemeGTK.h b/widget/gtk/nsNativeThemeGTK.h index 7a710f20a3d6..677492a16ba6 100644 --- a/widget/gtk/nsNativeThemeGTK.h +++ b/widget/gtk/nsNativeThemeGTK.h @@ -59,10 +59,9 @@ class nsNativeThemeGTK final : public mozilla::widget::Theme { enum class NonNative { No, Always, BecauseColorMismatch }; NonNative IsWidgetNonNative(nsIFrame*, StyleAppearance); - NS_IMETHOD GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* aFrame, - StyleAppearance aAppearance, - mozilla::LayoutDeviceIntSize* aResult, - bool* aIsOverridable) override; + mozilla::LayoutDeviceIntSize GetMinimumWidgetSize( + nsPresContext* aPresContext, nsIFrame* aFrame, + StyleAppearance aAppearance) override; NS_IMETHOD WidgetStateChanged(nsIFrame* aFrame, StyleAppearance aAppearance, nsAtom* aAttribute, bool* aShouldRepaint, diff --git a/widget/windows/nsNativeThemeWin.cpp b/widget/windows/nsNativeThemeWin.cpp index 549539b04a9f..c9c839bb272f 100644 --- a/widget/windows/nsNativeThemeWin.cpp +++ b/widget/windows/nsNativeThemeWin.cpp @@ -2097,31 +2097,22 @@ bool nsNativeThemeWin::GetWidgetOverflow(nsDeviceContext* aContext, return false; } -NS_IMETHODIMP -nsNativeThemeWin::GetMinimumWidgetSize(nsPresContext* aPresContext, - nsIFrame* aFrame, - StyleAppearance aAppearance, - LayoutDeviceIntSize* aResult, - bool* aIsOverridable) { +LayoutDeviceIntSize nsNativeThemeWin::GetMinimumWidgetSize( + nsPresContext* aPresContext, nsIFrame* aFrame, + StyleAppearance aAppearance) { if (IsWidgetNonNative(aFrame, aAppearance) == NonNative::Always) { - return Theme::GetMinimumWidgetSize(aPresContext, aFrame, aAppearance, - aResult, aIsOverridable); + return Theme::GetMinimumWidgetSize(aPresContext, aFrame, aAppearance); } - aResult->width = aResult->height = 0; - *aIsOverridable = true; - nsresult rv = NS_OK; - mozilla::Maybe themeClass = GetThemeClass(aAppearance); HTHEME theme = NULL; if (!themeClass.isNothing()) { theme = nsUXThemeData::GetTheme(themeClass.value()); } if (!theme) { - rv = ClassicGetMinimumWidgetSize(aFrame, aAppearance, aResult, - aIsOverridable); - ScaleForFrameDPI(aResult, aFrame); - return rv; + auto result = ClassicGetMinimumWidgetSize(aFrame, aAppearance); + ScaleForFrameDPI(&result, aFrame); + return result; } switch (aAppearance) { @@ -2142,13 +2133,13 @@ nsNativeThemeWin::GetMinimumWidgetSize(nsPresContext* aPresContext, case StyleAppearance::Menuitemtext: case StyleAppearance::MozWinGlass: case StyleAppearance::MozWinBorderlessGlass: - return NS_OK; // Don't worry about it. + return {}; // Don't worry about it. default: break; } if (aAppearance == StyleAppearance::Menuitem && IsTopLevelMenu(aFrame)) { - return NS_OK; // Don't worry about it for top level menus + return {}; // Don't worry about it for top level menus } // Call GetSystemMetrics to determine size for WinXP scrollbars @@ -2157,20 +2148,18 @@ nsNativeThemeWin::GetMinimumWidgetSize(nsPresContext* aPresContext, THEMESIZE sizeReq = TS_TRUE; // Best-fit size switch (aAppearance) { case StyleAppearance::MozMenulistArrowButton: { - rv = ClassicGetMinimumWidgetSize(aFrame, aAppearance, aResult, - aIsOverridable); - ScaleForFrameDPI(aResult, aFrame); - return rv; + auto result = ClassicGetMinimumWidgetSize(aFrame, aAppearance); + ScaleForFrameDPI(&result, aFrame); + return result; } case StyleAppearance::Menuitem: case StyleAppearance::Checkmenuitem: case StyleAppearance::Radiomenuitem: if (!IsTopLevelMenu(aFrame)) { SIZE gutterSize(GetCachedGutterSize(theme)); - aResult->width = gutterSize.cx; - aResult->height = gutterSize.cy; - ScaleForFrameDPI(aResult, aFrame); - return rv; + LayoutDeviceIntSize result(gutterSize.cx, gutterSize.cy); + ScaleForFrameDPI(&result, aFrame); + return result; } break; @@ -2178,15 +2167,13 @@ nsNativeThemeWin::GetMinimumWidgetSize(nsPresContext* aPresContext, case StyleAppearance::Menucheckbox: case StyleAppearance::Menuradio: { SIZE boxSize(GetCachedGutterSize(theme)); - aResult->width = boxSize.cx + 2; - aResult->height = boxSize.cy; - *aIsOverridable = false; - ScaleForFrameDPI(aResult, aFrame); - return rv; + LayoutDeviceIntSize result(boxSize.cx + 2, boxSize.cy); + ScaleForFrameDPI(&result, aFrame); + return result; } case StyleAppearance::Menuitemtext: - return NS_OK; + return {}; case StyleAppearance::ProgressBar: // Best-fit size for progress meters is too large for most @@ -2196,28 +2183,24 @@ nsNativeThemeWin::GetMinimumWidgetSize(nsPresContext* aPresContext, break; case StyleAppearance::Resizer: - *aIsOverridable = false; break; case StyleAppearance::RangeThumb: { - *aIsOverridable = false; - if (IsRangeHorizontal(aFrame)) { - aResult->width = 12; - aResult->height = 20; - } else { - aResult->width = 20; - aResult->height = 12; + LayoutDeviceIntSize result(12, 20); + if (!IsRangeHorizontal(aFrame)) { + std::swap(result.width, result.height); } - ScaleForFrameDPI(aResult, aFrame); - return rv; + ScaleForFrameDPI(&result, aFrame); + return result; } - case StyleAppearance::Separator: + case StyleAppearance::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; - ScaleForFrameDPI(aResult, aFrame); - return rv; + LayoutDeviceIntSize result(6, 0); + ScaleForFrameDPI(&result, aFrame); + return result; + } case StyleAppearance::Button: // We should let HTML buttons shrink to their min size. @@ -2230,41 +2213,36 @@ nsNativeThemeWin::GetMinimumWidgetSize(nsPresContext* aPresContext, break; case StyleAppearance::MozWindowButtonMaximize: - case StyleAppearance::MozWindowButtonRestore: + case StyleAppearance::MozWindowButtonRestore: { // 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::GetCommandButtonMetrics(CMDBUTTONIDX_RESTORE).cx; - aResult->height = - nsUXThemeData::GetCommandButtonMetrics(CMDBUTTONIDX_RESTORE).cy; - AddPaddingRect(aResult, CAPTIONBUTTON_RESTORE); - *aIsOverridable = false; - return rv; + SIZE sz = nsUXThemeData::GetCommandButtonMetrics(CMDBUTTONIDX_RESTORE); + LayoutDeviceIntSize result(sz.cx, sz.cy); + AddPaddingRect(&result, CAPTIONBUTTON_RESTORE); + return result; + } - case StyleAppearance::MozWindowButtonMinimize: - aResult->width = - nsUXThemeData::GetCommandButtonMetrics(CMDBUTTONIDX_MINIMIZE).cx; - aResult->height = - nsUXThemeData::GetCommandButtonMetrics(CMDBUTTONIDX_MINIMIZE).cy; - AddPaddingRect(aResult, CAPTIONBUTTON_MINIMIZE); - *aIsOverridable = false; - return rv; + case StyleAppearance::MozWindowButtonMinimize: { + SIZE sz = nsUXThemeData::GetCommandButtonMetrics(CMDBUTTONIDX_MINIMIZE); + LayoutDeviceIntSize result(sz.cx, sz.cy); + AddPaddingRect(&result, CAPTIONBUTTON_MINIMIZE); + return result; + } - case StyleAppearance::MozWindowButtonClose: - aResult->width = - nsUXThemeData::GetCommandButtonMetrics(CMDBUTTONIDX_CLOSE).cx; - aResult->height = - nsUXThemeData::GetCommandButtonMetrics(CMDBUTTONIDX_CLOSE).cy; - AddPaddingRect(aResult, CAPTIONBUTTON_CLOSE); - *aIsOverridable = false; - return rv; + case StyleAppearance::MozWindowButtonClose: { + SIZE sz = nsUXThemeData::GetCommandButtonMetrics(CMDBUTTONIDX_CLOSE); + LayoutDeviceIntSize result(sz.cx, sz.cy); + AddPaddingRect(&result, CAPTIONBUTTON_CLOSE); + return result; + } case StyleAppearance::MozWindowTitlebar: - case StyleAppearance::MozWindowTitlebarMaximized: - aResult->height = GetSystemMetrics(SM_CYCAPTION); - aResult->height += GetSystemMetrics(SM_CYFRAME); - aResult->height += GetSystemMetrics(SM_CXPADDEDBORDER); + case StyleAppearance::MozWindowTitlebarMaximized: { + LayoutDeviceIntSize result; + result.height = GetSystemMetrics(SM_CYCAPTION); + result.height += GetSystemMetrics(SM_CYFRAME); + result.height += GetSystemMetrics(SM_CXPADDEDBORDER); // On Win8.1, we don't want this scaling, because Windows doesn't scale // the non-client area of the window, and we can end up with ugly overlap // of the window frame controls into the tab bar or content area. But on @@ -2272,48 +2250,47 @@ nsNativeThemeWin::GetMinimumWidgetSize(nsPresContext* aPresContext, // better if we do apply this scaling (particularly with themes such as // DevEdition; see bug 1267636). if (IsWin10OrLater()) { - ScaleForFrameDPI(aResult, aFrame); + ScaleForFrameDPI(&result, aFrame); } - *aIsOverridable = false; - return rv; + return result; + } case StyleAppearance::MozWindowButtonBox: - case StyleAppearance::MozWindowButtonBoxMaximized: + case StyleAppearance::MozWindowButtonBoxMaximized: { if (gfxWindowsPlatform::GetPlatform()->DwmCompositionEnabled()) { - aResult->width = nsUXThemeData::GetCommandButtonBoxMetrics().cx; - aResult->height = nsUXThemeData::GetCommandButtonBoxMetrics().cy - - GetSystemMetrics(SM_CYFRAME) - - GetSystemMetrics(SM_CXPADDEDBORDER); + SIZE sz = nsUXThemeData::GetCommandButtonBoxMetrics(); + LayoutDeviceIntSize result(sz.cx, + sz.cy - GetSystemMetrics(SM_CYFRAME) - + GetSystemMetrics(SM_CXPADDEDBORDER)); if (aAppearance == StyleAppearance::MozWindowButtonBoxMaximized) { - aResult->width += 1; - aResult->height -= 2; + result.width += 1; + result.height -= 2; } - *aIsOverridable = false; - return rv; + return result; } break; + } case StyleAppearance::MozWindowFrameLeft: case StyleAppearance::MozWindowFrameRight: case StyleAppearance::MozWindowFrameBottom: - aResult->width = GetSystemMetrics(SM_CXFRAME); - aResult->height = GetSystemMetrics(SM_CYFRAME); - *aIsOverridable = false; - return rv; + return {GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME)}; default: break; } int32_t part, state; - rv = GetThemePartAndState(aFrame, aAppearance, part, state); - if (NS_FAILED(rv)) return rv; + nsresult rv = GetThemePartAndState(aFrame, aAppearance, part, state); + if (NS_FAILED(rv)) { + return {}; + } + LayoutDeviceIntSize result; rv = GetCachedMinimumWidgetSize(aFrame, theme, themeClass.value(), - aAppearance, part, state, sizeReq, aResult); - - ScaleForFrameDPI(aResult, aFrame); - return rv; + aAppearance, part, state, sizeReq, &result); + ScaleForFrameDPI(&result, aFrame); + return result; } NS_IMETHODIMP @@ -2677,41 +2654,37 @@ bool nsNativeThemeWin::ClassicGetWidgetPadding(nsDeviceContext* aContext, } } -nsresult nsNativeThemeWin::ClassicGetMinimumWidgetSize( - nsIFrame* aFrame, StyleAppearance aAppearance, LayoutDeviceIntSize* aResult, - bool* aIsOverridable) { - (*aResult).width = (*aResult).height = 0; - *aIsOverridable = true; +LayoutDeviceIntSize nsNativeThemeWin::ClassicGetMinimumWidgetSize( + nsIFrame* aFrame, StyleAppearance aAppearance) { + LayoutDeviceIntSize result; switch (aAppearance) { case StyleAppearance::Radio: case StyleAppearance::Checkbox: - (*aResult).width = (*aResult).height = 13; + result.width = result.height = 13; break; case StyleAppearance::Menucheckbox: case StyleAppearance::Menuradio: case StyleAppearance::Menuarrow: - (*aResult).width = ::GetSystemMetrics(SM_CXMENUCHECK); - (*aResult).height = ::GetSystemMetrics(SM_CYMENUCHECK); + result.width = ::GetSystemMetrics(SM_CXMENUCHECK); + result.height = ::GetSystemMetrics(SM_CYMENUCHECK); break; case StyleAppearance::SpinnerUpbutton: case StyleAppearance::SpinnerDownbutton: - (*aResult).width = ::GetSystemMetrics(SM_CXVSCROLL); - (*aResult).height = 8; // No good metrics available for this - *aIsOverridable = false; + result.width = ::GetSystemMetrics(SM_CXVSCROLL); + result.height = 8; // No good metrics available for this break; case StyleAppearance::RangeThumb: { if (IsRangeHorizontal(aFrame)) { - (*aResult).width = 12; - (*aResult).height = 20; + result.width = 12; + result.height = 20; } else { - (*aResult).width = 20; - (*aResult).height = 12; + result.width = 20; + result.height = 12; } - *aIsOverridable = false; break; } case StyleAppearance::MozMenulistArrowButton: - (*aResult).width = ::GetSystemMetrics(SM_CXVSCROLL); + result.width = ::GetSystemMetrics(SM_CXVSCROLL); break; case StyleAppearance::Menulist: case StyleAppearance::MenulistButton: @@ -2736,60 +2709,55 @@ nsresult nsNativeThemeWin::ClassicGetMinimumWidgetSize( NONCLIENTMETRICS nc; nc.cbSize = sizeof(nc); if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(nc), &nc, 0)) - (*aResult).width = (*aResult).height = - abs(nc.lfStatusFont.lfHeight) + 4; + result.width = result.height = abs(nc.lfStatusFont.lfHeight) + 4; else - (*aResult).width = (*aResult).height = 15; - *aIsOverridable = false; + result.width = result.height = 15; break; } case StyleAppearance::Menuseparator: { - aResult->width = 0; - aResult->height = 10; + result.width = 0; + result.height = 10; break; } case StyleAppearance::MozWindowTitlebarMaximized: case StyleAppearance::MozWindowTitlebar: - aResult->height = GetSystemMetrics(SM_CYCAPTION); - aResult->height += GetSystemMetrics(SM_CYFRAME); - aResult->width = 0; + result.height = + GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFRAME); break; case StyleAppearance::MozWindowFrameLeft: case StyleAppearance::MozWindowFrameRight: - aResult->width = GetSystemMetrics(SM_CXFRAME); - aResult->height = 0; + result.width = GetSystemMetrics(SM_CXFRAME); break; case StyleAppearance::MozWindowFrameBottom: - aResult->height = GetSystemMetrics(SM_CYFRAME); - aResult->width = 0; + result.height = GetSystemMetrics(SM_CYFRAME); break; case StyleAppearance::MozWindowButtonClose: case StyleAppearance::MozWindowButtonMinimize: case StyleAppearance::MozWindowButtonMaximize: case StyleAppearance::MozWindowButtonRestore: - aResult->width = GetSystemMetrics(SM_CXSIZE); - aResult->height = GetSystemMetrics(SM_CYSIZE); + result.width = GetSystemMetrics(SM_CXSIZE); + result.height = GetSystemMetrics(SM_CYSIZE); // XXX I have no idea why these caption metrics are always off, // but they are. - aResult->width -= 2; - aResult->height -= 4; + result.width -= 2; + result.height -= 4; if (aAppearance == StyleAppearance::MozWindowButtonMinimize) { - AddPaddingRect(aResult, CAPTIONBUTTON_MINIMIZE); + AddPaddingRect(&result, CAPTIONBUTTON_MINIMIZE); } else if (aAppearance == StyleAppearance::MozWindowButtonMaximize || aAppearance == StyleAppearance::MozWindowButtonRestore) { - AddPaddingRect(aResult, CAPTIONBUTTON_RESTORE); + AddPaddingRect(&result, CAPTIONBUTTON_RESTORE); } else if (aAppearance == StyleAppearance::MozWindowButtonClose) { - AddPaddingRect(aResult, CAPTIONBUTTON_CLOSE); + AddPaddingRect(&result, CAPTIONBUTTON_CLOSE); } break; default: - return NS_ERROR_FAILURE; + break; } - return NS_OK; + return result; } nsresult nsNativeThemeWin::ClassicGetThemePartAndState( diff --git a/widget/windows/nsNativeThemeWin.h b/widget/windows/nsNativeThemeWin.h index 9148f28c71c4..f56e5f9bc70e 100644 --- a/widget/windows/nsNativeThemeWin.h +++ b/widget/windows/nsNativeThemeWin.h @@ -61,10 +61,9 @@ class nsNativeThemeWin : public Theme { StyleAppearance aAppearance, nsRect* aOverflowRect) override; - NS_IMETHOD GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame* aFrame, - StyleAppearance aAppearance, - LayoutDeviceIntSize* aResult, - bool* aIsOverridable) override; + LayoutDeviceIntSize GetMinimumWidgetSize( + nsPresContext* aPresContext, nsIFrame* aFrame, + StyleAppearance aAppearance) override; virtual Transparency GetWidgetTransparency( nsIFrame* aFrame, StyleAppearance aAppearance) override; @@ -114,10 +113,8 @@ class nsNativeThemeWin : public Theme { bool ClassicGetWidgetPadding(nsDeviceContext* aContext, nsIFrame* aFrame, StyleAppearance aAppearance, LayoutDeviceIntMargin* aResult); - nsresult ClassicGetMinimumWidgetSize(nsIFrame* aFrame, - StyleAppearance aAppearance, - LayoutDeviceIntSize* aResult, - bool* aIsOverridable); + LayoutDeviceIntSize ClassicGetMinimumWidgetSize(nsIFrame* aFrame, + StyleAppearance aAppearance); bool ClassicThemeSupportsWidget(nsIFrame* aFrame, StyleAppearance aAppearance); void DrawCheckedRect(HDC hdc, const RECT& rc, int32_t fore, int32_t back,