Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-09 03:15:11 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1734009 - Pass color-related arguments down to the non-native theme in a more convenient way. r=dholbert

Browse Source 
This avoids adding yet another parameter for the light/dark
color-scheme.

This shouldn't have any behavior change, but is a prerequisite to
implement dark form controls on the non-native theme.

Differential Revision: https://phabricator.services.mozilla.com/D127482
This commit is contained in:
Emilio Cobos Álvarez 2021-10-05 09:40:00 +00:00
parent 4fdbd2ef36
commit faacceefe2
9 changed files with 278 additions and 314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
widget/android/nsNativeBasicThemeAndroid.cpp
View File

@ -42,10 +42,10 @@ void nsNativeBasicThemeAndroid::DoPaintScrollbarThumb(
PaintBackendData& aPaintData, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
// TODO(emilio): Maybe do like macOS and draw a stroke?
const auto color = ComputeScrollbarThumbColor(
aFrame, aStyle, aElementState, aDocumentState, aUseSystemColors);
const auto color = ComputeScrollbarThumbColor(aFrame, aStyle, aElementState,
aDocumentState, aColors);
// Draw the thumb rect centered in the scrollbar.
LayoutDeviceRect thumbRect(aRect);
@ -68,9 +68,9 @@ bool nsNativeBasicThemeAndroid::PaintScrollbarThumb(
DrawTarget& aDt, const LayoutDeviceRect& aRect, bool aHorizontal,
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
DoPaintScrollbarThumb(aDt, aRect, aHorizontal, aFrame, aStyle, aElementState,
aDocumentState, aUseSystemColors, aDpiRatio);
aDocumentState, aColors, aDpiRatio);
return true;
}
@ -78,10 +78,9 @@ bool nsNativeBasicThemeAndroid::PaintScrollbarThumb(
WebRenderBackendData& aWrData, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
DoPaintScrollbarThumb(aWrData, aRect, aHorizontal, aFrame, aStyle,
aElementState, aDocumentState, aUseSystemColors,
aDpiRatio);
aElementState, aDocumentState, aColors, aDpiRatio);
return true;
}

18
widget/android/nsNativeBasicThemeAndroid.h
View File

