mirror of
https://github.com/mozilla/gecko-dev.git
synced 2025-11-04 10:18:41 +02:00
ad12453cf8
It's suitable for foreground colors only. Differential Revision: https://phabricator.services.mozilla.com/D221557
600 lines
21 KiB
C++
600 lines
21 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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 "nsTextPaintStyle.h"
|
|
|
|
#include "nsCSSColorUtils.h"
|
|
#include "nsCSSRendering.h"
|
|
#include "nsFrameSelection.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsTextFrame.h"
|
|
#include "nsStyleConsts.h"
|
|
|
|
#include "mozilla/LookAndFeel.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
|
|
static nscolor EnsureDifferentColors(nscolor colorA, nscolor colorB) {
|
|
if (colorA == colorB) {
|
|
nscolor res;
|
|
res = NS_RGB(NS_GET_R(colorA) ^ 0xff, NS_GET_G(colorA) ^ 0xff,
|
|
NS_GET_B(colorA) ^ 0xff);
|
|
return res;
|
|
}
|
|
return colorA;
|
|
}
|
|
|
|
nsTextPaintStyle::nsTextPaintStyle(nsTextFrame* aFrame)
|
|
: mFrame(aFrame),
|
|
mPresContext(aFrame->PresContext()),
|
|
mInitCommonColors(false),
|
|
mInitSelectionColorsAndShadow(false),
|
|
mResolveColors(true),
|
|
mSelectionTextColor(NS_RGBA(0, 0, 0, 0)),
|
|
mSelectionBGColor(NS_RGBA(0, 0, 0, 0)),
|
|
mSufficientContrast(0),
|
|
mFrameBackgroundColor(NS_RGBA(0, 0, 0, 0)),
|
|
mSystemFieldForegroundColor(NS_RGBA(0, 0, 0, 0)),
|
|
mSystemFieldBackgroundColor(NS_RGBA(0, 0, 0, 0)) {}
|
|
|
|
bool nsTextPaintStyle::EnsureSufficientContrast(nscolor* aForeColor,
|
|
nscolor* aBackColor) {
|
|
InitCommonColors();
|
|
|
|
const bool sameAsForeground = *aForeColor == NS_SAME_AS_FOREGROUND_COLOR;
|
|
if (sameAsForeground) {
|
|
*aForeColor = GetTextColor();
|
|
}
|
|
|
|
// If the combination of selection background color and frame background color
|
|
// has sufficient contrast, don't exchange the selection colors.
|
|
//
|
|
// Note we use a different threshold here: mSufficientContrast is for contrast
|
|
// between text and background colors, but since we're diffing two
|
|
// backgrounds, we don't need that much contrast. We match the heuristic from
|
|
// NS_SUFFICIENT_LUMINOSITY_DIFFERENCE_BG and use 20% of mSufficientContrast.
|
|
const int32_t minLuminosityDifferenceForBackground = mSufficientContrast / 5;
|
|
const int32_t backLuminosityDifference =
|
|
NS_LUMINOSITY_DIFFERENCE(*aBackColor, mFrameBackgroundColor);
|
|
if (backLuminosityDifference >= minLuminosityDifferenceForBackground) {
|
|
return false;
|
|
}
|
|
|
|
// Otherwise, we should use the higher-contrast color for the selection
|
|
// background color.
|
|
//
|
|
// For NS_SAME_AS_FOREGROUND_COLOR we only do this if the background is
|
|
// totally indistinguishable, that is, if the luminosity difference is 0.
|
|
if (sameAsForeground && backLuminosityDifference) {
|
|
return false;
|
|
}
|
|
|
|
int32_t foreLuminosityDifference =
|
|
NS_LUMINOSITY_DIFFERENCE(*aForeColor, mFrameBackgroundColor);
|
|
if (backLuminosityDifference < foreLuminosityDifference) {
|
|
std::swap(*aForeColor, *aBackColor);
|
|
// Ensure foreground color is opaque to guarantee contrast.
|
|
*aForeColor = NS_RGB(NS_GET_R(*aForeColor), NS_GET_G(*aForeColor),
|
|
NS_GET_B(*aForeColor));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
nscolor nsTextPaintStyle::GetTextColor() {
|
|
if (mFrame->IsInSVGTextSubtree()) {
|
|
if (!mResolveColors) {
|
|
return NS_SAME_AS_FOREGROUND_COLOR;
|
|
}
|
|
|
|
const nsStyleSVG* style = mFrame->StyleSVG();
|
|
switch (style->mFill.kind.tag) {
|
|
case StyleSVGPaintKind::Tag::None:
|
|
return NS_RGBA(0, 0, 0, 0);
|
|
case StyleSVGPaintKind::Tag::Color:
|
|
return nsLayoutUtils::GetTextColor(mFrame, &nsStyleSVG::mFill);
|
|
default:
|
|
NS_ERROR("cannot resolve SVG paint to nscolor");
|
|
return NS_RGBA(0, 0, 0, 255);
|
|
}
|
|
}
|
|
|
|
return nsLayoutUtils::GetTextColor(mFrame,
|
|
&nsStyleText::mWebkitTextFillColor);
|
|
}
|
|
|
|
bool nsTextPaintStyle::GetSelectionColors(nscolor* aForeColor,
|
|
nscolor* aBackColor) {
|
|
NS_ASSERTION(aForeColor, "aForeColor is null");
|
|
NS_ASSERTION(aBackColor, "aBackColor is null");
|
|
|
|
if (!InitSelectionColorsAndShadow()) {
|
|
return false;
|
|
}
|
|
|
|
*aForeColor = mSelectionTextColor;
|
|
*aBackColor = mSelectionBGColor;
|
|
return true;
|
|
}
|
|
|
|
void nsTextPaintStyle::GetHighlightColors(nscolor* aForeColor,
|
|
nscolor* aBackColor) {
|
|
NS_ASSERTION(aForeColor, "aForeColor is null");
|
|
NS_ASSERTION(aBackColor, "aBackColor is null");
|
|
|
|
const nsFrameSelection* frameSelection = mFrame->GetConstFrameSelection();
|
|
const Selection* selection =
|
|
frameSelection->GetSelection(SelectionType::eFind);
|
|
const SelectionCustomColors* customColors = nullptr;
|
|
if (selection) {
|
|
customColors = selection->GetCustomColors();
|
|
}
|
|
|
|
if (!customColors) {
|
|
nscolor backColor = LookAndFeel::Color(
|
|
LookAndFeel::ColorID::TextHighlightBackground, mFrame);
|
|
nscolor foreColor = LookAndFeel::Color(
|
|
LookAndFeel::ColorID::TextHighlightForeground, mFrame);
|
|
EnsureSufficientContrast(&foreColor, &backColor);
|
|
*aForeColor = foreColor;
|
|
*aBackColor = backColor;
|
|
return;
|
|
}
|
|
|
|
if (customColors->mForegroundColor && customColors->mBackgroundColor) {
|
|
nscolor foreColor = *customColors->mForegroundColor;
|
|
nscolor backColor = *customColors->mBackgroundColor;
|
|
|
|
if (EnsureSufficientContrast(&foreColor, &backColor) &&
|
|
customColors->mAltForegroundColor &&
|
|
customColors->mAltBackgroundColor) {
|
|
foreColor = *customColors->mAltForegroundColor;
|
|
backColor = *customColors->mAltBackgroundColor;
|
|
}
|
|
|
|
*aForeColor = foreColor;
|
|
*aBackColor = backColor;
|
|
return;
|
|
}
|
|
|
|
InitCommonColors();
|
|
|
|
if (customColors->mBackgroundColor) {
|
|
// !mForegroundColor means "currentColor"; the current color of the text.
|
|
nscolor foreColor = GetTextColor();
|
|
nscolor backColor = *customColors->mBackgroundColor;
|
|
|
|
int32_t luminosityDifference =
|
|
NS_LUMINOSITY_DIFFERENCE(foreColor, backColor);
|
|
|
|
if (mSufficientContrast > luminosityDifference &&
|
|
customColors->mAltBackgroundColor) {
|
|
int32_t altLuminosityDifference = NS_LUMINOSITY_DIFFERENCE(
|
|
foreColor, *customColors->mAltBackgroundColor);
|
|
|
|
if (luminosityDifference < altLuminosityDifference) {
|
|
backColor = *customColors->mAltBackgroundColor;
|
|
}
|
|
}
|
|
|
|
*aForeColor = foreColor;
|
|
*aBackColor = backColor;
|
|
return;
|
|
}
|
|
|
|
if (customColors->mForegroundColor) {
|
|
nscolor foreColor = *customColors->mForegroundColor;
|
|
// !mBackgroundColor means "transparent"; the current color of the
|
|
// background.
|
|
|
|
int32_t luminosityDifference =
|
|
NS_LUMINOSITY_DIFFERENCE(foreColor, mFrameBackgroundColor);
|
|
|
|
if (mSufficientContrast > luminosityDifference &&
|
|
customColors->mAltForegroundColor) {
|
|
int32_t altLuminosityDifference = NS_LUMINOSITY_DIFFERENCE(
|
|
*customColors->mForegroundColor, mFrameBackgroundColor);
|
|
|
|
if (luminosityDifference < altLuminosityDifference) {
|
|
foreColor = *customColors->mAltForegroundColor;
|
|
}
|
|
}
|
|
|
|
*aForeColor = foreColor;
|
|
*aBackColor = NS_TRANSPARENT;
|
|
return;
|
|
}
|
|
|
|
// There are neither mForegroundColor nor mBackgroundColor.
|
|
*aForeColor = GetTextColor();
|
|
*aBackColor = NS_TRANSPARENT;
|
|
}
|
|
|
|
void nsTextPaintStyle::GetTargetTextColors(nscolor* aForeColor,
|
|
nscolor* aBackColor) {
|
|
NS_ASSERTION(aForeColor, "aForeColor is null");
|
|
NS_ASSERTION(aBackColor, "aBackColor is null");
|
|
const RefPtr<const ComputedStyle> targetTextStyle =
|
|
mFrame->ComputeTargetTextStyle();
|
|
if (targetTextStyle) {
|
|
*aForeColor = targetTextStyle->GetVisitedDependentColor(
|
|
&nsStyleText::mWebkitTextFillColor);
|
|
*aBackColor = targetTextStyle->GetVisitedDependentColor(
|
|
&nsStyleBackground::mBackgroundColor);
|
|
return;
|
|
}
|
|
*aBackColor =
|
|
LookAndFeel::Color(LookAndFeel::ColorID::TargetTextBackground, mFrame);
|
|
*aForeColor =
|
|
LookAndFeel::Color(LookAndFeel::ColorID::TargetTextForeground, mFrame);
|
|
}
|
|
|
|
bool nsTextPaintStyle::GetCustomHighlightTextColor(nsAtom* aHighlightName,
|
|
nscolor* aForeColor) {
|
|
NS_ASSERTION(aForeColor, "aForeColor is null");
|
|
|
|
// non-existing highlights will be stored as `aHighlightName->nullptr`,
|
|
// so subsequent calls only need a hashtable lookup and don't have
|
|
// to enter the style engine.
|
|
RefPtr<ComputedStyle> highlightStyle =
|
|
mCustomHighlightPseudoStyles.LookupOrInsertWith(
|
|
aHighlightName, [this, &aHighlightName] {
|
|
return mFrame->ComputeHighlightSelectionStyle(aHighlightName);
|
|
});
|
|
if (!highlightStyle) {
|
|
// highlight `aHighlightName` doesn't exist or has no style rules.
|
|
return false;
|
|
}
|
|
|
|
*aForeColor = highlightStyle->GetVisitedDependentColor(
|
|
&nsStyleText::mWebkitTextFillColor);
|
|
|
|
return highlightStyle->HasAuthorSpecifiedTextColor();
|
|
}
|
|
|
|
bool nsTextPaintStyle::GetCustomHighlightBackgroundColor(nsAtom* aHighlightName,
|
|
nscolor* aBackColor) {
|
|
NS_ASSERTION(aBackColor, "aBackColor is null");
|
|
// non-existing highlights will be stored as `aHighlightName->nullptr`,
|
|
// so subsequent calls only need a hashtable lookup and don't have
|
|
// to enter the style engine.
|
|
RefPtr<ComputedStyle> highlightStyle =
|
|
mCustomHighlightPseudoStyles.LookupOrInsertWith(
|
|
aHighlightName, [this, &aHighlightName] {
|
|
return mFrame->ComputeHighlightSelectionStyle(aHighlightName);
|
|
});
|
|
if (!highlightStyle) {
|
|
// highlight `aHighlightName` doesn't exist or has no style rules.
|
|
return false;
|
|
}
|
|
|
|
*aBackColor = highlightStyle->GetVisitedDependentColor(
|
|
&nsStyleBackground::mBackgroundColor);
|
|
return NS_GET_A(*aBackColor) != 0;
|
|
}
|
|
|
|
void nsTextPaintStyle::GetURLSecondaryColor(nscolor* aForeColor) {
|
|
NS_ASSERTION(aForeColor, "aForeColor is null");
|
|
|
|
const nscolor textColor = GetTextColor();
|
|
*aForeColor = NS_RGBA(NS_GET_R(textColor), NS_GET_G(textColor),
|
|
NS_GET_B(textColor), 127);
|
|
}
|
|
|
|
void nsTextPaintStyle::GetIMESelectionColors(SelectionStyleIndex aIndex,
|
|
nscolor* aForeColor,
|
|
nscolor* aBackColor) {
|
|
NS_ASSERTION(aForeColor, "aForeColor is null");
|
|
NS_ASSERTION(aBackColor, "aBackColor is null");
|
|
|
|
nsSelectionStyle* selectionStyle = SelectionStyle(aIndex);
|
|
*aForeColor = selectionStyle->mTextColor;
|
|
*aBackColor = selectionStyle->mBGColor;
|
|
}
|
|
|
|
bool nsTextPaintStyle::GetSelectionUnderlineForPaint(
|
|
SelectionStyleIndex aIndex, nscolor* aLineColor, float* aRelativeSize,
|
|
StyleTextDecorationStyle* aStyle) {
|
|
NS_ASSERTION(aLineColor, "aLineColor is null");
|
|
NS_ASSERTION(aRelativeSize, "aRelativeSize is null");
|
|
|
|
nsSelectionStyle* selectionStyle = SelectionStyle(aIndex);
|
|
if (selectionStyle->mUnderlineStyle == StyleTextDecorationStyle::None ||
|
|
selectionStyle->mUnderlineColor == NS_TRANSPARENT ||
|
|
selectionStyle->mUnderlineRelativeSize <= 0.0f)
|
|
return false;
|
|
|
|
*aLineColor = selectionStyle->mUnderlineColor;
|
|
*aRelativeSize = selectionStyle->mUnderlineRelativeSize;
|
|
*aStyle = selectionStyle->mUnderlineStyle;
|
|
return true;
|
|
}
|
|
|
|
void nsTextPaintStyle::InitCommonColors() {
|
|
if (mInitCommonColors) {
|
|
return;
|
|
}
|
|
|
|
auto bgColor = nsCSSRendering::FindEffectiveBackgroundColor(mFrame);
|
|
mFrameBackgroundColor = bgColor.mColor;
|
|
|
|
mSystemFieldForegroundColor =
|
|
LookAndFeel::Color(LookAndFeel::ColorID::Fieldtext, mFrame);
|
|
mSystemFieldBackgroundColor =
|
|
LookAndFeel::Color(LookAndFeel::ColorID::Field, mFrame);
|
|
|
|
if (bgColor.mIsThemed) {
|
|
// Assume a native widget has sufficient contrast always
|
|
mSufficientContrast = 0;
|
|
mInitCommonColors = true;
|
|
return;
|
|
}
|
|
|
|
nscolor defaultWindowBackgroundColor =
|
|
LookAndFeel::Color(LookAndFeel::ColorID::Window, mFrame);
|
|
nscolor selectionTextColor =
|
|
LookAndFeel::Color(LookAndFeel::ColorID::Highlighttext, mFrame);
|
|
nscolor selectionBGColor =
|
|
LookAndFeel::Color(LookAndFeel::ColorID::Highlight, mFrame);
|
|
|
|
mSufficientContrast = std::min(
|
|
std::min(NS_SUFFICIENT_LUMINOSITY_DIFFERENCE,
|
|
NS_LUMINOSITY_DIFFERENCE(selectionTextColor, selectionBGColor)),
|
|
NS_LUMINOSITY_DIFFERENCE(defaultWindowBackgroundColor, selectionBGColor));
|
|
|
|
mInitCommonColors = true;
|
|
}
|
|
|
|
nscolor nsTextPaintStyle::GetSystemFieldForegroundColor() {
|
|
InitCommonColors();
|
|
return mSystemFieldForegroundColor;
|
|
}
|
|
|
|
nscolor nsTextPaintStyle::GetSystemFieldBackgroundColor() {
|
|
InitCommonColors();
|
|
return mSystemFieldBackgroundColor;
|
|
}
|
|
|
|
bool nsTextPaintStyle::InitSelectionColorsAndShadow() {
|
|
if (mInitSelectionColorsAndShadow) {
|
|
return true;
|
|
}
|
|
|
|
int16_t selectionFlags;
|
|
const int16_t selectionStatus = mFrame->GetSelectionStatus(&selectionFlags);
|
|
if (!(selectionFlags & nsISelectionDisplay::DISPLAY_TEXT) ||
|
|
selectionStatus < nsISelectionController::SELECTION_ON) {
|
|
// Not displaying the normal selection.
|
|
// We're not caching this fact, so every call to GetSelectionColors
|
|
// will come through here. We could avoid this, but it's not really worth
|
|
// it.
|
|
return false;
|
|
}
|
|
|
|
mInitSelectionColorsAndShadow = true;
|
|
|
|
// Use ::selection pseudo class if applicable.
|
|
if (RefPtr<ComputedStyle> style =
|
|
mFrame->ComputeSelectionStyle(selectionStatus)) {
|
|
mSelectionBGColor =
|
|
style->GetVisitedDependentColor(&nsStyleBackground::mBackgroundColor);
|
|
mSelectionTextColor =
|
|
style->GetVisitedDependentColor(&nsStyleText::mWebkitTextFillColor);
|
|
mSelectionPseudoStyle = std::move(style);
|
|
return true;
|
|
}
|
|
|
|
mSelectionTextColor =
|
|
LookAndFeel::Color(LookAndFeel::ColorID::Highlighttext, mFrame);
|
|
|
|
nscolor selectionBGColor =
|
|
LookAndFeel::Color(LookAndFeel::ColorID::Highlight, mFrame);
|
|
|
|
switch (selectionStatus) {
|
|
case nsISelectionController::SELECTION_ATTENTION: {
|
|
mSelectionTextColor = LookAndFeel::Color(
|
|
LookAndFeel::ColorID::TextSelectAttentionForeground, mFrame);
|
|
mSelectionBGColor = LookAndFeel::Color(
|
|
LookAndFeel::ColorID::TextSelectAttentionBackground, mFrame);
|
|
mSelectionBGColor =
|
|
EnsureDifferentColors(mSelectionBGColor, selectionBGColor);
|
|
break;
|
|
}
|
|
case nsISelectionController::SELECTION_ON: {
|
|
mSelectionBGColor = selectionBGColor;
|
|
break;
|
|
}
|
|
default: {
|
|
mSelectionBGColor = LookAndFeel::Color(
|
|
LookAndFeel::ColorID::TextSelectDisabledBackground, mFrame);
|
|
mSelectionBGColor =
|
|
EnsureDifferentColors(mSelectionBGColor, selectionBGColor);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (mResolveColors) {
|
|
EnsureSufficientContrast(&mSelectionTextColor, &mSelectionBGColor);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
nsTextPaintStyle::nsSelectionStyle* nsTextPaintStyle::SelectionStyle(
|
|
SelectionStyleIndex aIndex) {
|
|
Maybe<nsSelectionStyle>& selectionStyle = mSelectionStyle[aIndex];
|
|
if (!selectionStyle) {
|
|
selectionStyle.emplace(InitSelectionStyle(aIndex));
|
|
}
|
|
return selectionStyle.ptr();
|
|
}
|
|
|
|
struct StyleIDs {
|
|
LookAndFeel::ColorID mForeground, mBackground, mLine;
|
|
LookAndFeel::IntID mLineStyle;
|
|
LookAndFeel::FloatID mLineRelativeSize;
|
|
};
|
|
EnumeratedArray<nsTextPaintStyle::SelectionStyleIndex, StyleIDs,
|
|
size_t(nsTextPaintStyle::SelectionStyleIndex::Count)>
|
|
SelectionStyleIDs = {
|
|
StyleIDs{LookAndFeel::ColorID::IMERawInputForeground,
|
|
LookAndFeel::ColorID::IMERawInputBackground,
|
|
LookAndFeel::ColorID::IMERawInputUnderline,
|
|
LookAndFeel::IntID::IMERawInputUnderlineStyle,
|
|
LookAndFeel::FloatID::IMEUnderlineRelativeSize},
|
|
StyleIDs{LookAndFeel::ColorID::IMESelectedRawTextForeground,
|
|
LookAndFeel::ColorID::IMESelectedRawTextBackground,
|
|
LookAndFeel::ColorID::IMESelectedRawTextUnderline,
|
|
LookAndFeel::IntID::IMESelectedRawTextUnderlineStyle,
|
|
LookAndFeel::FloatID::IMEUnderlineRelativeSize},
|
|
StyleIDs{LookAndFeel::ColorID::IMEConvertedTextForeground,
|
|
LookAndFeel::ColorID::IMEConvertedTextBackground,
|
|
LookAndFeel::ColorID::IMEConvertedTextUnderline,
|
|
LookAndFeel::IntID::IMEConvertedTextUnderlineStyle,
|
|
LookAndFeel::FloatID::IMEUnderlineRelativeSize},
|
|
StyleIDs{LookAndFeel::ColorID::IMESelectedConvertedTextForeground,
|
|
LookAndFeel::ColorID::IMESelectedConvertedTextBackground,
|
|
LookAndFeel::ColorID::IMESelectedConvertedTextUnderline,
|
|
LookAndFeel::IntID::IMESelectedConvertedTextUnderline,
|
|
LookAndFeel::FloatID::IMEUnderlineRelativeSize},
|
|
StyleIDs{LookAndFeel::ColorID::End, LookAndFeel::ColorID::End,
|
|
LookAndFeel::ColorID::SpellCheckerUnderline,
|
|
LookAndFeel::IntID::SpellCheckerUnderlineStyle,
|
|
LookAndFeel::FloatID::SpellCheckerUnderlineRelativeSize}};
|
|
|
|
nsTextPaintStyle::nsSelectionStyle nsTextPaintStyle::InitSelectionStyle(
|
|
SelectionStyleIndex aIndex) {
|
|
const StyleIDs& styleIDs = SelectionStyleIDs[aIndex];
|
|
|
|
nscolor foreColor, backColor;
|
|
if (styleIDs.mForeground == LookAndFeel::ColorID::End) {
|
|
foreColor = NS_SAME_AS_FOREGROUND_COLOR;
|
|
} else {
|
|
foreColor = LookAndFeel::Color(styleIDs.mForeground, mFrame);
|
|
}
|
|
if (styleIDs.mBackground == LookAndFeel::ColorID::End) {
|
|
backColor = NS_TRANSPARENT;
|
|
} else {
|
|
backColor = LookAndFeel::Color(styleIDs.mBackground, mFrame);
|
|
}
|
|
|
|
// Convert special color to actual color
|
|
NS_ASSERTION(foreColor != NS_TRANSPARENT,
|
|
"foreColor cannot be NS_TRANSPARENT");
|
|
NS_ASSERTION(backColor != NS_SAME_AS_FOREGROUND_COLOR,
|
|
"backColor cannot be NS_SAME_AS_FOREGROUND_COLOR");
|
|
NS_ASSERTION(backColor != NS_40PERCENT_FOREGROUND_COLOR,
|
|
"backColor cannot be NS_40PERCENT_FOREGROUND_COLOR");
|
|
|
|
if (mResolveColors) {
|
|
foreColor = GetResolvedForeColor(foreColor, GetTextColor(), backColor);
|
|
|
|
if (NS_GET_A(backColor) > 0) {
|
|
EnsureSufficientContrast(&foreColor, &backColor);
|
|
}
|
|
}
|
|
|
|
nscolor lineColor;
|
|
float relativeSize;
|
|
StyleTextDecorationStyle lineStyle;
|
|
GetSelectionUnderline(mFrame, aIndex, &lineColor, &relativeSize, &lineStyle);
|
|
|
|
if (mResolveColors) {
|
|
lineColor = GetResolvedForeColor(lineColor, foreColor, backColor);
|
|
}
|
|
|
|
return nsSelectionStyle{foreColor, backColor, lineColor, lineStyle,
|
|
relativeSize};
|
|
}
|
|
|
|
/* static */
|
|
bool nsTextPaintStyle::GetSelectionUnderline(nsIFrame* aFrame,
|
|
SelectionStyleIndex aIndex,
|
|
nscolor* aLineColor,
|
|
float* aRelativeSize,
|
|
StyleTextDecorationStyle* aStyle) {
|
|
NS_ASSERTION(aFrame, "aFrame is null");
|
|
NS_ASSERTION(aRelativeSize, "aRelativeSize is null");
|
|
NS_ASSERTION(aStyle, "aStyle is null");
|
|
|
|
const StyleIDs& styleIDs = SelectionStyleIDs[aIndex];
|
|
|
|
nscolor color = LookAndFeel::Color(styleIDs.mLine, aFrame);
|
|
const int32_t lineStyle = LookAndFeel::GetInt(styleIDs.mLineStyle);
|
|
auto style = static_cast<StyleTextDecorationStyle>(lineStyle);
|
|
if (lineStyle > static_cast<int32_t>(StyleTextDecorationStyle::Sentinel)) {
|
|
NS_ERROR("Invalid underline style value is specified");
|
|
style = StyleTextDecorationStyle::Solid;
|
|
}
|
|
float size = LookAndFeel::GetFloat(styleIDs.mLineRelativeSize);
|
|
|
|
NS_ASSERTION(size, "selection underline relative size must be larger than 0");
|
|
|
|
if (aLineColor) {
|
|
*aLineColor = color;
|
|
}
|
|
*aRelativeSize = size;
|
|
*aStyle = style;
|
|
|
|
return style != StyleTextDecorationStyle::None && color != NS_TRANSPARENT &&
|
|
size > 0.0f;
|
|
}
|
|
|
|
bool nsTextPaintStyle::GetSelectionShadow(
|
|
Span<const StyleSimpleShadow>* aShadows) {
|
|
if (!InitSelectionColorsAndShadow()) {
|
|
return false;
|
|
}
|
|
|
|
if (mSelectionPseudoStyle) {
|
|
*aShadows = mSelectionPseudoStyle->StyleText()->mTextShadow.AsSpan();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
inline nscolor Get40PercentColor(nscolor aForeColor, nscolor aBackColor) {
|
|
nscolor foreColor = NS_RGBA(NS_GET_R(aForeColor), NS_GET_G(aForeColor),
|
|
NS_GET_B(aForeColor), (uint8_t)(255 * 0.4f));
|
|
// Don't use true alpha color for readability.
|
|
return NS_ComposeColors(aBackColor, foreColor);
|
|
}
|
|
|
|
nscolor nsTextPaintStyle::GetResolvedForeColor(nscolor aColor,
|
|
nscolor aDefaultForeColor,
|
|
nscolor aBackColor) {
|
|
if (aColor == NS_SAME_AS_FOREGROUND_COLOR) {
|
|
return aDefaultForeColor;
|
|
}
|
|
|
|
if (aColor != NS_40PERCENT_FOREGROUND_COLOR) {
|
|
return aColor;
|
|
}
|
|
|
|
// Get actual background color
|
|
nscolor actualBGColor = aBackColor;
|
|
if (actualBGColor == NS_TRANSPARENT) {
|
|
InitCommonColors();
|
|
actualBGColor = mFrameBackgroundColor;
|
|
}
|
|
return Get40PercentColor(aDefaultForeColor, actualBGColor);
|
|
}
|
|
|
|
nscolor nsTextPaintStyle::GetWebkitTextStrokeColor() {
|
|
if (mFrame->IsInSVGTextSubtree()) {
|
|
return 0;
|
|
}
|
|
return mFrame->StyleText()->mWebkitTextStrokeColor.CalcColor(mFrame);
|
|
}
|
|
|
|
float nsTextPaintStyle::GetWebkitTextStrokeWidth() {
|
|
if (mFrame->IsInSVGTextSubtree()) {
|
|
return 0.0f;
|
|
}
|
|
nscoord coord = mFrame->StyleText()->mWebkitTextStrokeWidth;
|
|
return mFrame->PresContext()->AppUnitsToFloatDevPixels(coord);
|
|
}
|