summaryrefslogtreecommitdiffstats
path: root/widget/nsXPLookAndFeel.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /widget/nsXPLookAndFeel.cpp
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'widget/nsXPLookAndFeel.cpp')
-rw-r--r--widget/nsXPLookAndFeel.cpp1588
1 files changed, 1588 insertions, 0 deletions
diff --git a/widget/nsXPLookAndFeel.cpp b/widget/nsXPLookAndFeel.cpp
new file mode 100644
index 0000000000..fae1444161
--- /dev/null
+++ b/widget/nsXPLookAndFeel.cpp
@@ -0,0 +1,1588 @@
+/* -*- mode: C++; tab-width: 4; 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 "mozilla/ArrayUtils.h"
+
+#include "mozilla/LookAndFeel.h"
+#include "nscore.h"
+
+#include "nsXPLookAndFeel.h"
+#include "nsLookAndFeel.h"
+#include "HeadlessLookAndFeel.h"
+#include "RemoteLookAndFeel.h"
+#include "nsContentUtils.h"
+#include "nsCRT.h"
+#include "nsFont.h"
+#include "nsIFrame.h"
+#include "nsIXULRuntime.h"
+#include "nsLayoutUtils.h"
+#include "Theme.h"
+#include "SurfaceCacheUtils.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Services.h"
+#include "mozilla/ServoStyleSet.h"
+#include "mozilla/ServoCSSParser.h"
+#include "mozilla/StaticPrefs_browser.h"
+#include "mozilla/StaticPrefs_editor.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/StaticPrefs_ui.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/PreferenceSheet.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/widget/WidgetMessageUtils.h"
+#include "mozilla/dom/KeyboardEventBinding.h"
+#include "mozilla/RelativeLuminanceUtils.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/TelemetryScalarEnums.h"
+
+#include "gfxPlatform.h"
+#include "gfxFont.h"
+
+#include "qcms.h"
+
+#include <bitset>
+
+using namespace mozilla;
+
+using IntID = mozilla::LookAndFeel::IntID;
+using FloatID = mozilla::LookAndFeel::FloatID;
+using ColorID = mozilla::LookAndFeel::ColorID;
+using FontID = mozilla::LookAndFeel::FontID;
+
+template <typename Index, typename Value, Index kEnd>
+class EnumeratedCache {
+ mozilla::EnumeratedArray<Index, kEnd, Value> mEntries;
+ std::bitset<size_t(kEnd)> mValidity;
+
+ public:
+ constexpr EnumeratedCache() = default;
+
+ bool IsValid(Index aIndex) const { return mValidity[size_t(aIndex)]; }
+
+ const Value* Get(Index aIndex) const {
+ return IsValid(aIndex) ? &mEntries[aIndex] : nullptr;
+ }
+
+ void Insert(Index aIndex, Value aValue) {
+ mValidity[size_t(aIndex)] = true;
+ mEntries[aIndex] = aValue;
+ }
+
+ void Remove(Index aIndex) {
+ mValidity[size_t(aIndex)] = false;
+ mEntries[aIndex] = Value();
+ }
+
+ void Clear() {
+ mValidity.reset();
+ for (auto& entry : mEntries) {
+ entry = Value();
+ }
+ }
+};
+
+using ColorCache = EnumeratedCache<ColorID, Maybe<nscolor>, ColorID::End>;
+
+struct ColorCaches {
+ using UseStandins = LookAndFeel::UseStandins;
+
+ ColorCache mCaches[2][2];
+
+ constexpr ColorCaches() = default;
+
+ ColorCache& Get(ColorScheme aScheme, UseStandins aUseStandins) {
+ return mCaches[aScheme == ColorScheme::Dark]
+ [aUseStandins == UseStandins::Yes];
+ }
+
+ void Clear() {
+ for (auto& c : mCaches) {
+ for (auto& cache : c) {
+ cache.Clear();
+ }
+ }
+ }
+};
+
+static ColorCaches sColorCaches;
+
+static EnumeratedCache<FloatID, Maybe<float>, FloatID::End> sFloatCache;
+static EnumeratedCache<IntID, Maybe<int32_t>, IntID::End> sIntCache;
+static EnumeratedCache<FontID, widget::LookAndFeelFont, FontID::End> sFontCache;
+
+// To make one of these prefs toggleable from a reftest add a user
+// pref in testing/profiles/reftest/user.js. For example, to make
+// ui.useAccessibilityTheme toggleable, add:
+//
+// user_pref("ui.useAccessibilityTheme", 0);
+//
+// This needs to be of the same length and in the same order as
+// LookAndFeel::IntID values.
+static const char sIntPrefs[][45] = {
+ "ui.caretBlinkTime",
+ "ui.caretBlinkCount",
+ "ui.caretWidth",
+ "ui.caretVisibleWithSelection",
+ "ui.selectTextfieldsOnKeyFocus",
+ "ui.submenuDelay",
+ "ui.menusCanOverlapOSBar",
+ "ui.useOverlayScrollbars",
+ "ui.allowOverlayScrollbarsOverlap",
+ "ui.skipNavigatingDisabledMenuItem",
+ "ui.dragThresholdX",
+ "ui.dragThresholdY",
+ "ui.useAccessibilityTheme",
+ "ui.scrollArrowStyle",
+ "ui.scrollButtonLeftMouseButtonAction",
+ "ui.scrollButtonMiddleMouseButtonAction",
+ "ui.scrollButtonRightMouseButtonAction",
+ "ui.treeOpenDelay",
+ "ui.treeCloseDelay",
+ "ui.treeLazyScrollDelay",
+ "ui.treeScrollDelay",
+ "ui.treeScrollLinesMax",
+ "accessibility.tabfocus", // Weird one...
+ "ui.chosenMenuItemsShouldBlink",
+ "ui.windowsAccentColorInTitlebar",
+ "ui.windowsDefaultTheme",
+ "ui.dwmCompositor",
+ "ui.windowsClassic",
+ "ui.windowsGlass",
+ "ui.macGraphiteTheme",
+ "ui.macBigSurTheme",
+ "ui.macRTL",
+ "ui.alertNotificationOrigin",
+ "ui.scrollToClick",
+ "ui.IMERawInputUnderlineStyle",
+ "ui.IMESelectedRawTextUnderlineStyle",
+ "ui.IMEConvertedTextUnderlineStyle",
+ "ui.IMESelectedConvertedTextUnderlineStyle",
+ "ui.SpellCheckerUnderlineStyle",
+ "ui.menuBarDrag",
+ "ui.scrollbarButtonAutoRepeatBehavior",
+ "ui.tooltipDelay",
+ "ui.swipeAnimationEnabled",
+ "ui.scrollbarDisplayOnMouseMove",
+ "ui.scrollbarFadeBeginDelay",
+ "ui.scrollbarFadeDuration",
+ "ui.contextMenuOffsetVertical",
+ "ui.contextMenuOffsetHorizontal",
+ "ui.GtkCSDAvailable",
+ "ui.GtkCSDMinimizeButton",
+ "ui.GtkCSDMaximizeButton",
+ "ui.GtkCSDCloseButton",
+ "ui.GtkCSDMinimizeButtonPosition",
+ "ui.GtkCSDMaximizeButtonPosition",
+ "ui.GtkCSDCloseButtonPosition",
+ "ui.GtkCSDReversedPlacement",
+ "ui.systemUsesDarkTheme",
+ "ui.prefersReducedMotion",
+ "ui.prefersReducedTransparency",
+ "ui.invertedColors",
+ "ui.primaryPointerCapabilities",
+ "ui.allPointerCapabilities",
+ "ui.systemScrollbarSize",
+ "ui.touchDeviceSupportPresent",
+ "ui.titlebarRadius",
+ "ui.dynamicRange",
+ "ui.videoDynamicRange",
+ "ui.panelAnimations",
+};
+
+static_assert(ArrayLength(sIntPrefs) == size_t(LookAndFeel::IntID::End),
+ "Should have a pref for each int value");
+
+// This array MUST be kept in the same order as the float id list in
+// LookAndFeel.h
+// clang-format off
+static const char sFloatPrefs[][37] = {
+ "ui.IMEUnderlineRelativeSize",
+ "ui.SpellCheckerUnderlineRelativeSize",
+ "ui.caretAspectRatio",
+ "ui.textScaleFactor",
+ "ui.cursorScale",
+};
+// clang-format on
+
+static_assert(ArrayLength(sFloatPrefs) == size_t(LookAndFeel::FloatID::End),
+ "Should have a pref for each float value");
+
+// This array MUST be kept in the same order as the color list in
+// specified/color.rs
+static const char sColorPrefs[][41] = {
+ "ui.activeborder",
+ "ui.activecaption",
+ "ui.appworkspace",
+ "ui.background",
+ "ui.buttonface",
+ "ui.buttonhighlight",
+ "ui.buttonshadow",
+ "ui.buttontext",
+ "ui.buttonborder",
+ "ui.captiontext",
+ "ui.-moz-field",
+ "ui.-moz-disabledfield",
+ "ui.-moz-fieldtext",
+ "ui.mark",
+ "ui.marktext",
+ "ui.-moz-comboboxtext",
+ "ui.-moz-combobox",
+ "ui.graytext",
+ "ui.highlight",
+ "ui.highlighttext",
+ "ui.inactiveborder",
+ "ui.inactivecaption",
+ "ui.inactivecaptiontext",
+ "ui.infobackground",
+ "ui.infotext",
+ "ui.menu",
+ "ui.menutext",
+ "ui.scrollbar",
+ "ui.threeddarkshadow",
+ "ui.threedface",
+ "ui.threedhighlight",
+ "ui.threedlightshadow",
+ "ui.threedshadow",
+ "ui.window",
+ "ui.windowframe",
+ "ui.windowtext",
+ "ui.-moz-buttondefault",
+ "ui.-moz-default-color",
+ "ui.-moz-default-background-color",
+ "ui.-moz-dialog",
+ "ui.-moz-dialogtext",
+ "ui.-moz-dragtargetzone",
+ "ui.-moz-cellhighlight",
+ "ui.-moz_cellhighlighttext",
+ "ui.selecteditem",
+ "ui.selecteditemtext",
+ "ui.-moz-buttonhoverface",
+ "ui.-moz_buttonhovertext",
+ "ui.-moz_menuhover",
+ "ui.-moz_menuhoverdisabled",
+ "ui.-moz_menuhovertext",
+ "ui.-moz_menubartext",
+ "ui.-moz_menubarhovertext",
+ "ui.-moz_eventreerow",
+ "ui.-moz_oddtreerow",
+ "ui.-moz-buttonactivetext",
+ "ui.-moz-buttonactiveface",
+ "ui.-moz-buttondisabledface",
+ "ui.-moz_mac_chrome_active",
+ "ui.-moz_mac_chrome_inactive",
+ "ui.-moz-mac-defaultbuttontext",
+ "ui.-moz-mac-focusring",
+ "ui.-moz-mac-menuselect",
+ "ui.-moz-mac-menushadow",
+ "ui.-moz-mac-menutextdisable",
+ "ui.-moz-mac-menutextselect",
+ "ui.-moz_mac_disabledtoolbartext",
+ "ui.-moz-mac-secondaryhighlight",
+ "ui.-moz-mac-menupopup",
+ "ui.-moz-mac-menuitem",
+ "ui.-moz-mac-active-menuitem",
+ "ui.-moz-mac-source-list",
+ "ui.-moz-mac-source-list-selection",
+ "ui.-moz-mac-active-source-list-selection",
+ "ui.-moz-mac-tooltip",
+ "ui.accentcolor",
+ "ui.accentcolortext",
+ "ui.-moz-autofill-background",
+ "ui.-moz-win-mediatext",
+ "ui.-moz-win-communicationstext",
+ "ui.-moz-nativehyperlinktext",
+ "ui.-moz-nativevisitedhyperlinktext",
+ "ui.-moz-hyperlinktext",
+ "ui.-moz-activehyperlinktext",
+ "ui.-moz-visitedhyperlinktext",
+ "ui.-moz-colheadertext",
+ "ui.-moz-colheaderhovertext",
+ "ui.textSelectDisabledBackground",
+ "ui.textSelectAttentionBackground",
+ "ui.textSelectAttentionForeground",
+ "ui.textHighlightBackground",
+ "ui.textHighlightForeground",
+ "ui.IMERawInputBackground",
+ "ui.IMERawInputForeground",
+ "ui.IMERawInputUnderline",
+ "ui.IMESelectedRawTextBackground",
+ "ui.IMESelectedRawTextForeground",
+ "ui.IMESelectedRawTextUnderline",
+ "ui.IMEConvertedTextBackground",
+ "ui.IMEConvertedTextForeground",
+ "ui.IMEConvertedTextUnderline",
+ "ui.IMESelectedConvertedTextBackground",
+ "ui.IMESelectedConvertedTextForeground",
+ "ui.IMESelectedConvertedTextUnderline",
+ "ui.SpellCheckerUnderline",
+ "ui.themedScrollbar",
+ "ui.themedScrollbarInactive",
+ "ui.themedScrollbarThumb",
+ "ui.themedScrollbarThumbHover",
+ "ui.themedScrollbarThumbActive",
+ "ui.themedScrollbarThumbInactive",
+};
+
+static_assert(ArrayLength(sColorPrefs) == size_t(LookAndFeel::ColorID::End),
+ "Should have a pref for each color value");
+
+// This array MUST be kept in the same order as the SystemFont enum.
+static const char sFontPrefs[][41] = {
+ "ui.font.caption",
+ "ui.font.icon",
+ "ui.font.menu",
+ "ui.font.message-box",
+ "ui.font.small-caption",
+ "ui.font.status-bar",
+ "ui.font.-moz-pull-down-menu",
+ "ui.font.-moz-button",
+ "ui.font.-moz-list",
+ "ui.font.-moz-field",
+};
+
+static_assert(ArrayLength(sFontPrefs) == size_t(LookAndFeel::FontID::End),
+ "Should have a pref for each font value");
+
+const char* nsXPLookAndFeel::GetColorPrefName(ColorID aId) {
+ return sColorPrefs[size_t(aId)];
+}
+
+bool nsXPLookAndFeel::sInitialized = false;
+
+nsXPLookAndFeel* nsXPLookAndFeel::sInstance = nullptr;
+bool nsXPLookAndFeel::sShutdown = false;
+
+auto LookAndFeel::SystemZoomSettings() -> ZoomSettings {
+ ZoomSettings settings;
+ switch (StaticPrefs::browser_display_os_zoom_behavior()) {
+ case 0:
+ default:
+ break;
+ case 1:
+ settings.mFullZoom = GetTextScaleFactor();
+ break;
+ case 2:
+ settings.mTextZoom = GetTextScaleFactor();
+ break;
+ }
+ return settings;
+}
+
+// static
+nsXPLookAndFeel* nsXPLookAndFeel::GetInstance() {
+ if (sInstance) {
+ return sInstance;
+ }
+
+ NS_ENSURE_TRUE(!sShutdown, nullptr);
+
+ // If we're in a content process, then the parent process will have supplied
+ // us with an initial FullLookAndFeel object.
+ // We grab this data from the ContentChild,
+ // where it's been temporarily stashed, and initialize our new LookAndFeel
+ // object with it.
+
+ FullLookAndFeel* lnf = nullptr;
+
+ if (auto* cc = mozilla::dom::ContentChild::GetSingleton()) {
+ lnf = &cc->BorrowLookAndFeelData();
+ }
+
+ if (lnf) {
+ sInstance = new widget::RemoteLookAndFeel(std::move(*lnf));
+ } else if (gfxPlatform::IsHeadless()) {
+ sInstance = new widget::HeadlessLookAndFeel();
+ } else {
+ sInstance = new nsLookAndFeel();
+ }
+
+ // This is only ever used once during initialization, and can be cleared now.
+ if (lnf) {
+ *lnf = {};
+ }
+
+ widget::Theme::Init();
+ return sInstance;
+}
+
+// static
+void nsXPLookAndFeel::Shutdown() {
+ if (sShutdown) {
+ return;
+ }
+
+ sShutdown = true;
+ delete sInstance;
+ sInstance = nullptr;
+
+ // This keeps strings alive, so need to clear to make leak checking happy.
+ sFontCache.Clear();
+
+ widget::Theme::Shutdown();
+}
+
+static void IntPrefChanged(const nsACString& aPref) {
+ // Most Int prefs can't change our system colors or fonts, but
+ // ui.systemUsesDarkTheme can, since it affects the effective color-scheme
+ // (affecting system colors).
+ auto changeKind = aPref.EqualsLiteral("ui.systemUsesDarkTheme")
+ ? widget::ThemeChangeKind::Style
+ : widget::ThemeChangeKind::MediaQueriesOnly;
+ LookAndFeel::NotifyChangedAllWindows(changeKind);
+}
+
+static void FloatPrefChanged(const nsACString& aPref) {
+ // Most float prefs can't change our system colors or fonts, but
+ // textScaleFactor affects layout.
+ auto changeKind = aPref.EqualsLiteral("ui.textScaleFactor")
+ ? widget::ThemeChangeKind::StyleAndLayout
+ : widget::ThemeChangeKind::MediaQueriesOnly;
+ LookAndFeel::NotifyChangedAllWindows(changeKind);
+}
+
+static void ColorPrefChanged() {
+ // Color prefs affect style, because they by definition change system colors.
+ LookAndFeel::NotifyChangedAllWindows(widget::ThemeChangeKind::Style);
+}
+
+static void FontPrefChanged() {
+ // Color prefs affect style, because they by definition change system fonts.
+ LookAndFeel::NotifyChangedAllWindows(widget::ThemeChangeKind::Style);
+}
+
+// static
+void nsXPLookAndFeel::OnPrefChanged(const char* aPref, void* aClosure) {
+ nsDependentCString prefName(aPref);
+ for (const char* pref : sIntPrefs) {
+ if (prefName.Equals(pref)) {
+ IntPrefChanged(prefName);
+ return;
+ }
+ }
+
+ for (const char* pref : sFloatPrefs) {
+ if (prefName.Equals(pref)) {
+ FloatPrefChanged(prefName);
+ return;
+ }
+ }
+
+ for (const char* pref : sColorPrefs) {
+ // We use StringBeginsWith to handle .dark prefs too.
+ if (StringBeginsWith(prefName, nsDependentCString(pref))) {
+ ColorPrefChanged();
+ return;
+ }
+ }
+
+ for (const char* pref : sFontPrefs) {
+ if (StringBeginsWith(prefName, nsDependentCString(pref))) {
+ FontPrefChanged();
+ return;
+ }
+ }
+}
+
+bool LookAndFeel::WindowsNonNativeMenusEnabled() {
+ switch (StaticPrefs::browser_display_windows_non_native_menus()) {
+ case 0:
+ return false;
+ case 1:
+ return true;
+ default:
+#ifdef XP_WIN
+ return IsWin10OrLater();
+#else
+ return false;
+#endif
+ }
+}
+
+static constexpr struct {
+ nsLiteralCString mName;
+ widget::ThemeChangeKind mChangeKind =
+ widget::ThemeChangeKind::MediaQueriesOnly;
+} kMediaQueryPrefs[] = {
+ {"browser.display.windows.non_native_menus"_ns},
+ // Affects whether standins are used for the accent color.
+ {"widget.non-native-theme.use-theme-accent"_ns,
+ widget::ThemeChangeKind::Style},
+ // These two affect system colors on Windows.
+ {"widget.windows.uwp-system-colors.enabled"_ns,
+ widget::ThemeChangeKind::Style},
+ // These two affect system colors on Windows.
+ {"widget.windows.uwp-system-colors.highlight-accent"_ns,
+ widget::ThemeChangeKind::Style},
+ // Affects env().
+ {"layout.css.prefers-color-scheme.content-override"_ns,
+ widget::ThemeChangeKind::Style},
+ // Affects media queries and scrollbar sizes, so gotta relayout.
+ {"widget.gtk.overlay-scrollbars.enabled"_ns,
+ widget::ThemeChangeKind::StyleAndLayout},
+ // Affects zoom settings which includes text and full zoom.
+ {"browser.display.os-zoom-behavior"_ns,
+ widget::ThemeChangeKind::StyleAndLayout},
+ // This affects not only the media query, but also the native theme, so we
+ // need to re-layout.
+ {"browser.theme.toolbar-theme"_ns, widget::ThemeChangeKind::AllBits},
+ {"browser.theme.content-theme"_ns},
+ {"mathml.legacy_maction_and_semantics_implementations.disabled"_ns},
+ {"mathml.ms_lquote_rquote_attributes.disabled"_ns},
+ {"dom.element.popover.enabled"_ns},
+};
+
+// Read values from the user's preferences.
+// This is done once at startup, but since the user's preferences
+// haven't actually been read yet at that time, we also have to
+// set a callback to inform us of changes to each pref.
+void nsXPLookAndFeel::Init() {
+ MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+ // Say we're already initialized, and take the chance that it might fail;
+ // protects against some other process writing to our static variables.
+ sInitialized = true;
+
+ RecomputeColorSchemes();
+
+ if (XRE_IsParentProcess()) {
+ nsLayoutUtils::RecomputeSmoothScrollDefault();
+ }
+
+ // XXX If we could reorganize the pref names, we should separate the branch
+ // for each types. Then, we could reduce the unnecessary loop from
+ // nsXPLookAndFeel::OnPrefChanged().
+ Preferences::RegisterPrefixCallback(OnPrefChanged, "ui.");
+ // We really do just want the accessibility.tabfocus pref, not other prefs
+ // that start with that string.
+ Preferences::RegisterCallback(OnPrefChanged, "accessibility.tabfocus");
+
+ for (auto& pref : kMediaQueryPrefs) {
+ Preferences::RegisterCallback(
+ [](const char*, void* aChangeKind) {
+ auto changeKind =
+ widget::ThemeChangeKind(reinterpret_cast<uintptr_t>(aChangeKind));
+ LookAndFeel::NotifyChangedAllWindows(changeKind);
+ },
+ pref.mName, reinterpret_cast<void*>(uintptr_t(pref.mChangeKind)));
+ }
+}
+
+nsXPLookAndFeel::~nsXPLookAndFeel() {
+ NS_ASSERTION(sInstance == this,
+ "This destroying instance isn't the singleton instance");
+ sInstance = nullptr;
+}
+
+static bool IsSpecialColor(LookAndFeel::ColorID aID, nscolor aColor) {
+ using ColorID = LookAndFeel::ColorID;
+
+ if (aColor == NS_SAME_AS_FOREGROUND_COLOR) {
+ return true;
+ }
+
+ switch (aID) {
+ case ColorID::IMESelectedRawTextBackground:
+ case ColorID::IMESelectedConvertedTextBackground:
+ case ColorID::IMERawInputBackground:
+ case ColorID::IMEConvertedTextBackground:
+ case ColorID::IMESelectedRawTextForeground:
+ case ColorID::IMESelectedConvertedTextForeground:
+ case ColorID::IMERawInputForeground:
+ case ColorID::IMEConvertedTextForeground:
+ case ColorID::IMERawInputUnderline:
+ case ColorID::IMEConvertedTextUnderline:
+ case ColorID::IMESelectedRawTextUnderline:
+ case ColorID::IMESelectedConvertedTextUnderline:
+ case ColorID::SpellCheckerUnderline:
+ return NS_IS_SELECTION_SPECIAL_COLOR(aColor);
+ default:
+ break;
+ }
+ /*
+ * In GetColor(), every color that is not a special color is color
+ * corrected. Use false to make other colors color corrected.
+ */
+ return false;
+}
+
+nscolor nsXPLookAndFeel::GetStandinForNativeColor(ColorID aID,
+ ColorScheme aScheme) {
+ if (aScheme == ColorScheme::Dark) {
+ if (auto color = GenericDarkColor(aID)) {
+ return *color;
+ }
+ }
+
+ // The stand-in colors are taken from what the non-native theme needs (for
+ // field/button colors), the Windows 7 Aero theme except Mac-specific colors
+ // which are taken from Mac OS 10.7.
+
+#define COLOR(name_, r, g, b) \
+ case ColorID::name_: \
+ return NS_RGB(r, g, b);
+
+#define COLORA(name_, r, g, b, a) \
+ case ColorID::name_: \
+ return NS_RGBA(r, g, b, a);
+
+ switch (aID) {
+ // These are here for the purposes of headless mode.
+ case ColorID::IMESelectedRawTextBackground:
+ case ColorID::IMESelectedConvertedTextBackground:
+ case ColorID::IMERawInputBackground:
+ case ColorID::IMEConvertedTextBackground:
+ return NS_TRANSPARENT;
+ case ColorID::IMESelectedRawTextForeground:
+ case ColorID::IMESelectedConvertedTextForeground:
+ case ColorID::IMERawInputForeground:
+ case ColorID::IMEConvertedTextForeground:
+ return NS_SAME_AS_FOREGROUND_COLOR;
+ case ColorID::IMERawInputUnderline:
+ case ColorID::IMEConvertedTextUnderline:
+ return NS_40PERCENT_FOREGROUND_COLOR;
+ case ColorID::Accentcolor:
+ return widget::sDefaultAccent.ToABGR();
+ case ColorID::Accentcolortext:
+ return widget::sDefaultAccentText.ToABGR();
+ COLOR(SpellCheckerUnderline, 0xff, 0x00, 0x00)
+ COLOR(TextSelectDisabledBackground, 0xaa, 0xaa, 0xaa)
+
+ // CSS 2 colors:
+ COLOR(Activeborder, 0xB4, 0xB4, 0xB4)
+ COLOR(Activecaption, 0x99, 0xB4, 0xD1)
+ COLOR(Appworkspace, 0xAB, 0xAB, 0xAB)
+ COLOR(Background, 0x00, 0x00, 0x00)
+ COLOR(Buttonhighlight, 0xFF, 0xFF, 0xFF)
+ COLOR(Buttonshadow, 0xA0, 0xA0, 0xA0)
+
+ // Buttons and comboboxes should be kept in sync since they are drawn with
+ // the same colors by the non-native theme.
+ COLOR(Buttonface, 0xe9, 0xe9, 0xed)
+ COLORA(MozButtondisabledface, 0xe9, 0xe9, 0xed, 128)
+
+ COLOR(MozCombobox, 0xe9, 0xe9, 0xed)
+
+ COLOR(Buttontext, 0x00, 0x00, 0x00)
+ COLOR(MozComboboxtext, 0x00, 0x00, 0x00)
+
+ COLOR(Captiontext, 0x00, 0x00, 0x00)
+ COLOR(Graytext, 0x6D, 0x6D, 0x6D)
+ COLOR(Highlight, 0x33, 0x99, 0xFF)
+ COLOR(Highlighttext, 0xFF, 0xFF, 0xFF)
+ COLOR(Inactiveborder, 0xF4, 0xF7, 0xFC)
+ COLOR(Inactivecaption, 0xBF, 0xCD, 0xDB)
+ COLOR(Inactivecaptiontext, 0x43, 0x4E, 0x54)
+ COLOR(Infobackground, 0xFF, 0xFF, 0xE1)
+ COLOR(Infotext, 0x00, 0x00, 0x00)
+ COLOR(Menu, 0xF0, 0xF0, 0xF0)
+ COLOR(Menutext, 0x00, 0x00, 0x00)
+ COLOR(Scrollbar, 0xC8, 0xC8, 0xC8)
+ COLOR(Threeddarkshadow, 0x69, 0x69, 0x69)
+ COLOR(Threedface, 0xF0, 0xF0, 0xF0)
+ COLOR(Threedhighlight, 0xFF, 0xFF, 0xFF)
+ COLOR(Threedlightshadow, 0xE3, 0xE3, 0xE3)
+ COLOR(Threedshadow, 0xA0, 0xA0, 0xA0)
+ COLOR(Buttonborder, 0xE3, 0xE3, 0xE3)
+ COLOR(Mark, 0xFF, 0xFF, 0x00)
+ COLOR(Marktext, 0x00, 0x00, 0x00)
+ COLOR(Window, 0xFF, 0xFF, 0xFF)
+ COLOR(Windowframe, 0x64, 0x64, 0x64)
+ COLOR(Windowtext, 0x00, 0x00, 0x00)
+ COLOR(MozButtondefault, 0x69, 0x69, 0x69)
+ COLOR(Field, 0xFF, 0xFF, 0xFF)
+ COLORA(MozDisabledfield, 0xFF, 0xFF, 0xFF, 128)
+ COLOR(Fieldtext, 0x00, 0x00, 0x00)
+ COLOR(MozDialog, 0xF0, 0xF0, 0xF0)
+ COLOR(MozDialogtext, 0x00, 0x00, 0x00)
+ COLOR(MozColheadertext, 0x00, 0x00, 0x00)
+ COLOR(MozColheaderhovertext, 0x00, 0x00, 0x00)
+ COLOR(MozDragtargetzone, 0xFF, 0xFF, 0xFF)
+ COLOR(MozCellhighlight, 0xF0, 0xF0, 0xF0)
+ COLOR(MozCellhighlighttext, 0x00, 0x00, 0x00)
+ COLOR(Selecteditem, 0x33, 0x99, 0xFF)
+ COLOR(Selecteditemtext, 0xFF, 0xFF, 0xFF)
+ COLOR(MozButtonhoverface, 0xd0, 0xd0, 0xd7)
+ COLOR(MozButtonhovertext, 0x00, 0x00, 0x00)
+ COLOR(MozButtonactiveface, 0xb1, 0xb1, 0xb9)
+ COLOR(MozButtonactivetext, 0x00, 0x00, 0x00)
+ COLOR(MozMenuhover, 0x33, 0x99, 0xFF)
+ COLOR(MozMenuhovertext, 0x00, 0x00, 0x00)
+ COLOR(MozMenubartext, 0x00, 0x00, 0x00)
+ COLOR(MozMenubarhovertext, 0x00, 0x00, 0x00)
+ COLOR(MozMenuhoverdisabled, 0xF0, 0xF0, 0xF0)
+ COLOR(MozEventreerow, 0xFF, 0xFF, 0xFF)
+ COLOR(MozOddtreerow, 0xFF, 0xFF, 0xFF)
+ COLOR(MozMacChromeActive, 0xB2, 0xB2, 0xB2)
+ COLOR(MozMacChromeInactive, 0xE1, 0xE1, 0xE1)
+ COLOR(MozMacFocusring, 0x60, 0x9D, 0xD7)
+ COLOR(MozMacMenuselect, 0x38, 0x75, 0xD7)
+ COLOR(MozMacMenushadow, 0xA3, 0xA3, 0xA3)
+ COLOR(MozMacMenutextdisable, 0x88, 0x88, 0x88)
+ COLOR(MozMacMenutextselect, 0xFF, 0xFF, 0xFF)
+ COLOR(MozMacDisabledtoolbartext, 0x3F, 0x3F, 0x3F)
+ COLOR(MozMacSecondaryhighlight, 0xD4, 0xD4, 0xD4)
+ COLOR(MozMacMenupopup, 0xe6, 0xe6, 0xe6)
+ COLOR(MozMacMenuitem, 0xe6, 0xe6, 0xe6)
+ COLOR(MozMacActiveMenuitem, 0x0a, 0x64, 0xdc)
+ COLOR(MozMacSourceList, 0xf7, 0xf7, 0xf7)
+ COLOR(MozMacSourceListSelection, 0xc8, 0xc8, 0xc8)
+ COLOR(MozMacActiveSourceListSelection, 0x0a, 0x64, 0xdc)
+ COLOR(MozMacTooltip, 0xf7, 0xf7, 0xf7)
+ // Seems to be the default color (hardcoded because of bug 1065998)
+ COLOR(MozWinMediatext, 0xFF, 0xFF, 0xFF)
+ COLOR(MozWinCommunicationstext, 0xFF, 0xFF, 0xFF)
+ COLOR(MozNativehyperlinktext, 0x00, 0x66, 0xCC)
+ COLOR(MozNativevisitedhyperlinktext, 0x55, 0x1A, 0x8B)
+ default:
+ break;
+ }
+ return NS_RGB(0xFF, 0xFF, 0xFF);
+}
+
+#undef COLOR
+#undef COLORA
+
+// Taken from in-content/common.inc.css's dark theme.
+Maybe<nscolor> nsXPLookAndFeel::GenericDarkColor(ColorID aID) {
+ nscolor color = NS_RGB(0, 0, 0);
+ static constexpr nscolor kWindowBackground = NS_RGB(28, 27, 34);
+ static constexpr nscolor kWindowText = NS_RGB(251, 251, 254);
+ switch (aID) {
+ case ColorID::Window: // --in-content-page-background
+ case ColorID::Background:
+ color = kWindowBackground;
+ break;
+
+ case ColorID::Menu:
+ color = NS_RGB(0x2b, 0x2a, 0x33);
+ break;
+
+ case ColorID::MozMenuhovertext:
+ case ColorID::MozMenubarhovertext:
+ case ColorID::Menutext:
+ color = NS_RGB(0xfb, 0xfb, 0xfe);
+ break;
+
+ case ColorID::MozMenuhover:
+ color = NS_RGB(0x52, 0x52, 0x5e);
+ break;
+
+ case ColorID::MozMenuhoverdisabled:
+ color = NS_RGB(0x3a, 0x39, 0x44);
+ break;
+
+ case ColorID::MozOddtreerow:
+ case ColorID::MozDialog: // --in-content-box-background
+ color = NS_RGB(35, 34, 43);
+ break;
+ case ColorID::Windowtext: // --in-content-page-color
+ case ColorID::MozDialogtext:
+ case ColorID::Fieldtext:
+ case ColorID::Buttontext: // --in-content-button-text-color (via
+ // --in-content-page-color)
+ case ColorID::MozComboboxtext:
+ case ColorID::MozButtonhovertext:
+ case ColorID::MozButtonactivetext:
+ color = kWindowText;
+ break;
+ case ColorID::Buttonshadow:
+ case ColorID::Threedshadow:
+ case ColorID::Threedlightshadow:
+ case ColorID::Buttonborder: // --in-content-box-border-color computed
+ // with kWindowText above
+ // kWindowBackground.
+ case ColorID::Graytext: // opacity: 0.4 of kWindowText blended over the
+ // "Window" background color, which happens to be
+ // the same :-)
+ color = NS_ComposeColors(kWindowBackground, NS_RGBA(251, 251, 254, 102));
+ break;
+ case ColorID::MozCellhighlight:
+ case ColorID::Selecteditem: // --in-content-primary-button-background /
+ // --in-content-item-selected
+ color = NS_RGB(0, 221, 255);
+ break;
+ case ColorID::Field:
+ case ColorID::Buttonface: // --in-content-button-background
+ case ColorID::Threedface:
+ case ColorID::MozCombobox:
+ case ColorID::MozCellhighlighttext:
+ case ColorID::Selecteditemtext: // --in-content-primary-button-text-color /
+ // --in-content-item-selected-text
+ color = NS_RGB(43, 42, 51);
+ break;
+ case ColorID::Threeddarkshadow: // Same as Threedlightshadow but with the
+ // background.
+ case ColorID::MozDisabledfield: // opacity: 0.4 of the face above blended
+ // over the "Window" background color.
+ case ColorID::MozButtondisabledface:
+ color = NS_ComposeColors(kWindowBackground, NS_RGBA(43, 42, 51, 102));
+ break;
+ case ColorID::MozButtonhoverface: // --in-content-button-background-hover
+ color = NS_RGB(82, 82, 94);
+ break;
+ case ColorID::MozButtonactiveface: // --in-content-button-background-active
+ color = NS_RGB(91, 91, 102);
+ break;
+ case ColorID::Highlight:
+ color = NS_RGBA(0, 221, 255, 78);
+ break;
+ case ColorID::Highlighttext:
+ color = NS_SAME_AS_FOREGROUND_COLOR;
+ break;
+ case ColorID::MozNativehyperlinktext:
+ // If you change this color, you probably also want to change the default
+ // value of browser.anchor_color.dark.
+ color = NS_RGB(0x8c, 0x8c, 0xff);
+ break;
+ case ColorID::MozNativevisitedhyperlinktext:
+ // If you change this color, you probably also want to change the default
+ // value of browser.visited_color.dark.
+ color = NS_RGB(0xff, 0xad, 0xff);
+ break;
+ case ColorID::SpellCheckerUnderline:
+ // This is the default for active links in dark mode as well
+ // (browser.active_color.dark). See bug 1755564 for some analysis and
+ // other options too.
+ color = NS_RGB(0xff, 0x66, 0x66);
+ break;
+ default:
+ return Nothing();
+ }
+ return Some(color);
+}
+
+// Uncomment the #define below if you want to debug system color use in a skin
+// that uses them. When set, it will make all system color pairs that are
+// appropriate for foreground/background pairing the same. This means if the
+// skin is using system colors correctly you will not be able to see *any* text.
+//
+// #define DEBUG_SYSTEM_COLOR_USE
+
+#ifdef DEBUG_SYSTEM_COLOR_USE
+static nsresult SystemColorUseDebuggingColor(LookAndFeel::ColorID aID,
+ nscolor& aResult) {
+ using ColorID = LookAndFeel::ColorID;
+
+ switch (aID) {
+ // css2 http://www.w3.org/TR/REC-CSS2/ui.html#system-colors
+ case ColorID::Activecaption:
+ // active window caption background
+ case ColorID::Captiontext:
+ // text in active window caption
+ aResult = NS_RGB(0xff, 0x00, 0x00);
+ break;
+
+ case ColorID::Highlight:
+ // background of selected item
+ case ColorID::Highlighttext:
+ // text of selected item
+ aResult = NS_RGB(0xff, 0xff, 0x00);
+ break;
+
+ case ColorID::Inactivecaption:
+ // inactive window caption
+ case ColorID::Inactivecaptiontext:
+ // text in inactive window caption
+ aResult = NS_RGB(0x66, 0x66, 0x00);
+ break;
+
+ case ColorID::Infobackground:
+ // tooltip background color
+ case ColorID::Infotext:
+ // tooltip text color
+ aResult = NS_RGB(0x00, 0xff, 0x00);
+ break;
+
+ case ColorID::Menu:
+ // menu background
+ case ColorID::Menutext:
+ // menu text
+ aResult = NS_RGB(0x00, 0xff, 0xff);
+ break;
+
+ case ColorID::Threedface:
+ case ColorID::Buttonface:
+ // 3-D face color
+ case ColorID::Buttontext:
+ // text on push buttons
+ aResult = NS_RGB(0x00, 0x66, 0x66);
+ break;
+
+ case ColorID::Window:
+ case ColorID::Windowtext:
+ aResult = NS_RGB(0x00, 0x00, 0xff);
+ break;
+
+ // from the CSS3 working draft (not yet finalized)
+ // http://www.w3.org/tr/2000/wd-css3-userint-20000216.html#color
+
+ case ColorID::Field:
+ case ColorID::Fieldtext:
+ aResult = NS_RGB(0xff, 0x00, 0xff);
+ break;
+
+ case ColorID::MozDialog:
+ case ColorID::MozDialogtext:
+ aResult = NS_RGB(0x66, 0x00, 0x66);
+ break;
+
+ default:
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ return NS_OK;
+}
+#endif
+
+static nsresult GetPrefColor(const char* aPref, nscolor& aResult) {
+ nsAutoCString colorStr;
+ MOZ_TRY(Preferences::GetCString(aPref, colorStr));
+ if (!ServoCSSParser::ComputeColor(nullptr, NS_RGB(0, 0, 0), colorStr,
+ &aResult)) {
+ return NS_ERROR_FAILURE;
+ }
+ return NS_OK;
+}
+
+static nsresult GetColorFromPref(LookAndFeel::ColorID aID, ColorScheme aScheme,
+ nscolor& aResult) {
+ const char* prefName = sColorPrefs[size_t(aID)];
+ if (aScheme == ColorScheme::Dark) {
+ nsAutoCString darkPrefName(prefName);
+ darkPrefName.Append(".dark");
+ if (NS_SUCCEEDED(GetPrefColor(darkPrefName.get(), aResult))) {
+ return NS_OK;
+ }
+ }
+ return GetPrefColor(prefName, aResult);
+}
+
+// All these routines will return NS_OK if they have a value,
+// in which case the nsLookAndFeel should use that value;
+// otherwise we'll return NS_ERROR_NOT_AVAILABLE, in which case, the
+// platform-specific nsLookAndFeel should use its own values instead.
+nsresult nsXPLookAndFeel::GetColorValue(ColorID aID, ColorScheme aScheme,
+ UseStandins aUseStandins,
+ nscolor& aResult) {
+ if (!sInitialized) {
+ Init();
+ }
+
+#ifdef DEBUG_SYSTEM_COLOR_USE
+ if (NS_SUCCEEDED(SystemColorUseDebuggingColor(aID, aResult))) {
+ return NS_OK;
+ }
+#endif
+
+ auto& cache = sColorCaches.Get(aScheme, aUseStandins);
+ if (const auto* cached = cache.Get(aID)) {
+ if (cached->isNothing()) {
+ return NS_ERROR_FAILURE;
+ }
+ aResult = cached->value();
+ return NS_OK;
+ }
+
+ // NOTE: Servo holds a lock and the main thread is paused, so writing to the
+ // global cache here is fine.
+ auto result = GetUncachedColor(aID, aScheme, aUseStandins);
+ cache.Insert(aID, result);
+ if (!result) {
+ return NS_ERROR_FAILURE;
+ }
+ aResult = *result;
+ return NS_OK;
+}
+
+Maybe<nscolor> nsXPLookAndFeel::GetUncachedColor(ColorID aID,
+ ColorScheme aScheme,
+ UseStandins aUseStandins) {
+ if (aUseStandins == UseStandins::Yes) {
+ return Some(GetStandinForNativeColor(aID, aScheme));
+ }
+ nscolor r;
+ if (NS_SUCCEEDED(GetColorFromPref(aID, aScheme, r))) {
+ return Some(r);
+ }
+ if (NS_SUCCEEDED(NativeGetColor(aID, aScheme, r))) {
+ if (gfxPlatform::GetCMSMode() == CMSMode::All && !IsSpecialColor(aID, r)) {
+ qcms_transform* transform = gfxPlatform::GetCMSInverseRGBTransform();
+ if (transform) {
+ uint8_t color[4];
+ color[0] = NS_GET_R(r);
+ color[1] = NS_GET_G(r);
+ color[2] = NS_GET_B(r);
+ color[3] = NS_GET_A(r);
+ qcms_transform_data(transform, color, color, 1);
+ r = NS_RGBA(color[0], color[1], color[2], color[3]);
+ }
+ }
+
+ return Some(r);
+ }
+ return Nothing();
+}
+
+nsresult nsXPLookAndFeel::GetIntValue(IntID aID, int32_t& aResult) {
+ if (!sInitialized) {
+ Init();
+ }
+
+ if (const auto* cached = sIntCache.Get(aID)) {
+ if (cached->isNothing()) {
+ return NS_ERROR_FAILURE;
+ }
+ aResult = cached->value();
+ return NS_OK;
+ }
+
+ if (NS_SUCCEEDED(Preferences::GetInt(sIntPrefs[size_t(aID)], &aResult))) {
+ sIntCache.Insert(aID, Some(aResult));
+ return NS_OK;
+ }
+
+ if (NS_FAILED(NativeGetInt(aID, aResult))) {
+ sIntCache.Insert(aID, Nothing());
+ return NS_ERROR_FAILURE;
+ }
+
+ sIntCache.Insert(aID, Some(aResult));
+ return NS_OK;
+}
+
+nsresult nsXPLookAndFeel::GetFloatValue(FloatID aID, float& aResult) {
+ if (!sInitialized) {
+ Init();
+ }
+
+ if (const auto* cached = sFloatCache.Get(aID)) {
+ if (cached->isNothing()) {
+ return NS_ERROR_FAILURE;
+ }
+ aResult = cached->value();
+ return NS_OK;
+ }
+
+ int32_t pref = 0;
+ if (NS_SUCCEEDED(Preferences::GetInt(sFloatPrefs[size_t(aID)], &pref))) {
+ aResult = float(pref) / 100.0f;
+ sFloatCache.Insert(aID, Some(aResult));
+ return NS_OK;
+ }
+
+ if (NS_FAILED(NativeGetFloat(aID, aResult))) {
+ sFloatCache.Insert(aID, Nothing());
+ return NS_ERROR_FAILURE;
+ }
+
+ sFloatCache.Insert(aID, Some(aResult));
+ return NS_OK;
+}
+
+bool nsXPLookAndFeel::LookAndFeelFontToStyle(const LookAndFeelFont& aFont,
+ nsString& aName,
+ gfxFontStyle& aStyle) {
+ if (!aFont.haveFont()) {
+ return false;
+ }
+ aName = aFont.name();
+ aStyle = gfxFontStyle();
+ aStyle.size = aFont.size();
+ aStyle.weight = FontWeight::FromInt(aFont.weight());
+ aStyle.style =
+ aFont.italic() ? FontSlantStyle::ITALIC : FontSlantStyle::NORMAL;
+ aStyle.systemFont = true;
+ return true;
+}
+
+widget::LookAndFeelFont nsXPLookAndFeel::StyleToLookAndFeelFont(
+ const nsAString& aName, const gfxFontStyle& aStyle) {
+ LookAndFeelFont font;
+ font.haveFont() = true;
+ font.name() = aName;
+ font.size() = aStyle.size;
+ font.weight() = aStyle.weight.ToFloat();
+ font.italic() = aStyle.style.IsItalic();
+ MOZ_ASSERT(aStyle.style.IsNormal() || aStyle.style.IsItalic(),
+ "Cannot handle oblique font style");
+#ifdef DEBUG
+ {
+ // Assert that all the remaining font style properties have their
+ // default values.
+ gfxFontStyle candidate = aStyle;
+ gfxFontStyle defaults{};
+ candidate.size = defaults.size;
+ candidate.weight = defaults.weight;
+ candidate.style = defaults.style;
+ MOZ_ASSERT(candidate.Equals(defaults),
+ "Some font style properties not supported");
+ }
+#endif
+ return font;
+}
+
+bool nsXPLookAndFeel::GetFontValue(FontID aID, nsString& aName,
+ gfxFontStyle& aStyle) {
+ if (const LookAndFeelFont* cached = sFontCache.Get(aID)) {
+ return LookAndFeelFontToStyle(*cached, aName, aStyle);
+ }
+
+ LookAndFeelFont font;
+ auto GetFontsFromPrefs = [&]() -> bool {
+ nsDependentCString pref(sFontPrefs[size_t(aID)]);
+ if (NS_FAILED(Preferences::GetString(pref.get(), aName))) {
+ return false;
+ }
+ font.haveFont() = true;
+ font.name() = aName;
+ font.size() = Preferences::GetFloat(nsAutoCString(pref + ".size"_ns).get());
+ // This is written this way rather than using the fallback so that an empty
+ // pref (such like the one about:config creates) doesn't cause system fonts
+ // to have zero-size.
+ if (font.size() < 1.0f) {
+ font.size() = StyleFONT_MEDIUM_PX;
+ }
+ font.weight() = Preferences::GetFloat(
+ nsAutoCString(pref + ".weight"_ns).get(), FontWeight::NORMAL.ToFloat());
+ font.italic() =
+ Preferences::GetBool(nsAutoCString(pref + ".italic"_ns).get());
+ return true;
+ };
+
+ if (GetFontsFromPrefs()) {
+ LookAndFeelFontToStyle(font, aName, aStyle);
+ } else if (NativeGetFont(aID, aName, aStyle)) {
+ font = StyleToLookAndFeelFont(aName, aStyle);
+ } else {
+ MOZ_ASSERT(!font.haveFont());
+ }
+ bool success = font.haveFont();
+ sFontCache.Insert(aID, std::move(font));
+ return success;
+}
+
+void nsXPLookAndFeel::RefreshImpl() {
+ // Wipe out our caches.
+ sColorCaches.Clear();
+ sFontCache.Clear();
+ sFloatCache.Clear();
+ sIntCache.Clear();
+ RecomputeColorSchemes();
+
+ if (XRE_IsParentProcess()) {
+ nsLayoutUtils::RecomputeSmoothScrollDefault();
+ // Clear any cached FullLookAndFeel data, which is now invalid.
+ widget::RemoteLookAndFeel::ClearCachedData();
+ }
+}
+
+static bool sRecordedLookAndFeelTelemetry = false;
+
+void nsXPLookAndFeel::RecordTelemetry() {
+ if (!XRE_IsParentProcess()) {
+ return;
+ }
+
+ if (sRecordedLookAndFeelTelemetry) {
+ return;
+ }
+
+ sRecordedLookAndFeelTelemetry = true;
+
+ int32_t i;
+ Telemetry::ScalarSet(
+ Telemetry::ScalarID::WIDGET_DARK_MODE,
+ NS_SUCCEEDED(GetIntValue(IntID::SystemUsesDarkTheme, i)) && i != 0);
+
+ RecordLookAndFeelSpecificTelemetry();
+}
+
+namespace mozilla {
+
+static widget::ThemeChangeKind sGlobalThemeChangeKind{0};
+
+void LookAndFeel::NotifyChangedAllWindows(widget::ThemeChangeKind aKind) {
+ sGlobalThemeChanged = true;
+ sGlobalThemeChangeKind |= aKind;
+
+ if (nsCOMPtr<nsIObserverService> obs = services::GetObserverService()) {
+ const char16_t kind[] = {char16_t(aKind), 0};
+ obs->NotifyObservers(nullptr, "internal-look-and-feel-changed", kind);
+ }
+}
+
+void LookAndFeel::DoHandleGlobalThemeChange() {
+ MOZ_ASSERT(sGlobalThemeChanged);
+ sGlobalThemeChanged = false;
+ auto kind = std::exchange(sGlobalThemeChangeKind, widget::ThemeChangeKind(0));
+
+ // Tell the theme that it changed, so it can flush any handles to stale theme
+ // data.
+ //
+ // We can use the *DoNotUseDirectly functions directly here, because we want
+ // to notify all possible themes in a given process (but just once).
+ if (XRE_IsParentProcess() ||
+ !StaticPrefs::widget_non_native_theme_enabled()) {
+ if (nsCOMPtr<nsITheme> theme = do_GetNativeThemeDoNotUseDirectly()) {
+ theme->ThemeChanged();
+ }
+ }
+ if (nsCOMPtr<nsITheme> theme = do_GetBasicNativeThemeDoNotUseDirectly()) {
+ theme->ThemeChanged();
+ }
+
+ // Clear all cached LookAndFeel colors.
+ LookAndFeel::Refresh();
+
+ // Reset default background and foreground colors for the document since they
+ // may be using system colors.
+ PreferenceSheet::Refresh();
+
+ // Vector images (SVG) may be using theme colors so we discard all cached
+ // surfaces. (We could add a vector image only version of DiscardAll, but
+ // in bug 940625 we decided theme changes are rare enough not to bother.)
+ image::SurfaceCacheUtils::DiscardAll();
+
+ if (XRE_IsParentProcess()) {
+ dom::ContentParent::BroadcastThemeUpdate(kind);
+ }
+
+ nsContentUtils::AddScriptRunner(
+ NS_NewRunnableFunction("HandleGlobalThemeChange", [] {
+ if (nsCOMPtr<nsIObserverService> obs = services::GetObserverService()) {
+ obs->NotifyObservers(nullptr, "look-and-feel-changed", nullptr);
+ }
+ }));
+}
+
+#define BIT_FOR(_c) (1ull << size_t(ColorID::_c))
+
+// We want to use a non-native color scheme for the non-native theme (except in
+// high-contrast mode), so spoof some of the colors with stand-ins to prevent
+// lack of contrast.
+static constexpr std::bitset<size_t(ColorID::End)> sNonNativeThemeStandinColors{
+ // Used by default button styles.
+ BIT_FOR(Buttonface) | BIT_FOR(Buttontext) | BIT_FOR(MozButtonhoverface) |
+ BIT_FOR(MozButtonhovertext) | BIT_FOR(MozButtonactiveface) |
+ BIT_FOR(MozButtonactivetext) | BIT_FOR(MozButtondisabledface) |
+ BIT_FOR(Buttonborder) |
+ // Used by select elements.
+ BIT_FOR(MozCombobox) | BIT_FOR(MozComboboxtext) |
+ BIT_FOR(Threedlightshadow) |
+ // For symmetry with the above.
+ BIT_FOR(Threeddarkshadow) |
+ // Used by fieldset borders.
+ BIT_FOR(Threedface) |
+ // Used by input / textarea.
+ BIT_FOR(Field) | BIT_FOR(Fieldtext) |
+ // Used by disabled form controls.
+ BIT_FOR(MozDisabledfield) | BIT_FOR(Graytext) |
+ // Some pages expect these to return windows-like colors, see bug 1773795.
+ // Also, per spec these should match Canvas/CanvasText, see
+ // https://drafts.csswg.org/css-color-4/#window
+ BIT_FOR(Window) | BIT_FOR(Windowtext)};
+#undef BIT_FOR
+
+static bool ShouldUseStandinsForNativeColorForNonNativeTheme(
+ const dom::Document& aDoc, LookAndFeel::ColorID aColor,
+ const PreferenceSheet::Prefs& aPrefs) {
+ const bool shouldUseStandinsForColor = [&] {
+ if (sNonNativeThemeStandinColors[size_t(aColor)]) {
+ return true;
+ }
+ // There are platforms where we want the content-exposed accent color to be
+ // the windows blue rather than the system accent color, for now.
+ return !StaticPrefs::widget_non_native_theme_use_theme_accent() &&
+ (aColor == LookAndFeel::ColorID::Accentcolor ||
+ aColor == LookAndFeel::ColorID::Accentcolortext);
+ }();
+
+ return shouldUseStandinsForColor && aDoc.ShouldAvoidNativeTheme() &&
+ !aPrefs.NonNativeThemeShouldBeHighContrast();
+}
+
+ColorScheme LookAndFeel::sChromeColorScheme;
+ColorScheme LookAndFeel::sContentColorScheme;
+bool LookAndFeel::sColorSchemeInitialized;
+bool LookAndFeel::sGlobalThemeChanged;
+
+bool LookAndFeel::IsDarkColor(nscolor aColor) {
+ // Given https://www.w3.org/TR/WCAG20/#contrast-ratiodef, this is the
+ // threshold that tells us whether contrast is better against white or black.
+ //
+ // Contrast ratio against black is: (L + 0.05) / 0.05
+ // Contrast ratio against white is: 1.05 / (L + 0.05)
+ //
+ // So the intersection is:
+ //
+ // (L + 0.05) / 0.05 = 1.05 / (L + 0.05)
+ //
+ // And the solution to that equation is:
+ //
+ // sqrt(1.05 * 0.05) - 0.05
+ //
+ // So we consider a color dark if the contrast is below this threshold, and
+ // it's at least half-opaque.
+ constexpr float kThreshold = 0.179129;
+ return NS_GET_A(aColor) > 127 &&
+ RelativeLuminanceUtils::Compute(aColor) < kThreshold;
+}
+
+auto LookAndFeel::ColorSchemeSettingForChrome() -> ChromeColorSchemeSetting {
+ switch (StaticPrefs::browser_theme_toolbar_theme()) {
+ case 0: // Dark
+ return ChromeColorSchemeSetting::Dark;
+ case 1: // Light
+ return ChromeColorSchemeSetting::Light;
+ default:
+ return ChromeColorSchemeSetting::System;
+ }
+}
+
+ColorScheme LookAndFeel::ThemeDerivedColorSchemeForContent() {
+ switch (StaticPrefs::browser_theme_content_theme()) {
+ case 0: // Dark
+ return ColorScheme::Dark;
+ case 1: // Light
+ return ColorScheme::Light;
+ default:
+ return SystemColorScheme();
+ }
+}
+
+void LookAndFeel::RecomputeColorSchemes() {
+ sColorSchemeInitialized = true;
+
+ sChromeColorScheme = [] {
+ switch (ColorSchemeSettingForChrome()) {
+ case ChromeColorSchemeSetting::Light:
+ return ColorScheme::Light;
+ case ChromeColorSchemeSetting::Dark:
+ return ColorScheme::Dark;
+ case ChromeColorSchemeSetting::System:
+ break;
+ }
+ return SystemColorScheme();
+ }();
+
+ sContentColorScheme = [] {
+ switch (StaticPrefs::layout_css_prefers_color_scheme_content_override()) {
+ case 0:
+ return ColorScheme::Dark;
+ case 1:
+ return ColorScheme::Light;
+ default:
+ return ThemeDerivedColorSchemeForContent();
+ }
+ }();
+}
+
+ColorScheme LookAndFeel::ColorSchemeForStyle(
+ const dom::Document& aDoc, const StyleColorSchemeFlags& aFlags,
+ ColorSchemeMode aMode) {
+ using Choice = PreferenceSheet::Prefs::ColorSchemeChoice;
+
+ const auto& prefs = PreferenceSheet::PrefsFor(aDoc);
+ switch (prefs.mColorSchemeChoice) {
+ case Choice::Standard:
+ break;
+ case Choice::UserPreferred:
+ return aDoc.PreferredColorScheme();
+ case Choice::Light:
+ return ColorScheme::Light;
+ case Choice::Dark:
+ return ColorScheme::Dark;
+ }
+
+ StyleColorSchemeFlags style(aFlags);
+ if (!style) {
+ style.bits = aDoc.GetColorSchemeBits();
+ }
+ const bool supportsDark = bool(style & StyleColorSchemeFlags::DARK);
+ const bool supportsLight = bool(style & StyleColorSchemeFlags::LIGHT);
+ if (supportsLight && supportsDark) {
+ // Both color-schemes are explicitly supported, use the preferred one.
+ return aDoc.PreferredColorScheme();
+ }
+ if (supportsDark || supportsLight) {
+ // One color-scheme is explicitly supported and one isn't, so use the one
+ // the content supports.
+ return supportsDark ? ColorScheme::Dark : ColorScheme::Light;
+ }
+ // No value specified. Chrome docs always supports both, so use the preferred
+ // color-scheme.
+ if (aMode == ColorSchemeMode::Preferred ||
+ nsContentUtils::IsChromeDoc(&aDoc)) {
+ return aDoc.PreferredColorScheme();
+ }
+ // Default content to light.
+ return ColorScheme::Light;
+}
+
+LookAndFeel::ColorScheme LookAndFeel::ColorSchemeForFrame(
+ const nsIFrame* aFrame, ColorSchemeMode aMode) {
+ return ColorSchemeForStyle(*aFrame->PresContext()->Document(),
+ aFrame->StyleUI()->mColorScheme.bits, aMode);
+}
+
+// static
+Maybe<nscolor> LookAndFeel::GetColor(ColorID aId, ColorScheme aScheme,
+ UseStandins aUseStandins) {
+ nscolor result;
+ nsresult rv = nsLookAndFeel::GetInstance()->GetColorValue(
+ aId, aScheme, aUseStandins, result);
+ if (NS_FAILED(rv)) {
+ return Nothing();
+ }
+ return Some(result);
+}
+
+// Returns whether there is a CSS color name for this color.
+static bool ColorIsCSSAccessible(LookAndFeel::ColorID aId) {
+ using ColorID = LookAndFeel::ColorID;
+
+ switch (aId) {
+ case ColorID::TextSelectDisabledBackground:
+ case ColorID::TextSelectAttentionBackground:
+ case ColorID::TextSelectAttentionForeground:
+ case ColorID::TextHighlightBackground:
+ case ColorID::TextHighlightForeground:
+ case ColorID::ThemedScrollbar:
+ case ColorID::ThemedScrollbarInactive:
+ case ColorID::ThemedScrollbarThumb:
+ case ColorID::ThemedScrollbarThumbActive:
+ case ColorID::ThemedScrollbarThumbInactive:
+ case ColorID::ThemedScrollbarThumbHover:
+ case ColorID::IMERawInputBackground:
+ case ColorID::IMERawInputForeground:
+ case ColorID::IMERawInputUnderline:
+ case ColorID::IMESelectedRawTextBackground:
+ case ColorID::IMESelectedRawTextForeground:
+ case ColorID::IMESelectedRawTextUnderline:
+ case ColorID::IMEConvertedTextBackground:
+ case ColorID::IMEConvertedTextForeground:
+ case ColorID::IMEConvertedTextUnderline:
+ case ColorID::IMESelectedConvertedTextBackground:
+ case ColorID::IMESelectedConvertedTextForeground:
+ case ColorID::IMESelectedConvertedTextUnderline:
+ case ColorID::SpellCheckerUnderline:
+ return false;
+ default:
+ break;
+ }
+
+ return true;
+}
+
+LookAndFeel::UseStandins LookAndFeel::ShouldUseStandins(
+ const dom::Document& aDoc, ColorID aId) {
+ const auto& prefs = PreferenceSheet::PrefsFor(aDoc);
+ if (ShouldUseStandinsForNativeColorForNonNativeTheme(aDoc, aId, prefs)) {
+ return UseStandins::Yes;
+ }
+ if (prefs.mUseStandins && ColorIsCSSAccessible(aId)) {
+ return UseStandins::Yes;
+ }
+ return UseStandins::No;
+}
+
+Maybe<nscolor> LookAndFeel::GetColor(ColorID aId, const nsIFrame* aFrame) {
+ const auto* doc = aFrame->PresContext()->Document();
+ return GetColor(aId, ColorSchemeForFrame(aFrame),
+ ShouldUseStandins(*doc, aId));
+}
+
+// static
+nsresult LookAndFeel::GetInt(IntID aID, int32_t* aResult) {
+ return nsLookAndFeel::GetInstance()->GetIntValue(aID, *aResult);
+}
+
+// static
+nsresult LookAndFeel::GetFloat(FloatID aID, float* aResult) {
+ return nsLookAndFeel::GetInstance()->GetFloatValue(aID, *aResult);
+}
+
+// static
+bool LookAndFeel::GetFont(FontID aID, nsString& aName, gfxFontStyle& aStyle) {
+ return nsLookAndFeel::GetInstance()->GetFontValue(aID, aName, aStyle);
+}
+
+// static
+char16_t LookAndFeel::GetPasswordCharacter() {
+ return nsLookAndFeel::GetInstance()->GetPasswordCharacterImpl();
+}
+
+// static
+bool LookAndFeel::GetEchoPassword() {
+ if (StaticPrefs::editor_password_mask_delay() >= 0) {
+ return StaticPrefs::editor_password_mask_delay() > 0;
+ }
+ return nsLookAndFeel::GetInstance()->GetEchoPasswordImpl();
+}
+
+// static
+uint32_t LookAndFeel::GetPasswordMaskDelay() {
+ int32_t delay = StaticPrefs::editor_password_mask_delay();
+ if (delay < 0) {
+ return nsLookAndFeel::GetInstance()->GetPasswordMaskDelayImpl();
+ }
+ return delay;
+}
+
+bool LookAndFeel::DrawInTitlebar() {
+ switch (StaticPrefs::browser_tabs_inTitlebar()) {
+ case 0:
+ return false;
+ case 1:
+ return true;
+ default:
+ break;
+ }
+ return nsLookAndFeel::GetInstance()->GetDefaultDrawInTitlebar();
+}
+
+void LookAndFeel::GetThemeInfo(nsACString& aOut) {
+ nsLookAndFeel::GetInstance()->GetThemeInfo(aOut);
+}
+
+uint32_t LookAndFeel::GetMenuAccessKey() {
+ return StaticPrefs::ui_key_menuAccessKey();
+}
+
+Modifiers LookAndFeel::GetMenuAccessKeyModifiers() {
+ switch (GetMenuAccessKey()) {
+ case dom::KeyboardEvent_Binding::DOM_VK_SHIFT:
+ return MODIFIER_SHIFT;
+ case dom::KeyboardEvent_Binding::DOM_VK_CONTROL:
+ return MODIFIER_CONTROL;
+ case dom::KeyboardEvent_Binding::DOM_VK_ALT:
+ return MODIFIER_ALT;
+ case dom::KeyboardEvent_Binding::DOM_VK_META:
+ return MODIFIER_META;
+ case dom::KeyboardEvent_Binding::DOM_VK_WIN:
+ return MODIFIER_OS;
+ default:
+ return 0;
+ }
+}
+
+// static
+void LookAndFeel::Refresh() {
+ nsLookAndFeel::GetInstance()->RefreshImpl();
+ widget::Theme::LookAndFeelChanged();
+}
+
+// static
+void LookAndFeel::NativeInit() { nsLookAndFeel::GetInstance()->NativeInit(); }
+
+// static
+void LookAndFeel::SetData(widget::FullLookAndFeel&& aTables) {
+ nsLookAndFeel::GetInstance()->SetDataImpl(std::move(aTables));
+}
+
+} // namespace mozilla