@ -25,25 +25,25 @@ class nsNativeBasicThemeAndroid final : public nsNativeBasicTheme {
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio);
bool PaintScrollbarThumb(DrawTarget&, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override;
bool PaintScrollbarThumb(WebRenderBackendData&, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override;
bool PaintScrollbarTrack(DrawTarget&, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override {
// There's no visible track on android.
return true;
@ -51,7 +51,7 @@ class nsNativeBasicThemeAndroid final : public nsNativeBasicTheme {
bool PaintScrollbarTrack(WebRenderBackendData&, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override {
// There's no visible track on Android.
return true;
@ -61,7 +61,7 @@ class nsNativeBasicThemeAndroid final : public nsNativeBasicTheme {
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override {
// Draw nothing, we only draw the thumb.
return true;
@ -70,7 +70,7 @@ class nsNativeBasicThemeAndroid final : public nsNativeBasicTheme {
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override {
// Draw nothing, we only draw the thumb.
return true;
@ -78,14 +78,14 @@ class nsNativeBasicThemeAndroid final : public nsNativeBasicTheme {
bool PaintScrollCorner(DrawTarget&, const LayoutDeviceRect& aRect,
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio aDpiRatio) override {
// Draw nothing, we only draw the thumb.
return true;
}
bool PaintScrollCorner(WebRenderBackendData&, const LayoutDeviceRect& aRect,
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio aDpiRatio) override {
// Draw nothing, we only draw the thumb.
return true;

12
widget/cocoa/nsNativeBasicThemeCocoa.cpp
View File

@ -100,7 +100,7 @@ bool nsNativeBasicThemeCocoa::PaintScrollbarThumb(
DrawTarget& aDt, const LayoutDeviceRect& aRect, bool aHorizontal,
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors, DPIRatio aDpiRatio) {
const Colors&, DPIRatio aDpiRatio) {
// TODO: Maybe respect the UseSystemColors setting?
DoPaintScrollbarThumb(aDt, aRect, aHorizontal, aFrame, aStyle, aElementState,
aDocumentState, aDpiRatio);
@ -111,7 +111,7 @@ bool nsNativeBasicThemeCocoa::PaintScrollbarThumb(
WebRenderBackendData& aWrData, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors, DPIRatio aDpiRatio) {
const Colors&, DPIRatio aDpiRatio) {
// TODO: Maybe respect the UseSystemColors setting?
DoPaintScrollbarThumb(aWrData, aRect, aHorizontal, aFrame, aStyle,
aElementState, aDocumentState, aDpiRatio);
@ -138,7 +138,7 @@ void nsNativeBasicThemeCocoa::DoPaintScrollbarTrack(
bool nsNativeBasicThemeCocoa::PaintScrollbarTrack(
DrawTarget& aDt, const LayoutDeviceRect& aRect, bool aHorizontal,
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors, DPIRatio aDpiRatio) {
const EventStates& aDocumentState, const Colors&, DPIRatio aDpiRatio) {
// TODO: Maybe respect the UseSystemColors setting?
DoPaintScrollbarTrack(aDt, aRect, aHorizontal, aFrame, aStyle, aDocumentState,
aDpiRatio);
@ -148,7 +148,7 @@ bool nsNativeBasicThemeCocoa::PaintScrollbarTrack(
bool nsNativeBasicThemeCocoa::PaintScrollbarTrack(
WebRenderBackendData& aWrData, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors, DPIRatio aDpiRatio) {
const EventStates& aDocumentState, const Colors&, DPIRatio aDpiRatio) {
// TODO: Maybe respect the UseSystemColors setting?
DoPaintScrollbarTrack(aWrData, aRect, aHorizontal, aFrame, aStyle,
aDocumentState, aDpiRatio);
@ -175,7 +175,7 @@ void nsNativeBasicThemeCocoa::DoPaintScrollCorner(
bool nsNativeBasicThemeCocoa::PaintScrollCorner(
DrawTarget& aDt, const LayoutDeviceRect& aRect, nsIFrame* aFrame,
const ComputedStyle& aStyle, const EventStates& aDocumentState,
UseSystemColors, DPIRatio aDpiRatio) {
const Colors&, DPIRatio aDpiRatio) {
// TODO: Maybe respect the UseSystemColors setting?
DoPaintScrollCorner(aDt, aRect, aFrame, aStyle, aDocumentState, aDpiRatio);
return true;
@ -184,7 +184,7 @@ bool nsNativeBasicThemeCocoa::PaintScrollCorner(
bool nsNativeBasicThemeCocoa::PaintScrollCorner(
WebRenderBackendData& aWrData, const LayoutDeviceRect& aRect,
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors, DPIRatio aDpiRatio) {
const EventStates& aDocumentState, const Colors&, DPIRatio aDpiRatio) {
// TODO: Maybe respect the UseSystemColors setting?
DoPaintScrollCorner(aWrData, aRect, aFrame, aStyle, aDocumentState,
aDpiRatio);

16
widget/cocoa/nsNativeBasicThemeCocoa.h
View File

@ -36,13 +36,13 @@ class nsNativeBasicThemeCocoa : public nsNativeBasicTheme {
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override;
bool PaintScrollbarThumb(WebRenderBackendData&, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override;
template <typename PaintBackendData>
@ -54,19 +54,19 @@ class nsNativeBasicThemeCocoa : public nsNativeBasicTheme {
bool PaintScrollbarTrack(DrawTarget&, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override;
bool PaintScrollbarTrack(WebRenderBackendData&, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override;
bool PaintScrollbar(DrawTarget&, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override {
// Draw nothing; the scrollbar track is drawn in PaintScrollbarTrack.
return true;
@ -75,7 +75,7 @@ class nsNativeBasicThemeCocoa : public nsNativeBasicTheme {
bool aHorizontal, nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override {
// Draw nothing; the scrollbar track is drawn in PaintScrollbarTrack.
return true;
@ -89,11 +89,11 @@ class nsNativeBasicThemeCocoa : public nsNativeBasicTheme {
bool PaintScrollCorner(DrawTarget&, const LayoutDeviceRect& aRect,
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio aDpiRatio) override;
bool PaintScrollCorner(WebRenderBackendData&, const LayoutDeviceRect& aRect,
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio aDpiRatio) override;
ThemeGeometryType ThemeGeometryTypeForWidget(nsIFrame*,

28
widget/gtk/nsNativeBasicThemeGTK.cpp
View File

@ -25,17 +25,11 @@ already_AddRefed<nsITheme> do_GetBasicNativeThemeDoNotUseDirectly() {
nsITheme::Transparency nsNativeBasicThemeGTK::GetWidgetTransparency(
nsIFrame* aFrame, StyleAppearance aAppearance) {
if (!sOverlayScrollbars) {
if (aAppearance == StyleAppearance::ScrollbarVertical ||
aAppearance == StyleAppearance::ScrollbarHorizontal) {
nsPresContext* pc = aFrame->PresContext();
auto docState = pc->Document()->GetDocumentState();
const auto useSystemColors = ShouldUseSystemColors(*pc);
const auto* style = nsLayoutUtils::StyleForScrollbar(aFrame);
auto trackColor =
ComputeScrollbarTrackColor(aFrame, *style, docState, useSystemColors);
return trackColor.a == 1.0 ? eOpaque : eTransparent;
}
if (!sOverlayScrollbars &&
(aAppearance == StyleAppearance::ScrollbarVertical ||
aAppearance == StyleAppearance::ScrollbarHorizontal) &&
IsScrollbarTrackOpaque(aFrame)) {
return eOpaque;
}
return nsNativeBasicTheme::GetWidgetTransparency(aFrame, aAppearance);
}
@ -109,9 +103,9 @@ bool nsNativeBasicThemeGTK::DoPaintScrollbarThumb(
PaintBackendData& aPaintData, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
sRGBColor thumbColor = ComputeScrollbarThumbColor(
aFrame, aStyle, aElementState, aDocumentState, aUseSystemColors);
aFrame, aStyle, aElementState, aDocumentState, aColors);
LayoutDeviceRect thumbRect(aRect);
@ -149,9 +143,9 @@ bool nsNativeBasicThemeGTK::PaintScrollbarThumb(
DrawTarget& aDrawTarget, const LayoutDeviceRect& aRect, bool aHorizontal,
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
return DoPaintScrollbarThumb(aDrawTarget, aRect, aHorizontal, aFrame, aStyle,
aElementState, aDocumentState, aUseSystemColors,
aElementState, aDocumentState, aColors,
aDpiRatio);
}
@ -159,8 +153,8 @@ bool nsNativeBasicThemeGTK::PaintScrollbarThumb(
WebRenderBackendData& aWrData, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
return DoPaintScrollbarThumb(aWrData, aRect, aHorizontal, aFrame, aStyle,
aElementState, aDocumentState, aUseSystemColors,
aElementState, aDocumentState, aColors,
aDpiRatio);
}

10
widget/gtk/nsNativeBasicThemeGTK.h
View File

@ -13,30 +13,30 @@ class nsNativeBasicThemeGTK : public nsNativeBasicTheme {
public:
nsNativeBasicThemeGTK() = default;
Transparency GetWidgetTransparency(nsIFrame*, StyleAppearance) override;
NS_IMETHOD GetMinimumWidgetSize(nsPresContext* aPresContext, nsIFrame*,
StyleAppearance,
mozilla::LayoutDeviceIntSize* aResult,
bool* aIsOverridable) override;
nsITheme::Transparency GetWidgetTransparency(nsIFrame*,
StyleAppearance) override;
bool PaintScrollbarThumb(DrawTarget&, const LayoutDeviceRect&,
bool aHorizontal, nsIFrame*,
const ComputedStyle& aStyle,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override;
bool PaintScrollbarThumb(WebRenderBackendData&, const LayoutDeviceRect&,
bool aHorizontal, nsIFrame*,
const ComputedStyle& aStyle,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio) override;
template <typename PaintBackendData>
bool DoPaintScrollbarThumb(PaintBackendData&, const LayoutDeviceRect&,
bool aHorizontal, nsIFrame*, const ComputedStyle&,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio);
bool ThemeSupportsScrollbarButtons() override;

380
widget/nsNativeBasicTheme.cpp
View File

@ -247,6 +247,24 @@ class nsNativeBasicTheme::AccentColor {
}
};
// Widget color information associated to a particular frame.
class nsNativeBasicTheme::Colors {
const AccentColor mAccentColor;
const bool mUseSystemColors;
const LookAndFeel::ColorScheme mColorScheme;
public:
explicit Colors(const nsIFrame* aFrame)
: mAccentColor(*aFrame->Style()),
mUseSystemColors(ShouldUseSystemColors(*aFrame->PresContext()) ==
UseSystemColors::Yes),
mColorScheme(LookAndFeel::ColorSchemeForFrame(aFrame)) {}
const AccentColor& Accent() const { return mAccentColor; }
bool UseSystemColors() const { return mUseSystemColors; }
bool IsDark() const { return mColorScheme == LookAndFeel::ColorScheme::Dark; }
};
CSSIntCoord nsNativeBasicTheme::sHorizontalScrollbarHeight = CSSIntCoord(0);
CSSIntCoord nsNativeBasicTheme::sVerticalScrollbarWidth = CSSIntCoord(0);
bool nsNativeBasicTheme::sOverlayScrollbars = false;
@ -418,7 +436,7 @@ static LayoutDeviceRect CheckBoxRadioRect(const LayoutDeviceRect& aRect) {
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeCheckboxColors(
const EventStates& aState, StyleAppearance aAppearance,
const AccentColor& aAccent, UseSystemColors aUseSystemColors) {
const Colors& aColors) {
MOZ_ASSERT(aAppearance == StyleAppearance::Checkbox ||
aAppearance == StyleAppearance::Radio);
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
@ -429,7 +447,7 @@ std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeCheckboxColors(
bool isIndeterminate = aAppearance == StyleAppearance::Checkbox &&
aState.HasState(NS_EVENT_STATE_INDETERMINATE);
if (bool(aUseSystemColors)) {
if (aColors.UseSystemColors()) {
sRGBColor backgroundColor = SystemColor(StyleSystemColor::Buttonface);
sRGBColor borderColor = SystemColor(StyleSystemColor::Buttontext);
if (isDisabled) {
@ -453,9 +471,9 @@ std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeCheckboxColors(
backgroundColor = borderColor;
}
} else if (isChecked || isIndeterminate) {
const auto& color = isPressed ? aAccent.GetDarker()
: isHovered ? aAccent.GetDark()
: aAccent.Get();
const auto& color = isPressed ? aColors.Accent().GetDarker()
: isHovered ? aColors.Accent().GetDark()
: aColors.Accent().Get();
backgroundColor = borderColor = color;
} else if (isPressed) {
backgroundColor = sColorGrey20;
@ -468,22 +486,21 @@ std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeCheckboxColors(
return std::make_pair(backgroundColor, borderColor);
}
sRGBColor nsNativeBasicTheme::ComputeCheckmarkColor(
const EventStates& aState, const AccentColor& aAccent,
UseSystemColors aUseSystemColors) {
if (bool(aUseSystemColors)) {
sRGBColor nsNativeBasicTheme::ComputeCheckmarkColor(const EventStates& aState,
const Colors& aColors) {
if (aColors.UseSystemColors()) {
return SystemColor(StyleSystemColor::Selecteditemtext);
}
if (aState.HasState(NS_EVENT_STATE_DISABLED)) {
return sColorWhiteAlpha80;
}
return aAccent.GetForeground();
return aColors.Accent().GetForeground();
}
sRGBColor nsNativeBasicTheme::ComputeBorderColor(
const EventStates& aState, UseSystemColors aUseSystemColors) {
sRGBColor nsNativeBasicTheme::ComputeBorderColor(const EventStates& aState,
const Colors& aColors) {
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
if (bool(aUseSystemColors)) {
if (aColors.UseSystemColors()) {
return SystemColor(isDisabled ? StyleSystemColor::Graytext
: StyleSystemColor::Buttontext);
}
@ -513,15 +530,14 @@ sRGBColor nsNativeBasicTheme::ComputeBorderColor(
}
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeButtonColors(
const EventStates& aState, UseSystemColors aUseSystemColors,
nsIFrame* aFrame) {
const EventStates& aState, const Colors& aColors, nsIFrame* aFrame) {
bool isActive =
aState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE);
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
bool isHovered = aState.HasState(NS_EVENT_STATE_HOVER);
const sRGBColor backgroundColor = [&] {
if (bool(aUseSystemColors)) {
if (aColors.UseSystemColors()) {
return SystemColor(StyleSystemColor::Buttonface);
}
@ -540,7 +556,7 @@ std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeButtonColors(
return sColorGrey10;
}();
const sRGBColor borderColor = ComputeBorderColor(aState, aUseSystemColors);
const sRGBColor borderColor = ComputeBorderColor(aState, aColors);
return std::make_pair(backgroundColor, borderColor);
}
@ -549,9 +565,9 @@ std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeButtonColors(
constexpr nscolor kAutofillColor = NS_RGBA(255, 249, 145, 128);
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeTextfieldColors(
const EventStates& aState, UseSystemColors aUseSystemColors) {
const EventStates& aState, const Colors& aColors) {
nscolor backgroundColor = [&] {
if (bool(aUseSystemColors)) {
if (aColors.UseSystemColors()) {
return SystemNsColor(StyleSystemColor::Field);
}
if (aState.HasState(NS_EVENT_STATE_DISABLED)) {
@ -565,14 +581,13 @@ std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeTextfieldColors(
backgroundColor = NS_ComposeColors(backgroundColor, kAutofillColor);
}
const sRGBColor borderColor = ComputeBorderColor(aState, aUseSystemColors);
const sRGBColor borderColor = ComputeBorderColor(aState, aColors);
return std::make_pair(sRGBColor::FromABGR(backgroundColor), borderColor);
}
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeRangeProgressColors(
const EventStates& aState, const AccentColor& aAccent,
UseSystemColors aUseSystemColors) {
if (bool(aUseSystemColors)) {
const EventStates& aState, const Colors& aColors) {
if (aColors.UseSystemColors()) {
return SystemColorPair(StyleSystemColor::Selecteditem,
StyleSystemColor::Buttontext);
}
@ -586,14 +601,15 @@ std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeRangeProgressColors(
return std::make_pair(sColorGrey40Alpha50, sColorGrey40Alpha50);
}
if (isActive || isHovered) {
return std::make_pair(aAccent.GetDark(), aAccent.GetDarker());
return std::make_pair(aColors.Accent().GetDark(),
aColors.Accent().GetDarker());
}
return std::make_pair(aAccent.Get(), aAccent.GetDark());
return std::make_pair(aColors.Accent().Get(), aColors.Accent().GetDark());
}
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeRangeTrackColors(
const EventStates& aState, UseSystemColors aUseSystemColors) {
if (bool(aUseSystemColors)) {
const EventStates& aState, const Colors& aColors) {
if (aColors.UseSystemColors()) {
return SystemColorPair(StyleSystemColor::TextBackground,
StyleSystemColor::Buttontext);
}
@ -612,9 +628,8 @@ std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeRangeTrackColors(
}
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeRangeThumbColors(
const EventStates& aState, const AccentColor& aAccent,
UseSystemColors aUseSystemColors) {
if (bool(aUseSystemColors)) {
const EventStates& aState, const Colors& aColors) {
if (aColors.UseSystemColors()) {
return SystemColorPair(StyleSystemColor::Selecteditemtext,
StyleSystemColor::Selecteditem);
}
@ -629,7 +644,7 @@ std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeRangeThumbColors(
return sColorGrey40;
}
if (isActive) {
return aAccent.Get();
return aColors.Accent().Get();
}
if (isHovered) {
return sColorGrey60;
@ -643,17 +658,17 @@ std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeRangeThumbColors(
}
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeProgressColors(
const AccentColor& aAccent, UseSystemColors aUseSystemColors) {
if (bool(aUseSystemColors)) {
const Colors& aColors) {
if (aColors.UseSystemColors()) {
return SystemColorPair(StyleSystemColor::Selecteditem,
StyleSystemColor::Buttontext);
}
return std::make_pair(aAccent.Get(), aAccent.GetDark());
return std::make_pair(aColors.Accent().Get(), aColors.Accent().GetDark());
}
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeProgressTrackColors(
UseSystemColors aUseSystemColors) {
if (bool(aUseSystemColors)) {
const Colors& aColors) {
if (aColors.UseSystemColors()) {
return SystemColorPair(StyleSystemColor::Buttonface,
StyleSystemColor::Buttontext);
}
@ -661,10 +676,9 @@ std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeProgressTrackColors(
}
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeMeterchunkColors(
const EventStates& aMeterState, UseSystemColors aUseSystemColors) {
if (bool(aUseSystemColors)) {
// Accent color doesn't matter when using system colors.
return ComputeProgressColors(AccentColor(), aUseSystemColors);
const EventStates& aMeterState, const Colors& aColors) {
if (aColors.UseSystemColors()) {
return ComputeProgressColors(aColors);
}
sRGBColor borderColor = sColorMeterGreen20;
sRGBColor chunkColor = sColorMeterGreen10;
@ -681,21 +695,29 @@ std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeMeterchunkColors(
}
std::array<sRGBColor, 3> nsNativeBasicTheme::ComputeFocusRectColors(
const AccentColor& aAccent, UseSystemColors aUseSystemColors) {
if (bool(aUseSystemColors)) {
const Colors& aColors) {
if (aColors.UseSystemColors()) {
return {SystemColor(StyleSystemColor::Selecteditem),
SystemColor(StyleSystemColor::Buttontext),
SystemColor(StyleSystemColor::TextBackground)};
}
return {aAccent.Get(), sColorWhiteAlpha80, aAccent.GetLight()};
return {aColors.Accent().Get(), sColorWhiteAlpha80,
aColors.Accent().GetLight()};
}
bool nsNativeBasicTheme::IsScrollbarTrackOpaque(nsIFrame* aFrame) {
auto trackColor = ComputeScrollbarTrackColor(
aFrame, *nsLayoutUtils::StyleForScrollbar(aFrame),
aFrame->PresContext()->Document()->GetDocumentState(), Colors(aFrame));
return trackColor.a == 1.0f;
}
sRGBColor nsNativeBasicTheme::ComputeScrollbarTrackColor(
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors aUseSystemColors) {
const EventStates& aDocumentState, const Colors& aColors) {
const nsStyleUI* ui = aStyle.StyleUI();
if (bool(aUseSystemColors)) {
if (aColors.UseSystemColors()) {
return SystemColor(StyleSystemColor::TextBackground);
}
if (ShouldUseDarkScrollbar(aFrame, aStyle)) {
@ -841,8 +863,8 @@ static bool ShouldUseColorForActiveDarkScrollbarThumb(nscolor aColor) {
sRGBColor nsNativeBasicTheme::ComputeScrollbarThumbColor(
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors) {
if (!bool(aUseSystemColors) && ShouldUseDarkScrollbar(aFrame, aStyle)) {
const Colors& aColors) {
if (!aColors.UseSystemColors() && ShouldUseDarkScrollbar(aFrame, aStyle)) {
if (aElementState.HasState(NS_EVENT_STATE_ACTIVE) &&
StaticPrefs::widget_non_native_theme_scrollbar_active_always_themed()) {
auto color = LookAndFeel::GetColor(
@ -867,18 +889,18 @@ sRGBColor nsNativeBasicTheme::ComputeScrollbarThumbColor(
return StyleSystemColor::ThemedScrollbarThumbInactive;
}
if (aElementState.HasState(NS_EVENT_STATE_ACTIVE)) {
if (bool(aUseSystemColors)) {
if (aColors.UseSystemColors()) {
return StyleSystemColor::Selecteditem;
}
return StyleSystemColor::ThemedScrollbarThumbActive;
}
if (aElementState.HasState(NS_EVENT_STATE_HOVER)) {
if (bool(aUseSystemColors)) {
if (aColors.UseSystemColors()) {
return StyleSystemColor::Selecteditem;
}
return StyleSystemColor::ThemedScrollbarThumbHover;
}
if (bool(aUseSystemColors)) {
if (aColors.UseSystemColors()) {
return StyleSystemColor::TextForeground;
}
return StyleSystemColor::ThemedScrollbarThumb;
@ -894,8 +916,8 @@ std::pair<sRGBColor, sRGBColor>
nsNativeBasicTheme::ComputeScrollbarButtonColors(
nsIFrame* aFrame, StyleAppearance aAppearance, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors) {
if (bool(aUseSystemColors)) {
const Colors& aColors) {
if (aColors.UseSystemColors()) {
if (aElementState.HasAtLeastOneOfStates(NS_EVENT_STATE_ACTIVE |
NS_EVENT_STATE_HOVER)) {
return SystemColorPair(StyleSystemColor::Selecteditem,
@ -905,8 +927,8 @@ nsNativeBasicTheme::ComputeScrollbarButtonColors(
StyleSystemColor::TextForeground);
}
auto trackColor = ComputeScrollbarTrackColor(aFrame, aStyle, aDocumentState,
aUseSystemColors);
auto trackColor =
ComputeScrollbarTrackColor(aFrame, aStyle, aDocumentState, aColors);
nscolor buttonColor =
GetScrollbarButtonColor(trackColor.ToABGR(), aElementState);
auto arrowColor =
@ -914,7 +936,7 @@ nsNativeBasicTheme::ComputeScrollbarButtonColors(
.map(sRGBColor::FromABGR)
.valueOrFrom([&] {
return ComputeScrollbarThumbColor(aFrame, aStyle, aElementState,
aDocumentState, aUseSystemColors);
aDocumentState, aColors);
});
return {sRGBColor::FromABGR(buttonColor), arrowColor};
}
@ -922,14 +944,15 @@ nsNativeBasicTheme::ComputeScrollbarButtonColors(
static const CSSCoord kInnerFocusOutlineWidth = 2.0f;
template <typename PaintBackendData>
void nsNativeBasicTheme::PaintRoundedFocusRect(
PaintBackendData& aBackendData, const LayoutDeviceRect& aRect,
const AccentColor& aAccent, UseSystemColors aUseSystemColors,
DPIRatio aDpiRatio, CSSCoord aRadius, CSSCoord aOffset) {
void nsNativeBasicTheme::PaintRoundedFocusRect(PaintBackendData& aBackendData,
const LayoutDeviceRect& aRect,
const Colors& aColors,
DPIRatio aDpiRatio,
CSSCoord aRadius,
CSSCoord aOffset) {
// NOTE(emilio): If the widths or offsets here change, make sure to tweak
// the GetWidgetOverflow path for FocusOutline.
auto [innerColor, middleColor, outerColor] =
ComputeFocusRectColors(aAccent, aUseSystemColors);
auto [innerColor, middleColor, outerColor] = ComputeFocusRectColors(aColors);
LayoutDeviceRect focusRect(aRect);
@ -1105,11 +1128,10 @@ void nsNativeBasicTheme::PaintRoundedRectWithRadius(
void nsNativeBasicTheme::PaintCheckboxControl(DrawTarget& aDrawTarget,
const LayoutDeviceRect& aRect,
const EventStates& aState,
const AccentColor& aAccent,
UseSystemColors aUseSystemColors,
const Colors& aColors,
DPIRatio aDpiRatio) {
auto [backgroundColor, borderColor] = ComputeCheckboxColors(
aState, StyleAppearance::Checkbox, aAccent, aUseSystemColors);
auto [backgroundColor, borderColor] =
ComputeCheckboxColors(aState, StyleAppearance::Checkbox, aColors);
{
const CSSCoord radius = 2.0f;
CSSCoord borderWidth = kCheckboxRadioBorderWidth;
@ -1121,15 +1143,13 @@ void nsNativeBasicTheme::PaintCheckboxControl(DrawTarget& aDrawTarget,
}
if (aState.HasState(NS_EVENT_STATE_INDETERMINATE)) {
PaintIndeterminateMark(aDrawTarget, aRect, aState, aAccent,
aUseSystemColors);
PaintIndeterminateMark(aDrawTarget, aRect, aState, aColors);
} else if (aState.HasState(NS_EVENT_STATE_CHECKED)) {
PaintCheckMark(aDrawTarget, aRect, aState, aAccent, aUseSystemColors);
PaintCheckMark(aDrawTarget, aRect, aState, aColors);
}
if (aState.HasState(NS_EVENT_STATE_FOCUSRING)) {
PaintRoundedFocusRect(aDrawTarget, aRect, aAccent, aUseSystemColors,
aDpiRatio, 5.0f, 1.0f);
PaintRoundedFocusRect(aDrawTarget, aRect, aColors, aDpiRatio, 5.0f, 1.0f);
}
}
@ -1146,8 +1166,7 @@ static float ScaleToFillRect(const LayoutDeviceRect& aRect, const float aSize) {
void nsNativeBasicTheme::PaintCheckMark(DrawTarget& aDrawTarget,
const LayoutDeviceRect& aRect,
const EventStates& aState,
const AccentColor& aAccent,
UseSystemColors aUseSystemColors) {
const Colors& aColors) {
// Points come from the coordinates on a 14X14 (kCheckboxRadioBorderBoxSize)
// unit box centered at 0,0
const float checkPolygonX[] = {-4.5f, -1.5f, -0.5f, 5.0f, 4.75f,
@ -1167,15 +1186,14 @@ void nsNativeBasicTheme::PaintCheckMark(DrawTarget& aDrawTarget,
}
RefPtr<Path> path = builder->Finish();
sRGBColor fillColor =
ComputeCheckmarkColor(aState, aAccent, aUseSystemColors);
sRGBColor fillColor = ComputeCheckmarkColor(aState, aColors);
aDrawTarget.Fill(path, ColorPattern(ToDeviceColor(fillColor)));
}
void nsNativeBasicTheme::PaintIndeterminateMark(
DrawTarget& aDrawTarget, const LayoutDeviceRect& aRect,
const EventStates& aState, const AccentColor& aAccent,
UseSystemColors aUseSystemColors) {
void nsNativeBasicTheme::PaintIndeterminateMark(DrawTarget& aDrawTarget,
const LayoutDeviceRect& aRect,
const EventStates& aState,
const Colors& aColors) {
const CSSCoord borderWidth = 2.0f;
const float scale = ScaleToFillRect(aRect, kCheckboxRadioBorderBoxSize);
@ -1185,8 +1203,7 @@ void nsNativeBasicTheme::PaintIndeterminateMark(
rect.x += (borderWidth * scale) + (borderWidth * scale / 8);
rect.width -= ((borderWidth * scale) + (borderWidth * scale / 8)) * 2;
sRGBColor fillColor =
ComputeCheckmarkColor(aState, aAccent, aUseSystemColors);
sRGBColor fillColor = ComputeCheckmarkColor(aState, aColors);
aDrawTarget.FillRect(rect, ColorPattern(ToDeviceColor(fillColor)));
}
@ -1280,11 +1297,10 @@ template <typename PaintBackendData>
void nsNativeBasicTheme::PaintRadioControl(PaintBackendData& aPaintData,
const LayoutDeviceRect& aRect,
const EventStates& aState,
const AccentColor& aAccent,
UseSystemColors aUseSystemColors,
const Colors& aColors,
DPIRatio aDpiRatio) {
auto [backgroundColor, borderColor] = ComputeCheckboxColors(
aState, StyleAppearance::Radio, aAccent, aUseSystemColors);
auto [backgroundColor, borderColor] =
ComputeCheckboxColors(aState, StyleAppearance::Radio, aColors);
{
CSSCoord borderWidth = kCheckboxRadioBorderWidth;
if (backgroundColor == borderColor) {
@ -1298,14 +1314,13 @@ void nsNativeBasicTheme::PaintRadioControl(PaintBackendData& aPaintData,
LayoutDeviceRect rect(aRect);
rect.Deflate(SnapBorderWidth(kCheckboxRadioBorderWidth, aDpiRatio));
auto checkColor = ComputeCheckmarkColor(aState, aAccent, aUseSystemColors);
auto checkColor = ComputeCheckmarkColor(aState, aColors);
PaintStrokedCircle(aPaintData, rect, backgroundColor, checkColor,
kCheckboxRadioBorderWidth, aDpiRatio);
}
if (aState.HasState(NS_EVENT_STATE_FOCUSRING)) {
PaintRoundedFocusRect(aPaintData, aRect, aAccent, aUseSystemColors,
aDpiRatio, 5.0f, 1.0f);
PaintRoundedFocusRect(aPaintData, aRect, aColors, aDpiRatio, 5.0f, 1.0f);
}
}
@ -1313,11 +1328,9 @@ template <typename PaintBackendData>
void nsNativeBasicTheme::PaintTextField(PaintBackendData& aPaintData,
const LayoutDeviceRect& aRect,
const EventStates& aState,
const AccentColor& aAccent,
UseSystemColors aUseSystemColors,
const Colors& aColors,
DPIRatio aDpiRatio) {
auto [backgroundColor, borderColor] =
ComputeTextfieldColors(aState, aUseSystemColors);
auto [backgroundColor, borderColor] = ComputeTextfieldColors(aState, aColors);
const CSSCoord radius = 2.0f;
@ -1325,8 +1338,8 @@ void nsNativeBasicTheme::PaintTextField(PaintBackendData& aPaintData,
kTextFieldBorderWidth, radius, aDpiRatio);
if (aState.HasState(NS_EVENT_STATE_FOCUSRING)) {
PaintRoundedFocusRect(aPaintData, aRect, aAccent, aUseSystemColors,
aDpiRatio, radius + kTextFieldBorderWidth,
PaintRoundedFocusRect(aPaintData, aRect, aColors, aDpiRatio,
radius + kTextFieldBorderWidth,
-kTextFieldBorderWidth);
}
}
@ -1335,20 +1348,17 @@ template <typename PaintBackendData>
void nsNativeBasicTheme::PaintListbox(PaintBackendData& aPaintData,
const LayoutDeviceRect& aRect,
const EventStates& aState,
const AccentColor& aAccent,
UseSystemColors aUseSystemColors,
const Colors& aColors,
DPIRatio aDpiRatio) {
const CSSCoord radius = 2.0f;
auto [backgroundColor, borderColor] =
ComputeTextfieldColors(aState, aUseSystemColors);
auto [backgroundColor, borderColor] = ComputeTextfieldColors(aState, aColors);
PaintRoundedRectWithRadius(aPaintData, aRect, backgroundColor, borderColor,
kMenulistBorderWidth, radius, aDpiRatio);
if (aState.HasState(NS_EVENT_STATE_FOCUSRING)) {
PaintRoundedFocusRect(aPaintData, aRect, aAccent, aUseSystemColors,
aDpiRatio, radius + kMenulistBorderWidth,
-kMenulistBorderWidth);
PaintRoundedFocusRect(aPaintData, aRect, aColors, aDpiRatio,
radius + kMenulistBorderWidth, -kMenulistBorderWidth);
}
}
@ -1356,20 +1366,17 @@ template <typename PaintBackendData>
void nsNativeBasicTheme::PaintMenulist(PaintBackendData& aDrawTarget,
const LayoutDeviceRect& aRect,
const EventStates& aState,
const AccentColor& aAccent,
UseSystemColors aUseSystemColors,
const Colors& aColors,
DPIRatio aDpiRatio) {
const CSSCoord radius = 4.0f;
auto [backgroundColor, borderColor] =
ComputeButtonColors(aState, aUseSystemColors);
auto [backgroundColor, borderColor] = ComputeButtonColors(aState, aColors);
PaintRoundedRectWithRadius(aDrawTarget, aRect, backgroundColor, borderColor,
kMenulistBorderWidth, radius, aDpiRatio);
if (aState.HasState(NS_EVENT_STATE_FOCUSRING)) {
PaintRoundedFocusRect(aDrawTarget, aRect, aAccent, aUseSystemColors,
aDpiRatio, radius + kMenulistBorderWidth,
-kMenulistBorderWidth);
PaintRoundedFocusRect(aDrawTarget, aRect, aColors, aDpiRatio,
radius + kMenulistBorderWidth, -kMenulistBorderWidth);
}
}
@ -1397,9 +1404,10 @@ void nsNativeBasicTheme::PaintArrow(DrawTarget& aDrawTarget,
aDrawTarget.Fill(path, ColorPattern(ToDeviceColor(aFillColor)));
}
void nsNativeBasicTheme::PaintMenulistArrowButton(
nsIFrame* aFrame, DrawTarget& aDrawTarget, const LayoutDeviceRect& aRect,
const EventStates& aState, UseSystemColors aUseSystemColors) {
void nsNativeBasicTheme::PaintMenulistArrowButton(nsIFrame* aFrame,
DrawTarget& aDrawTarget,
const LayoutDeviceRect& aRect,
const EventStates& aState) {
const float kPolygonX[] = {-4.0f, -0.5f, 0.5f, 4.0f, 4.0f,
3.0f, 0.0f, 0.0f, -3.0f, -4.0f};
const float kPolygonY[] = {-1, 3.0f, 3.0f, -1.0f, -2.0f,
@ -1416,9 +1424,8 @@ void nsNativeBasicTheme::PaintMenulistArrowButton(
void nsNativeBasicTheme::PaintSpinnerButton(
nsIFrame* aFrame, DrawTarget& aDrawTarget, const LayoutDeviceRect& aRect,
const EventStates& aState, StyleAppearance aAppearance,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
auto [backgroundColor, borderColor] =
ComputeButtonColors(aState, aUseSystemColors);
const Colors& aColors, DPIRatio aDpiRatio) {
auto [backgroundColor, borderColor] = ComputeButtonColors(aState, aColors);
aDrawTarget.FillRect(aRect.ToUnknownRect(),
ColorPattern(ToDeviceColor(backgroundColor)));
@ -1444,9 +1451,8 @@ void nsNativeBasicTheme::PaintRange(nsIFrame* aFrame,
PaintBackendData& aPaintData,
const LayoutDeviceRect& aRect,
const EventStates& aState,
const AccentColor& aAccent,
UseSystemColors aUseSystemColors,
DPIRatio aDpiRatio, bool aHorizontal) {
const Colors& aColors, DPIRatio aDpiRatio,
bool aHorizontal) {
nsRangeFrame* rangeFrame = do_QueryFrame(aFrame);
if (!rangeFrame) {
return;
@ -1492,9 +1498,9 @@ void nsNativeBasicTheme::PaintRange(nsIFrame* aFrame,
const CSSCoord radius = 3.0f;
auto [progressColor, progressBorderColor] =
ComputeRangeProgressColors(aState, aAccent, aUseSystemColors);
ComputeRangeProgressColors(aState, aColors);
auto [trackColor, trackBorderColor] =
ComputeRangeTrackColors(aState, aUseSystemColors);
ComputeRangeTrackColors(aState, aColors);
PaintRoundedRectWithRadius(aPaintData, rect, progressClipRect, progressColor,
progressBorderColor, borderWidth, radius,
@ -1516,14 +1522,13 @@ void nsNativeBasicTheme::PaintRange(nsIFrame* aFrame,
// Draw the thumb on top.
const CSSCoord thumbBorderWidth = 2.0f;
auto [thumbColor, thumbBorderColor] =
ComputeRangeThumbColors(aState, aAccent, aUseSystemColors);
ComputeRangeThumbColors(aState, aColors);
PaintStrokedCircle(aPaintData, thumbRect, thumbColor, thumbBorderColor,
thumbBorderWidth, aDpiRatio);
if (aState.HasState(NS_EVENT_STATE_FOCUSRING)) {
PaintRoundedFocusRect(aPaintData, aRect, aAccent, aUseSystemColors,
aDpiRatio, radius, 1.0f);
PaintRoundedFocusRect(aPaintData, aRect, aColors, aDpiRatio, radius, 1.0f);
}
}
@ -1532,8 +1537,7 @@ void nsNativeBasicTheme::PaintProgress(nsIFrame* aFrame,
PaintBackendData& aPaintData,
const LayoutDeviceRect& aRect,
const EventStates& aState,
const AccentColor& aAccent,
UseSystemColors aUseSystemColors,
const Colors& aColors,
DPIRatio aDpiRatio, bool aIsMeter) {
const CSSCoord borderWidth = 1.0f;
const CSSCoord radius = aIsMeter ? 6.0f : 3.0f;
@ -1555,8 +1559,7 @@ void nsNativeBasicTheme::PaintProgress(nsIFrame* aFrame,
{
// Paint the track, unclipped.
auto [backgroundColor, borderColor] =
ComputeProgressTrackColors(aUseSystemColors);
auto [backgroundColor, borderColor] = ComputeProgressTrackColors(aColors);
PaintRoundedRectWithRadius(aPaintData, rect, rect, backgroundColor,
borderColor, borderWidth, radius, aDpiRatio);
}
@ -1620,8 +1623,8 @@ void nsNativeBasicTheme::PaintProgress(nsIFrame* aFrame,
}
auto [backgroundColor, borderColor] =
aIsMeter ? ComputeMeterchunkColors(aState, aUseSystemColors)
: ComputeProgressColors(aAccent, aUseSystemColors);
aIsMeter ? ComputeMeterchunkColors(aState, aColors)
: ComputeProgressColors(aColors);
PaintRoundedRectWithRadius(aPaintData, rect, clipRect, backgroundColor,
borderColor, borderWidth, radius, aDpiRatio);
}
@ -1631,20 +1634,18 @@ void nsNativeBasicTheme::PaintButton(nsIFrame* aFrame,
PaintBackendData& aPaintData,
const LayoutDeviceRect& aRect,
const EventStates& aState,
const AccentColor& aAccent,
UseSystemColors aUseSystemColors,
const Colors& aColors,
DPIRatio aDpiRatio) {
const CSSCoord radius = 4.0f;
auto [backgroundColor, borderColor] =
ComputeButtonColors(aState, aUseSystemColors, aFrame);
ComputeButtonColors(aState, aColors, aFrame);
PaintRoundedRectWithRadius(aPaintData, aRect, backgroundColor, borderColor,
kButtonBorderWidth, radius, aDpiRatio);
if (aState.HasState(NS_EVENT_STATE_FOCUSRING)) {
PaintRoundedFocusRect(aPaintData, aRect, aAccent, aUseSystemColors,
aDpiRatio, radius + kButtonBorderWidth,
-kButtonBorderWidth);
PaintRoundedFocusRect(aPaintData, aRect, aColors, aDpiRatio,
radius + kButtonBorderWidth, -kButtonBorderWidth);
}
}
@ -1653,9 +1654,9 @@ bool nsNativeBasicTheme::DoPaintDefaultScrollbarThumb(
PaintBackendData& aPaintData, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
sRGBColor thumbColor = ComputeScrollbarThumbColor(
aFrame, aStyle, aElementState, aDocumentState, aUseSystemColors);
aFrame, aStyle, aElementState, aDocumentState, aColors);
FillRect(aPaintData, aRect, thumbColor);
return true;
}
@ -1664,20 +1665,20 @@ bool nsNativeBasicTheme::PaintScrollbarThumb(
DrawTarget& aDrawTarget, const LayoutDeviceRect& aRect, bool aHorizontal,
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
return DoPaintDefaultScrollbarThumb(aDrawTarget, aRect, aHorizontal, aFrame,
aStyle, aElementState, aDocumentState,
aUseSystemColors, aDpiRatio);
aColors, aDpiRatio);
}
bool nsNativeBasicTheme::PaintScrollbarThumb(
WebRenderBackendData& aWrData, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
return DoPaintDefaultScrollbarThumb(aWrData, aRect, aHorizontal, aFrame,
aStyle, aElementState, aDocumentState,
aUseSystemColors, aDpiRatio);
aColors, aDpiRatio);
}
template <typename PaintBackendData>
@ -1685,13 +1686,13 @@ bool nsNativeBasicTheme::DoPaintDefaultScrollbar(
PaintBackendData& aPaintData, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
if (sOverlayScrollbars && !aElementState.HasAtLeastOneOfStates(
NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE)) {
return true;
}
auto scrollbarColor = ComputeScrollbarTrackColor(
aFrame, aStyle, aDocumentState, aUseSystemColors);
auto scrollbarColor =
ComputeScrollbarTrackColor(aFrame, aStyle, aDocumentState, aColors);
FillRect(aPaintData, aRect, scrollbarColor);
return true;
}
@ -1700,30 +1701,30 @@ bool nsNativeBasicTheme::PaintScrollbar(
DrawTarget& aDrawTarget, const LayoutDeviceRect& aRect, bool aHorizontal,
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
return DoPaintDefaultScrollbar(aDrawTarget, aRect, aHorizontal, aFrame,
aStyle, aElementState, aDocumentState,
aUseSystemColors, aDpiRatio);
aStyle, aElementState, aDocumentState, aColors,
aDpiRatio);
}
bool nsNativeBasicTheme::PaintScrollbar(
WebRenderBackendData& aWrData, const LayoutDeviceRect& aRect,
bool aHorizontal, nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
return DoPaintDefaultScrollbar(aWrData, aRect, aHorizontal, aFrame, aStyle,
aElementState, aDocumentState,
aUseSystemColors, aDpiRatio);
aElementState, aDocumentState, aColors,
aDpiRatio);
}
template <typename PaintBackendData>
bool nsNativeBasicTheme::DoPaintDefaultScrollCorner(
PaintBackendData& aPaintData, const LayoutDeviceRect& aRect,
nsIFrame* aFrame, const ComputedStyle& aStyle,
const EventStates& aDocumentState, UseSystemColors aUseSystemColors,
const EventStates& aDocumentState, const Colors& aColors,
DPIRatio aDpiRatio) {
auto scrollbarColor = ComputeScrollbarTrackColor(
aFrame, aStyle, aDocumentState, aUseSystemColors);
auto scrollbarColor =
ComputeScrollbarTrackColor(aFrame, aStyle, aDocumentState, aColors);
FillRect(aPaintData, aRect, scrollbarColor);
return true;
}
@ -1731,10 +1732,9 @@ bool nsNativeBasicTheme::DoPaintDefaultScrollCorner(
bool nsNativeBasicTheme::PaintScrollCorner(
DrawTarget& aDrawTarget, const LayoutDeviceRect& aRect, nsIFrame* aFrame,
const ComputedStyle& aStyle, const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio aDpiRatio) {
const Colors& aColors, DPIRatio aDpiRatio) {
return DoPaintDefaultScrollCorner(aDrawTarget, aRect, aFrame, aStyle,
aDocumentState, aUseSystemColors,
aDpiRatio);
aDocumentState, aColors, aDpiRatio);
}
bool nsNativeBasicTheme::PaintScrollCorner(WebRenderBackendData& aWrData,
@ -1742,22 +1742,20 @@ bool nsNativeBasicTheme::PaintScrollCorner(WebRenderBackendData& aWrData,
nsIFrame* aFrame,
const ComputedStyle& aStyle,
const EventStates& aDocumentState,
UseSystemColors aUseSystemColors,
const Colors& aColors,
DPIRatio aDpiRatio) {
return DoPaintDefaultScrollCorner(aWrData, aRect, aFrame, aStyle,
aDocumentState, aUseSystemColors,
aDpiRatio);
aDocumentState, aColors, aDpiRatio);
}
void nsNativeBasicTheme::PaintScrollbarButton(
DrawTarget& aDrawTarget, StyleAppearance aAppearance,
const LayoutDeviceRect& aRect, nsIFrame* aFrame,
const ComputedStyle& aStyle, const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors aUseSystemColors,
const EventStates& aDocumentState, const Colors& aColors,
DPIRatio aDpiRatio) {
auto [buttonColor, arrowColor] =
ComputeScrollbarButtonColors(aFrame, aAppearance, aStyle, aElementState,
aDocumentState, aUseSystemColors);
auto [buttonColor, arrowColor] = ComputeScrollbarButtonColors(
aFrame, aAppearance, aStyle, aElementState, aDocumentState, aColors);
aDrawTarget.FillRect(aRect.ToUnknownRect(),
ColorPattern(ToDeviceColor(buttonColor)));
@ -1861,7 +1859,6 @@ bool nsNativeBasicTheme::DoDrawWidgetBackground(PaintBackendData& aPaintData,
const auto devPxRect = ToSnappedRect(aRect, twipsPerPixel, aPaintData);
const EventStates docState = pc->Document()->GetDocumentState();
const auto useSystemColors = ShouldUseSystemColors(*pc);
EventStates eventState = GetContentState(aFrame, aAppearance);
if (aAppearance == StyleAppearance::MozMenulistArrowButton) {
bool isHTML = IsHTMLContent(aFrame);
@ -1893,15 +1890,13 @@ bool nsNativeBasicTheme::DoDrawWidgetBackground(PaintBackendData& aPaintData,
}
}
const AccentColor accent(*aFrame->Style());
const Colors colors(aFrame);
DPIRatio dpiRatio = GetDPIRatio(aFrame, aAppearance);
switch (aAppearance) {
case StyleAppearance::Radio: {
auto rect = CheckBoxRadioRect(devPxRect);
PaintRadioControl(aPaintData, rect, eventState, accent, useSystemColors,
dpiRatio);
PaintRadioControl(aPaintData, rect, eventState, colors, dpiRatio);
break;
}
case StyleAppearance::Checkbox: {
@ -1910,33 +1905,28 @@ bool nsNativeBasicTheme::DoDrawWidgetBackground(PaintBackendData& aPaintData,
return false;
} else {
auto rect = CheckBoxRadioRect(devPxRect);
PaintCheckboxControl(aPaintData, rect, eventState, accent,
useSystemColors, dpiRatio);
PaintCheckboxControl(aPaintData, rect, eventState, colors, dpiRatio);
}
break;
}
case StyleAppearance::Textarea:
case StyleAppearance::Textfield:
case StyleAppearance::NumberInput:
PaintTextField(aPaintData, devPxRect, eventState, accent, useSystemColors,
dpiRatio);
PaintTextField(aPaintData, devPxRect, eventState, colors, dpiRatio);
break;
case StyleAppearance::Listbox:
PaintListbox(aPaintData, devPxRect, eventState, accent, useSystemColors,
dpiRatio);
PaintListbox(aPaintData, devPxRect, eventState, colors, dpiRatio);
break;
case StyleAppearance::MenulistButton:
case StyleAppearance::Menulist:
PaintMenulist(aPaintData, devPxRect, eventState, accent, useSystemColors,
dpiRatio);
PaintMenulist(aPaintData, devPxRect, eventState, colors, dpiRatio);
break;
case StyleAppearance::MozMenulistArrowButton:
if constexpr (std::is_same_v<PaintBackendData, WebRenderBackendData>) {
// TODO: Need to figure out how to best draw this using WR.
return false;
} else {
PaintMenulistArrowButton(aFrame, aPaintData, devPxRect, eventState,
useSystemColors);
PaintMenulistArrowButton(aFrame, aPaintData, devPxRect, eventState);
}
break;
case StyleAppearance::SpinnerUpbutton:
@ -1946,27 +1936,26 @@ bool nsNativeBasicTheme::DoDrawWidgetBackground(PaintBackendData& aPaintData,
return false;
} else {
PaintSpinnerButton(aFrame, aPaintData, devPxRect, eventState,
aAppearance, useSystemColors, dpiRatio);
aAppearance, colors, dpiRatio);
}
break;
case StyleAppearance::Range:
PaintRange(aFrame, aPaintData, devPxRect, eventState, accent,
useSystemColors, dpiRatio, IsRangeHorizontal(aFrame));
PaintRange(aFrame, aPaintData, devPxRect, eventState, colors, dpiRatio,
IsRangeHorizontal(aFrame));
break;
case StyleAppearance::RangeThumb:
// Painted as part of StyleAppearance::Range.
break;
case StyleAppearance::ProgressBar:
PaintProgress(aFrame, aPaintData, devPxRect, eventState, accent,
useSystemColors, dpiRatio,
PaintProgress(aFrame, aPaintData, devPxRect, eventState, colors, dpiRatio,
/* aIsMeter = */ false);
break;
case StyleAppearance::Progresschunk:
/* Painted as part of the progress bar */
break;
case StyleAppearance::Meter:
PaintProgress(aFrame, aPaintData, devPxRect, eventState, accent,
useSystemColors, dpiRatio, /* aIsMeter = */ true);
PaintProgress(aFrame, aPaintData, devPxRect, eventState, colors, dpiRatio,
/* aIsMeter = */ true);
break;
case StyleAppearance::Meterchunk:
/* Painted as part of the meter bar */
@ -1977,8 +1966,7 @@ bool nsNativeBasicTheme::DoDrawWidgetBackground(PaintBackendData& aPaintData,
aAppearance == StyleAppearance::ScrollbarthumbHorizontal;
return PaintScrollbarThumb(aPaintData, devPxRect, isHorizontal, aFrame,
*nsLayoutUtils::StyleForScrollbar(aFrame),
eventState, docState, useSystemColors,
dpiRatio);
eventState, docState, colors, dpiRatio);
}
case StyleAppearance::ScrollbartrackHorizontal:
case StyleAppearance::ScrollbartrackVertical: {
@ -1986,19 +1974,19 @@ bool nsNativeBasicTheme::DoDrawWidgetBackground(PaintBackendData& aPaintData,
aAppearance == StyleAppearance::ScrollbartrackHorizontal;
return PaintScrollbarTrack(aPaintData, devPxRect, isHorizontal, aFrame,
*nsLayoutUtils::StyleForScrollbar(aFrame),
docState, useSystemColors, dpiRatio);
docState, colors, dpiRatio);
}
case StyleAppearance::ScrollbarHorizontal:
case StyleAppearance::ScrollbarVertical: {
bool isHorizontal = aAppearance == StyleAppearance::ScrollbarHorizontal;
return PaintScrollbar(aPaintData, devPxRect, isHorizontal, aFrame,
*nsLayoutUtils::StyleForScrollbar(aFrame),
eventState, docState, useSystemColors, dpiRatio);
eventState, docState, colors, dpiRatio);
}
case StyleAppearance::Scrollcorner:
return PaintScrollCorner(aPaintData, devPxRect, aFrame,
*nsLayoutUtils::StyleForScrollbar(aFrame),
docState, useSystemColors, dpiRatio);
docState, colors, dpiRatio);
case StyleAppearance::ScrollbarbuttonUp:
case StyleAppearance::ScrollbarbuttonDown:
case StyleAppearance::ScrollbarbuttonLeft:
@ -2011,17 +1999,15 @@ bool nsNativeBasicTheme::DoDrawWidgetBackground(PaintBackendData& aPaintData,
} else {
PaintScrollbarButton(aPaintData, aAppearance, devPxRect, aFrame,
*nsLayoutUtils::StyleForScrollbar(aFrame),
eventState, docState, useSystemColors, dpiRatio);
eventState, docState, colors, dpiRatio);
}
}
break;
case StyleAppearance::Button:
PaintButton(aFrame, aPaintData, devPxRect, eventState, accent,
useSystemColors, dpiRatio);
PaintButton(aFrame, aPaintData, devPxRect, eventState, colors, dpiRatio);
break;
case StyleAppearance::FocusOutline:
PaintAutoStyleOutline(aFrame, aPaintData, devPxRect, accent,
useSystemColors, dpiRatio);
PaintAutoStyleOutline(aFrame, aPaintData, devPxRect, colors, dpiRatio);
break;
default:
// Various appearance values are used for XUL elements. Normally these
@ -2039,11 +2025,9 @@ template <typename PaintBackendData>
void nsNativeBasicTheme::PaintAutoStyleOutline(nsIFrame* aFrame,
PaintBackendData& aPaintData,
const LayoutDeviceRect& aRect,
const AccentColor& aAccent,
UseSystemColors aUseSystemColors,
const Colors& aColors,
DPIRatio aDpiRatio) {
auto [innerColor, middleColor, outerColor] =
ComputeFocusRectColors(aAccent, aUseSystemColors);
auto [innerColor, middleColor, outerColor] = ComputeFocusRectColors(aColors);
Unused << middleColor;
Unused << outerColor;
@ -2277,7 +2261,7 @@ nsNativeBasicTheme::GetMinimumWidgetSize(nsPresContext* aPresContext,
}
nsITheme::Transparency nsNativeBasicTheme::GetWidgetTransparency(
nsIFrame* aFrame, StyleAppearance aAppearance) {
nsIFrame*, StyleAppearance) {
return eUnknownTransparency;
}

110
widget/nsNativeBasicTheme.h
View File

@ -105,6 +105,7 @@ class nsNativeBasicTheme : protected nsNativeTheme, public nsITheme {
using LayoutDeviceCoord = mozilla::LayoutDeviceCoord;
using LayoutDeviceRect = mozilla::LayoutDeviceRect;
class AccentColor;
class Colors;
public:
static void Init();
@ -193,55 +194,49 @@ class nsNativeBasicTheme : protected nsNativeTheme, public nsITheme {
std::pair<sRGBColor, sRGBColor> ComputeCheckboxColors(const EventStates&,
StyleAppearance,
const AccentColor&,
UseSystemColors);
sRGBColor ComputeCheckmarkColor(const EventStates&, const AccentColor&,
UseSystemColors);
sRGBColor ComputeBorderColor(const EventStates&, UseSystemColors);
const Colors&);
sRGBColor ComputeCheckmarkColor(const EventStates&, const Colors&);
sRGBColor ComputeBorderColor(const EventStates&, const Colors&);
std::pair<sRGBColor, sRGBColor> ComputeButtonColors(const EventStates&,
UseSystemColors,
const Colors&,
nsIFrame* = nullptr);
std::pair<sRGBColor, sRGBColor> ComputeTextfieldColors(const EventStates&,
UseSystemColors);
const Colors&);
std::pair<sRGBColor, sRGBColor> ComputeRangeProgressColors(const EventStates&,
const AccentColor&,
UseSystemColors);
const Colors&);
std::pair<sRGBColor, sRGBColor> ComputeRangeTrackColors(const EventStates&,
UseSystemColors);
const Colors&);
std::pair<sRGBColor, sRGBColor> ComputeRangeThumbColors(const EventStates&,
const AccentColor&,
UseSystemColors);
std::pair<sRGBColor, sRGBColor> ComputeProgressColors(const AccentColor&,
UseSystemColors);
std::pair<sRGBColor, sRGBColor> ComputeProgressTrackColors(UseSystemColors);
const Colors&);
std::pair<sRGBColor, sRGBColor> ComputeProgressColors(const Colors&);
std::pair<sRGBColor, sRGBColor> ComputeProgressTrackColors(const Colors&);
std::pair<sRGBColor, sRGBColor> ComputeMeterchunkColors(
const EventStates& aMeterState, UseSystemColors);
std::array<sRGBColor, 3> ComputeFocusRectColors(const AccentColor&,
UseSystemColors);
const EventStates& aMeterState, const Colors&);
std::array<sRGBColor, 3> ComputeFocusRectColors(const Colors&);
static bool ShouldUseDarkScrollbar(nsIFrame*, const ComputedStyle&);
bool IsScrollbarTrackOpaque(nsIFrame*);
sRGBColor ComputeScrollbarTrackColor(nsIFrame*, const ComputedStyle&,
const EventStates& aDocumentState,
UseSystemColors);
const Colors&);
sRGBColor ComputeScrollbarThumbColor(nsIFrame*, const ComputedStyle&,
const EventStates& aElementState,
const EventStates& aDocumentState,
UseSystemColors);
const Colors&);
// Returned colors are button, arrow.
std::pair<sRGBColor, sRGBColor> ComputeScrollbarButtonColors(
nsIFrame*, StyleAppearance, const ComputedStyle&,
const EventStates& aElementState, const EventStates& aDocumentState,
UseSystemColors);
const Colors&);
template <typename PaintBackendData>
void PaintRoundedFocusRect(PaintBackendData&, const LayoutDeviceRect&,
const AccentColor&, UseSystemColors, DPIRatio,
CSSCoord aRadius, CSSCoord aOffset);
const Colors&, DPIRatio, CSSCoord aRadius,
CSSCoord aOffset);
template <typename PaintBackendData>
void PaintAutoStyleOutline(nsIFrame*, PaintBackendData&,
const LayoutDeviceRect&, const AccentColor&,
UseSystemColors, DPIRatio);
const LayoutDeviceRect&, const Colors&, DPIRatio);
static void PaintRoundedRectWithRadius(DrawTarget&,
const LayoutDeviceRect& aRect,
@ -273,13 +268,11 @@ class nsNativeBasicTheme : protected nsNativeTheme, public nsITheme {
const sRGBColor&);
void PaintCheckboxControl(DrawTarget& aDrawTarget, const LayoutDeviceRect&,
const EventStates&, const AccentColor&,
UseSystemColors, DPIRatio);
const EventStates&, const Colors&, DPIRatio);
void PaintCheckMark(DrawTarget&, const LayoutDeviceRect&, const EventStates&,
const AccentColor&, UseSystemColors);
const Colors&);
void PaintIndeterminateMark(DrawTarget&, const LayoutDeviceRect&,
const EventStates&, const AccentColor&,
UseSystemColors);
const EventStates&, const Colors&);
template <typename PaintBackendData>
void PaintStrokedCircle(PaintBackendData&, const LayoutDeviceRect&,
@ -297,50 +290,45 @@ class nsNativeBasicTheme : protected nsNativeTheme, public nsITheme {
CSSCoord aShadowBlurStdDev, DPIRatio);
template <typename PaintBackendData>
void PaintRadioControl(PaintBackendData&, const LayoutDeviceRect&,
const EventStates&, const AccentColor&,
UseSystemColors, DPIRatio);
const EventStates&, const Colors&, DPIRatio);
template <typename PaintBackendData>
void PaintRadioCheckmark(PaintBackendData&, const LayoutDeviceRect&,
const EventStates&, DPIRatio);
template <typename PaintBackendData>
void PaintTextField(PaintBackendData&, const LayoutDeviceRect&,
const EventStates&, const AccentColor& aAccent,
UseSystemColors, DPIRatio);
const EventStates&, const Colors&, DPIRatio);
template <typename PaintBackendData>
void PaintListbox(PaintBackendData&, const LayoutDeviceRect&,
const EventStates&, const AccentColor&, UseSystemColors,
DPIRatio);
const EventStates&, const Colors&, DPIRatio);
template <typename PaintBackendData>
void PaintMenulist(PaintBackendData&, const LayoutDeviceRect&,
const EventStates&, const AccentColor&, UseSystemColors,
DPIRatio);
const EventStates&, const Colors&, DPIRatio);
void PaintArrow(DrawTarget&, const LayoutDeviceRect&,
const float aArrowPolygonX[], const float aArrowPolygonY[],
const float aArrowPolygonSize, const int32_t aArrowNumPoints,
const sRGBColor aFillColor);
void PaintMenulistArrowButton(nsIFrame*, DrawTarget&, const LayoutDeviceRect&,
const EventStates&, UseSystemColors);
const EventStates&);
void PaintSpinnerButton(nsIFrame*, DrawTarget&, const LayoutDeviceRect&,
const EventStates&, StyleAppearance, UseSystemColors,
const EventStates&, StyleAppearance, const Colors&,
DPIRatio);
template <typename PaintBackendData>
void PaintRange(nsIFrame*, PaintBackendData&, const LayoutDeviceRect&,
const EventStates&, const AccentColor&, UseSystemColors,
DPIRatio, bool aHorizontal);
const EventStates&, const Colors&, DPIRatio,
bool aHorizontal);
template <typename PaintBackendData>
void PaintProgress(nsIFrame*, PaintBackendData&, const LayoutDeviceRect&,
const EventStates&, const AccentColor&, UseSystemColors,
DPIRatio, bool aIsMeter);
const EventStates&, const Colors&, DPIRatio,
bool aIsMeter);
template <typename PaintBackendData>
void PaintButton(nsIFrame*, PaintBackendData&, const LayoutDeviceRect&,
const EventStates&, const AccentColor&, UseSystemColors,
DPIRatio);
const EventStates&, const Colors&, DPIRatio);
void PaintScrollbarButton(DrawTarget&, StyleAppearance,
const LayoutDeviceRect&, nsIFrame*,
const ComputedStyle&,
const EventStates& aElementState,
const EventStates& aDocumentState, UseSystemColors,
const EventStates& aDocumentState, const Colors&,
DPIRatio);
virtual bool PaintScrollbarThumb(DrawTarget&, const LayoutDeviceRect&,
@ -348,44 +336,44 @@ class nsNativeBasicTheme : protected nsNativeTheme, public nsITheme {
const ComputedStyle&,
const EventStates& aElementState,
const EventStates& aDocumentState,
UseSystemColors, DPIRatio);
const Colors&, DPIRatio);
virtual bool PaintScrollbarThumb(WebRenderBackendData&,
const LayoutDeviceRect&, bool aHorizontal,
nsIFrame*, const ComputedStyle&,
const EventStates& aElementState,
const EventStates& aDocumentState,
UseSystemColors, DPIRatio);
const Colors&, DPIRatio);
template <typename PaintBackendData>
bool DoPaintDefaultScrollbarThumb(PaintBackendData&, const LayoutDeviceRect&,
bool aHorizontal, nsIFrame*,
const ComputedStyle&,
const EventStates& aElementState,
const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio);
const Colors&, DPIRatio);
virtual bool PaintScrollbar(DrawTarget&, const LayoutDeviceRect&,
bool aHorizontal, nsIFrame*, const ComputedStyle&,
const EventStates& aElementState,
const EventStates& aDocumentState,
UseSystemColors, DPIRatio);
const EventStates& aDocumentState, const Colors&,
DPIRatio);
virtual bool PaintScrollbar(WebRenderBackendData&, const LayoutDeviceRect&,
bool aHorizontal, nsIFrame*, const ComputedStyle&,
const EventStates& aElementState,
const EventStates& aDocumentState,
UseSystemColors, DPIRatio);
const EventStates& aDocumentState, const Colors&,
DPIRatio);
template <typename PaintBackendData>
bool DoPaintDefaultScrollbar(PaintBackendData&, const LayoutDeviceRect&,
bool aHorizontal, nsIFrame*,
const ComputedStyle&,
const EventStates& aElementState,
const EventStates& aDocumentState,
UseSystemColors aUseSystemColors, DPIRatio);
const EventStates& aDocumentState, const Colors&,
DPIRatio);
virtual bool PaintScrollbarTrack(DrawTarget&, const LayoutDeviceRect&,
bool aHorizontal, nsIFrame*,
const ComputedStyle&,
const EventStates& aDocumentState,
UseSystemColors, DPIRatio) {
const Colors&, DPIRatio) {
// Draw nothing by default. Subclasses can override this.
return true;
}
@ -393,7 +381,7 @@ class nsNativeBasicTheme : protected nsNativeTheme, public nsITheme {
const LayoutDeviceRect&, bool aHorizontal,
nsIFrame*, const ComputedStyle&,
const EventStates& aDocumentState,
UseSystemColors, DPIRatio) {
const Colors&, DPIRatio) {
// Draw nothing by default. Subclasses can override this.
return true;
}
@ -401,16 +389,16 @@ class nsNativeBasicTheme : protected nsNativeTheme, public nsITheme {
virtual bool PaintScrollCorner(DrawTarget&, const LayoutDeviceRect&,
nsIFrame*, const ComputedStyle&,
const EventStates& aDocumentState,
UseSystemColors, DPIRatio);
const Colors&, DPIRatio);
virtual bool PaintScrollCorner(WebRenderBackendData&, const LayoutDeviceRect&,
nsIFrame*, const ComputedStyle&,
const EventStates& aDocumentState,
UseSystemColors, DPIRatio);
const Colors&, DPIRatio);
template <typename PaintBackendData>
bool DoPaintDefaultScrollCorner(PaintBackendData&, const LayoutDeviceRect&,
nsIFrame*, const ComputedStyle&,
const EventStates& aDocumentState,
UseSystemColors, DPIRatio);
const Colors&, DPIRatio);
static CSSIntCoord sHorizontalScrollbarHeight;
static CSSIntCoord sVerticalScrollbarWidth;

3
widget/windows/nsNativeBasicThemeWin.h
View File

@ -13,8 +13,7 @@ class nsNativeBasicThemeWin : public nsNativeBasicTheme {
public:
nsNativeBasicThemeWin() = default;
Transparency GetWidgetTransparency(nsIFrame* aFrame,
StyleAppearance aAppearance) override;
Transparency GetWidgetTransparency(nsIFrame*, StyleAppearance) override;
protected:
virtual ~nsNativeBasicThemeWin() = default;