Source code

Revision control

Other Tools

/* -*- Mode: C++; tab-width: 40; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsNativeBasicTheme.h"
#include "nsCSSRendering.h"
#include "PathHelpers.h"
using namespace mozilla;
using namespace mozilla::widget;
using namespace mozilla::gfx;
NS_IMPL_ISUPPORTS_INHERITED(nsNativeBasicTheme, nsNativeTheme, nsITheme)
/* static */
uint32_t nsNativeBasicTheme::GetDPIRatio(nsIFrame* aFrame) {
return AppUnitsPerCSSPixel() / aFrame->PresContext()
->DeviceContext()
->AppUnitsPerDevPixelAtUnitFullZoom();
}
/* static */
bool nsNativeBasicTheme::IsDateTimeResetButton(nsIFrame* aFrame) {
if (!aFrame) {
return false;
}
nsIFrame* parent = aFrame->GetParent();
if (parent && (parent = parent->GetParent()) &&
(parent = parent->GetParent())) {
nsDateTimeControlFrame* dateTimeFrame = do_QueryFrame(parent);
if (dateTimeFrame) {
return true;
}
}
return false;
}
/* static */
bool nsNativeBasicTheme::IsDateTimeTextField(nsIFrame* aFrame) {
nsDateTimeControlFrame* dateTimeFrame = do_QueryFrame(aFrame);
return dateTimeFrame;
}
/* static */
bool nsNativeBasicTheme::IsColorPickerButton(nsIFrame* aFrame) {
nsColorControlFrame* colorPickerButton = do_QueryFrame(aFrame);
return colorPickerButton;
}
/* static */
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeCheckColors(
const EventStates& aState) {
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
bool isPressed = !isDisabled && aState.HasAllStates(NS_EVENT_STATE_HOVER |
NS_EVENT_STATE_ACTIVE);
bool isHovered = !isDisabled && aState.HasState(NS_EVENT_STATE_HOVER);
bool isChecked = aState.HasState(NS_EVENT_STATE_CHECKED);
sRGBColor fillColor = sColorWhite;
sRGBColor borderColor = sColorGrey40;
if (isDisabled) {
if (isChecked) {
fillColor = borderColor = sColorGrey40Alpha50;
} else {
fillColor = sColorWhiteAlpha50;
borderColor = sColorGrey40Alpha50;
}
} else {
if (isChecked) {
if (isPressed) {
fillColor = borderColor = sColorAccentDarker;
} else if (isHovered) {
fillColor = borderColor = sColorAccentDark;
} else {
fillColor = borderColor = sColorAccent;
}
} else if (isPressed) {
fillColor = sColorGrey20;
borderColor = sColorGrey60;
} else if (isHovered) {
fillColor = sColorWhite;
borderColor = sColorGrey50;
} else {
fillColor = sColorWhite;
borderColor = sColorGrey40;
}
}
return std::make_pair(fillColor, borderColor);
}
/* static */
Rect nsNativeBasicTheme::FixAspectRatio(const Rect& aRect) {
// Checkbox and radio need to preserve aspect-ratio for compat.
Rect rect(aRect);
if (rect.width == rect.height) {
return rect;
}
if (rect.width > rect.height) {
auto diff = rect.width - rect.height;
rect.width = rect.height;
rect.x += diff / 2;
} else {
auto diff = rect.height - rect.width;
rect.height = rect.width;
rect.y += diff / 2;
}
return rect;
}
/* static */
void nsNativeBasicTheme::GetFocusStrokeRect(DrawTarget* aDrawTarget,
Rect& aFocusRect, CSSCoord aOffset,
const CSSCoord aRadius,
CSSCoord aFocusWidth,
RefPtr<Path>& aOutRect) {
RectCornerRadii radii(aRadius, aRadius, aRadius, aRadius);
aFocusRect.y -= aOffset;
aFocusRect.x -= aOffset;
aFocusRect.width += 2.0f * aOffset;
aFocusRect.height += 2.0f * aOffset;
// Deflate the rect by half the border width, so that the middle of the
// stroke fills exactly the area we want to fill and not more.
Rect focusRect(aFocusRect);
focusRect.Deflate(aFocusWidth * 0.5f);
aOutRect = MakePathForRoundedRect(*aDrawTarget, focusRect, radii);
}
/* static */
void nsNativeBasicTheme::PaintRoundedFocusRect(DrawTarget* aDrawTarget,
const Rect& aRect,
uint32_t aDpiRatio,
CSSCoord aRadius,
CSSCoord aOffset) {
Rect focusRect(aRect);
RefPtr<Path> roundedRect;
CSSCoord offset = aOffset * aDpiRatio;
CSSCoord strokeRadius((aRadius * aDpiRatio) + offset);
CSSCoord strokeWidth(2.0f * aDpiRatio);
GetFocusStrokeRect(aDrawTarget, focusRect, offset, strokeRadius, strokeWidth,
roundedRect);
aDrawTarget->Stroke(roundedRect, ColorPattern(ToDeviceColor(sColorAccent)),
StrokeOptions(strokeWidth));
offset = 1.0f * aDpiRatio;
strokeRadius += offset;
strokeWidth = 1.0f * aDpiRatio;
GetFocusStrokeRect(aDrawTarget, focusRect, offset, strokeRadius, strokeWidth,
roundedRect);
aDrawTarget->Stroke(roundedRect,
ColorPattern(ToDeviceColor(sColorWhiteAlpha80)),
StrokeOptions(strokeWidth));
offset = 2.0f * aDpiRatio;
strokeRadius += offset;
strokeWidth = 2.0f * aDpiRatio;
GetFocusStrokeRect(aDrawTarget, focusRect, offset, strokeRadius, strokeWidth,
roundedRect);
aDrawTarget->Stroke(roundedRect,
ColorPattern(ToDeviceColor(sColorAccentLight)),
StrokeOptions(strokeWidth));
}
/* static */
void nsNativeBasicTheme::PaintRoundedRect(DrawTarget* aDrawTarget,
const Rect& aRect,
const sRGBColor& aBackgroundColor,
const sRGBColor& aBorderColor,
CSSCoord aBorderWidth,
RectCornerRadii aDpiAdjustedRadii,
uint32_t aDpiRatio) {
const CSSCoord borderWidth(aBorderWidth * aDpiRatio);
Rect rect(aRect);
// Deflate the rect by half the border width, so that the middle of the stroke
// fills exactly the area we want to fill and not more.
rect.Deflate(borderWidth * 0.5f);
RefPtr<Path> roundedRect =
MakePathForRoundedRect(*aDrawTarget, rect, aDpiAdjustedRadii);
aDrawTarget->Fill(roundedRect, ColorPattern(ToDeviceColor(aBackgroundColor)));
aDrawTarget->Stroke(roundedRect, ColorPattern(ToDeviceColor(aBorderColor)),
StrokeOptions(borderWidth));
}
/* static */
void nsNativeBasicTheme::PaintRoundedRectWithRadius(
DrawTarget* aDrawTarget, const Rect& aRect,
const sRGBColor& aBackgroundColor, const sRGBColor& aBorderColor,
CSSCoord aBorderWidth, CSSCoord aRadius, uint32_t aDpiRatio) {
const CSSCoord radius(aRadius * aDpiRatio);
RectCornerRadii radii(radius, radius, radius, radius);
PaintRoundedRect(aDrawTarget, aRect, aBackgroundColor, aBorderColor,
aBorderWidth, radii, aDpiRatio);
}
/* static */
void nsNativeBasicTheme::PaintCheckboxControl(DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
const CSSCoord borderWidth = 2.0f;
const CSSCoord radius = 3.0f - (borderWidth / 2.0f);
auto [backgroundColor, borderColor] = ComputeCheckColors(aState);
PaintRoundedRectWithRadius(aDrawTarget, aRect, backgroundColor, borderColor,
borderWidth, radius, aDpiRatio);
if (aState.HasState(NS_EVENT_STATE_FOCUS)) {
PaintRoundedFocusRect(aDrawTarget, aRect, aDpiRatio, radius, 3.0f);
}
}
/* static */
void nsNativeBasicTheme::PaintCheckMark(DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
// Points come from the coordinates on a 14X14 unit box centered at 0,0
const float checkPolygonX[] = {-4.5f, -1.5f, -0.5f, 5.0f, 4.75f,
3.5f, -0.5f, -1.5f, -3.5f};
const float checkPolygonY[] = {0.5f, 4.0f, 4.0f, -2.5f, -4.0f,
-4.0f, 1.0f, 1.25f, -1.0f};
const int32_t checkNumPoints = sizeof(checkPolygonX) / sizeof(float);
const float scale = aDpiRatio * std::min(aRect.width, aRect.height) /
(kMinimumWidgetSize * (float)aDpiRatio);
auto center = aRect.Center();
RefPtr<PathBuilder> builder = aDrawTarget->CreatePathBuilder();
Point p = center + Point(checkPolygonX[0] * scale, checkPolygonY[0] * scale);
builder->MoveTo(p);
for (int32_t i = 1; i < checkNumPoints; i++) {
p = center + Point(checkPolygonX[i] * scale, checkPolygonY[i] * scale);
builder->LineTo(p);
}
RefPtr<Path> path = builder->Finish();
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
sRGBColor fillColor = isDisabled ? sColorWhiteAlpha50 : sColorWhite;
aDrawTarget->Fill(path, ColorPattern(ToDeviceColor(fillColor)));
}
/* static */
void nsNativeBasicTheme::PaintIndeterminateMark(DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
const CSSCoord borderWidth = 2.0f;
const float scale = aDpiRatio * std::min(aRect.width, aRect.height) /
(kMinimumWidgetSize * (float)aDpiRatio);
Rect rect(aRect);
rect.y += (rect.height / 2) - (borderWidth * scale / 2);
rect.height = borderWidth * scale;
rect.x += (borderWidth * scale) + (borderWidth * scale / 8);
rect.width -= ((borderWidth * scale) + (borderWidth * scale / 8)) * 2;
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
sRGBColor fillColor = isDisabled ? sColorWhiteAlpha50 : sColorWhite;
aDrawTarget->FillRect(rect, ColorPattern(ToDeviceColor(fillColor)));
}
/* static */
void nsNativeBasicTheme::PaintStrokedEllipse(DrawTarget* aDrawTarget,
const Rect& aRect,
const sRGBColor& aBackgroundColor,
const sRGBColor& aBorderColor,
const CSSCoord aBorderWidth,
uint32_t aDpiRatio) {
const CSSCoord borderWidth(aBorderWidth * aDpiRatio);
RefPtr<PathBuilder> builder = aDrawTarget->CreatePathBuilder();
// Deflate for the same reason as PaintRoundedRectWithRadius. Note that the
// size is the diameter, so we just shrink by the border width once.
Size size(aRect.Size() - Size(borderWidth, borderWidth));
AppendEllipseToPath(builder, aRect.Center(), size);
RefPtr<Path> ellipse = builder->Finish();
aDrawTarget->Fill(ellipse, ColorPattern(ToDeviceColor(aBackgroundColor)));
aDrawTarget->Stroke(ellipse, ColorPattern(ToDeviceColor(aBorderColor)),
StrokeOptions(borderWidth));
}
/* static */
void nsNativeBasicTheme::PaintRadioControl(DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
const CSSCoord borderWidth = 2.0f;
auto [backgroundColor, borderColor] = ComputeCheckColors(aState);
PaintStrokedEllipse(aDrawTarget, aRect, backgroundColor, borderColor,
borderWidth, aDpiRatio);
if (aState.HasState(NS_EVENT_STATE_FOCUS)) {
PaintRoundedFocusRect(aDrawTarget, aRect, aDpiRatio, 2.0f, 3.0f);
}
}
/* static */
void nsNativeBasicTheme::PaintRadioCheckMark(DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
const CSSCoord borderWidth = 2.0f;
const float scale = aDpiRatio * std::min(aRect.width, aRect.height) /
(kMinimumWidgetSize * (float)aDpiRatio);
auto [unusedColor, checkColor] = ComputeCheckColors(aState);
(void)unusedColor;
Rect rect(aRect);
rect.y += borderWidth * scale;
rect.x += borderWidth * scale;
rect.height -= borderWidth * scale * 2;
rect.width -= borderWidth * scale * 2;
PaintStrokedEllipse(aDrawTarget, rect, checkColor, sColorWhite, borderWidth,
aDpiRatio);
}
/* static */
sRGBColor nsNativeBasicTheme::ComputeBorderColor(const EventStates& aState) {
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
bool isActive =
aState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE);
bool isHovered = !isDisabled && aState.HasState(NS_EVENT_STATE_HOVER);
bool isFocused = aState.HasState(NS_EVENT_STATE_FOCUS);
if (isDisabled) {
return sColorGrey40Alpha50;
}
if (isFocused) {
return sColorAccent;
}
if (isActive) {
return sColorGrey60;
}
if (isHovered) {
return sColorGrey50;
}
return sColorGrey40;
}
/* static */
void nsNativeBasicTheme::PaintTextField(DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
const sRGBColor& backgroundColor =
isDisabled ? sColorWhiteAlpha50 : sColorWhite;
const sRGBColor borderColor = ComputeBorderColor(aState);
const CSSCoord radius = 2.0f;
PaintRoundedRectWithRadius(aDrawTarget, aRect, backgroundColor, borderColor,
kTextFieldBorderWidth, radius, aDpiRatio);
if (aState.HasState(NS_EVENT_STATE_FOCUS)) {
PaintRoundedFocusRect(aDrawTarget, aRect, aDpiRatio, radius, 0.0f);
}
}
/* static */
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeButtonColors(
const EventStates& aState, nsIFrame* aFrame) {
bool isActive =
aState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE);
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
bool isHovered = !isDisabled && aState.HasState(NS_EVENT_STATE_HOVER);
const sRGBColor& backgroundColor = [&] {
if (isDisabled) {
return sColorGrey10Alpha50;
}
if (IsDateTimeResetButton(aFrame)) {
return sColorWhite;
}
if (isActive) {
return sColorGrey30;
}
if (isHovered) {
return sColorGrey20;
}
return sColorGrey10;
}();
const sRGBColor borderColor = ComputeBorderColor(aState);
return std::make_pair(backgroundColor, borderColor);
}
sRGBColor nsNativeBasicTheme::ComputeRangeProgressBorderColor(
const EventStates& aState) {
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
bool isActive =
aState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE);
bool isHovered = !isDisabled && aState.HasState(NS_EVENT_STATE_HOVER);
if (isDisabled) {
return sColorGrey40Alpha50;
}
if (isActive || isHovered) {
return sColorAccentDarker;
}
return sColorAccentDark;
}
/* static */
sRGBColor nsNativeBasicTheme::ComputeRangeTrackBorderColor(
const EventStates& aState) {
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
bool isActive =
aState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE);
bool isHovered = !isDisabled && aState.HasState(NS_EVENT_STATE_HOVER);
if (isDisabled) {
return sColorGrey40Alpha50;
}
if (isActive || isHovered) {
return sColorGrey50;
}
return sColorGrey40;
}
/* static */
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeRangeProgressColors(
const EventStates& aState) {
bool isActive =
aState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE);
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
bool isHovered = !isDisabled && aState.HasState(NS_EVENT_STATE_HOVER);
const sRGBColor& backgroundColor = [&] {
if (isDisabled) {
return sColorGrey40Alpha50;
}
if (isActive || isHovered) {
return sColorAccentDark;
}
return sColorAccent;
}();
const sRGBColor borderColor = ComputeRangeProgressBorderColor(aState);
return std::make_pair(backgroundColor, borderColor);
}
/* static */
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeRangeTrackColors(
const EventStates& aState) {
bool isActive =
aState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE);
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
bool isHovered = !isDisabled && aState.HasState(NS_EVENT_STATE_HOVER);
const sRGBColor& backgroundColor = [&] {
if (isDisabled) {
return sColorGrey10Alpha50;
}
if (isActive || isHovered) {
return sColorGrey20;
}
return sColorGrey10;
}();
const sRGBColor borderColor = ComputeRangeTrackBorderColor(aState);
return std::make_pair(backgroundColor, borderColor);
}
/* static */
std::pair<sRGBColor, sRGBColor> nsNativeBasicTheme::ComputeRangeThumbColors(
const EventStates& aState) {
bool isActive =
aState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE);
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
bool isHovered = !isDisabled && aState.HasState(NS_EVENT_STATE_HOVER);
const sRGBColor& backgroundColor = [&] {
if (isDisabled) {
return sColorGrey50Alpha50;
}
if (isActive) {
return sColorAccent;
}
if (isHovered) {
return sColorGrey60;
}
return sColorGrey50;
}();
const sRGBColor borderColor = sColorWhite;
return std::make_pair(backgroundColor, borderColor);
}
/* static */
void nsNativeBasicTheme::PaintListbox(DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
const CSSCoord radius = 2.0f;
auto [unusedColor, borderColor] = ComputeButtonColors(aState);
(void)unusedColor;
PaintRoundedRectWithRadius(aDrawTarget, aRect, sColorWhite, borderColor,
kMenulistBorderWidth, radius, aDpiRatio);
if (aState.HasState(NS_EVENT_STATE_FOCUS)) {
PaintRoundedFocusRect(aDrawTarget, aRect, aDpiRatio, radius, 0.0f);
}
}
/* static */
void nsNativeBasicTheme::PaintMenulist(DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
const CSSCoord radius = 4.0f;
auto [backgroundColor, borderColor] = ComputeButtonColors(aState);
PaintRoundedRectWithRadius(aDrawTarget, aRect, backgroundColor, borderColor,
kMenulistBorderWidth, radius, aDpiRatio);
if (aState.HasState(NS_EVENT_STATE_FOCUS)) {
PaintRoundedFocusRect(aDrawTarget, aRect, aDpiRatio, radius, 0.0f);
}
}
/* static */
void nsNativeBasicTheme::PaintArrow(
DrawTarget* aDrawTarget, const Rect& aRect, const int32_t aArrowPolygonX[],
const int32_t aArrowPolygonY[], const int32_t aArrowNumPoints,
const int32_t aArrowSize, const sRGBColor aFillColor, uint32_t aDpiRatio) {
nscoord paintScale = std::min(aRect.width, aRect.height) / aArrowSize;
RefPtr<PathBuilder> builder = aDrawTarget->CreatePathBuilder();
Point p = aRect.Center() + Point(aArrowPolygonX[0] * paintScale,
aArrowPolygonY[0] * paintScale);
builder->MoveTo(p);
for (int32_t polyIndex = 1; polyIndex < aArrowNumPoints; polyIndex++) {
p = aRect.Center() + Point(aArrowPolygonX[polyIndex] * paintScale,
aArrowPolygonY[polyIndex] * paintScale);
builder->LineTo(p);
}
RefPtr<Path> path = builder->Finish();
aDrawTarget->Stroke(path, ColorPattern(ToDeviceColor(aFillColor)),
StrokeOptions(2.0f * aDpiRatio));
}
/* static */
void nsNativeBasicTheme::PaintMenulistArrowButton(nsIFrame* aFrame,
DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
const float arrowPolygonX[] = {-3.5f, -0.5f, 0.5f, 3.5f, 3.5f,
3.0f, 0.5f, -0.5f, -3.0f, -3.5};
const float arrowPolygonY[] = {-0.5f, 2.5f, 2.5f, -0.5f, -2.0f,
-2.0f, 1.0f, 1.0f, -2.0f, -2.0f};
const int32_t arrowNumPoints = sizeof(arrowPolygonX) / sizeof(float);
const float scale = aDpiRatio * std::min(aRect.width, aRect.height) /
(kMinimumWidgetSize * (float)aDpiRatio);
auto center = aRect.Center();
RefPtr<PathBuilder> builder = aDrawTarget->CreatePathBuilder();
Point p = center + Point(arrowPolygonX[0] * scale, arrowPolygonY[0] * scale);
builder->MoveTo(p);
for (int32_t i = 1; i < arrowNumPoints; i++) {
p = center + Point(arrowPolygonX[i] * scale, arrowPolygonY[i] * scale);
builder->LineTo(p);
}
RefPtr<Path> path = builder->Finish();
bool isDisabled = aState.HasState(NS_EVENT_STATE_DISABLED);
sRGBColor fillColor = isDisabled ? sColorGrey60Alpha50 : sColorGrey60;
aDrawTarget->Fill(path, ColorPattern(ToDeviceColor(fillColor)));
}
/* static */
void nsNativeBasicTheme::PaintSpinnerButton(nsIFrame* aFrame,
DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
StyleAppearance aAppearance,
uint32_t aDpiRatio) {
auto [backgroundColor, borderColor] = ComputeButtonColors(aState);
RefPtr<Path> pathRect = MakePathForRect(*aDrawTarget, aRect);
aDrawTarget->Fill(pathRect, ColorPattern(ToDeviceColor(backgroundColor)));
RefPtr<PathBuilder> builder = aDrawTarget->CreatePathBuilder();
Point p;
if (IsFrameRTL(aFrame)) {
p = Point(aRect.x + aRect.width - 0.5f, aRect.y);
} else {
p = Point(aRect.x - 0.5f, aRect.y);
}
builder->MoveTo(p);
p = Point(p.x, p.y + aRect.height);
builder->LineTo(p);
RefPtr<Path> path = builder->Finish();
aDrawTarget->Stroke(path, ColorPattern(ToDeviceColor(borderColor)),
StrokeOptions(kSpinnerBorderWidth * aDpiRatio));
const float arrowPolygonX[] = {-3.5f, -0.5f, 0.5f, 3.5f, 3.5f,
3.0f, 0.5f, -0.5f, -3.0f, -3.5};
float arrowPolygonY[] = {-3.5f, -0.5f, -0.5f, -3.5f, -5.0f,
-5.0f, -2.0f, -2.0f, -5.0f, -5.0f};
const int32_t arrowNumPoints = sizeof(arrowPolygonX) / sizeof(float);
const float scale = aDpiRatio * std::min(aRect.width, aRect.height) /
(kMinimumWidgetSize * (float)aDpiRatio);
if (aAppearance == StyleAppearance::SpinnerUpbutton) {
for (int32_t i = 0; i < arrowNumPoints; i++) {
arrowPolygonY[i] *= -1;
}
}
auto center = aRect.Center();
builder = aDrawTarget->CreatePathBuilder();
p = center + Point(arrowPolygonX[0] * scale, arrowPolygonY[0] * scale);
builder->MoveTo(p);
for (int32_t i = 1; i < arrowNumPoints; i++) {
p = center + Point(arrowPolygonX[i] * scale, arrowPolygonY[i] * scale);
builder->LineTo(p);
}
path = builder->Finish();
aDrawTarget->Fill(path, ColorPattern(ToDeviceColor(borderColor)));
}
/* static */
void nsNativeBasicTheme::PaintRangeTrackBackground(
nsIFrame* aFrame, DrawTarget* aDrawTarget, const Rect& aRect,
const EventStates& aState, uint32_t aDpiRatio, bool aHorizontal) {
nsRangeFrame* rangeFrame = do_QueryFrame(aFrame);
if (!rangeFrame) {
return;
}
Rect rect(aRect);
const CSSCoord verticalSize = kRangeHeight * aDpiRatio;
if (aHorizontal) {
rect.y += (rect.height - verticalSize) / 2;
rect.height = verticalSize;
} else {
rect.x += (rect.width - verticalSize) / 2;
rect.width = verticalSize;
}
double progress = rangeFrame->GetValueAsFractionOfRange();
Rect progressRect(rect);
Rect trackRect(rect);
if (aHorizontal) {
progressRect.width = rect.width * progress;
if (IsFrameRTL(aFrame)) {
progressRect.x += rect.width - progressRect.width;
} else {
trackRect.x += progressRect.width;
}
trackRect.width -= progressRect.width;
} else {
progressRect.height = rect.height * progress;
progressRect.y += rect.height - progressRect.height;
trackRect.height -= progressRect.height;
}
const CSSCoord borderWidth = 1.0f;
const CSSCoord radius = 2.0f;
// Avoid artifacts between thumb and track when progress is approaching
// 0.0f or 1.0f.
if ((aHorizontal && ((progressRect.width > (radius * 2.0f)))) ||
(!aHorizontal && ((progressRect.height > radius * 2.0f)))) {
sRGBColor progressColor, progressBorderColor;
std::tie(progressColor, progressBorderColor) =
ComputeRangeProgressColors(aState);
PaintRoundedRectWithRadius(aDrawTarget, progressRect, progressColor,
progressBorderColor, borderWidth, radius,
aDpiRatio);
}
if ((aHorizontal && ((trackRect.width > (radius * 2.0f)))) ||
(!aHorizontal && (trackRect.height > (radius * 2.0f)))) {
sRGBColor trackColor, trackBorderColor;
std::tie(trackColor, trackBorderColor) = ComputeRangeTrackColors(aState);
PaintRoundedRectWithRadius(aDrawTarget, trackRect, trackColor,
trackBorderColor, borderWidth, radius,
aDpiRatio);
}
if (aState.HasState(NS_EVENT_STATE_FOCUS)) {
PaintRoundedFocusRect(aDrawTarget, aRect, aDpiRatio, radius, 3.0f);
}
}
/* static */
void nsNativeBasicTheme::PaintRangeThumb(DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
const CSSCoord borderWidth = 2.0f;
auto [backgroundColor, borderColor] = ComputeRangeThumbColors(aState);
PaintStrokedEllipse(aDrawTarget, aRect, backgroundColor, borderColor,
borderWidth, aDpiRatio);
// TODO: Paint thumb shadow.
}
/* static */
void nsNativeBasicTheme::PaintProgressBar(DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
const CSSCoord borderWidth = 1.0f;
const CSSCoord radius = 2.0f;
Rect rect(aRect);
const CSSCoord height = kProgressbarHeight * aDpiRatio;
rect.y += (rect.height - height) / 2;
rect.height = height;
PaintRoundedRectWithRadius(aDrawTarget, rect, sColorGrey10, sColorGrey40,
borderWidth, radius, aDpiRatio);
}
/* static */
void nsNativeBasicTheme::PaintProgresschunk(nsIFrame* aFrame,
DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
// TODO: vertical?
// TODO: Address artifacts when position is between 0 and radius + border.
// TODO: Handle indeterminate case.
nsProgressFrame* progressFrame = do_QueryFrame(aFrame->GetParent());
if (!progressFrame) {
return;
}
const CSSCoord borderWidth = 1.0f;
const CSSCoord radius = 2.0f * aDpiRatio;
CSSCoord progressEndRadius = 0.0f;
Rect rect(aRect);
const CSSCoord height = kProgressbarHeight * aDpiRatio;
rect.y += (rect.height - height) / 2;
rect.height = height;
double position = GetProgressValue(aFrame) / GetProgressMaxValue(aFrame);
if (rect.width - (rect.width * position) < (borderWidth + radius)) {
// Round corners when the progress chunk approaches the maximum value to
// avoid artifacts.
progressEndRadius = radius;
}
RectCornerRadii radii;
if (IsFrameRTL(aFrame)) {
radii =
RectCornerRadii(progressEndRadius, radius, radius, progressEndRadius);
} else {
radii =
RectCornerRadii(radius, progressEndRadius, progressEndRadius, radius);
}
PaintRoundedRect(aDrawTarget, rect, sColorAccent, sColorAccentDark,
borderWidth, radii, aDpiRatio);
}
/* static */
void nsNativeBasicTheme::PaintMeter(DrawTarget* aDrawTarget, const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
const CSSCoord borderWidth = 1.0f;
const CSSCoord radius = 5.0f;
Rect rect(aRect);
const CSSCoord height = kMeterHeight * aDpiRatio;
rect.y += (rect.height - height) / 2;
rect.height = height;
PaintRoundedRectWithRadius(aDrawTarget, rect, sColorGrey10, sColorGrey40,
borderWidth, radius, aDpiRatio);
}
/* static */
void nsNativeBasicTheme::PaintMeterchunk(nsIFrame* aFrame,
DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
// TODO: Address artifacts when position is between 0 and (radius + border).
nsMeterFrame* meterFrame = do_QueryFrame(aFrame->GetParent());
if (!meterFrame) {
return;
}
const CSSCoord borderWidth = 1.0f;
const CSSCoord radius = 5.0f * aDpiRatio;
CSSCoord progressEndRadius = 0.0f;
Rect rect(aRect);
const CSSCoord height = kMeterHeight * aDpiRatio;
rect.y += (rect.height - height) / 2;
rect.height = height;
auto* meter =
static_cast<mozilla::dom::HTMLMeterElement*>(meterFrame->GetContent());
double value = meter->Value();
double max = meter->Max();
double position = value / max;
if (rect.width - (rect.width * position) < (borderWidth + radius)) {
// Round corners when the progress chunk approaches the maximum value to
// avoid artifacts.
progressEndRadius = radius;
}
RectCornerRadii radii;
if (IsFrameRTL(aFrame)) {
radii =
RectCornerRadii(progressEndRadius, radius, radius, progressEndRadius);
} else {
radii =
RectCornerRadii(radius, progressEndRadius, progressEndRadius, radius);
}
sRGBColor borderColor = sColorMeterGreen20;
sRGBColor chunkColor = sColorMeterGreen10;
double optimum = meter->Optimum();
if (value < optimum) {
double low = meter->Low();
if (value < low) {
borderColor = sColorMeterRed20;
chunkColor = sColorMeterRed10;
} else {
borderColor = sColorMeterYellow20;
chunkColor = sColorMeterYellow10;
}
}
PaintRoundedRect(aDrawTarget, rect, chunkColor, borderColor, borderWidth,
radii, aDpiRatio);
}
void nsNativeBasicTheme::PaintButton(nsIFrame* aFrame, DrawTarget* aDrawTarget,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
const CSSCoord radius = 4.0f;
auto [backgroundColor, borderColor] = ComputeButtonColors(aState, aFrame);
PaintRoundedRectWithRadius(aDrawTarget, aRect, backgroundColor, borderColor,
kButtonBorderWidth, radius, aDpiRatio);
if (aState.HasState(NS_EVENT_STATE_FOCUS)) {
PaintRoundedFocusRect(aDrawTarget, aRect, aDpiRatio, radius, 0.0f);
}
}
void nsNativeBasicTheme::PaintScrollbarthumbHorizontal(
DrawTarget* aDrawTarget, const Rect& aRect, const EventStates& aState) {
sRGBColor thumbColor = sScrollbarThumbColor;
if (aState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE)) {
thumbColor = sScrollbarThumbColorActive;
} else if (aState.HasState(NS_EVENT_STATE_HOVER)) {
thumbColor = sScrollbarThumbColorHover;
}
aDrawTarget->FillRect(aRect, ColorPattern(ToDeviceColor(thumbColor)));
}
void nsNativeBasicTheme::PaintScrollbarthumbVertical(
DrawTarget* aDrawTarget, const Rect& aRect, const EventStates& aState) {
sRGBColor thumbColor = sScrollbarThumbColor;
if (aState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE)) {
thumbColor = sScrollbarThumbColorActive;
} else if (aState.HasState(NS_EVENT_STATE_HOVER)) {
thumbColor = sScrollbarThumbColorHover;
}
aDrawTarget->FillRect(aRect, ColorPattern(ToDeviceColor(thumbColor)));
}
void nsNativeBasicTheme::PaintScrollbarHorizontal(DrawTarget* aDrawTarget,
const Rect& aRect) {
aDrawTarget->FillRect(aRect, ColorPattern(ToDeviceColor(sScrollbarColor)));
RefPtr<PathBuilder> builder = aDrawTarget->CreatePathBuilder();
builder->MoveTo(Point(aRect.x, aRect.y));
builder->LineTo(Point(aRect.x + aRect.width, aRect.y));
RefPtr<Path> path = builder->Finish();
aDrawTarget->Stroke(path, ColorPattern(ToDeviceColor(sScrollbarBorderColor)));
}
void nsNativeBasicTheme::PaintScrollbarVerticalAndCorner(
DrawTarget* aDrawTarget, const Rect& aRect, uint32_t aDpiRatio) {
aDrawTarget->FillRect(aRect, ColorPattern(ToDeviceColor(sScrollbarColor)));
RefPtr<PathBuilder> builder = aDrawTarget->CreatePathBuilder();
builder->MoveTo(Point(aRect.x, aRect.y));
builder->LineTo(Point(aRect.x, aRect.y + aRect.height));
RefPtr<Path> path = builder->Finish();
aDrawTarget->Stroke(path, ColorPattern(ToDeviceColor(sScrollbarBorderColor)),
StrokeOptions(1.0f * aDpiRatio));
}
void nsNativeBasicTheme::PaintScrollbarbutton(DrawTarget* aDrawTarget,
StyleAppearance aAppearance,
const Rect& aRect,
const EventStates& aState,
uint32_t aDpiRatio) {
bool isActive =
aState.HasAllStates(NS_EVENT_STATE_HOVER | NS_EVENT_STATE_ACTIVE);
bool isHovered = aState.HasState(NS_EVENT_STATE_HOVER);
aDrawTarget->FillRect(
aRect, ColorPattern(
ToDeviceColor(isActive ? sScrollbarButtonActiveColor
: isHovered ? sScrollbarButtonHoverColor
: sScrollbarColor)));
// Start with Up arrow.
int32_t arrowPolygonX[] = {3, 0, -3};
int32_t arrowPolygonY[] = {2, -1, 2};
const int32_t arrowNumPoints = sizeof(arrowPolygonX) / sizeof(int32_t);
const int32_t arrowSize = 14;
switch (aAppearance) {
case StyleAppearance::ScrollbarbuttonUp:
break;
case StyleAppearance::ScrollbarbuttonDown:
for (int32_t i = 0; i < arrowNumPoints; i++) {
arrowPolygonY[i] *= -1;
}
break;
case StyleAppearance::ScrollbarbuttonLeft:
for (int32_t i = 0; i < arrowNumPoints; i++) {
int32_t temp = arrowPolygonX[i];
arrowPolygonX[i] = arrowPolygonY[i];
arrowPolygonY[i] = temp;
}
break;
case StyleAppearance::ScrollbarbuttonRight:
for (int32_t i = 0; i < arrowNumPoints; i++) {
int32_t temp = arrowPolygonX[i];
arrowPolygonX[i] = arrowPolygonY[i] * -1;
arrowPolygonY[i] = temp;
}
break;
default:
return;
}
PaintArrow(aDrawTarget, aRect, arrowPolygonX, arrowPolygonY, arrowNumPoints,
arrowSize,
isActive
? sScrollbarArrowColorActive
: isHovered ? sScrollbarArrowColorHover : sScrollbarArrowColor,
aDpiRatio);
RefPtr<PathBuilder> builder = aDrawTarget->CreatePathBuilder();
builder->MoveTo(Point(aRect.x, aRect.y));
if (aAppearance == StyleAppearance::ScrollbarbuttonUp ||
aAppearance == StyleAppearance::ScrollbarbuttonDown) {
builder->LineTo(Point(aRect.x, aRect.y + aRect.height));
} else {
builder->LineTo(Point(aRect.x + aRect.width, aRect.y));
}
RefPtr<Path> path = builder->Finish();
aDrawTarget->Stroke(path, ColorPattern(ToDeviceColor(sScrollbarBorderColor)),
StrokeOptions(1.0f * aDpiRatio));
}
NS_IMETHODIMP
nsNativeBasicTheme::DrawWidgetBackground(gfxContext* aContext, nsIFrame* aFrame,
StyleAppearance aAppearance,
const nsRect& aRect,
const nsRect& /* aDirtyRect */) {
DrawTarget* dt = aContext->GetDrawTarget();
const nscoord twipsPerPixel = aFrame->PresContext()->AppUnitsPerDevPixel();
EventStates eventState = GetContentState(aFrame, aAppearance);
Rect devPxRect = NSRectToSnappedRect(aRect, twipsPerPixel, *dt);
if (aAppearance == StyleAppearance::MozMenulistArrowButton) {
bool isHTML = IsHTMLContent(aFrame);
nsIFrame* parentFrame = aFrame->GetParent();
bool isMenulist = !isHTML && parentFrame->IsMenuFrame();
// HTML select and XUL menulist dropdown buttons get state from the
// parent.
if (isHTML || isMenulist) {
aFrame = parentFrame;
eventState = GetContentState(parentFrame, aAppearance);
}
}
uint32_t dpiRatio = GetDPIRatio(aFrame);
switch (aAppearance) {
case StyleAppearance::Radio: {
auto rect = FixAspectRatio(devPxRect);
PaintRadioControl(dt, rect, eventState, dpiRatio);
if (IsSelected(aFrame)) {
PaintRadioCheckMark(dt, rect, eventState, dpiRatio);
}
break;
}
case StyleAppearance::Checkbox: {
auto rect = FixAspectRatio(devPxRect);
PaintCheckboxControl(dt, rect, eventState, dpiRatio);
if (GetIndeterminate(aFrame)) {
PaintIndeterminateMark(dt, rect, eventState, dpiRatio);
} else if (IsChecked(aFrame)) {
PaintCheckMark(dt, rect, eventState, dpiRatio);
}
break;
}
case StyleAppearance::Textarea:
case StyleAppearance::Textfield:
case StyleAppearance::NumberInput:
PaintTextField(dt, devPxRect, eventState, dpiRatio);
break;
case StyleAppearance::Listbox:
PaintListbox(dt, devPxRect, eventState, dpiRatio);
break;
case StyleAppearance::MenulistButton:
case StyleAppearance::Menulist:
PaintMenulist(dt, devPxRect, eventState, dpiRatio);
break;
case StyleAppearance::MozMenulistArrowButton:
PaintMenulistArrowButton(aFrame, dt, devPxRect, eventState, dpiRatio);
break;
case StyleAppearance::SpinnerUpbutton:
case StyleAppearance::SpinnerDownbutton:
PaintSpinnerButton(aFrame, dt, devPxRect, eventState, aAppearance,
dpiRatio);
break;
case StyleAppearance::Range:
PaintRangeTrackBackground(aFrame, dt, devPxRect, eventState, dpiRatio,
IsRangeHorizontal(aFrame));
break;
case StyleAppearance::RangeThumb:
PaintRangeThumb(dt, devPxRect, eventState, dpiRatio);
break;
case StyleAppearance::ProgressBar:
PaintProgressBar(dt, devPxRect, eventState, dpiRatio);
break;
case StyleAppearance::Progresschunk:
PaintProgresschunk(aFrame, dt, devPxRect, eventState, dpiRatio);
break;
case StyleAppearance::Meter:
PaintMeter(dt, devPxRect, eventState, dpiRatio);
break;
case StyleAppearance::Meterchunk:
PaintMeterchunk(aFrame, dt, devPxRect, eventState, dpiRatio);
break;
case StyleAppearance::ScrollbarthumbHorizontal:
PaintScrollbarthumbHorizontal(dt, devPxRect, eventState);
break;
case StyleAppearance::ScrollbarthumbVertical:
PaintScrollbarthumbVertical(dt, devPxRect, eventState);
break;
case StyleAppearance::ScrollbarHorizontal:
PaintScrollbarHorizontal(dt, devPxRect);
break;
case StyleAppearance::ScrollbarVertical:
case StyleAppearance::Scrollcorner:
PaintScrollbarVerticalAndCorner(dt, devPxRect, dpiRatio);
break;
case StyleAppearance::ScrollbarbuttonUp:
case StyleAppearance::ScrollbarbuttonDown:
case StyleAppearance::ScrollbarbuttonLeft:
case StyleAppearance::ScrollbarbuttonRight:
PaintScrollbarbutton(dt, aAppearance, devPxRect, eventState, dpiRatio);
break;
case StyleAppearance::Button:
PaintButton(aFrame, dt, devPxRect, eventState, dpiRatio);
break;
default:
MOZ_ASSERT_UNREACHABLE(
"Should not get here with a widget type we don't support.");
return NS_ERROR_NOT_IMPLEMENTED;
}
return NS_OK;
}
/*bool
nsNativeBasicTheme::CreateWebRenderCommandsForWidget(mozilla::wr::DisplayListBuilder&
aBuilder, mozilla::wr::IpcResourceUpdateQueue& aResources, const
mozilla::layers::StackingContextHelper& aSc,
mozilla::layers::RenderRootStateManager*
aManager, nsIFrame* aFrame, StyleAppearance aAppearance, const nsRect& aRect) {
}*/
LayoutDeviceIntMargin nsNativeBasicTheme::GetWidgetBorder(
nsDeviceContext* aContext, nsIFrame* aFrame, StyleAppearance aAppearance) {
uint32_t dpiRatio = GetDPIRatio(aFrame);
switch (aAppearance) {
case StyleAppearance::Textfield:
case StyleAppearance::Textarea:
case StyleAppearance::NumberInput: {
LayoutDeviceIntCoord w = kTextFieldBorderWidth * dpiRatio;
return LayoutDeviceIntMargin(w, w, w, w);
}
case StyleAppearance::Listbox:
case StyleAppearance::Menulist:
case StyleAppearance::MenulistButton: {
const LayoutDeviceIntCoord w = kMenulistBorderWidth * dpiRatio;
return LayoutDeviceIntMargin(w, w, w, w);
}
case StyleAppearance::Button: {
LayoutDeviceIntCoord w = kButtonBorderWidth * dpiRatio;
return LayoutDeviceIntMargin(w, w, w, w);
}
default:
return LayoutDeviceIntMargin();
}
}
bool nsNativeBasicTheme::GetWidgetPadding(nsDeviceContext* aContext,
nsIFrame* aFrame,
StyleAppearance aAppearance,
LayoutDeviceIntMargin* aResult) {
switch (aAppearance) {
// Radios and checkboxes return a fixed size in GetMinimumWidgetSize
// and have a meaningful baseline, so they can't have
// author-specified padding.
case StyleAppearance::Radio:
case StyleAppearance::Checkbox:
aResult->SizeTo(0, 0, 0, 0);
return true;
default:
break;
}
// Respect author padding.
//
// TODO(emilio): Consider just unconditionally returning false, so that the
// default size of all elements matches other platforms and the UA stylesheet.
if (aFrame->PresContext()->HasAuthorSpecifiedRules(
aFrame, NS_AUTHOR_SPECIFIED_PADDING)) {
return false;
}
uint32_t dpiRatio = GetDPIRatio(aFrame);
switch (aAppearance) {
case StyleAppearance::Listbox:
case StyleAppearance::Menulist:
aResult->SizeTo(0, 0, 0, 0);
return true;
case StyleAppearance::NumberInput:
if (IsFrameRTL(aFrame)) {
aResult->SizeTo(1 * dpiRatio, 4 * dpiRatio, 1 * dpiRatio, 0);
} else {
aResult->SizeTo(1 * dpiRatio, 0, 1 * dpiRatio, 4 * dpiRatio);
}
return true;
case StyleAppearance::Textarea:
case StyleAppearance::MozMenulistArrowButton:
case StyleAppearance::Menuitemtext:
case StyleAppearance::Menuitem:
case StyleAppearance::MenulistText:
case StyleAppearance::MenulistButton:
aResult->SizeTo(1 * dpiRatio, 4 * dpiRatio, 1 * dpiRatio, 4 * dpiRatio);
return true;
case StyleAppearance::Button:
if (IsColorPickerButton(aFrame)) {
aResult->SizeTo(4 * dpiRatio, 4 * dpiRatio, 4 * dpiRatio, 4 * dpiRatio);
return true;
}
aResult->SizeTo(1 * dpiRatio, 4 * dpiRatio, 1 * dpiRatio, 4 * dpiRatio);
return true;
case StyleAppearance::Textfield:
if (IsDateTimeTextField(aFrame)) {
aResult->SizeTo(2 * dpiRatio, 3 * dpiRatio, 0, 3 * dpiRatio);
return true;
}
aResult->SizeTo(1 * dpiRatio, 4 * dpiRatio, 1 * dpiRatio, 4 * dpiRatio);
return true;
default:
return false;
}
}
bool nsNativeBasicTheme::GetWidgetOverflow(nsDeviceContext* aContext,
nsIFrame* aFrame,
StyleAppearance aAppearance,
nsRect* aOverflowRect) {
// TODO(bug 1620360): This should return non-zero for
// StyleAppearance::FocusOutline, if we implement outline-style: auto.
nsIntMargin overflow;
switch (aAppearance) {
case StyleAppearance::Radio:
case StyleAppearance::Checkbox:
case StyleAppearance::Range:
overflow.SizeTo(6, 6, 6, 6);
break;
case StyleAppearance::Textarea:
case StyleAppearance::Textfield:
case StyleAppearance::NumberInput:
case StyleAppearance::Listbox:
case StyleAppearance::MenulistButton:
case StyleAppearance::Menulist:
case StyleAppearance::Button:
overflow.SizeTo(4, 4, 4, 4);
break;
default:
return false;
}
aOverflowRect->Inflate(nsMargin(CSSPixel::ToAppUnits(overflow.top),
CSSPixel::ToAppUnits(overflow.right),
CSSPixel::ToAppUnits(overflow.bottom),
CSSPixel::ToAppUnits(overflow.left)));
return true;
}
NS_IMETHODIMP
nsNativeBasicTheme::GetMinimumWidgetSize(nsPresContext* aPresContext,
nsIFrame* aFrame,
StyleAppearance aAppearance,
LayoutDeviceIntSize* aResult,
bool* aIsOverridable) {
uint32_t dpiRatio = GetDPIRatio(aFrame);
aResult->width = aResult->height =
static_cast<uint32_t>(kMinimumWidgetSize) * dpiRatio;
switch (aAppearance) {
case StyleAppearance::Button:
if (IsColorPickerButton(aFrame)) {
aResult->height =
static_cast<uint32_t>(kMinimumColorPickerHeight) * dpiRatio;
}
break;
case StyleAppearance::RangeThumb:
aResult->SizeTo(static_cast<uint32_t>(kMinimumRangeThumbSize) * dpiRatio,
static_cast<uint32_t>(kMinimumRangeThumbSize) * dpiRatio);
break;
case StyleAppearance::MozMenulistArrowButton:
aResult->width =
static_cast<uint32_t>(kMinimumDropdownArrowButtonWidth) * dpiRatio;
break;
case StyleAppearance::SpinnerUpbutton:
case StyleAppearance::SpinnerDownbutton:
aResult->width =
static_cast<uint32_t>(kMinimumSpinnerButtonWidth) * dpiRatio;
break;
default:
break;
}
*aIsOverridable = true;
return NS_OK;
}
nsITheme::Transparency nsNativeBasicTheme::GetWidgetTransparency(
nsIFrame* aFrame, StyleAppearance aAppearance) {
return eUnknownTransparency;
}
NS_IMETHODIMP
nsNativeBasicTheme::WidgetStateChanged(nsIFrame* aFrame,
StyleAppearance aAppearance,
nsAtom* aAttribute, bool* aShouldRepaint,
const nsAttrValue* aOldValue) {
if (!aAttribute) {
// Hover/focus/active changed. Always repaint.
*aShouldRepaint = true;
} else {
// Check the attribute to see if it's relevant.
// disabled, checked, dlgtype, default, etc.
*aShouldRepaint = false;
if ((aAttribute == nsGkAtoms::disabled) ||
(aAttribute == nsGkAtoms::checked) ||
(aAttribute == nsGkAtoms::selected) ||
(aAttribute == nsGkAtoms::visuallyselected) ||
(aAttribute == nsGkAtoms::menuactive) ||
(aAttribute == nsGkAtoms::sortDirection) ||
(aAttribute == nsGkAtoms::focused) ||
(aAttribute == nsGkAtoms::_default) ||
(aAttribute == nsGkAtoms::open) || (aAttribute == nsGkAtoms::hover)) {
*aShouldRepaint = true;
}
}
return NS_OK;
}
NS_IMETHODIMP
nsNativeBasicTheme::ThemeChanged() { return NS_OK; }
bool nsNativeBasicTheme::WidgetAppearanceDependsOnWindowFocus(StyleAppearance) {
return false;
}
nsITheme::ThemeGeometryType nsNativeBasicTheme::ThemeGeometryTypeForWidget(
nsIFrame* aFrame, StyleAppearance aAppearance) {
return eThemeGeometryTypeUnknown;
}
bool nsNativeBasicTheme::ThemeSupportsWidget(nsPresContext* aPresContext,
nsIFrame* aFrame,
StyleAppearance aAppearance) {
if (IsWidgetScrollbarPart(aAppearance)) {
const auto* style = nsLayoutUtils::StyleForScrollbar(aFrame);
// We don't currently handle custom scrollbars on nsNativeBasicTheme. We
// could, potentially.
if (style->StyleUI()->HasCustomScrollbars() ||
style->StyleUIReset()->mScrollbarWidth == StyleScrollbarWidth::Thin) {
return false;
}
}
switch (aAppearance) {
case StyleAppearance::Radio:
case StyleAppearance::Checkbox:
case StyleAppearance::Textarea:
case StyleAppearance::Textfield:
case StyleAppearance::Range:
case StyleAppearance::RangeThumb:
case StyleAppearance::ProgressBar:
case StyleAppearance::Progresschunk:
case StyleAppearance::Meter:
case StyleAppearance::Meterchunk:
case StyleAppearance::ScrollbarbuttonUp:
case StyleAppearance::ScrollbarbuttonDown:
case StyleAppearance::ScrollbarbuttonLeft:
case StyleAppearance::ScrollbarbuttonRight:
case StyleAppearance::ScrollbarthumbHorizontal:
case StyleAppearance::ScrollbarthumbVertical:
case StyleAppearance::ScrollbarHorizontal:
case StyleAppearance::ScrollbarVertical:
case StyleAppearance::Scrollcorner:
case StyleAppearance::Button:
case StyleAppearance::Listbox:
case StyleAppearance::Menulist:
case StyleAppearance::Menuitem:
case StyleAppearance::Menuitemtext:
case StyleAppearance::MenulistText:
case StyleAppearance::MenulistButton:
case StyleAppearance::NumberInput:
case StyleAppearance::MozMenulistArrowButton:
case StyleAppearance::SpinnerUpbutton:
case StyleAppearance::SpinnerDownbutton:
return !IsWidgetStyled(aPresContext, aFrame, aAppearance);
default:
return false;
}
}
bool nsNativeBasicTheme::WidgetIsContainer(StyleAppearance aAppearance) {
switch (aAppearance) {
case StyleAppearance::MozMenulistArrowButton:
case StyleAppearance::Radio:
case StyleAppearance::Checkbox:
return false;
default:
return true;
}
}
bool nsNativeBasicTheme::ThemeDrawsFocusForWidget(StyleAppearance aAppearance) {
return true;
}
bool nsNativeBasicTheme::ThemeNeedsComboboxDropmarker() { return true; }