diff options
Diffstat (limited to 'widget/gtk/nsLookAndFeel.cpp')
| -rw-r--r-- | widget/gtk/nsLookAndFeel.cpp | 2329 |
1 files changed, 2329 insertions, 0 deletions
diff --git a/widget/gtk/nsLookAndFeel.cpp b/widget/gtk/nsLookAndFeel.cpp new file mode 100644 index 0000000000..c4b430d2eb --- /dev/null +++ b/widget/gtk/nsLookAndFeel.cpp @@ -0,0 +1,2329 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:expandtab:shiftwidth=2:tabstop=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/. */ + +// for strtod() +#include <stdlib.h> +#include <dlfcn.h> + +#include "nsLookAndFeel.h" + +#include <gtk/gtk.h> +#include <gdk/gdk.h> + +#include <pango/pango.h> +#include <pango/pango-fontmap.h> +#include <fontconfig/fontconfig.h> + +#include "GRefPtr.h" +#include "GUniquePtr.h" +#include "nsGtkUtils.h" +#include "gfxPlatformGtk.h" +#include "mozilla/FontPropertyTypes.h" +#include "mozilla/Preferences.h" +#include "mozilla/RelativeLuminanceUtils.h" +#include "mozilla/StaticPrefs_layout.h" +#include "mozilla/StaticPrefs_widget.h" +#include "mozilla/StaticPrefs_browser.h" +#include "mozilla/AutoRestore.h" +#include "mozilla/Telemetry.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/WidgetUtilsGtk.h" +#include "ScreenHelperGTK.h" +#include "ScrollbarDrawing.h" + +#include "gtkdrawing.h" +#include "nsString.h" +#include "nsStyleConsts.h" +#include "gfxFontConstants.h" +#include "WidgetUtils.h" +#include "nsWindow.h" + +#include "mozilla/gfx/2D.h" + +#include <cairo-gobject.h> +#include <dlfcn.h> +#include "WidgetStyleCache.h" +#include "prenv.h" +#include "nsCSSColorUtils.h" +#include "mozilla/Preferences.h" + +using namespace mozilla; +using namespace mozilla::widget; + +#ifdef MOZ_LOGGING +# include "mozilla/Logging.h" +# include "nsTArray.h" +# include "Units.h" +static LazyLogModule gLnfLog("LookAndFeel"); +# define LOGLNF(...) MOZ_LOG(gLnfLog, LogLevel::Debug, (__VA_ARGS__)) +# define LOGLNF_ENABLED() MOZ_LOG_TEST(gLnfLog, LogLevel::Debug) +#else +# define LOGLNF(args) +# define LOGLNF_ENABLED() false +#endif /* MOZ_LOGGING */ + +#define GDK_COLOR_TO_NS_RGB(c) \ + ((nscolor)NS_RGB(c.red >> 8, c.green >> 8, c.blue >> 8)) +#define GDK_RGBA_TO_NS_RGBA(c) \ + ((nscolor)NS_RGBA((int)((c).red * 255), (int)((c).green * 255), \ + (int)((c).blue * 255), (int)((c).alpha * 255))) + +static bool sIgnoreChangedSettings = false; + +static void OnSettingsChange() { + if (sIgnoreChangedSettings) { + return; + } + // TODO: We could be more granular here, but for now assume everything + // changed. + LookAndFeel::NotifyChangedAllWindows(widget::ThemeChangeKind::StyleAndLayout); + widget::IMContextWrapper::OnThemeChanged(); +} + +static void settings_changed_cb(GtkSettings*, GParamSpec*, void*) { + OnSettingsChange(); +} + +static bool sCSDAvailable; + +static nsCString GVariantToString(GVariant* aVariant) { + nsCString ret; + gchar* s = g_variant_print(aVariant, TRUE); + if (s) { + ret.Assign(s); + g_free(s); + } + return ret; +} + +static nsDependentCString GVariantGetString(GVariant* aVariant) { + gsize len = 0; + const gchar* v = g_variant_get_string(aVariant, &len); + return nsDependentCString(v, len); +} + +static void settings_changed_signal_cb(GDBusProxy* proxy, gchar* sender_name, + gchar* signal_name, GVariant* parameters, + gpointer user_data) { + LOGLNF("Settings Change sender=%s signal=%s params=%s\n", sender_name, + signal_name, GVariantToString(parameters).get()); + if (strcmp(signal_name, "SettingChanged")) { + NS_WARNING("Unknown change signal for settings"); + return; + } + RefPtr<GVariant> ns = dont_AddRef(g_variant_get_child_value(parameters, 0)); + RefPtr<GVariant> key = dont_AddRef(g_variant_get_child_value(parameters, 1)); + // Third parameter is the value, but we don't care about it. + if (!ns || !key || !g_variant_is_of_type(ns, G_VARIANT_TYPE_STRING) || + !g_variant_is_of_type(key, G_VARIANT_TYPE_STRING)) { + MOZ_ASSERT(false, "Unexpected setting change signal parameters"); + return; + } + + auto* lnf = static_cast<nsLookAndFeel*>(user_data); + + auto nsStr = GVariantGetString(ns); + auto keyStr = GVariantGetString(key); + if (nsStr.Equals("org.freedesktop.appearance"_ns) && + keyStr.Equals("color-scheme"_ns)) { + lnf->OnColorSchemeSettingChanged(); + } +} + +void nsLookAndFeel::WatchDBus() { + GUniquePtr<GError> error; + mDBusSettingsProxy = dont_AddRef(g_dbus_proxy_new_for_bus_sync( + G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, nullptr, + "org.freedesktop.portal.Desktop", "/org/freedesktop/portal/desktop", + "org.freedesktop.portal.Settings", nullptr, getter_Transfers(error))); + if (mDBusSettingsProxy) { + g_signal_connect(mDBusSettingsProxy, "g-signal", + G_CALLBACK(settings_changed_signal_cb), this); + } else { + LOGLNF("Can't create DBus proxy for settings: %s\n", error->message); + return; + } + + // DBus interface was started after L&F init so we need to load + // our settings from DBus explicitly. + if (!sIgnoreChangedSettings) { + OnColorSchemeSettingChanged(); + } +} + +void nsLookAndFeel::UnwatchDBus() { + if (mDBusSettingsProxy) { + g_signal_handlers_disconnect_by_func( + mDBusSettingsProxy, FuncToGpointer(settings_changed_signal_cb), this); + mDBusSettingsProxy = nullptr; + } +} + +nsLookAndFeel::nsLookAndFeel() { + static constexpr nsLiteralCString kObservedSettings[] = { + // Affects system font sizes. + "notify::gtk-xft-dpi"_ns, + // Affects mSystemTheme and mAltTheme as expected. + "notify::gtk-theme-name"_ns, + // System fonts? + "notify::gtk-font-name"_ns, + // prefers-reduced-motion + "notify::gtk-enable-animations"_ns, + // CSD media queries, etc. + "notify::gtk-decoration-layout"_ns, + // Text resolution affects system font and widget sizes. + "notify::resolution"_ns, + // These three Affect mCaretBlinkTime + "notify::gtk-cursor-blink"_ns, + "notify::gtk-cursor-blink-time"_ns, + "notify::gtk-cursor-blink-timeout"_ns, + // Affects SelectTextfieldsOnKeyFocus + "notify::gtk-entry-select-on-focus"_ns, + // Affects ScrollToClick + "notify::gtk-primary-button-warps-slider"_ns, + // Affects SubmenuDelay + "notify::gtk-menu-popup-delay"_ns, + // Affects DragThresholdX/Y + "notify::gtk-dnd-drag-threshold"_ns, + // Affects titlebar actions loaded at moz_gtk_refresh(). + "notify::gtk-titlebar-double-click"_ns, + "notify::gtk-titlebar-middle-click"_ns, + }; + + GtkSettings* settings = gtk_settings_get_default(); + for (const auto& setting : kObservedSettings) { + g_signal_connect_after(settings, setting.get(), + G_CALLBACK(settings_changed_cb), nullptr); + } + + sCSDAvailable = + nsWindow::GetSystemGtkWindowDecoration() != nsWindow::GTK_DECORATION_NONE; + + if (ShouldUsePortal(PortalKind::Settings)) { + mDBusID = g_bus_watch_name( + G_BUS_TYPE_SESSION, "org.freedesktop.portal.Desktop", + G_BUS_NAME_WATCHER_FLAGS_AUTO_START, + [](GDBusConnection*, const gchar*, const gchar*, + gpointer data) -> void { + auto* lnf = static_cast<nsLookAndFeel*>(data); + lnf->WatchDBus(); + }, + [](GDBusConnection*, const gchar*, gpointer data) -> void { + auto* lnf = static_cast<nsLookAndFeel*>(data); + lnf->UnwatchDBus(); + }, + this, nullptr); + } + if (IsKdeDesktopEnvironment()) { + GUniquePtr<gchar> path( + g_strconcat(g_get_user_config_dir(), "/gtk-3.0/colors.css", NULL)); + mKdeColors = dont_AddRef(g_file_new_for_path(path.get())); + mKdeColorsMonitor = dont_AddRef( + g_file_monitor_file(mKdeColors.get(), G_FILE_MONITOR_NONE, NULL, NULL)); + if (mKdeColorsMonitor) { + g_signal_connect(mKdeColorsMonitor.get(), "changed", + G_CALLBACK(settings_changed_cb), NULL); + } + } +} + +nsLookAndFeel::~nsLookAndFeel() { + ClearRoundedCornerProvider(); + if (mDBusID) { + g_bus_unwatch_name(mDBusID); + mDBusID = 0; + } + UnwatchDBus(); + g_signal_handlers_disconnect_by_func( + gtk_settings_get_default(), FuncToGpointer(settings_changed_cb), nullptr); +} + +#if 0 +static void DumpStyleContext(GtkStyleContext* aStyle) { + static auto sGtkStyleContextToString = + reinterpret_cast<char* (*)(GtkStyleContext*, gint)>( + dlsym(RTLD_DEFAULT, "gtk_style_context_to_string")); + char* str = sGtkStyleContextToString(aStyle, ~0); + printf("%s\n", str); + g_free(str); + str = gtk_widget_path_to_string(gtk_style_context_get_path(aStyle)); + printf("%s\n", str); + g_free(str); +} +#endif + +// Modifies color |*aDest| as if a pattern of color |aSource| was painted with +// CAIRO_OPERATOR_OVER to a surface with color |*aDest|. +static void ApplyColorOver(const GdkRGBA& aSource, GdkRGBA* aDest) { + gdouble sourceCoef = aSource.alpha; + gdouble destCoef = aDest->alpha * (1.0 - sourceCoef); + gdouble resultAlpha = sourceCoef + destCoef; + if (resultAlpha != 0.0) { // don't divide by zero + destCoef /= resultAlpha; + sourceCoef /= resultAlpha; + aDest->red = sourceCoef * aSource.red + destCoef * aDest->red; + aDest->green = sourceCoef * aSource.green + destCoef * aDest->green; + aDest->blue = sourceCoef * aSource.blue + destCoef * aDest->blue; + aDest->alpha = resultAlpha; + } +} + +static void GetLightAndDarkness(const GdkRGBA& aColor, double* aLightness, + double* aDarkness) { + double sum = aColor.red + aColor.green + aColor.blue; + *aLightness = sum * aColor.alpha; + *aDarkness = (3.0 - sum) * aColor.alpha; +} + +static bool GetGradientColors(const GValue* aValue, GdkRGBA* aLightColor, + GdkRGBA* aDarkColor) { + if (!G_TYPE_CHECK_VALUE_TYPE(aValue, CAIRO_GOBJECT_TYPE_PATTERN)) { + return false; + } + + auto pattern = static_cast<cairo_pattern_t*>(g_value_get_boxed(aValue)); + if (!pattern) { + return false; + } + + // Just picking the lightest and darkest colors as simple samples rather + // than trying to blend, which could get messy if there are many stops. + if (CAIRO_STATUS_SUCCESS != + cairo_pattern_get_color_stop_rgba(pattern, 0, nullptr, &aDarkColor->red, + &aDarkColor->green, &aDarkColor->blue, + &aDarkColor->alpha)) { + return false; + } + + double maxLightness, maxDarkness; + GetLightAndDarkness(*aDarkColor, &maxLightness, &maxDarkness); + *aLightColor = *aDarkColor; + + GdkRGBA stop; + for (int index = 1; + CAIRO_STATUS_SUCCESS == + cairo_pattern_get_color_stop_rgba(pattern, index, nullptr, &stop.red, + &stop.green, &stop.blue, &stop.alpha); + ++index) { + double lightness, darkness; + GetLightAndDarkness(stop, &lightness, &darkness); + if (lightness > maxLightness) { + maxLightness = lightness; + *aLightColor = stop; + } + if (darkness > maxDarkness) { + maxDarkness = darkness; + *aDarkColor = stop; + } + } + + return true; +} + +static bool GetColorFromImagePattern(const GValue* aValue, nscolor* aColor) { + if (!G_TYPE_CHECK_VALUE_TYPE(aValue, CAIRO_GOBJECT_TYPE_PATTERN)) { + return false; + } + + auto* pattern = static_cast<cairo_pattern_t*>(g_value_get_boxed(aValue)); + if (!pattern) { + return false; + } + + cairo_surface_t* surface; + if (cairo_pattern_get_surface(pattern, &surface) != CAIRO_STATUS_SUCCESS) { + return false; + } + + cairo_format_t format = cairo_image_surface_get_format(surface); + if (format == CAIRO_FORMAT_INVALID) { + return false; + } + int width = cairo_image_surface_get_width(surface); + int height = cairo_image_surface_get_height(surface); + int stride = cairo_image_surface_get_stride(surface); + if (!width || !height) { + return false; + } + + // Guesstimate the central pixel would have a sensible color. + int x = width / 2; + int y = height / 2; + + unsigned char* data = cairo_image_surface_get_data(surface); + switch (format) { + // Most (all?) GTK images / patterns / etc use ARGB32. + case CAIRO_FORMAT_ARGB32: { + size_t offset = x * 4 + y * stride; + uint32_t* pixel = reinterpret_cast<uint32_t*>(data + offset); + *aColor = gfx::sRGBColor::UnusualFromARGB(*pixel).ToABGR(); + return true; + } + default: + break; + } + + return false; +} + +static bool GetUnicoBorderGradientColors(GtkStyleContext* aContext, + GdkRGBA* aLightColor, + GdkRGBA* aDarkColor) { + // Ubuntu 12.04 has GTK engine Unico-1.0.2, which overrides render_frame, + // providing its own border code. Ubuntu 14.04 has + // Unico-1.0.3+14.04.20140109, which does not override render_frame, and + // so does not need special attention. The earlier Unico can be detected + // by the -unico-border-gradient style property it registers. + // gtk_style_properties_lookup_property() is checked first to avoid the + // warning from gtk_style_context_get_property() when the property does + // not exist. (gtk_render_frame() of GTK+ 3.16 no longer uses the + // engine.) + const char* propertyName = "-unico-border-gradient"; + if (!gtk_style_properties_lookup_property(propertyName, nullptr, nullptr)) + return false; + + // -unico-border-gradient is used only when the CSS node's engine is Unico. + GtkThemingEngine* engine; + GtkStateFlags state = gtk_style_context_get_state(aContext); + gtk_style_context_get(aContext, state, "engine", &engine, nullptr); + if (strcmp(g_type_name(G_TYPE_FROM_INSTANCE(engine)), "UnicoEngine") != 0) + return false; + + // draw_border() of Unico engine uses -unico-border-gradient + // in preference to border-color. + GValue value = G_VALUE_INIT; + gtk_style_context_get_property(aContext, propertyName, state, &value); + + bool result = GetGradientColors(&value, aLightColor, aDarkColor); + + g_value_unset(&value); + return result; +} + +// Sets |aLightColor| and |aDarkColor| to colors from |aContext|. Returns +// true if |aContext| uses these colors to render a visible border. +// If returning false, then the colors returned are a fallback from the +// border-color value even though |aContext| does not use these colors to +// render a border. +static bool GetBorderColors(GtkStyleContext* aContext, GdkRGBA* aLightColor, + GdkRGBA* aDarkColor) { + // Determine whether the border on this style context is visible. + GtkStateFlags state = gtk_style_context_get_state(aContext); + GtkBorderStyle borderStyle; + gtk_style_context_get(aContext, state, GTK_STYLE_PROPERTY_BORDER_STYLE, + &borderStyle, nullptr); + bool visible = borderStyle != GTK_BORDER_STYLE_NONE && + borderStyle != GTK_BORDER_STYLE_HIDDEN; + if (visible) { + // GTK has an initial value of zero for border-widths, and so themes + // need to explicitly set border-widths to make borders visible. + GtkBorder border; + gtk_style_context_get_border(aContext, state, &border); + visible = border.top != 0 || border.right != 0 || border.bottom != 0 || + border.left != 0; + } + + if (visible && + GetUnicoBorderGradientColors(aContext, aLightColor, aDarkColor)) + return true; + + // The initial value for the border-color is the foreground color, and so + // this will usually return a color distinct from the background even if + // there is no visible border detected. + gtk_style_context_get_border_color(aContext, state, aDarkColor); + // TODO GTK3 - update aLightColor + // for GTK_BORDER_STYLE_INSET/OUTSET/GROVE/RIDGE border styles. + // https://bugzilla.mozilla.org/show_bug.cgi?id=978172#c25 + *aLightColor = *aDarkColor; + return visible; +} + +static bool GetBorderColors(GtkStyleContext* aContext, nscolor* aLightColor, + nscolor* aDarkColor) { + GdkRGBA lightColor, darkColor; + bool ret = GetBorderColors(aContext, &lightColor, &darkColor); + *aLightColor = GDK_RGBA_TO_NS_RGBA(lightColor); + *aDarkColor = GDK_RGBA_TO_NS_RGBA(darkColor); + return ret; +} + +// Finds ideal cell highlight colors used for unfocused+selected cells distinct +// from both Highlight, used as focused+selected background, and the listbox +// background which is assumed to be similar to -moz-field +void nsLookAndFeel::PerThemeData::InitCellHighlightColors() { + int32_t minLuminosityDifference = NS_SUFFICIENT_LUMINOSITY_DIFFERENCE_BG; + int32_t backLuminosityDifference = + NS_LUMINOSITY_DIFFERENCE(mWindow.mBg, mField.mBg); + if (backLuminosityDifference >= minLuminosityDifference) { + mCellHighlight = mWindow; + return; + } + + uint16_t hue, sat, luminance; + uint8_t alpha; + mCellHighlight = mField; + + NS_RGB2HSV(mCellHighlight.mBg, hue, sat, luminance, alpha); + + uint16_t step = 30; + // Lighten the color if the color is very dark + if (luminance <= step) { + luminance += step; + } + // Darken it if it is very light + else if (luminance >= 255 - step) { + luminance -= step; + } + // Otherwise, compute what works best depending on the text luminance. + else { + uint16_t textHue, textSat, textLuminance; + uint8_t textAlpha; + NS_RGB2HSV(mCellHighlight.mFg, textHue, textSat, textLuminance, textAlpha); + // Text is darker than background, use a lighter shade + if (textLuminance < luminance) { + luminance += step; + } + // Otherwise, use a darker shade + else { + luminance -= step; + } + } + NS_HSV2RGB(mCellHighlight.mBg, hue, sat, luminance, alpha); +} + +void nsLookAndFeel::NativeInit() { EnsureInit(); } + +void nsLookAndFeel::RefreshImpl() { + mInitialized = false; + moz_gtk_refresh(); + + nsXPLookAndFeel::RefreshImpl(); +} + +nsresult nsLookAndFeel::NativeGetColor(ColorID aID, ColorScheme aScheme, + nscolor& aColor) { + EnsureInit(); + + const auto& theme = + aScheme == ColorScheme::Light ? LightTheme() : DarkTheme(); + return theme.GetColor(aID, aColor); +} + +static bool ShouldUseColorForActiveDarkScrollbarThumb(nscolor aColor) { + auto IsDifferentEnough = [](int32_t aChannel, int32_t aOtherChannel) { + return std::abs(aChannel - aOtherChannel) > 10; + }; + return IsDifferentEnough(NS_GET_R(aColor), NS_GET_G(aColor)) || + IsDifferentEnough(NS_GET_R(aColor), NS_GET_B(aColor)); +} + +static bool ShouldUseThemedScrollbarColor(StyleSystemColor aID, nscolor aColor, + bool aIsDark) { + if (!aIsDark) { + return true; + } + if (StaticPrefs::widget_non_native_theme_scrollbar_dark_themed()) { + return true; + } + return aID == StyleSystemColor::ThemedScrollbarThumbActive && + StaticPrefs::widget_non_native_theme_scrollbar_active_always_themed(); +} + +nsresult nsLookAndFeel::PerThemeData::GetColor(ColorID aID, + nscolor& aColor) const { + nsresult res = NS_OK; + + switch (aID) { + // These colors don't seem to be used for anything anymore in Mozilla + // The CSS2 colors below are used. + case ColorID::Appworkspace: // MDI background color + case ColorID::Background: // desktop background + case ColorID::Window: + case ColorID::Windowframe: + case ColorID::MozCombobox: + aColor = mWindow.mBg; + break; + case ColorID::Windowtext: + aColor = mWindow.mFg; + break; + case ColorID::MozDialog: + aColor = mDialog.mBg; + break; + case ColorID::MozDialogtext: + aColor = mDialog.mFg; + break; + case ColorID::IMESelectedRawTextBackground: + case ColorID::IMESelectedConvertedTextBackground: + case ColorID::Highlight: // preference selected item, + aColor = mSelectedText.mBg; + break; + case ColorID::Highlighttext: + if (NS_GET_A(mSelectedText.mBg) < 155) { + aColor = NS_SAME_AS_FOREGROUND_COLOR; + break; + } + [[fallthrough]]; + case ColorID::IMESelectedRawTextForeground: + case ColorID::IMESelectedConvertedTextForeground: + aColor = mSelectedText.mFg; + break; + case ColorID::Selecteditem: + aColor = mSelectedItem.mBg; + break; + case ColorID::Selecteditemtext: + aColor = mSelectedItem.mFg; + break; + case ColorID::Accentcolor: + aColor = mAccent.mBg; + break; + case ColorID::Accentcolortext: + aColor = mAccent.mFg; + break; + case ColorID::MozCellhighlight: + aColor = mCellHighlight.mBg; + break; + case ColorID::MozCellhighlighttext: + aColor = mCellHighlight.mFg; + break; + case ColorID::IMERawInputBackground: + case ColorID::IMEConvertedTextBackground: + aColor = NS_TRANSPARENT; + break; + case ColorID::IMERawInputForeground: + case ColorID::IMEConvertedTextForeground: + aColor = NS_SAME_AS_FOREGROUND_COLOR; + break; + case ColorID::IMERawInputUnderline: + case ColorID::IMEConvertedTextUnderline: + aColor = NS_SAME_AS_FOREGROUND_COLOR; + break; + case ColorID::IMESelectedRawTextUnderline: + case ColorID::IMESelectedConvertedTextUnderline: + aColor = NS_TRANSPARENT; + break; + case ColorID::Scrollbar: + aColor = mThemedScrollbar; + break; + case ColorID::ThemedScrollbar: + aColor = mThemedScrollbar; + if (!ShouldUseThemedScrollbarColor(aID, aColor, mIsDark)) { + return NS_ERROR_FAILURE; + } + break; + case ColorID::ThemedScrollbarInactive: + aColor = mThemedScrollbarInactive; + if (!ShouldUseThemedScrollbarColor(aID, aColor, mIsDark)) { + return NS_ERROR_FAILURE; + } + break; + case ColorID::ThemedScrollbarThumb: + aColor = mThemedScrollbarThumb; + if (!ShouldUseThemedScrollbarColor(aID, aColor, mIsDark)) { + return NS_ERROR_FAILURE; + } + break; + case ColorID::ThemedScrollbarThumbHover: + aColor = mThemedScrollbarThumbHover; + if (!ShouldUseThemedScrollbarColor(aID, aColor, mIsDark)) { + return NS_ERROR_FAILURE; + } + break; + case ColorID::ThemedScrollbarThumbActive: + aColor = mThemedScrollbarThumbActive; + if (!ShouldUseThemedScrollbarColor(aID, aColor, mIsDark)) { + return NS_ERROR_FAILURE; + } + break; + case ColorID::ThemedScrollbarThumbInactive: + aColor = mThemedScrollbarThumbInactive; + if (!ShouldUseThemedScrollbarColor(aID, aColor, mIsDark)) { + return NS_ERROR_FAILURE; + } + break; + + // css2 http://www.w3.org/TR/REC-CSS2/ui.html#system-colors + case ColorID::Activeborder: + // active window border + aColor = mMozWindowActiveBorder; + break; + case ColorID::Inactiveborder: + // inactive window border + aColor = mMozWindowInactiveBorder; + break; + case ColorID::Graytext: // disabled text in windows, menus, etc. + aColor = mGrayText; + break; + case ColorID::Activecaption: + aColor = mTitlebar.mBg; + break; + case ColorID::Captiontext: // text in active window caption (titlebar) + aColor = mTitlebar.mFg; + break; + case ColorID::Inactivecaption: + // inactive window caption + aColor = mTitlebarInactive.mBg; + break; + case ColorID::Inactivecaptiontext: + aColor = mTitlebarInactive.mFg; + break; + case ColorID::Infobackground: + aColor = mInfo.mBg; + break; + case ColorID::Infotext: + aColor = mInfo.mFg; + break; + case ColorID::Menu: + aColor = mMenu.mBg; + break; + case ColorID::Menutext: + aColor = mMenu.mFg; + break; + case ColorID::MozHeaderbar: + aColor = mHeaderBar.mBg; + break; + case ColorID::MozHeaderbartext: + aColor = mHeaderBar.mFg; + break; + case ColorID::MozHeaderbarinactive: + aColor = mHeaderBarInactive.mBg; + break; + case ColorID::MozHeaderbarinactivetext: + aColor = mHeaderBarInactive.mFg; + break; + case ColorID::Threedface: + case ColorID::Buttonface: + case ColorID::MozButtondisabledface: + // 3-D face color + aColor = mWindow.mBg; + break; + + case ColorID::Buttontext: + // text on push buttons + aColor = mButton.mFg; + break; + + case ColorID::Buttonhighlight: + // 3-D highlighted edge color + case ColorID::Threedhighlight: + // 3-D highlighted outer edge color + aColor = mThreeDHighlight; + break; + + case ColorID::Buttonshadow: + // 3-D shadow edge color + case ColorID::Threedshadow: + // 3-D shadow inner edge color + aColor = mThreeDShadow; + break; + case ColorID::Buttonborder: + aColor = mButtonBorder; + break; + case ColorID::Threedlightshadow: + case ColorID::MozDisabledfield: + aColor = mIsDark ? *GenericDarkColor(aID) : NS_RGB(0xE0, 0xE0, 0xE0); + break; + case ColorID::Threeddarkshadow: + aColor = mIsDark ? *GenericDarkColor(aID) : NS_RGB(0xDC, 0xDC, 0xDC); + break; + + case ColorID::MozEventreerow: + case ColorID::Field: + aColor = mField.mBg; + break; + case ColorID::Fieldtext: + aColor = mField.mFg; + break; + case ColorID::MozSidebar: + aColor = mSidebar.mBg; + break; + case ColorID::MozSidebartext: + aColor = mSidebar.mFg; + break; + case ColorID::MozSidebarborder: + aColor = mSidebarBorder; + break; + case ColorID::MozButtonhoverface: + aColor = mButtonHover.mBg; + break; + case ColorID::MozButtonhovertext: + aColor = mButtonHover.mFg; + break; + case ColorID::MozButtonactiveface: + aColor = mButtonActive.mBg; + break; + case ColorID::MozButtonactivetext: + aColor = mButtonActive.mFg; + break; + case ColorID::MozMenuhover: + aColor = mMenuHover.mBg; + break; + case ColorID::MozMenuhovertext: + aColor = mMenuHover.mFg; + break; + case ColorID::MozMenuhoverdisabled: + aColor = NS_TRANSPARENT; + break; + case ColorID::MozOddtreerow: + aColor = mOddCellBackground; + break; + case ColorID::MozNativehyperlinktext: + aColor = mNativeHyperLinkText; + break; + case ColorID::MozNativevisitedhyperlinktext: + aColor = mNativeVisitedHyperLinkText; + break; + case ColorID::MozComboboxtext: + aColor = mComboBoxText; + break; + case ColorID::MozColheader: + aColor = mMozColHeader.mBg; + break; + case ColorID::MozColheadertext: + aColor = mMozColHeader.mFg; + break; + case ColorID::MozColheaderhover: + aColor = mMozColHeaderHover.mBg; + break; + case ColorID::MozColheaderhovertext: + aColor = mMozColHeaderHover.mFg; + break; + case ColorID::MozColheaderactive: + aColor = mMozColHeaderActive.mBg; + break; + case ColorID::MozColheaderactivetext: + aColor = mMozColHeaderActive.mFg; + break; + case ColorID::SpellCheckerUnderline: + case ColorID::Mark: + case ColorID::Marktext: + aColor = GetStandinForNativeColor( + aID, mIsDark ? ColorScheme::Dark : ColorScheme::Light); + break; + default: + /* default color is BLACK */ + aColor = 0; + res = NS_ERROR_FAILURE; + break; + } + + return res; +} + +static int32_t CheckWidgetStyle(GtkWidget* aWidget, const char* aStyle, + int32_t aResult) { + gboolean value = FALSE; + gtk_widget_style_get(aWidget, aStyle, &value, nullptr); + return value ? aResult : 0; +} + +static int32_t ConvertGTKStepperStyleToMozillaScrollArrowStyle( + GtkWidget* aWidget) { + if (!aWidget) return mozilla::LookAndFeel::eScrollArrowStyle_Single; + + return CheckWidgetStyle(aWidget, "has-backward-stepper", + mozilla::LookAndFeel::eScrollArrow_StartBackward) | + CheckWidgetStyle(aWidget, "has-forward-stepper", + mozilla::LookAndFeel::eScrollArrow_EndForward) | + CheckWidgetStyle(aWidget, "has-secondary-backward-stepper", + mozilla::LookAndFeel::eScrollArrow_EndBackward) | + CheckWidgetStyle(aWidget, "has-secondary-forward-stepper", + mozilla::LookAndFeel::eScrollArrow_StartForward); +} + +nsresult nsLookAndFeel::NativeGetInt(IntID aID, int32_t& aResult) { + nsresult res = NS_OK; + + // We use delayed initialization by EnsureInit() here + // to make sure mozilla::Preferences is available (Bug 115807). + // IntID::UseAccessibilityTheme is requested before user preferences + // are read, and so EnsureInit(), which depends on preference values, + // is deliberately delayed until required. + switch (aID) { + case IntID::ScrollButtonLeftMouseButtonAction: + aResult = 0; + break; + case IntID::ScrollButtonMiddleMouseButtonAction: + aResult = 1; + break; + case IntID::ScrollButtonRightMouseButtonAction: + aResult = 2; + break; + case IntID::CaretBlinkTime: + EnsureInit(); + aResult = mCaretBlinkTime; + break; + case IntID::CaretBlinkCount: + EnsureInit(); + aResult = mCaretBlinkCount; + break; + case IntID::CaretWidth: + aResult = 1; + break; + case IntID::ShowCaretDuringSelection: + aResult = 0; + break; + case IntID::SelectTextfieldsOnKeyFocus: { + GtkSettings* settings; + gboolean select_on_focus; + + settings = gtk_settings_get_default(); + g_object_get(settings, "gtk-entry-select-on-focus", &select_on_focus, + nullptr); + + if (select_on_focus) + aResult = 1; + else + aResult = 0; + + } break; + case IntID::ScrollToClick: { + GtkSettings* settings; + gboolean warps_slider = FALSE; + + settings = gtk_settings_get_default(); + if (g_object_class_find_property(G_OBJECT_GET_CLASS(settings), + "gtk-primary-button-warps-slider")) { + g_object_get(settings, "gtk-primary-button-warps-slider", &warps_slider, + nullptr); + } + + if (warps_slider) + aResult = 1; + else + aResult = 0; + } break; + case IntID::SubmenuDelay: { + GtkSettings* settings; + gint delay; + + settings = gtk_settings_get_default(); + g_object_get(settings, "gtk-menu-popup-delay", &delay, nullptr); + aResult = (int32_t)delay; + break; + } + case IntID::TooltipDelay: { + aResult = 500; + break; + } + case IntID::MenusCanOverlapOSBar: + // we want XUL popups to be able to overlap the task bar. + aResult = 1; + break; + case IntID::SkipNavigatingDisabledMenuItem: + aResult = 1; + break; + case IntID::DragThresholdX: + case IntID::DragThresholdY: { + gint threshold = 0; + g_object_get(gtk_settings_get_default(), "gtk-dnd-drag-threshold", + &threshold, nullptr); + + aResult = threshold; + } break; + case IntID::ScrollArrowStyle: { + GtkWidget* scrollbar = GetWidget(MOZ_GTK_SCROLLBAR_VERTICAL); + aResult = ConvertGTKStepperStyleToMozillaScrollArrowStyle(scrollbar); + break; + } + case IntID::TreeOpenDelay: + aResult = 1000; + break; + case IntID::TreeCloseDelay: + aResult = 1000; + break; + case IntID::TreeLazyScrollDelay: + aResult = 150; + break; + case IntID::TreeScrollDelay: + aResult = 100; + break; + case IntID::TreeScrollLinesMax: + aResult = 3; + break; + case IntID::AlertNotificationOrigin: + aResult = NS_ALERT_TOP; + break; + case IntID::IMERawInputUnderlineStyle: + case IntID::IMEConvertedTextUnderlineStyle: + aResult = static_cast<int32_t>(StyleTextDecorationStyle::Solid); + break; + case IntID::IMESelectedRawTextUnderlineStyle: + case IntID::IMESelectedConvertedTextUnderline: + aResult = static_cast<int32_t>(StyleTextDecorationStyle::None); + break; + case IntID::SpellCheckerUnderlineStyle: + aResult = static_cast<int32_t>(StyleTextDecorationStyle::Wavy); + break; + case IntID::MenuBarDrag: + EnsureInit(); + aResult = mSystemTheme.mMenuSupportsDrag; + break; + case IntID::ScrollbarButtonAutoRepeatBehavior: + aResult = 1; + break; + case IntID::SwipeAnimationEnabled: + aResult = 1; + break; + case IntID::ContextMenuOffsetVertical: + case IntID::ContextMenuOffsetHorizontal: + aResult = 2; + break; + case IntID::GTKCSDAvailable: + aResult = sCSDAvailable; + break; + case IntID::GTKCSDMaximizeButton: + EnsureInit(); + aResult = mCSDMaximizeButton; + break; + case IntID::GTKCSDMinimizeButton: + EnsureInit(); + aResult = mCSDMinimizeButton; + break; + case IntID::GTKCSDCloseButton: + EnsureInit(); + aResult = mCSDCloseButton; + break; + case IntID::GTKCSDReversedPlacement: + EnsureInit(); + aResult = mCSDReversedPlacement; + break; + case IntID::PrefersReducedMotion: { + EnsureInit(); + aResult = mPrefersReducedMotion; + break; + } + case IntID::SystemUsesDarkTheme: { + EnsureInit(); + if (mColorSchemePreference) { + aResult = *mColorSchemePreference == ColorScheme::Dark; + } else { + aResult = mSystemTheme.mIsDark; + } + break; + } + case IntID::GTKCSDMaximizeButtonPosition: + aResult = mCSDMaximizeButtonPosition; + break; + case IntID::GTKCSDMinimizeButtonPosition: + aResult = mCSDMinimizeButtonPosition; + break; + case IntID::GTKCSDCloseButtonPosition: + aResult = mCSDCloseButtonPosition; + break; + case IntID::GTKThemeFamily: { + EnsureInit(); + aResult = int32_t(EffectiveTheme().mFamily); + break; + } + case IntID::UseAccessibilityTheme: + // If high contrast is enabled, enable prefers-reduced-transparency media + // query as well as there is no dedicated option. + case IntID::PrefersReducedTransparency: + EnsureInit(); + aResult = mSystemTheme.mHighContrast; + break; + case IntID::InvertedColors: + // No GTK API for checking if inverted colors is enabled + aResult = 0; + break; + case IntID::TitlebarRadius: { + EnsureInit(); + aResult = EffectiveTheme().mTitlebarRadius; + break; + } + case IntID::AllowOverlayScrollbarsOverlap: { + aResult = 1; + break; + } + case IntID::ScrollbarFadeBeginDelay: { + aResult = 1000; + break; + } + case IntID::ScrollbarFadeDuration: { + aResult = 400; + break; + } + case IntID::ScrollbarDisplayOnMouseMove: { + aResult = 1; + break; + } + case IntID::PanelAnimations: + aResult = [&]() -> bool { + if (!sCSDAvailable) { + // Disabled on systems without CSD, see bug 1385079. + return false; + } + if (GdkIsWaylandDisplay()) { + // Disabled on wayland, see bug 1800442 and bug 1800368. + return false; + } + return true; + }(); + break; + case IntID::UseOverlayScrollbars: { + aResult = StaticPrefs::widget_gtk_overlay_scrollbars_enabled(); + break; + } + case IntID::HideCursorWhileTyping: { + aResult = StaticPrefs::widget_gtk_hide_pointer_while_typing_enabled(); + break; + } + case IntID::TouchDeviceSupportPresent: + aResult = widget::WidgetUtilsGTK::IsTouchDeviceSupportPresent(); + break; + default: + aResult = 0; + res = NS_ERROR_FAILURE; + } + + return res; +} + +nsresult nsLookAndFeel::NativeGetFloat(FloatID aID, float& aResult) { + nsresult rv = NS_OK; + switch (aID) { + case FloatID::IMEUnderlineRelativeSize: + aResult = 1.0f; + break; + case FloatID::SpellCheckerUnderlineRelativeSize: + aResult = 1.0f; + break; + case FloatID::CaretAspectRatio: + EnsureInit(); + aResult = mSystemTheme.mCaretRatio; + break; + case FloatID::TextScaleFactor: + aResult = gfxPlatformGtk::GetFontScaleFactor(); + break; + default: + aResult = -1.0; + rv = NS_ERROR_FAILURE; + } + return rv; +} + +static void GetSystemFontInfo(GtkStyleContext* aStyle, nsString* aFontName, + gfxFontStyle* aFontStyle) { + aFontStyle->style = FontSlantStyle::NORMAL; + + // As in + // https://git.gnome.org/browse/gtk+/tree/gtk/gtkwidget.c?h=3.22.19#n10333 + PangoFontDescription* desc; + gtk_style_context_get(aStyle, gtk_style_context_get_state(aStyle), "font", + &desc, nullptr); + + aFontStyle->systemFont = true; + + constexpr auto quote = u"\""_ns; + NS_ConvertUTF8toUTF16 family(pango_font_description_get_family(desc)); + *aFontName = quote + family + quote; + + aFontStyle->weight = + FontWeight::FromInt(pango_font_description_get_weight(desc)); + + // FIXME: Set aFontStyle->stretch correctly! + aFontStyle->stretch = FontStretch::NORMAL; + + float size = float(pango_font_description_get_size(desc)) / PANGO_SCALE; + + // |size| is now either pixels or pango-points (not Mozilla-points!) + + if (!pango_font_description_get_size_is_absolute(desc)) { + // |size| is in pango-points, so convert to pixels. + size *= float(gfxPlatformGtk::GetFontScaleDPI()) / POINTS_PER_INCH_FLOAT; + } + + // |size| is now pixels but not scaled for the hidpi displays, + aFontStyle->size = size; + + pango_font_description_free(desc); +} + +bool nsLookAndFeel::NativeGetFont(FontID aID, nsString& aFontName, + gfxFontStyle& aFontStyle) { + return mSystemTheme.GetFont(aID, aFontName, aFontStyle); +} + +bool nsLookAndFeel::PerThemeData::GetFont(FontID aID, nsString& aFontName, + gfxFontStyle& aFontStyle) const { + switch (aID) { + case FontID::Menu: // css2 + case FontID::MozPullDownMenu: // css3 + aFontName = mMenuFontName; + aFontStyle = mMenuFontStyle; + break; + + case FontID::MozField: // css3 + case FontID::MozList: // css3 + aFontName = mFieldFontName; + aFontStyle = mFieldFontStyle; + break; + + case FontID::MozButton: // css3 + aFontName = mButtonFontName; + aFontStyle = mButtonFontStyle; + break; + + case FontID::Caption: // css2 + case FontID::Icon: // css2 + case FontID::MessageBox: // css2 + case FontID::SmallCaption: // css2 + case FontID::StatusBar: // css2 + default: + aFontName = mDefaultFontName; + aFontStyle = mDefaultFontStyle; + break; + } + + // Convert GDK pixels to CSS pixels. + // When "layout.css.devPixelsPerPx" > 0, this is not a direct conversion. + // The difference produces a scaling of system fonts in proportion with + // other scaling from the change in CSS pixel sizes. + aFontStyle.size /= LookAndFeel::GetTextScaleFactor(); + return true; +} + +static nsCString GetGtkSettingsStringKey(const char* aKey) { + MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread()); + nsCString ret; + GtkSettings* settings = gtk_settings_get_default(); + char* value = nullptr; + g_object_get(settings, aKey, &value, nullptr); + if (value) { + ret.Assign(value); + g_free(value); + } + return ret; +} + +static nsCString GetGtkTheme() { + return GetGtkSettingsStringKey("gtk-theme-name"); +} + +static bool GetPreferDarkTheme() { + GtkSettings* settings = gtk_settings_get_default(); + gboolean preferDarkTheme = FALSE; + g_object_get(settings, "gtk-application-prefer-dark-theme", &preferDarkTheme, + nullptr); + return preferDarkTheme == TRUE; +} + +// It seems GTK doesn't have an API to query if the current theme is "light" or +// "dark", so we synthesize it from the CSS2 Window/WindowText colors instead, +// by comparing their luminosity. +static bool GetThemeIsDark() { + GdkRGBA bg, fg; + GtkStyleContext* style = GetStyleContext(MOZ_GTK_WINDOW); + gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &bg); + gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &fg); + return RelativeLuminanceUtils::Compute(GDK_RGBA_TO_NS_RGBA(bg)) < + RelativeLuminanceUtils::Compute(GDK_RGBA_TO_NS_RGBA(fg)); +} + +void nsLookAndFeel::RestoreSystemTheme() { + LOGLNF("RestoreSystemTheme(%s, %d, %d)\n", mSystemTheme.mName.get(), + mSystemTheme.mPreferDarkTheme, mSystemThemeOverridden); + + if (!mSystemThemeOverridden) { + return; + } + + // Available on Gtk 3.20+. + static auto sGtkSettingsResetProperty = + (void (*)(GtkSettings*, const gchar*))dlsym( + RTLD_DEFAULT, "gtk_settings_reset_property"); + + GtkSettings* settings = gtk_settings_get_default(); + if (sGtkSettingsResetProperty) { + sGtkSettingsResetProperty(settings, "gtk-theme-name"); + sGtkSettingsResetProperty(settings, "gtk-application-prefer-dark-theme"); + } else { + g_object_set(settings, "gtk-theme-name", mSystemTheme.mName.get(), + "gtk-application-prefer-dark-theme", + mSystemTheme.mPreferDarkTheme, nullptr); + } + mSystemThemeOverridden = false; + UpdateRoundedBottomCornerStyles(); + moz_gtk_refresh(); +} + +static bool AnyColorChannelIsDifferent(nscolor aColor) { + return NS_GET_R(aColor) != NS_GET_G(aColor) || + NS_GET_R(aColor) != NS_GET_B(aColor); +} + +bool nsLookAndFeel::ConfigureAltTheme() { + GtkSettings* settings = gtk_settings_get_default(); + // Toggling gtk-application-prefer-dark-theme is not enough generally to + // switch from dark to light theme. If the theme didn't change, and we have + // a dark theme, try to first remove -Dark{,er,est} from the theme name to + // find the light variant. + if (mSystemTheme.mIsDark) { + nsCString potentialLightThemeName = mSystemTheme.mName; + // clang-format off + constexpr nsLiteralCString kSubstringsToRemove[] = { + "-darkest"_ns, "-darker"_ns, "-dark"_ns, + "-Darkest"_ns, "-Darker"_ns, "-Dark"_ns, + "_darkest"_ns, "_darker"_ns, "_dark"_ns, + "_Darkest"_ns, "_Darker"_ns, "_Dark"_ns, + }; + // clang-format on + bool found = false; + for (const auto& s : kSubstringsToRemove) { + potentialLightThemeName = mSystemTheme.mName; + potentialLightThemeName.ReplaceSubstring(s, ""_ns); + if (potentialLightThemeName.Length() != mSystemTheme.mName.Length()) { + found = true; + break; + } + } + if (found) { + LOGLNF(" found potential light variant of %s: %s", + mSystemTheme.mName.get(), potentialLightThemeName.get()); + g_object_set(settings, "gtk-theme-name", potentialLightThemeName.get(), + "gtk-application-prefer-dark-theme", !mSystemTheme.mIsDark, + nullptr); + moz_gtk_refresh(); + + if (!GetThemeIsDark()) { + return true; // Success! + } + } + } + + LOGLNF(" toggling gtk-application-prefer-dark-theme"); + g_object_set(settings, "gtk-application-prefer-dark-theme", + !mSystemTheme.mIsDark, nullptr); + moz_gtk_refresh(); + if (mSystemTheme.mIsDark != GetThemeIsDark()) { + return true; // Success! + } + + LOGLNF(" didn't work, falling back to default theme"); + // If the theme still didn't change enough, fall back to Adwaita with the + // appropriate color preference. + g_object_set(settings, "gtk-theme-name", "Adwaita", + "gtk-application-prefer-dark-theme", !mSystemTheme.mIsDark, + nullptr); + moz_gtk_refresh(); + + // If it _still_ didn't change enough, and we're looking for a dark theme, + // try to set Adwaita-dark as a theme name. This might be needed in older GTK + // versions. + if (!mSystemTheme.mIsDark && !GetThemeIsDark()) { + LOGLNF(" last resort Adwaita-dark fallback"); + g_object_set(settings, "gtk-theme-name", "Adwaita-dark", nullptr); + moz_gtk_refresh(); + } + + return false; +} + +// We override some adwaita colors from GTK3 to LibAdwaita, see: +// https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/named-colors.html +void nsLookAndFeel::MaybeApplyAdwaitaOverrides() { + auto& dark = mSystemTheme.mIsDark ? mSystemTheme : mAltTheme; + auto& light = mSystemTheme.mIsDark ? mAltTheme : mSystemTheme; + + // Unconditional special case for Adwaita-dark: In GTK3 we don't have more + // proper accent colors, so we use the selected background colors. Those + // colors, however, don't have much contrast in dark mode (see bug 1741293). + if (dark.mFamily == ThemeFamily::Adwaita) { + dark.mAccent = {NS_RGB(0x35, 0x84, 0xe4), NS_RGB(0xff, 0xff, 0xff)}; + dark.mSelectedText = dark.mAccent; + } + + if (light.mFamily == ThemeFamily::Adwaita) { + light.mAccent = {NS_RGB(0x35, 0x84, 0xe4), NS_RGB(0xff, 0xff, 0xff)}; + light.mSelectedText = light.mAccent; + } + + if (!StaticPrefs::widget_gtk_libadwaita_colors_enabled()) { + return; + } + + if (light.mFamily == ThemeFamily::Adwaita) { + // #323232 is rgba(0,0,0,.8) over #fafafa. + light.mWindow = + light.mDialog = {NS_RGB(0xfa, 0xfa, 0xfa), NS_RGB(0x32, 0x32, 0x32)}; + light.mField = {NS_RGB(0xff, 0xff, 0xff), NS_RGB(0x32, 0x32, 0x32)}; + + // We use the sidebar colors for the headerbar in light mode background + // because it creates much better contrast. GTK headerbar colors are white, + // and meant to "blend" with the contents otherwise. + // #2f2f2f is rgba(0,0,0,.8) over #ebebeb. + light.mSidebar = light.mHeaderBar = + light.mTitlebar = {NS_RGB(0xeb, 0xeb, 0xeb), NS_RGB(0x2f, 0x2f, 0x2f)}; + light.mHeaderBarInactive = light.mTitlebarInactive = { + NS_RGB(0xf2, 0xf2, 0xf2), NS_RGB(0x2f, 0x2f, 0x2f)}; + light.mThreeDShadow = NS_RGB(0xe0, 0xe0, 0xe0); + light.mSidebarBorder = NS_RGBA(0, 0, 0, 18); + } + + if (dark.mFamily == ThemeFamily::Adwaita) { + dark.mWindow = {NS_RGB(0x24, 0x24, 0x24), NS_RGB(0xff, 0xff, 0xff)}; + dark.mDialog = {NS_RGB(0x38, 0x38, 0x38), NS_RGB(0xff, 0xff, 0xff)}; + dark.mField = {NS_RGB(0x3a, 0x3a, 0x3a), NS_RGB(0xff, 0xff, 0xff)}; + dark.mSidebar = dark.mHeaderBar = + dark.mTitlebar = {NS_RGB(0x30, 0x30, 0x30), NS_RGB(0xff, 0xff, 0xff)}; + dark.mHeaderBarInactive = dark.mTitlebarInactive = { + NS_RGB(0x24, 0x24, 0x24), NS_RGB(0xff, 0xff, 0xff)}; + // headerbar_shade_color + dark.mThreeDShadow = NS_RGB(0x1f, 0x1f, 0x1f); + dark.mSidebarBorder = NS_RGBA(0, 0, 0, 92); + } +} + +void nsLookAndFeel::ConfigureAndInitializeAltTheme() { + const bool fellBackToDefaultTheme = !ConfigureAltTheme(); + + mAltTheme.Init(); + + MaybeApplyAdwaitaOverrides(); + + // Some of the alt theme colors we can grab from the system theme, if we fell + // back to the default light / dark themes. + if (fellBackToDefaultTheme) { + if (StaticPrefs::widget_gtk_alt_theme_selection()) { + mAltTheme.mSelectedText = mSystemTheme.mSelectedText; + } + + if (StaticPrefs::widget_gtk_alt_theme_scrollbar_active() && + (!mAltTheme.mIsDark || ShouldUseColorForActiveDarkScrollbarThumb( + mSystemTheme.mThemedScrollbarThumbActive))) { + mAltTheme.mThemedScrollbarThumbActive = + mSystemTheme.mThemedScrollbarThumbActive; + } + + if (StaticPrefs::widget_gtk_alt_theme_accent()) { + mAltTheme.mAccent = mSystemTheme.mAccent; + } + } + + // Right now we're using the opposite color-scheme theme, make sure to record + // it. + mSystemThemeOverridden = true; + UpdateRoundedBottomCornerStyles(); +} + +void nsLookAndFeel::ClearRoundedCornerProvider() { + if (mRoundedCornerProvider) { + gtk_style_context_remove_provider_for_screen( + gdk_screen_get_default(), + GTK_STYLE_PROVIDER(mRoundedCornerProvider.get())); + mRoundedCornerProvider = nullptr; + } +} + +void nsLookAndFeel::UpdateRoundedBottomCornerStyles() { + ClearRoundedCornerProvider(); + if (!StaticPrefs::widget_gtk_rounded_bottom_corners_enabled()) { + return; + } + int32_t radius = EffectiveTheme().mTitlebarRadius; + if (!radius) { + return; + } + mRoundedCornerProvider = dont_AddRef(gtk_css_provider_new()); + nsPrintfCString string( + "window.csd decoration {" + "border-bottom-right-radius: %dpx;" + "border-bottom-left-radius: %dpx;" + "}\n", + radius, radius); + GUniquePtr<GError> error; + if (!gtk_css_provider_load_from_data(mRoundedCornerProvider.get(), + string.get(), string.Length(), + getter_Transfers(error))) { + NS_WARNING(nsPrintfCString("Failed to load provider: %s - %s\n", + string.get(), error ? error->message : nullptr) + .get()); + } + gtk_style_context_add_provider_for_screen( + gdk_screen_get_default(), + GTK_STYLE_PROVIDER(mRoundedCornerProvider.get()), + GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); +} + +Maybe<ColorScheme> nsLookAndFeel::ComputeColorSchemeSetting() { + { + // Check the pref explicitly here. Usually this shouldn't be needed, but + // since we can only load one GTK theme at a time, and the pref will + // override the effective value that the rest of gecko assumes for the + // "system" color scheme, we need to factor it in our GTK theme decisions. + int32_t pref = 0; + if (NS_SUCCEEDED(Preferences::GetInt("ui.systemUsesDarkTheme", &pref))) { + return Some(pref ? ColorScheme::Dark : ColorScheme::Light); + } + } + + if (!mDBusSettingsProxy) { + return Nothing(); + } + GUniquePtr<GError> error; + RefPtr<GVariant> variant = dont_AddRef(g_dbus_proxy_call_sync( + mDBusSettingsProxy, "Read", + g_variant_new("(ss)", "org.freedesktop.appearance", "color-scheme"), + G_DBUS_CALL_FLAGS_NONE, + StaticPrefs::widget_gtk_settings_portal_timeout_ms(), nullptr, + getter_Transfers(error))); + if (!variant) { + LOGLNF("color-scheme query error: %s\n", error->message); + return Nothing(); + } + LOGLNF("color-scheme query result: %s\n", GVariantToString(variant).get()); + variant = dont_AddRef(g_variant_get_child_value(variant, 0)); + while (variant && g_variant_is_of_type(variant, G_VARIANT_TYPE_VARIANT)) { + // Unbox the return value. + variant = dont_AddRef(g_variant_get_variant(variant)); + } + if (!variant || !g_variant_is_of_type(variant, G_VARIANT_TYPE_UINT32)) { + MOZ_ASSERT(false, "Unexpected color-scheme query return value"); + return Nothing(); + } + switch (g_variant_get_uint32(variant)) { + default: + MOZ_FALLTHROUGH_ASSERT("Unexpected color-scheme query return value"); + case 0: + break; + case 1: + return Some(ColorScheme::Dark); + case 2: + return Some(ColorScheme::Light); + } + return Nothing(); +} + +void nsLookAndFeel::Initialize() { + LOGLNF("nsLookAndFeel::Initialize"); + MOZ_DIAGNOSTIC_ASSERT(!mInitialized); + MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread(), + "LookAndFeel init should be done on the main thread"); + + mInitialized = true; + + GtkSettings* settings = gtk_settings_get_default(); + if (MOZ_UNLIKELY(!settings)) { + NS_WARNING("EnsureInit: No settings"); + return; + } + + AutoRestore<bool> restoreIgnoreSettings(sIgnoreChangedSettings); + sIgnoreChangedSettings = true; + + // Our current theme may be different from the system theme if we're matching + // the Firefox theme or using the alt theme intentionally due to the + // color-scheme preference. Make sure to restore the original system theme. + RestoreSystemTheme(); + + // First initialize global settings. + InitializeGlobalSettings(); + + // Record our system theme settings now. + mSystemTheme.Init(); + + // Find the alternative-scheme theme (light if the system theme is dark, or + // vice versa), configure it and initialize it. + ConfigureAndInitializeAltTheme(); + + LOGLNF("System Theme: %s. Alt Theme: %s\n", mSystemTheme.mName.get(), + mAltTheme.mName.get()); + + // Go back to the system theme or keep the alt theme configured, depending on + // Firefox theme or user color-scheme preference. + ConfigureFinalEffectiveTheme(); + + RecordTelemetry(); +} + +void nsLookAndFeel::OnColorSchemeSettingChanged() { + if (NS_WARN_IF(mColorSchemePreference == ComputeColorSchemeSetting())) { + // We sometimes get duplicate color-scheme changes from dbus, avoid doing + // extra work if not needed. + return; + } + OnSettingsChange(); +} + +void nsLookAndFeel::InitializeGlobalSettings() { + GtkSettings* settings = gtk_settings_get_default(); + + mColorSchemePreference = ComputeColorSchemeSetting(); + + gboolean enableAnimations = false; + g_object_get(settings, "gtk-enable-animations", &enableAnimations, nullptr); + mPrefersReducedMotion = !enableAnimations; + + gint blink_time = 0; // In milliseconds + gint blink_timeout = 0; // in seconds + gboolean blink; + g_object_get(settings, "gtk-cursor-blink-time", &blink_time, + "gtk-cursor-blink-timeout", &blink_timeout, "gtk-cursor-blink", + &blink, nullptr); + // From + // https://docs.gtk.org/gtk3/property.Settings.gtk-cursor-blink-timeout.html: + // + // Setting this to zero has the same effect as setting + // GtkSettings:gtk-cursor-blink to FALSE. + // + mCaretBlinkTime = blink && blink_timeout ? (int32_t)blink_time : 0; + + if (mCaretBlinkTime) { + // blink_time * 2 because blink count is a full blink cycle. + mCaretBlinkCount = + std::max(1, int32_t(std::ceil(float(blink_timeout * 1000) / + (float(blink_time) * 2.0f)))); + } else { + mCaretBlinkCount = -1; + } + + mCSDCloseButton = false; + mCSDMinimizeButton = false; + mCSDMaximizeButton = false; + mCSDCloseButtonPosition = 0; + mCSDMinimizeButtonPosition = 0; + mCSDMaximizeButtonPosition = 0; + + // We need to initialize whole CSD config explicitly because it's queried + // as -moz-gtk* media features. + ButtonLayout buttonLayout[TOOLBAR_BUTTONS]; + + size_t activeButtons = + GetGtkHeaderBarButtonLayout(Span(buttonLayout), &mCSDReversedPlacement); + for (size_t i = 0; i < activeButtons; i++) { + // We check if a button is represented on the right side of the tabbar. + // Then we assign it a value from 3 to 5, instead of 0 to 2 when it is on + // the left side. + const ButtonLayout& layout = buttonLayout[i]; + int32_t* pos = nullptr; + switch (layout.mType) { + case MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE: + mCSDMinimizeButton = true; + pos = &mCSDMinimizeButtonPosition; + break; + case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE: + mCSDMaximizeButton = true; + pos = &mCSDMaximizeButtonPosition; + break; + case MOZ_GTK_HEADER_BAR_BUTTON_CLOSE: + mCSDCloseButton = true; + pos = &mCSDCloseButtonPosition; + break; + default: + break; + } + + if (pos) { + *pos = i; + } + } + + struct actionMapping { + TitlebarAction action; + char name[100]; + } ActionMapping[] = { + {TitlebarAction::None, "none"}, + {TitlebarAction::WindowLower, "lower"}, + {TitlebarAction::WindowMenu, "menu"}, + {TitlebarAction::WindowMinimize, "minimize"}, + {TitlebarAction::WindowMaximize, "maximize"}, + {TitlebarAction::WindowMaximizeToggle, "toggle-maximize"}, + }; + + auto GetWindowAction = [&](const char* eventName) -> TitlebarAction { + gchar* action = nullptr; + g_object_get(settings, eventName, &action, nullptr); + if (!action) { + return TitlebarAction::None; + } + auto free = mozilla::MakeScopeExit([&] { g_free(action); }); + for (auto const& mapping : ActionMapping) { + if (!strncmp(action, mapping.name, strlen(mapping.name))) { + return mapping.action; + } + } + return TitlebarAction::None; + }; + + mDoubleClickAction = GetWindowAction("gtk-titlebar-double-click"); + mMiddleClickAction = GetWindowAction("gtk-titlebar-middle-click"); +} + +void nsLookAndFeel::ConfigureFinalEffectiveTheme() { + MOZ_ASSERT(mSystemThemeOverridden, + "By this point, the alt theme should be configured"); + const bool shouldUseSystemTheme = [&] { + using ChromeSetting = PreferenceSheet::ChromeColorSchemeSetting; + // NOTE: We can't call ColorSchemeForChrome directly because this might run + // while we're computing it. + switch (PreferenceSheet::ColorSchemeSettingForChrome()) { + case ChromeSetting::Light: + return !mSystemTheme.mIsDark; + case ChromeSetting::Dark: + return mSystemTheme.mIsDark; + case ChromeSetting::System: + break; + }; + if (!mColorSchemePreference) { + return true; + } + const bool preferenceIsDark = *mColorSchemePreference == ColorScheme::Dark; + return preferenceIsDark == mSystemTheme.mIsDark; + }(); + + const bool usingSystem = !mSystemThemeOverridden; + LOGLNF("OverrideSystemThemeIfNeeded(matchesSystem=%d, usingSystem=%d)\n", + shouldUseSystemTheme, usingSystem); + + if (shouldUseSystemTheme) { + RestoreSystemTheme(); + } else if (usingSystem) { + LOGLNF("Setting theme %s, %d\n", mAltTheme.mName.get(), + mAltTheme.mPreferDarkTheme); + + GtkSettings* settings = gtk_settings_get_default(); + if (mSystemTheme.mName == mAltTheme.mName) { + // Prefer setting only gtk-application-prefer-dark-theme, so we can still + // get notified from notify::gtk-theme-name if the user changes the theme. + g_object_set(settings, "gtk-application-prefer-dark-theme", + mAltTheme.mPreferDarkTheme, nullptr); + } else { + g_object_set(settings, "gtk-theme-name", mAltTheme.mName.get(), + "gtk-application-prefer-dark-theme", + mAltTheme.mPreferDarkTheme, nullptr); + } + mSystemThemeOverridden = true; + UpdateRoundedBottomCornerStyles(); + moz_gtk_refresh(); + } +} + +static bool GetColorFromBackgroundImage(GtkStyleContext* aStyle, + nscolor aForForegroundColor, + GtkStateFlags aState, nscolor* aColor) { + GValue value = G_VALUE_INIT; + gtk_style_context_get_property(aStyle, "background-image", aState, &value); + auto cleanup = MakeScopeExit([&] { g_value_unset(&value); }); + if (GetColorFromImagePattern(&value, aColor)) { + return true; + } + + { + GdkRGBA light, dark; + if (GetGradientColors(&value, &light, &dark)) { + nscolor l = GDK_RGBA_TO_NS_RGBA(light); + nscolor d = GDK_RGBA_TO_NS_RGBA(dark); + // Return the one with more contrast. + // TODO(emilio): This could do interpolation or what not but seems + // overkill. + if (NS_LUMINOSITY_DIFFERENCE(l, aForForegroundColor) > + NS_LUMINOSITY_DIFFERENCE(d, aForForegroundColor)) { + *aColor = l; + } else { + *aColor = d; + } + return true; + } + } + + return false; +} + +static nscolor GetBackgroundColor( + GtkStyleContext* aStyle, nscolor aForForegroundColor, + GtkStateFlags aState = GTK_STATE_FLAG_NORMAL, + nscolor aOverBackgroundColor = NS_TRANSPARENT) { + // Try to synthesize a color from a background-image. + nscolor imageColor = NS_TRANSPARENT; + if (GetColorFromBackgroundImage(aStyle, aForForegroundColor, aState, + &imageColor)) { + if (NS_GET_A(imageColor) == 255) { + return imageColor; + } + } + + GdkRGBA gdkColor; + gtk_style_context_get_background_color(aStyle, aState, &gdkColor); + nscolor bgColor = GDK_RGBA_TO_NS_RGBA(gdkColor); + // background-image paints over background-color. + const nscolor finalColor = NS_ComposeColors(bgColor, imageColor); + if (finalColor != aOverBackgroundColor) { + return finalColor; + } + return NS_TRANSPARENT; +} + +static nscolor GetTextColor(GtkStyleContext* aStyle, + GtkStateFlags aState = GTK_STATE_FLAG_NORMAL) { + GdkRGBA color; + gtk_style_context_get_color(aStyle, aState, &color); + return GDK_RGBA_TO_NS_RGBA(color); +} + +using ColorPair = nsLookAndFeel::ColorPair; +static ColorPair GetColorPair(GtkStyleContext* aStyle, + GtkStateFlags aState = GTK_STATE_FLAG_NORMAL) { + ColorPair result; + result.mFg = GetTextColor(aStyle, aState); + result.mBg = GetBackgroundColor(aStyle, result.mFg, aState); + return result; +} + +static bool GetNamedColorPair(GtkStyleContext* aStyle, const char* aBgName, + const char* aFgName, ColorPair* aPair) { + GdkRGBA bg, fg; + if (!gtk_style_context_lookup_color(aStyle, aBgName, &bg) || + !gtk_style_context_lookup_color(aStyle, aFgName, &fg)) { + return false; + } + + aPair->mBg = GDK_RGBA_TO_NS_RGBA(bg); + aPair->mFg = GDK_RGBA_TO_NS_RGBA(fg); + + // If the colors are semi-transparent and the theme provides a + // background color, blend with them to get the "final" color, see + // bug 1717077. + if (NS_GET_A(aPair->mBg) != 255 && + (gtk_style_context_lookup_color(aStyle, "bg_color", &bg) || + gtk_style_context_lookup_color(aStyle, "theme_bg_color", &bg))) { + aPair->mBg = NS_ComposeColors(GDK_RGBA_TO_NS_RGBA(bg), aPair->mBg); + } + + // A semi-transparent foreground color would be kinda silly, but is done + // for symmetry. + if (NS_GET_A(aPair->mFg) != 255) { + aPair->mFg = NS_ComposeColors(aPair->mBg, aPair->mFg); + } + + return true; +} + +static void EnsureColorPairIsOpaque(ColorPair& aPair) { + // Blend with white, ensuring the color is opaque, so that the UI doesn't have + // to care about alpha. + aPair.mBg = NS_ComposeColors(NS_RGB(0xff, 0xff, 0xff), aPair.mBg); + aPair.mFg = NS_ComposeColors(aPair.mBg, aPair.mFg); +} + +static void PreferDarkerBackground(ColorPair& aPair) { + // We use the darker one unless the foreground isn't really a color (is all + // white / black / gray) and the background is, in which case we stick to what + // we have. + if (RelativeLuminanceUtils::Compute(aPair.mBg) > + RelativeLuminanceUtils::Compute(aPair.mFg) && + (AnyColorChannelIsDifferent(aPair.mFg) || + !AnyColorChannelIsDifferent(aPair.mBg))) { + std::swap(aPair.mBg, aPair.mFg); + } +} + +void nsLookAndFeel::PerThemeData::Init() { + mName = GetGtkTheme(); + + mFamily = [&] { + if (mName.EqualsLiteral("Adwaita") || mName.EqualsLiteral("Adwaita-dark")) { + return ThemeFamily::Adwaita; + } + if (mName.EqualsLiteral("Breeze") || mName.EqualsLiteral("Breeze-Dark")) { + return ThemeFamily::Breeze; + } + if (StringBeginsWith(mName, "Yaru"_ns)) { + return ThemeFamily::Yaru; + } + return ThemeFamily::Unknown; + }(); + + GtkStyleContext* style; + + mHighContrast = StaticPrefs::widget_content_gtk_high_contrast_enabled() && + mName.Find("HighContrast"_ns) >= 0; + + mPreferDarkTheme = GetPreferDarkTheme(); + + mIsDark = GetThemeIsDark(); + + GdkRGBA color; + // Some themes style the <trough>, while others style the <scrollbar> + // itself, so we look at both and compose the colors. + style = GetStyleContext(MOZ_GTK_SCROLLBAR_VERTICAL); + gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &color); + mThemedScrollbar = GDK_RGBA_TO_NS_RGBA(color); + gtk_style_context_get_background_color(style, GTK_STATE_FLAG_BACKDROP, + &color); + mThemedScrollbarInactive = GDK_RGBA_TO_NS_RGBA(color); + + style = GetStyleContext(MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL); + gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &color); + mThemedScrollbar = + NS_ComposeColors(mThemedScrollbar, GDK_RGBA_TO_NS_RGBA(color)); + gtk_style_context_get_background_color(style, GTK_STATE_FLAG_BACKDROP, + &color); + mThemedScrollbarInactive = + NS_ComposeColors(mThemedScrollbarInactive, GDK_RGBA_TO_NS_RGBA(color)); + + style = GetStyleContext(MOZ_GTK_SCROLLBAR_THUMB_VERTICAL); + gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &color); + mThemedScrollbarThumb = GDK_RGBA_TO_NS_RGBA(color); + gtk_style_context_get_background_color(style, GTK_STATE_FLAG_PRELIGHT, + &color); + mThemedScrollbarThumbHover = GDK_RGBA_TO_NS_RGBA(color); + gtk_style_context_get_background_color( + style, GtkStateFlags(GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_ACTIVE), + &color); + mThemedScrollbarThumbActive = GDK_RGBA_TO_NS_RGBA(color); + gtk_style_context_get_background_color(style, GTK_STATE_FLAG_BACKDROP, + &color); + mThemedScrollbarThumbInactive = GDK_RGBA_TO_NS_RGBA(color); + + // Make sure that the thumb is visible, at least. + const bool fallbackToUnthemedColors = [&] { + if (!StaticPrefs::widget_gtk_theme_scrollbar_colors_enabled()) { + return true; + } + + if (!ShouldHonorThemeScrollbarColors()) { + return true; + } + // If any of the scrollbar thumb colors are fully transparent, fall back to + // non-native ones. + if (!NS_GET_A(mThemedScrollbarThumb) || + !NS_GET_A(mThemedScrollbarThumbHover) || + !NS_GET_A(mThemedScrollbarThumbActive)) { + return true; + } + // If the thumb and track are the same color and opaque, fall back to + // non-native colors as well. + if (mThemedScrollbar == mThemedScrollbarThumb && + NS_GET_A(mThemedScrollbar) == 0xff) { + return true; + } + return false; + }(); + + if (fallbackToUnthemedColors) { + if (mIsDark) { + // Taken from Adwaita-dark. + mThemedScrollbar = NS_RGB(0x31, 0x31, 0x31); + mThemedScrollbarInactive = NS_RGB(0x2d, 0x2d, 0x2d); + mThemedScrollbarThumb = NS_RGB(0xa3, 0xa4, 0xa4); + mThemedScrollbarThumbInactive = NS_RGB(0x59, 0x5a, 0x5a); + } else { + // Taken from Adwaita. + mThemedScrollbar = NS_RGB(0xce, 0xce, 0xce); + mThemedScrollbarInactive = NS_RGB(0xec, 0xed, 0xef); + mThemedScrollbarThumb = NS_RGB(0x82, 0x81, 0x7e); + mThemedScrollbarThumbInactive = NS_RGB(0xce, 0xcf, 0xce); + } + + mThemedScrollbarThumbHover = ThemeColors::AdjustUnthemedScrollbarThumbColor( + mThemedScrollbarThumb, dom::ElementState::HOVER); + mThemedScrollbarThumbActive = + ThemeColors::AdjustUnthemedScrollbarThumbColor( + mThemedScrollbarThumb, dom::ElementState::ACTIVE); + } + + // The label is not added to a parent widget, but shared for constructing + // different style contexts. The node hierarchy is constructed only on + // the label style context. + GtkWidget* labelWidget = gtk_label_new("M"); + g_object_ref_sink(labelWidget); + + // Window colors + style = GetStyleContext(MOZ_GTK_WINDOW); + mWindow = mDialog = GetColorPair(style); + + gtk_style_context_get_border_color(style, GTK_STATE_FLAG_NORMAL, &color); + mMozWindowActiveBorder = GDK_RGBA_TO_NS_RGBA(color); + + gtk_style_context_get_border_color(style, GTK_STATE_FLAG_INSENSITIVE, &color); + mMozWindowInactiveBorder = GDK_RGBA_TO_NS_RGBA(color); + + style = GetStyleContext(MOZ_GTK_WINDOW_CONTAINER); + { + GtkStyleContext* labelStyle = CreateStyleForWidget(labelWidget, style); + GetSystemFontInfo(labelStyle, &mDefaultFontName, &mDefaultFontStyle); + g_object_unref(labelStyle); + } + + // tooltip foreground and background + style = GetStyleContext(MOZ_GTK_TOOLTIP_BOX_LABEL); + mInfo.mFg = GetTextColor(style); + style = GetStyleContext(MOZ_GTK_TOOLTIP); + mInfo.mBg = GetBackgroundColor(style, mInfo.mFg); + + style = GetStyleContext(MOZ_GTK_MENUITEM); + { + GtkStyleContext* accelStyle = + CreateStyleForWidget(gtk_accel_label_new("M"), style); + + GetSystemFontInfo(accelStyle, &mMenuFontName, &mMenuFontStyle); + + gtk_style_context_get_color(accelStyle, GTK_STATE_FLAG_NORMAL, &color); + mMenu.mFg = GetTextColor(accelStyle); + mGrayText = GetTextColor(accelStyle, GTK_STATE_FLAG_INSENSITIVE); + g_object_unref(accelStyle); + } + + const auto effectiveTitlebarStyle = + HeaderBarShouldDrawContainer(MOZ_GTK_HEADER_BAR) ? MOZ_GTK_HEADERBAR_FIXED + : MOZ_GTK_HEADER_BAR; + style = GetStyleContext(effectiveTitlebarStyle); + { + mTitlebar = GetColorPair(style, GTK_STATE_FLAG_NORMAL); + mTitlebarInactive = GetColorPair(style, GTK_STATE_FLAG_BACKDROP); + mTitlebarRadius = IsSolidCSDStyleUsed() ? 0 : GetBorderRadius(style); + } + + // We special-case the header bar color in Adwaita, Yaru and Breeze to be the + // titlebar color, because it looks better and matches what apps do by + // default, see bug 1838460. + // + // We only do this in the relevant desktop environments, however, since in + // other cases we don't really know if the DE's titlebars are going to match. + // + // For breeze, additionally we read the KDE colors directly, if available, + // since these are user-configurable. + // + // For most other themes or those in unknown DEs, we use the menubar colors. + // + // FIXME(emilio): Can we do something a bit less special-case-y? + const bool shouldUseTitlebarColorsForHeaderBar = [&] { + if (mFamily == ThemeFamily::Adwaita || mFamily == ThemeFamily::Yaru) { + return IsGnomeDesktopEnvironment(); + } + if (mFamily == ThemeFamily::Breeze) { + return IsKdeDesktopEnvironment(); + } + return false; + }(); + + if (shouldUseTitlebarColorsForHeaderBar) { + mHeaderBar = mTitlebar; + mHeaderBarInactive = mTitlebarInactive; + if (mFamily == ThemeFamily::Breeze) { + GetNamedColorPair(style, "theme_header_background_breeze", + "theme_header_foreground_breeze", &mHeaderBar); + GetNamedColorPair(style, "theme_header_background_backdrop_breeze", + "theme_header_foreground_backdrop_breeze", + &mHeaderBarInactive); + } + } else { + style = GetStyleContext(MOZ_GTK_MENUBARITEM); + mHeaderBar.mFg = GetTextColor(style); + mHeaderBarInactive.mFg = GetTextColor(style, GTK_STATE_FLAG_BACKDROP); + + style = GetStyleContext(MOZ_GTK_MENUBAR); + mHeaderBar.mBg = GetBackgroundColor(style, mHeaderBar.mFg); + mHeaderBarInactive.mBg = GetBackgroundColor(style, mHeaderBarInactive.mFg, + GTK_STATE_FLAG_BACKDROP); + } + + style = GetStyleContext(MOZ_GTK_MENUPOPUP); + mMenu.mBg = [&] { + nscolor color = GetBackgroundColor(style, mMenu.mFg); + if (NS_GET_A(color)) { + return color; + } + // Some themes only style menupopups with the backdrop pseudo-class. Since a + // context / popup menu always seems to match that, try that before giving + // up. + color = GetBackgroundColor(style, mMenu.mFg, GTK_STATE_FLAG_BACKDROP); + if (NS_GET_A(color)) { + return color; + } + // If we get here we couldn't figure out the right color to use. Rather than + // falling back to transparent, fall back to the window background. + NS_WARNING( + "Couldn't find menu background color, falling back to window " + "background"); + return mWindow.mBg; + }(); + + style = GetStyleContext(MOZ_GTK_MENUITEM); + gtk_style_context_get_color(style, GTK_STATE_FLAG_PRELIGHT, &color); + mMenuHover.mFg = GDK_RGBA_TO_NS_RGBA(color); + mMenuHover.mBg = NS_ComposeColors( + mMenu.mBg, + GetBackgroundColor(style, mMenu.mFg, GTK_STATE_FLAG_PRELIGHT, mMenu.mBg)); + + GtkWidget* parent = gtk_fixed_new(); + GtkWidget* window = gtk_window_new(GTK_WINDOW_POPUP); + GtkWidget* treeView = gtk_tree_view_new(); + GtkWidget* linkButton = gtk_link_button_new("http://example.com/"); + GtkWidget* menuBar = gtk_menu_bar_new(); + GtkWidget* menuBarItem = gtk_menu_item_new(); + GtkWidget* entry = gtk_entry_new(); + GtkWidget* textView = gtk_text_view_new(); + + gtk_container_add(GTK_CONTAINER(parent), treeView); + gtk_container_add(GTK_CONTAINER(parent), linkButton); + gtk_container_add(GTK_CONTAINER(parent), menuBar); + gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuBarItem); + gtk_container_add(GTK_CONTAINER(window), parent); + gtk_container_add(GTK_CONTAINER(parent), entry); + gtk_container_add(GTK_CONTAINER(parent), textView); + + // Text colors + GdkRGBA bgColor; + // If the text window background is translucent, then the background of + // the textview root node is visible. + style = GetStyleContext(MOZ_GTK_TEXT_VIEW); + gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, + &bgColor); + + style = GetStyleContext(MOZ_GTK_TEXT_VIEW_TEXT); + gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &color); + ApplyColorOver(color, &bgColor); + mField.mBg = GDK_RGBA_TO_NS_RGBA(bgColor); + gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &color); + mField.mFg = GDK_RGBA_TO_NS_RGBA(color); + mSidebar = mField; + + // Selected text and background + { + GtkStyleContext* selectionStyle = + GetStyleContext(MOZ_GTK_TEXT_VIEW_TEXT_SELECTION); + auto GrabSelectionColors = [&](GtkStyleContext* style) { + gtk_style_context_get_background_color( + style, + static_cast<GtkStateFlags>(GTK_STATE_FLAG_FOCUSED | + GTK_STATE_FLAG_SELECTED), + &color); + mSelectedText.mBg = GDK_RGBA_TO_NS_RGBA(color); + gtk_style_context_get_color( + style, + static_cast<GtkStateFlags>(GTK_STATE_FLAG_FOCUSED | + GTK_STATE_FLAG_SELECTED), + &color); + mSelectedText.mFg = GDK_RGBA_TO_NS_RGBA(color); + }; + GrabSelectionColors(selectionStyle); + if (mSelectedText.mBg == mSelectedText.mFg) { + // Some old distros/themes don't properly use the .selection style, so + // fall back to the regular text view style. + GrabSelectionColors(style); + } + + // Default selected item color is the selection background / foreground + // colors, but we prefer named colors, as those are more general purpose + // than the actual selection style, which might e.g. be too-transparent. + // + // NOTE(emilio): It's unclear which one of the theme_selected_* or the + // selected_* pairs should we prefer, in all themes that define both that + // I've found, they're always the same. + if (!GetNamedColorPair(style, "selected_bg_color", "selected_fg_color", + &mSelectedItem) && + !GetNamedColorPair(style, "theme_selected_bg_color", + "theme_selected_fg_color", &mSelectedItem)) { + mSelectedItem = mSelectedText; + } + + EnsureColorPairIsOpaque(mSelectedItem); + + // In a similar fashion, default accent color is the selected item/text + // pair, but we also prefer named colors, if available. + // + // accent_{bg,fg}_color is not _really_ a gtk3 thing (it's a gtk4 thing), + // but if gtk 3 themes want to specify these we let them, see: + // + // https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/named-colors.html#accent-colors + if (!GetNamedColorPair(style, "accent_bg_color", "accent_fg_color", + &mAccent)) { + mAccent = mSelectedItem; + } + + EnsureColorPairIsOpaque(mAccent); + PreferDarkerBackground(mAccent); + } + + // Button text color + style = GetStyleContext(MOZ_GTK_BUTTON); + { + GtkStyleContext* labelStyle = CreateStyleForWidget(labelWidget, style); + GetSystemFontInfo(labelStyle, &mButtonFontName, &mButtonFontStyle); + g_object_unref(labelStyle); + } + + gtk_style_context_get_border_color(style, GTK_STATE_FLAG_NORMAL, &color); + mButtonBorder = GDK_RGBA_TO_NS_RGBA(color); + mButton = GetColorPair(style); + mButtonHover = GetColorPair(style, GTK_STATE_FLAG_PRELIGHT); + mButtonActive = GetColorPair(style, GTK_STATE_FLAG_ACTIVE); + if (!NS_GET_A(mButtonHover.mBg)) { + mButtonHover.mBg = mWindow.mBg; + } + if (!NS_GET_A(mButtonActive.mBg)) { + mButtonActive.mBg = mWindow.mBg; + } + + // Combobox text color + style = GetStyleContext(MOZ_GTK_COMBOBOX_ENTRY_TEXTAREA); + gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &color); + mComboBoxText = GDK_RGBA_TO_NS_RGBA(color); + + // GTK's guide to fancy odd row background colors: + // 1) Check if a theme explicitly defines an odd row color + // 2) If not, check if it defines an even row color, and darken it + // slightly by a hardcoded value (gtkstyle.c) + // 3) If neither are defined, take the base background color and + // darken that by a hardcoded value + style = GetStyleContext(MOZ_GTK_TREEVIEW); + + // Get odd row background color + gtk_style_context_save(style); + gtk_style_context_add_region(style, GTK_STYLE_REGION_ROW, GTK_REGION_ODD); + gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &color); + mOddCellBackground = GDK_RGBA_TO_NS_RGBA(color); + gtk_style_context_restore(style); + + // Column header colors + style = GetStyleContext(MOZ_GTK_TREE_HEADER_CELL); + mMozColHeader = GetColorPair(style, GTK_STATE_FLAG_NORMAL); + mMozColHeaderHover = GetColorPair(style, GTK_STATE_FLAG_NORMAL); + mMozColHeaderActive = GetColorPair(style, GTK_STATE_FLAG_ACTIVE); + + // Compute cell highlight colors + InitCellHighlightColors(); + + // GtkFrame has a "border" subnode on which Adwaita draws the border. + // Some themes do not draw on this node but draw a border on the widget + // root node, so check the root node if no border is found on the border + // node. + style = GetStyleContext(MOZ_GTK_FRAME_BORDER); + bool themeUsesColors = + GetBorderColors(style, &mThreeDHighlight, &mThreeDShadow); + if (!themeUsesColors) { + style = GetStyleContext(MOZ_GTK_FRAME); + GetBorderColors(style, &mThreeDHighlight, &mThreeDShadow); + } + mSidebarBorder = mThreeDShadow; + + // Some themes have a unified menu bar, and support window dragging on it + gboolean supports_menubar_drag = FALSE; + GParamSpec* param_spec = gtk_widget_class_find_style_property( + GTK_WIDGET_GET_CLASS(menuBar), "window-dragging"); + if (param_spec) { + if (g_type_is_a(G_PARAM_SPEC_VALUE_TYPE(param_spec), G_TYPE_BOOLEAN)) { + gtk_widget_style_get(menuBar, "window-dragging", &supports_menubar_drag, + nullptr); + } + } + mMenuSupportsDrag = supports_menubar_drag; + + // TODO: It returns wrong color for themes which + // sets link color for GtkLabel only as we query + // GtkLinkButton style here. + style = gtk_widget_get_style_context(linkButton); + gtk_style_context_get_color(style, GTK_STATE_FLAG_LINK, &color); + mNativeHyperLinkText = GDK_RGBA_TO_NS_RGBA(color); + + gtk_style_context_get_color(style, GTK_STATE_FLAG_VISITED, &color); + mNativeVisitedHyperLinkText = GDK_RGBA_TO_NS_RGBA(color); + + // invisible character styles + guint value; + g_object_get(entry, "invisible-char", &value, nullptr); + mInvisibleCharacter = char16_t(value); + + // caret styles + gtk_widget_style_get(entry, "cursor-aspect-ratio", &mCaretRatio, nullptr); + + GetSystemFontInfo(gtk_widget_get_style_context(entry), &mFieldFontName, + &mFieldFontStyle); + + gtk_widget_destroy(window); + g_object_unref(labelWidget); + + if (LOGLNF_ENABLED()) { + LOGLNF("Initialized theme %s (%d)\n", mName.get(), mPreferDarkTheme); + for (auto id : MakeEnumeratedRange(ColorID::End)) { + nscolor color; + nsresult rv = GetColor(id, color); + LOGLNF(" * color %d: pref=%s success=%d value=%x\n", int(id), + GetColorPrefName(id), NS_SUCCEEDED(rv), + NS_SUCCEEDED(rv) ? color : 0); + } + LOGLNF(" * titlebar-radius: %d\n", mTitlebarRadius); + } +} + +// virtual +char16_t nsLookAndFeel::GetPasswordCharacterImpl() { + EnsureInit(); + return mSystemTheme.mInvisibleCharacter; +} + +bool nsLookAndFeel::GetEchoPasswordImpl() { return false; } + +bool nsLookAndFeel::GetDefaultDrawInTitlebar() { return sCSDAvailable; } + +nsXPLookAndFeel::TitlebarAction nsLookAndFeel::GetTitlebarAction( + TitlebarEvent aEvent) { + return aEvent == TitlebarEvent::Double_Click ? mDoubleClickAction + : mMiddleClickAction; +} + +void nsLookAndFeel::GetThemeInfo(nsACString& aInfo) { + aInfo.Append(mSystemTheme.mName); + aInfo.Append(" / "); + aInfo.Append(mAltTheme.mName); +} + +bool nsLookAndFeel::WidgetUsesImage(WidgetNodeType aNodeType) { + static constexpr GtkStateFlags sFlagsToCheck[]{ + GTK_STATE_FLAG_NORMAL, GTK_STATE_FLAG_PRELIGHT, + GtkStateFlags(GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_ACTIVE), + GTK_STATE_FLAG_BACKDROP, GTK_STATE_FLAG_INSENSITIVE}; + + GtkStyleContext* style = GetStyleContext(aNodeType); + + GValue value = G_VALUE_INIT; + for (GtkStateFlags state : sFlagsToCheck) { + gtk_style_context_get_property(style, "background-image", state, &value); + bool hasPattern = G_VALUE_TYPE(&value) == CAIRO_GOBJECT_TYPE_PATTERN && + g_value_get_boxed(&value); + g_value_unset(&value); + if (hasPattern) { + return true; + } + } + return false; +} + +void nsLookAndFeel::RecordLookAndFeelSpecificTelemetry() { + // Gtk version we're on. + nsString version; + version.AppendPrintf("%d.%d", gtk_major_version, gtk_minor_version); + Telemetry::ScalarSet(Telemetry::ScalarID::WIDGET_GTK_VERSION, version); + + // Whether the current Gtk theme has scrollbar buttons. + bool hasScrollbarButtons = + GetInt(LookAndFeel::IntID::ScrollArrowStyle) != eScrollArrow_None; + mozilla::Telemetry::ScalarSet( + mozilla::Telemetry::ScalarID::WIDGET_GTK_THEME_HAS_SCROLLBAR_BUTTONS, + hasScrollbarButtons); + + // Whether the current Gtk theme uses something other than a solid color + // background for scrollbar parts. + bool scrollbarUsesImage = !ShouldHonorThemeScrollbarColors(); + mozilla::Telemetry::ScalarSet( + mozilla::Telemetry::ScalarID::WIDGET_GTK_THEME_SCROLLBAR_USES_IMAGES, + scrollbarUsesImage); +} + +bool nsLookAndFeel::ShouldHonorThemeScrollbarColors() { + // If the Gtk theme uses anything other than solid color backgrounds for Gtk + // scrollbar parts, this is a good indication that painting XUL scrollbar part + // elements using colors extracted from the theme won't provide good results. + return !WidgetUsesImage(MOZ_GTK_SCROLLBAR_VERTICAL) && + !WidgetUsesImage(MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL) && + !WidgetUsesImage(MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL) && + !WidgetUsesImage(MOZ_GTK_SCROLLBAR_THUMB_VERTICAL); +} + +#undef LOGLNF +#undef LOGLNF_ENABLED |