зеркало из https://github.com/mozilla/gecko-dev.git
1076 строки
31 KiB
C++
1076 строки
31 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/* the features that media queries can test */
|
|
|
|
#include "nsMediaFeatures.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsCSSKeywords.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsCSSValue.h"
|
|
#ifdef XP_WIN
|
|
#include "mozilla/LookAndFeel.h"
|
|
#endif
|
|
#include "nsCSSRuleProcessor.h"
|
|
#include "nsDeviceContext.h"
|
|
#include "nsIBaseWindow.h"
|
|
#include "nsIDocShell.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsIWidget.h"
|
|
#include "nsContentUtils.h"
|
|
#include "mozilla/StyleSheet.h"
|
|
#include "mozilla/StyleSheetInlines.h"
|
|
|
|
using namespace mozilla;
|
|
|
|
static nsTArray<RefPtr<nsAtom>>* sSystemMetrics = nullptr;
|
|
|
|
#ifdef XP_WIN
|
|
// Cached theme identifier for the moz-windows-theme media query.
|
|
static uint8_t sWinThemeId = LookAndFeel::eWindowsTheme_Generic;
|
|
#endif
|
|
|
|
static const nsCSSProps::KTableEntry kOrientationKeywords[] = {
|
|
{ eCSSKeyword_portrait, NS_STYLE_ORIENTATION_PORTRAIT },
|
|
{ eCSSKeyword_landscape, NS_STYLE_ORIENTATION_LANDSCAPE },
|
|
{ eCSSKeyword_UNKNOWN, -1 }
|
|
};
|
|
|
|
static const nsCSSProps::KTableEntry kScanKeywords[] = {
|
|
{ eCSSKeyword_progressive, NS_STYLE_SCAN_PROGRESSIVE },
|
|
{ eCSSKeyword_interlace, NS_STYLE_SCAN_INTERLACE },
|
|
{ eCSSKeyword_UNKNOWN, -1 }
|
|
};
|
|
|
|
static const nsCSSProps::KTableEntry kDisplayModeKeywords[] = {
|
|
{ eCSSKeyword_browser, NS_STYLE_DISPLAY_MODE_BROWSER },
|
|
{ eCSSKeyword_minimal_ui, NS_STYLE_DISPLAY_MODE_MINIMAL_UI },
|
|
{ eCSSKeyword_standalone, NS_STYLE_DISPLAY_MODE_STANDALONE },
|
|
{ eCSSKeyword_fullscreen, NS_STYLE_DISPLAY_MODE_FULLSCREEN },
|
|
{ eCSSKeyword_UNKNOWN, -1 }
|
|
};
|
|
|
|
#ifdef XP_WIN
|
|
struct WindowsThemeName {
|
|
LookAndFeel::WindowsTheme id;
|
|
const wchar_t* name;
|
|
};
|
|
|
|
// Windows theme identities used in the -moz-windows-theme media query.
|
|
const WindowsThemeName themeStrings[] = {
|
|
{ LookAndFeel::eWindowsTheme_Aero, L"aero" },
|
|
{ LookAndFeel::eWindowsTheme_AeroLite, L"aero-lite" },
|
|
{ LookAndFeel::eWindowsTheme_LunaBlue, L"luna-blue" },
|
|
{ LookAndFeel::eWindowsTheme_LunaOlive, L"luna-olive" },
|
|
{ LookAndFeel::eWindowsTheme_LunaSilver, L"luna-silver" },
|
|
{ LookAndFeel::eWindowsTheme_Royale, L"royale" },
|
|
{ LookAndFeel::eWindowsTheme_Zune, L"zune" },
|
|
{ LookAndFeel::eWindowsTheme_Generic, L"generic" }
|
|
};
|
|
|
|
struct OperatingSystemVersionInfo {
|
|
LookAndFeel::OperatingSystemVersion id;
|
|
const wchar_t* name;
|
|
};
|
|
|
|
// Os version identities used in the -moz-os-version media query.
|
|
const OperatingSystemVersionInfo osVersionStrings[] = {
|
|
{ LookAndFeel::eOperatingSystemVersion_Windows7, L"windows-win7" },
|
|
{ LookAndFeel::eOperatingSystemVersion_Windows8, L"windows-win8" },
|
|
{ LookAndFeel::eOperatingSystemVersion_Windows10, L"windows-win10" }
|
|
};
|
|
#endif
|
|
|
|
static nsPresContext*
|
|
GetPresContext(nsIDocument* aDocument)
|
|
{
|
|
nsIPresShell* presShell = aDocument->GetShell();
|
|
if (!presShell) {
|
|
return nullptr;
|
|
}
|
|
|
|
return presShell->GetPresContext();
|
|
}
|
|
|
|
// A helper for four features below
|
|
static nsSize
|
|
GetSize(nsIDocument* aDocument)
|
|
{
|
|
nsPresContext* pc = GetPresContext(aDocument);
|
|
|
|
// Per spec, return a 0x0 viewport if we're not being rendered. See:
|
|
//
|
|
// * https://github.com/w3c/csswg-drafts/issues/571
|
|
// * https://github.com/whatwg/html/issues/1813
|
|
//
|
|
if (!pc) {
|
|
return { };
|
|
}
|
|
|
|
if (pc->IsRootPaginatedDocument()) {
|
|
// We want the page size, including unprintable areas and margins.
|
|
//
|
|
// FIXME(emilio, bug 1414600): Not quite!
|
|
return pc->GetPageSize();
|
|
}
|
|
|
|
return pc->GetVisibleArea().Size();
|
|
}
|
|
|
|
static void
|
|
GetWidth(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
nsSize size = GetSize(aDocument);
|
|
aResult.SetFloatValue(CSSPixel::FromAppUnits(size.width), eCSSUnit_Pixel);
|
|
}
|
|
|
|
static void
|
|
GetHeight(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
nsSize size = GetSize(aDocument);
|
|
aResult.SetFloatValue(CSSPixel::FromAppUnits(size.height), eCSSUnit_Pixel);
|
|
}
|
|
|
|
static bool
|
|
ShouldResistFingerprinting(nsIDocument* aDocument)
|
|
{
|
|
return nsContentUtils::ShouldResistFingerprinting(aDocument->GetDocShell());
|
|
}
|
|
|
|
static bool
|
|
IsDeviceSizePageSize(nsIDocument* aDocument)
|
|
{
|
|
nsIDocShell* docShell = aDocument->GetDocShell();
|
|
if (!docShell) {
|
|
return false;
|
|
}
|
|
return docShell->GetDeviceSizeIsPageSize();
|
|
}
|
|
|
|
// A helper for three features below.
|
|
static nsSize
|
|
GetDeviceSize(nsIDocument* aDocument)
|
|
{
|
|
if (ShouldResistFingerprinting(aDocument) || IsDeviceSizePageSize(aDocument)) {
|
|
return GetSize(aDocument);
|
|
}
|
|
|
|
nsPresContext* pc = GetPresContext(aDocument);
|
|
// NOTE(emilio): We should probably figure out how to return an appropriate
|
|
// device size here, though in a multi-screen world that makes no sense
|
|
// really.
|
|
if (!pc) {
|
|
return { };
|
|
}
|
|
|
|
if (pc->IsRootPaginatedDocument()) {
|
|
// We want the page size, including unprintable areas and margins.
|
|
// XXX The spec actually says we want the "page sheet size", but
|
|
// how is that different?
|
|
return pc->GetPageSize();
|
|
}
|
|
|
|
nsSize size;
|
|
pc->DeviceContext()->GetDeviceSurfaceDimensions(size.width, size.height);
|
|
return size;
|
|
}
|
|
|
|
static void
|
|
GetDeviceWidth(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
nsSize size = GetDeviceSize(aDocument);
|
|
aResult.SetFloatValue(CSSPixel::FromAppUnits(size.width), eCSSUnit_Pixel);
|
|
}
|
|
|
|
static void
|
|
GetDeviceHeight(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
nsSize size = GetDeviceSize(aDocument);
|
|
aResult.SetFloatValue(CSSPixel::FromAppUnits(size.height), eCSSUnit_Pixel);
|
|
}
|
|
|
|
static void
|
|
GetOrientation(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
nsSize size = GetSize(aDocument);
|
|
// Per spec, square viewports should be 'portrait'
|
|
int32_t orientation = size.width > size.height
|
|
? NS_STYLE_ORIENTATION_LANDSCAPE : NS_STYLE_ORIENTATION_PORTRAIT;
|
|
aResult.SetIntValue(orientation, eCSSUnit_Enumerated);
|
|
}
|
|
|
|
static void
|
|
GetDeviceOrientation(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
nsSize size = GetDeviceSize(aDocument);
|
|
// Per spec, square viewports should be 'portrait'
|
|
int32_t orientation = size.width > size.height
|
|
? NS_STYLE_ORIENTATION_LANDSCAPE : NS_STYLE_ORIENTATION_PORTRAIT;
|
|
aResult.SetIntValue(orientation, eCSSUnit_Enumerated);
|
|
}
|
|
|
|
static void
|
|
GetIsResourceDocument(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
aResult.SetIntValue(aDocument->IsResourceDoc() ? 1 : 0, eCSSUnit_Integer);
|
|
}
|
|
|
|
// Helper for two features below
|
|
static void
|
|
MakeArray(const nsSize& aSize, nsCSSValue& aResult)
|
|
{
|
|
RefPtr<nsCSSValue::Array> a = nsCSSValue::Array::Create(2);
|
|
|
|
a->Item(0).SetIntValue(aSize.width, eCSSUnit_Integer);
|
|
a->Item(1).SetIntValue(aSize.height, eCSSUnit_Integer);
|
|
|
|
aResult.SetArrayValue(a, eCSSUnit_Array);
|
|
}
|
|
|
|
static void
|
|
GetAspectRatio(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
MakeArray(GetSize(aDocument), aResult);
|
|
}
|
|
|
|
static void
|
|
GetDeviceAspectRatio(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
MakeArray(GetDeviceSize(aDocument), aResult);
|
|
}
|
|
|
|
static nsDeviceContext*
|
|
GetDeviceContextFor(nsIDocument* aDocument)
|
|
{
|
|
nsPresContext* pc = GetPresContext(aDocument);
|
|
if (!pc) {
|
|
return nullptr;
|
|
}
|
|
|
|
// It would be nice to call nsLayoutUtils::GetDeviceContextForScreenInfo here,
|
|
// except for two things: (1) it can flush, and flushing is bad here, and (2)
|
|
// it doesn't really get us consistency in multi-monitor situations *anyway*.
|
|
return pc->DeviceContext();
|
|
}
|
|
|
|
static void
|
|
GetColor(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
// Use depth of 24 when resisting fingerprinting, or when we're not being
|
|
// rendered.
|
|
uint32_t depth = 24;
|
|
|
|
if (!ShouldResistFingerprinting(aDocument)) {
|
|
if (nsDeviceContext* dx = GetDeviceContextFor(aDocument)) {
|
|
// FIXME: On a monochrome device, return 0!
|
|
dx->GetDepth(depth);
|
|
}
|
|
}
|
|
|
|
// The spec says to use bits *per color component*, so divide by 3,
|
|
// and round down, since the spec says to use the smallest when the
|
|
// color components differ.
|
|
depth /= 3;
|
|
aResult.SetIntValue(int32_t(depth), eCSSUnit_Integer);
|
|
}
|
|
|
|
static void
|
|
GetColorIndex(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
// We should return zero if the device does not use a color lookup
|
|
// table. Stuart says that our handling of displays with 8-bit
|
|
// color is bad enough that we never change the lookup table to
|
|
// match what we're trying to display, so perhaps we should always
|
|
// return zero. Given that there isn't any better information
|
|
// exposed, we don't have much other choice.
|
|
aResult.SetIntValue(0, eCSSUnit_Integer);
|
|
}
|
|
|
|
static void
|
|
GetMonochrome(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
// For color devices we should return 0.
|
|
// FIXME: On a monochrome device, return the actual color depth, not
|
|
// 0!
|
|
aResult.SetIntValue(0, eCSSUnit_Integer);
|
|
}
|
|
|
|
static void
|
|
GetResolution(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
// We're returning resolution in terms of device pixels per css pixel, since
|
|
// that is the preferred unit for media queries of resolution. This avoids
|
|
// introducing precision error from conversion to and from less-used
|
|
// physical units like inches.
|
|
|
|
float dppx = 1.;
|
|
|
|
if (nsDeviceContext* dx = GetDeviceContextFor(aDocument)) {
|
|
if (ShouldResistFingerprinting(aDocument)) {
|
|
dppx = dx->GetFullZoom();
|
|
} else {
|
|
// Get the actual device pixel ratio, which also takes zoom into account.
|
|
dppx =
|
|
float(nsPresContext::AppUnitsPerCSSPixel()) / dx->AppUnitsPerDevPixel();
|
|
}
|
|
}
|
|
|
|
aResult.SetFloatValue(dppx, eCSSUnit_Pixel);
|
|
}
|
|
|
|
static void
|
|
GetScan(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
// Since Gecko doesn't support the 'tv' media type, the 'scan'
|
|
// feature is never present.
|
|
aResult.Reset();
|
|
}
|
|
|
|
static nsIDocument*
|
|
TopDocument(nsIDocument* aDocument)
|
|
{
|
|
nsIDocument* current = aDocument;
|
|
while (nsIDocument* parent = current->GetParentDocument()) {
|
|
current = parent;
|
|
}
|
|
return current;
|
|
}
|
|
|
|
static void
|
|
GetDisplayMode(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
nsIDocument* rootDocument = TopDocument(aDocument);
|
|
|
|
nsCOMPtr<nsISupports> container = rootDocument->GetContainer();
|
|
if (nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(container)) {
|
|
nsCOMPtr<nsIWidget> mainWidget;
|
|
baseWindow->GetMainWidget(getter_AddRefs(mainWidget));
|
|
if (mainWidget && mainWidget->SizeMode() == nsSizeMode_Fullscreen) {
|
|
aResult.SetIntValue(NS_STYLE_DISPLAY_MODE_FULLSCREEN, eCSSUnit_Enumerated);
|
|
return;
|
|
}
|
|
}
|
|
|
|
static_assert(nsIDocShell::DISPLAY_MODE_BROWSER == NS_STYLE_DISPLAY_MODE_BROWSER &&
|
|
nsIDocShell::DISPLAY_MODE_MINIMAL_UI == NS_STYLE_DISPLAY_MODE_MINIMAL_UI &&
|
|
nsIDocShell::DISPLAY_MODE_STANDALONE == NS_STYLE_DISPLAY_MODE_STANDALONE &&
|
|
nsIDocShell::DISPLAY_MODE_FULLSCREEN == NS_STYLE_DISPLAY_MODE_FULLSCREEN,
|
|
"nsIDocShell display modes must mach nsStyleConsts.h");
|
|
|
|
uint32_t displayMode = NS_STYLE_DISPLAY_MODE_BROWSER;
|
|
if (nsIDocShell* docShell = rootDocument->GetDocShell()) {
|
|
docShell->GetDisplayMode(&displayMode);
|
|
}
|
|
|
|
aResult.SetIntValue(displayMode, eCSSUnit_Enumerated);
|
|
}
|
|
|
|
static void
|
|
GetGrid(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
// Gecko doesn't support grid devices (e.g., ttys), so the 'grid'
|
|
// feature is always 0.
|
|
aResult.SetIntValue(0, eCSSUnit_Integer);
|
|
}
|
|
|
|
static void
|
|
GetDevicePixelRatio(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
if (ShouldResistFingerprinting(aDocument)) {
|
|
aResult.SetFloatValue(1.0, eCSSUnit_Number);
|
|
return;
|
|
}
|
|
|
|
nsIPresShell* presShell = aDocument->GetShell();
|
|
if (!presShell) {
|
|
aResult.SetFloatValue(1.0, eCSSUnit_Number);
|
|
return;
|
|
}
|
|
|
|
nsPresContext* pc = presShell->GetPresContext();
|
|
if (!pc) {
|
|
aResult.SetFloatValue(1.0, eCSSUnit_Number);
|
|
return;
|
|
}
|
|
|
|
float ratio = pc->CSSPixelsToDevPixels(1.0f);
|
|
aResult.SetFloatValue(ratio, eCSSUnit_Number);
|
|
}
|
|
|
|
static void
|
|
GetTransform3d(nsIDocument* aDocument, const nsMediaFeature*,
|
|
nsCSSValue& aResult)
|
|
{
|
|
// Gecko supports 3d transforms, so this feature is always 1.
|
|
aResult.SetIntValue(1, eCSSUnit_Integer);
|
|
}
|
|
|
|
static bool
|
|
HasSystemMetric(nsAtom* aMetric)
|
|
{
|
|
nsMediaFeatures::InitSystemMetrics();
|
|
return sSystemMetrics->IndexOf(aMetric) != sSystemMetrics->NoIndex;
|
|
}
|
|
|
|
#ifdef XP_WIN
|
|
static uint8_t
|
|
GetWindowsThemeIdentifier()
|
|
{
|
|
nsMediaFeatures::InitSystemMetrics();
|
|
return sWinThemeId;
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
GetSystemMetric(nsIDocument* aDocument, const nsMediaFeature* aFeature,
|
|
nsCSSValue& aResult)
|
|
{
|
|
aResult.Reset();
|
|
|
|
const bool isAccessibleFromContentPages =
|
|
!(aFeature->mReqFlags & nsMediaFeature::eUserAgentAndChromeOnly);
|
|
|
|
MOZ_ASSERT(!isAccessibleFromContentPages ||
|
|
*aFeature->mName == nsGkAtoms::_moz_touch_enabled);
|
|
|
|
if (isAccessibleFromContentPages && ShouldResistFingerprinting(aDocument)) {
|
|
// If "privacy.resistFingerprinting" is enabled, then we simply don't
|
|
// return any system-backed media feature values. (No spoofed values
|
|
// returned.)
|
|
return;
|
|
}
|
|
|
|
MOZ_ASSERT(aFeature->mValueType == nsMediaFeature::eBoolInteger,
|
|
"unexpected type");
|
|
|
|
nsAtom* metricAtom = *aFeature->mData.mMetric;
|
|
bool hasMetric = HasSystemMetric(metricAtom);
|
|
aResult.SetIntValue(hasMetric ? 1 : 0, eCSSUnit_Integer);
|
|
}
|
|
|
|
static void
|
|
GetWindowsTheme(nsIDocument* aDocument, const nsMediaFeature* aFeature,
|
|
nsCSSValue& aResult)
|
|
{
|
|
aResult.Reset();
|
|
|
|
MOZ_ASSERT(aFeature->mReqFlags & nsMediaFeature::eUserAgentAndChromeOnly);
|
|
if (ShouldResistFingerprinting(aDocument)) {
|
|
return;
|
|
}
|
|
|
|
#ifdef XP_WIN
|
|
uint8_t windowsThemeId = GetWindowsThemeIdentifier();
|
|
|
|
// Classic mode should fail to match.
|
|
if (windowsThemeId == LookAndFeel::eWindowsTheme_Classic)
|
|
return;
|
|
|
|
// Look up the appropriate theme string
|
|
for (size_t i = 0; i < ArrayLength(themeStrings); ++i) {
|
|
if (windowsThemeId == themeStrings[i].id) {
|
|
aResult.SetStringValue(nsDependentString(themeStrings[i].name),
|
|
eCSSUnit_Ident);
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
GetOperatingSystemVersion(nsIDocument* aDocument, const nsMediaFeature* aFeature,
|
|
nsCSSValue& aResult)
|
|
{
|
|
aResult.Reset();
|
|
|
|
MOZ_ASSERT(aFeature->mReqFlags & nsMediaFeature::eUserAgentAndChromeOnly);
|
|
if (ShouldResistFingerprinting(aDocument)) {
|
|
return;
|
|
}
|
|
|
|
#ifdef XP_WIN
|
|
int32_t metricResult;
|
|
if (NS_SUCCEEDED(
|
|
LookAndFeel::GetInt(LookAndFeel::eIntID_OperatingSystemVersionIdentifier,
|
|
&metricResult))) {
|
|
for (size_t i = 0; i < ArrayLength(osVersionStrings); ++i) {
|
|
if (metricResult == osVersionStrings[i].id) {
|
|
aResult.SetStringValue(nsDependentString(osVersionStrings[i].name),
|
|
eCSSUnit_Ident);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
GetIsGlyph(nsIDocument* aDocument, const nsMediaFeature* aFeature,
|
|
nsCSSValue& aResult)
|
|
{
|
|
MOZ_ASSERT(aFeature->mReqFlags & nsMediaFeature::eUserAgentAndChromeOnly);
|
|
aResult.SetIntValue(aDocument->IsSVGGlyphsDocument() ? 1 : 0, eCSSUnit_Integer);
|
|
}
|
|
|
|
/* static */ void
|
|
nsMediaFeatures::InitSystemMetrics()
|
|
{
|
|
if (sSystemMetrics)
|
|
return;
|
|
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
sSystemMetrics = new nsTArray<RefPtr<nsAtom>>;
|
|
|
|
/***************************************************************************
|
|
* ANY METRICS ADDED HERE SHOULD ALSO BE ADDED AS MEDIA QUERIES BELOW *
|
|
***************************************************************************/
|
|
|
|
int32_t metricResult =
|
|
LookAndFeel::GetInt(LookAndFeel::eIntID_ScrollArrowStyle);
|
|
if (metricResult & LookAndFeel::eScrollArrow_StartBackward) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::scrollbar_start_backward);
|
|
}
|
|
if (metricResult & LookAndFeel::eScrollArrow_StartForward) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::scrollbar_start_forward);
|
|
}
|
|
if (metricResult & LookAndFeel::eScrollArrow_EndBackward) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::scrollbar_end_backward);
|
|
}
|
|
if (metricResult & LookAndFeel::eScrollArrow_EndForward) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::scrollbar_end_forward);
|
|
}
|
|
|
|
metricResult =
|
|
LookAndFeel::GetInt(LookAndFeel::eIntID_ScrollSliderStyle);
|
|
if (metricResult != LookAndFeel::eScrollThumbStyle_Normal) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::scrollbar_thumb_proportional);
|
|
}
|
|
|
|
metricResult =
|
|
LookAndFeel::GetInt(LookAndFeel::eIntID_UseOverlayScrollbars);
|
|
if (metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::overlay_scrollbars);
|
|
}
|
|
|
|
metricResult =
|
|
LookAndFeel::GetInt(LookAndFeel::eIntID_MenuBarDrag);
|
|
if (metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::menubar_drag);
|
|
}
|
|
|
|
nsresult rv =
|
|
LookAndFeel::GetInt(LookAndFeel::eIntID_WindowsDefaultTheme, &metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_default_theme);
|
|
}
|
|
|
|
rv = LookAndFeel::GetInt(LookAndFeel::eIntID_MacGraphiteTheme, &metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::mac_graphite_theme);
|
|
}
|
|
|
|
rv = LookAndFeel::GetInt(LookAndFeel::eIntID_MacYosemiteTheme, &metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::mac_yosemite_theme);
|
|
}
|
|
|
|
rv = LookAndFeel::GetInt(LookAndFeel::eIntID_WindowsAccentColorInTitlebar, &metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_accent_color_in_titlebar);
|
|
}
|
|
|
|
rv = LookAndFeel::GetInt(LookAndFeel::eIntID_DWMCompositor, &metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_compositor);
|
|
}
|
|
|
|
rv = LookAndFeel::GetInt(LookAndFeel::eIntID_WindowsGlass, &metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_glass);
|
|
}
|
|
|
|
rv = LookAndFeel::GetInt(LookAndFeel::eIntID_WindowsClassic, &metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_classic);
|
|
}
|
|
|
|
rv = LookAndFeel::GetInt(LookAndFeel::eIntID_TouchEnabled, &metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::touch_enabled);
|
|
}
|
|
|
|
rv = LookAndFeel::GetInt(LookAndFeel::eIntID_SwipeAnimationEnabled,
|
|
&metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::swipe_animation_enabled);
|
|
}
|
|
|
|
rv = LookAndFeel::GetInt(LookAndFeel::eIntID_GTKCSDAvailable,
|
|
&metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::gtk_csd_available);
|
|
}
|
|
|
|
rv = LookAndFeel::GetInt(LookAndFeel::eIntID_GTKCSDMinimizeButton,
|
|
&metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::gtk_csd_minimize_button);
|
|
}
|
|
|
|
rv = LookAndFeel::GetInt(LookAndFeel::eIntID_GTKCSDMaximizeButton,
|
|
&metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::gtk_csd_maximize_button);
|
|
}
|
|
|
|
rv = LookAndFeel::GetInt(LookAndFeel::eIntID_GTKCSDCloseButton,
|
|
&metricResult);
|
|
if (NS_SUCCEEDED(rv) && metricResult) {
|
|
sSystemMetrics->AppendElement(nsGkAtoms::gtk_csd_close_button);
|
|
}
|
|
|
|
#ifdef XP_WIN
|
|
if (NS_SUCCEEDED(
|
|
LookAndFeel::GetInt(LookAndFeel::eIntID_WindowsThemeIdentifier,
|
|
&metricResult))) {
|
|
sWinThemeId = metricResult;
|
|
switch (metricResult) {
|
|
case LookAndFeel::eWindowsTheme_Aero:
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_theme_aero);
|
|
break;
|
|
case LookAndFeel::eWindowsTheme_AeroLite:
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_theme_aero_lite);
|
|
break;
|
|
case LookAndFeel::eWindowsTheme_LunaBlue:
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_theme_luna_blue);
|
|
break;
|
|
case LookAndFeel::eWindowsTheme_LunaOlive:
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_theme_luna_olive);
|
|
break;
|
|
case LookAndFeel::eWindowsTheme_LunaSilver:
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_theme_luna_silver);
|
|
break;
|
|
case LookAndFeel::eWindowsTheme_Royale:
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_theme_royale);
|
|
break;
|
|
case LookAndFeel::eWindowsTheme_Zune:
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_theme_zune);
|
|
break;
|
|
case LookAndFeel::eWindowsTheme_Generic:
|
|
sSystemMetrics->AppendElement(nsGkAtoms::windows_theme_generic);
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* static */ void
|
|
nsMediaFeatures::FreeSystemMetrics()
|
|
{
|
|
delete sSystemMetrics;
|
|
sSystemMetrics = nullptr;
|
|
}
|
|
|
|
/* static */ void
|
|
nsMediaFeatures::Shutdown()
|
|
{
|
|
FreeSystemMetrics();
|
|
}
|
|
|
|
/*
|
|
* Adding new media features requires (1) adding the new feature to this
|
|
* array, with appropriate entries (and potentially any new code needed
|
|
* to support new types in these entries and (2) ensuring that either
|
|
* nsPresContext::MediaFeatureValuesChanged or
|
|
* nsPresContext::PostMediaFeatureValuesChangedEvent is called when the
|
|
* value that would be returned by the entry's mGetter changes.
|
|
*/
|
|
|
|
/* static */ const nsMediaFeature
|
|
nsMediaFeatures::features[] = {
|
|
{
|
|
&nsGkAtoms::width,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eLength,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetWidth
|
|
},
|
|
{
|
|
&nsGkAtoms::height,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eLength,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetHeight
|
|
},
|
|
{
|
|
&nsGkAtoms::deviceWidth,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eLength,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetDeviceWidth
|
|
},
|
|
{
|
|
&nsGkAtoms::deviceHeight,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eLength,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetDeviceHeight
|
|
},
|
|
{
|
|
&nsGkAtoms::orientation,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eEnumerated,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ kOrientationKeywords },
|
|
GetOrientation
|
|
},
|
|
{
|
|
&nsGkAtoms::aspectRatio,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eIntRatio,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetAspectRatio
|
|
},
|
|
{
|
|
&nsGkAtoms::deviceAspectRatio,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eIntRatio,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetDeviceAspectRatio
|
|
},
|
|
{
|
|
&nsGkAtoms::color,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eInteger,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetColor
|
|
},
|
|
{
|
|
&nsGkAtoms::colorIndex,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eInteger,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetColorIndex
|
|
},
|
|
{
|
|
&nsGkAtoms::monochrome,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eInteger,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetMonochrome
|
|
},
|
|
{
|
|
&nsGkAtoms::resolution,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eResolution,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetResolution
|
|
},
|
|
{
|
|
&nsGkAtoms::scan,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eEnumerated,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ kScanKeywords },
|
|
GetScan
|
|
},
|
|
{
|
|
&nsGkAtoms::grid,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetGrid
|
|
},
|
|
{
|
|
&nsGkAtoms::displayMode,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eEnumerated,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ kDisplayModeKeywords },
|
|
GetDisplayMode
|
|
},
|
|
|
|
// Webkit extensions that we support for de-facto web compatibility
|
|
// -webkit-{min|max}-device-pixel-ratio (controlled with its own pref):
|
|
{
|
|
&nsGkAtoms::devicePixelRatio,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eFloat,
|
|
nsMediaFeature::eHasWebkitPrefix |
|
|
nsMediaFeature::eWebkitDevicePixelRatioPrefEnabled,
|
|
{ nullptr },
|
|
GetDevicePixelRatio
|
|
},
|
|
// -webkit-transform-3d:
|
|
{
|
|
&nsGkAtoms::transform_3d,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eHasWebkitPrefix,
|
|
{ nullptr },
|
|
GetTransform3d
|
|
},
|
|
|
|
// Mozilla extensions
|
|
{
|
|
&nsGkAtoms::_moz_device_pixel_ratio,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eFloat,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetDevicePixelRatio
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_device_orientation,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eEnumerated,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ kOrientationKeywords },
|
|
GetDeviceOrientation
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_is_resource_document,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
GetIsResourceDocument
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_scrollbar_start_backward,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::scrollbar_start_backward },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_scrollbar_start_forward,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::scrollbar_start_forward },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_scrollbar_end_backward,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::scrollbar_end_backward },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_scrollbar_end_forward,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::scrollbar_end_forward },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_scrollbar_thumb_proportional,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::scrollbar_thumb_proportional },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_overlay_scrollbars,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::overlay_scrollbars },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_windows_default_theme,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::windows_default_theme },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_mac_graphite_theme,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::mac_graphite_theme },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_mac_yosemite_theme,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::mac_yosemite_theme },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_windows_accent_color_in_titlebar,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::windows_accent_color_in_titlebar },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_windows_compositor,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::windows_compositor },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_windows_classic,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::windows_classic },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_windows_glass,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::windows_glass },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_touch_enabled,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
// FIXME(emilio): Restrict (or remove?) when bug 1035774 lands.
|
|
nsMediaFeature::eNoRequirements,
|
|
{ &nsGkAtoms::touch_enabled },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_menubar_drag,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::menubar_drag },
|
|
GetSystemMetric
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_windows_theme,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eIdent,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ nullptr },
|
|
GetWindowsTheme
|
|
},
|
|
{
|
|
&nsGkAtoms::_moz_os_version,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eIdent,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ nullptr },
|
|
GetOperatingSystemVersion
|
|
},
|
|
|
|
{
|
|
&nsGkAtoms::_moz_swipe_animation_enabled,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::swipe_animation_enabled },
|
|
GetSystemMetric
|
|
},
|
|
|
|
{
|
|
&nsGkAtoms::_moz_gtk_csd_available,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::gtk_csd_available },
|
|
GetSystemMetric
|
|
},
|
|
|
|
{
|
|
&nsGkAtoms::_moz_gtk_csd_minimize_button,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::gtk_csd_minimize_button },
|
|
GetSystemMetric
|
|
},
|
|
|
|
{
|
|
&nsGkAtoms::_moz_gtk_csd_maximize_button,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::gtk_csd_maximize_button },
|
|
GetSystemMetric
|
|
},
|
|
|
|
{
|
|
&nsGkAtoms::_moz_gtk_csd_close_button,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ &nsGkAtoms::gtk_csd_close_button },
|
|
GetSystemMetric
|
|
},
|
|
|
|
// Internal -moz-is-glyph media feature: applies only inside SVG glyphs.
|
|
// Internal because it is really only useful in the user agent anyway
|
|
// and therefore not worth standardizing.
|
|
{
|
|
&nsGkAtoms::_moz_is_glyph,
|
|
nsMediaFeature::eMinMaxNotAllowed,
|
|
nsMediaFeature::eBoolInteger,
|
|
nsMediaFeature::eUserAgentAndChromeOnly,
|
|
{ nullptr },
|
|
GetIsGlyph
|
|
},
|
|
// Null-mName terminator:
|
|
{
|
|
nullptr,
|
|
nsMediaFeature::eMinMaxAllowed,
|
|
nsMediaFeature::eInteger,
|
|
nsMediaFeature::eNoRequirements,
|
|
{ nullptr },
|
|
nullptr
|
|
},
|
|
};
|