summaryrefslogtreecommitdiffstats
path: root/layout/style/nsCSSProps.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/style/nsCSSProps.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/style/nsCSSProps.h')
-rw-r--r--layout/style/nsCSSProps.h895
1 files changed, 895 insertions, 0 deletions
diff --git a/layout/style/nsCSSProps.h b/layout/style/nsCSSProps.h
new file mode 100644
index 000000000..ab78e6174
--- /dev/null
+++ b/layout/style/nsCSSProps.h
@@ -0,0 +1,895 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * methods for dealing with CSS properties and tables of the keyword
+ * values they accept
+ */
+
+#ifndef nsCSSProps_h___
+#define nsCSSProps_h___
+
+#include <limits>
+#include <type_traits>
+#include "nsIAtom.h"
+#include "nsString.h"
+#include "nsCSSPropertyID.h"
+#include "nsStyleStructFwd.h"
+#include "nsCSSKeywords.h"
+#include "mozilla/CSSEnabledState.h"
+#include "mozilla/UseCounter.h"
+#include "mozilla/EnumTypeTraits.h"
+
+// Length of the "--" prefix on custom names (such as custom property names,
+// and, in the future, custom media query names).
+#define CSS_CUSTOM_NAME_PREFIX_LENGTH 2
+
+// Flags for ParseVariant method
+#define VARIANT_KEYWORD 0x000001 // K
+#define VARIANT_LENGTH 0x000002 // L
+#define VARIANT_PERCENT 0x000004 // P
+#define VARIANT_COLOR 0x000008 // C eCSSUnit_*Color, eCSSUnit_Ident (e.g. "red")
+#define VARIANT_URL 0x000010 // U
+#define VARIANT_NUMBER 0x000020 // N
+#define VARIANT_INTEGER 0x000040 // I
+#define VARIANT_ANGLE 0x000080 // G
+#define VARIANT_FREQUENCY 0x000100 // F
+#define VARIANT_TIME 0x000200 // T
+#define VARIANT_STRING 0x000400 // S
+#define VARIANT_COUNTER 0x000800 //
+#define VARIANT_ATTR 0x001000 //
+#define VARIANT_IDENTIFIER 0x002000 // D
+#define VARIANT_IDENTIFIER_NO_INHERIT 0x004000 // like above, but excluding
+// 'inherit' and 'initial'
+#define VARIANT_AUTO 0x010000 // A
+#define VARIANT_INHERIT 0x020000 // H eCSSUnit_Initial, eCSSUnit_Inherit, eCSSUnit_Unset
+#define VARIANT_NONE 0x040000 // O
+#define VARIANT_NORMAL 0x080000 // M
+#define VARIANT_SYSFONT 0x100000 // eCSSUnit_System_Font
+#define VARIANT_GRADIENT 0x200000 // eCSSUnit_Gradient
+#define VARIANT_TIMING_FUNCTION 0x400000 // cubic-bezier() and steps()
+#define VARIANT_ALL 0x800000 //
+#define VARIANT_IMAGE_RECT 0x01000000 // eCSSUnit_Function
+// This is an extra bit that says that a VARIANT_ANGLE allows unitless zero:
+#define VARIANT_ZERO_ANGLE 0x02000000 // unitless zero for angles
+#define VARIANT_CALC 0x04000000 // eCSSUnit_Calc
+#define VARIANT_ELEMENT 0x08000000 // eCSSUnit_Element
+#define VARIANT_NONNEGATIVE_DIMENSION 0x10000000 // Only lengths greater than or equal to 0.0
+// Keyword used iff gfx.font_rendering.opentype_svg.enabled is true:
+#define VARIANT_OPENTYPE_SVG_KEYWORD 0x20000000
+#define VARIANT_ABSOLUTE_DIMENSION 0x40000000 // B Only lengths with absolute length unit
+
+// Variants that can consume more than one token
+#define VARIANT_MULTIPLE_TOKENS \
+ (VARIANT_COLOR | /* rgb(...), hsl(...), etc. */ \
+ VARIANT_COUNTER | /* counter(...), counters(...) */ \
+ VARIANT_ATTR | /* attr(...) */ \
+ VARIANT_GRADIENT | /* linear-gradient(...), etc. */ \
+ VARIANT_TIMING_FUNCTION | /* cubic-bezier(...), steps(...) */ \
+ VARIANT_IMAGE_RECT | /* -moz-image-rect(...) */ \
+ VARIANT_CALC | /* calc(...) */ \
+ VARIANT_ELEMENT) /* -moz-element(...) */
+
+// Common combinations of variants
+#define VARIANT_AL (VARIANT_AUTO | VARIANT_LENGTH)
+#define VARIANT_LP (VARIANT_LENGTH | VARIANT_PERCENT)
+#define VARIANT_LN (VARIANT_LENGTH | VARIANT_NUMBER)
+#define VARIANT_AH (VARIANT_AUTO | VARIANT_INHERIT)
+#define VARIANT_AHLP (VARIANT_AH | VARIANT_LP)
+#define VARIANT_AHI (VARIANT_AH | VARIANT_INTEGER)
+#define VARIANT_AHK (VARIANT_AH | VARIANT_KEYWORD)
+#define VARIANT_AHKLP (VARIANT_AHLP | VARIANT_KEYWORD)
+#define VARIANT_AHL (VARIANT_AH | VARIANT_LENGTH)
+#define VARIANT_AHKL (VARIANT_AHK | VARIANT_LENGTH)
+#define VARIANT_HK (VARIANT_INHERIT | VARIANT_KEYWORD)
+#define VARIANT_HKF (VARIANT_HK | VARIANT_FREQUENCY)
+#define VARIANT_HKI (VARIANT_HK | VARIANT_INTEGER)
+#define VARIANT_HKL (VARIANT_HK | VARIANT_LENGTH)
+#define VARIANT_HKLP (VARIANT_HK | VARIANT_LP)
+#define VARIANT_HKLPO (VARIANT_HKLP | VARIANT_NONE)
+#define VARIANT_HL (VARIANT_INHERIT | VARIANT_LENGTH)
+#define VARIANT_HI (VARIANT_INHERIT | VARIANT_INTEGER)
+#define VARIANT_HLP (VARIANT_HL | VARIANT_PERCENT)
+#define VARIANT_HLPN (VARIANT_HLP | VARIANT_NUMBER)
+#define VARIANT_HLPO (VARIANT_HLP | VARIANT_NONE)
+#define VARIANT_HTP (VARIANT_INHERIT | VARIANT_TIME | VARIANT_PERCENT)
+#define VARIANT_HMK (VARIANT_HK | VARIANT_NORMAL)
+#define VARIANT_HC (VARIANT_INHERIT | VARIANT_COLOR)
+#define VARIANT_HCK (VARIANT_HK | VARIANT_COLOR)
+#define VARIANT_HUK (VARIANT_HK | VARIANT_URL)
+#define VARIANT_HUO (VARIANT_INHERIT | VARIANT_URL | VARIANT_NONE)
+#define VARIANT_AHUO (VARIANT_AUTO | VARIANT_HUO)
+#define VARIANT_HPN (VARIANT_INHERIT | VARIANT_PERCENT | VARIANT_NUMBER)
+#define VARIANT_PN (VARIANT_PERCENT | VARIANT_NUMBER)
+#define VARIANT_ALPN (VARIANT_AL | VARIANT_PN)
+#define VARIANT_HN (VARIANT_INHERIT | VARIANT_NUMBER)
+#define VARIANT_HON (VARIANT_HN | VARIANT_NONE)
+#define VARIANT_HOS (VARIANT_INHERIT | VARIANT_NONE | VARIANT_STRING)
+#define VARIANT_LPN (VARIANT_LP | VARIANT_NUMBER)
+#define VARIANT_UK (VARIANT_URL | VARIANT_KEYWORD)
+#define VARIANT_UO (VARIANT_URL | VARIANT_NONE)
+#define VARIANT_ANGLE_OR_ZERO (VARIANT_ANGLE | VARIANT_ZERO_ANGLE)
+#define VARIANT_LB (VARIANT_LENGTH | VARIANT_ABSOLUTE_DIMENSION)
+#define VARIANT_LBCALC (VARIANT_LB | VARIANT_CALC)
+#define VARIANT_LCALC (VARIANT_LENGTH | VARIANT_CALC)
+#define VARIANT_LPCALC (VARIANT_LCALC | VARIANT_PERCENT)
+#define VARIANT_LNCALC (VARIANT_LCALC | VARIANT_NUMBER)
+#define VARIANT_LPNCALC (VARIANT_LNCALC | VARIANT_PERCENT)
+#define VARIANT_IMAGE (VARIANT_URL | VARIANT_NONE | VARIANT_GRADIENT | \
+ VARIANT_IMAGE_RECT | VARIANT_ELEMENT)
+
+// Flags for the kFlagsTable bitfield (flags_ in nsCSSPropList.h)
+
+// This property is a logical property (such as padding-inline-start).
+#define CSS_PROPERTY_LOGICAL (1<<0)
+
+#define CSS_PROPERTY_VALUE_LIST_USES_COMMAS (1<<1) /* otherwise spaces */
+
+#define CSS_PROPERTY_APPLIES_TO_FIRST_LETTER (1<<2)
+#define CSS_PROPERTY_APPLIES_TO_FIRST_LINE (1<<3)
+#define CSS_PROPERTY_APPLIES_TO_FIRST_LETTER_AND_FIRST_LINE \
+ (CSS_PROPERTY_APPLIES_TO_FIRST_LETTER | CSS_PROPERTY_APPLIES_TO_FIRST_LINE)
+
+// Note that 'background-color' is ignored differently from the other
+// properties that have this set, but that's just special-cased.
+#define CSS_PROPERTY_IGNORED_WHEN_COLORS_DISABLED (1<<4)
+
+// A property that needs to have image loads started when a URL value
+// for the property is used for an element. This is supported only
+// for a few possible value formats: image directly in the value; list
+// of images; and with CSS_PROPERTY_IMAGE_IS_IN_ARRAY_0, image in slot
+// 0 of an array, or list of such arrays.
+#define CSS_PROPERTY_START_IMAGE_LOADS (1<<5)
+
+// Should be set only for properties with START_IMAGE_LOADS. Indicates
+// that the property has an array value with a URL/image value at index
+// 0 in the array, rather than the URL/image being in the value or value
+// list.
+#define CSS_PROPERTY_IMAGE_IS_IN_ARRAY_0 (1<<6)
+
+// This is a logical property that represents some value associated with
+// a logical axis rather than a logical box side, and thus has two
+// corresponding physical properties it could set rather than four. For
+// example, the block-size logical property has this flag set, as it
+// represents the size in either the block or inline axis dimensions, and
+// has two corresponding physical properties, width and height. Must not
+// be used in conjunction with CSS_PROPERTY_LOGICAL_END_EDGE.
+#define CSS_PROPERTY_LOGICAL_AXIS (1<<7)
+
+// This property allows calc() between lengths and percentages and
+// stores such calc() expressions in its style structs (typically in an
+// nsStyleCoord, although this is not the case for 'background-position'
+// and 'background-size').
+#define CSS_PROPERTY_STORES_CALC (1<<8)
+
+// Define what mechanism the CSS parser uses for parsing the property.
+// See CSSParserImpl::ParseProperty(nsCSSPropertyID). Don't use 0 so that
+// we can verify that every property sets one of the values.
+//
+// CSS_PROPERTY_PARSE_FUNCTION must be used for shorthand properties,
+// since it's the only mechanism that allows appending values for
+// separate properties. Longhand properties that require custom parsing
+// functions should prefer using CSS_PROPERTY_PARSE_VALUE (or
+// CSS_PROPERTY_PARSE_VALUE_LIST) and
+// CSS_PROPERTY_VALUE_PARSER_FUNCTION, though a number of existing
+// longhand properties use CSS_PROPERTY_PARSE_FUNCTION instead.
+#define CSS_PROPERTY_PARSE_PROPERTY_MASK (7<<9)
+#define CSS_PROPERTY_PARSE_INACCESSIBLE (1<<9)
+#define CSS_PROPERTY_PARSE_FUNCTION (2<<9)
+#define CSS_PROPERTY_PARSE_VALUE (3<<9)
+#define CSS_PROPERTY_PARSE_VALUE_LIST (4<<9)
+
+// See CSSParserImpl::ParseSingleValueProperty and comment above
+// CSS_PROPERTY_PARSE_FUNCTION (which is different).
+#define CSS_PROPERTY_VALUE_PARSER_FUNCTION (1<<12)
+static_assert((CSS_PROPERTY_PARSE_PROPERTY_MASK &
+ CSS_PROPERTY_VALUE_PARSER_FUNCTION) == 0,
+ "didn't leave enough room for the parse property constants");
+
+#define CSS_PROPERTY_VALUE_RESTRICTION_MASK (3<<13)
+// The parser (in particular, CSSParserImpl::ParseSingleValueProperty)
+// should enforce that the value of this property must be 0 or larger.
+#define CSS_PROPERTY_VALUE_NONNEGATIVE (1<<13)
+// The parser (in particular, CSSParserImpl::ParseSingleValueProperty)
+// should enforce that the value of this property must be 1 or larger.
+#define CSS_PROPERTY_VALUE_AT_LEAST_ONE (2<<13)
+
+// Does this property support the hashless hex color quirk in quirks mode?
+#define CSS_PROPERTY_HASHLESS_COLOR_QUIRK (1<<15)
+
+// Does this property support the unitless length quirk in quirks mode?
+#define CSS_PROPERTY_UNITLESS_LENGTH_QUIRK (1<<16)
+
+// Is this property (which must be a shorthand) really an alias?
+#define CSS_PROPERTY_IS_ALIAS (1<<17)
+
+// Does the property apply to ::placeholder?
+#define CSS_PROPERTY_APPLIES_TO_PLACEHOLDER (1<<18)
+
+// This property is allowed in an @page rule.
+#define CSS_PROPERTY_APPLIES_TO_PAGE_RULE (1<<19)
+
+// This property's getComputedStyle implementation requires layout to be
+// flushed.
+#define CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH (1<<20)
+
+// This property requires a stacking context.
+#define CSS_PROPERTY_CREATES_STACKING_CONTEXT (1<<21)
+
+// The following two flags along with the pref defines where the this
+// property can be used:
+// * If none of the two flags is presented, the pref completely controls
+// the availability of this property. And in that case, if it has no
+// pref, this property is usable everywhere.
+// * If any of the flags is set, this property is always enabled in the
+// specific contexts regardless of the value of the pref. If there is
+// no pref for this property at all in this case, it is an internal-
+// only property, which cannot be used anywhere else, and should be
+// wrapped in "#ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL".
+// Note that, these flags have no effect on the use of aliases of this
+// property.
+// Furthermore, for the purposes of animation (including triggering
+// transitions) these flags are ignored. That is, if the property is disabled
+// by a pref, we will *not* run animations or transitions on it even in
+// UA sheets or chrome.
+#define CSS_PROPERTY_ENABLED_MASK (3<<22)
+#define CSS_PROPERTY_ENABLED_IN_UA_SHEETS (1<<22)
+#define CSS_PROPERTY_ENABLED_IN_CHROME (1<<23)
+#define CSS_PROPERTY_ENABLED_IN_UA_SHEETS_AND_CHROME \
+ (CSS_PROPERTY_ENABLED_IN_UA_SHEETS | CSS_PROPERTY_ENABLED_IN_CHROME)
+
+// This property's unitless values are pixels.
+#define CSS_PROPERTY_NUMBERS_ARE_PIXELS (1<<24)
+
+// This property is a logical property for one of the two block axis
+// sides (such as margin-block-start or margin-block-end). Must only be
+// set if CSS_PROPERTY_LOGICAL is set. When not set, the logical
+// property is for one of the two inline axis sides (such as
+// margin-inline-start or margin-inline-end).
+#define CSS_PROPERTY_LOGICAL_BLOCK_AXIS (1<<25)
+
+// This property is a logical property for the "end" edge of the
+// axis determined by the presence or absence of
+// CSS_PROPERTY_LOGICAL_BLOCK_AXIS (such as margin-block-end or
+// margin-inline-end). Must only be set if CSS_PROPERTY_LOGICAL is set.
+// When not set, the logical property is for the "start" edge (such as
+// margin-block-start or margin-inline-start).
+#define CSS_PROPERTY_LOGICAL_END_EDGE (1<<26)
+
+// This property can be animated on the compositor.
+#define CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR (1<<27)
+
+// This property is an internal property that is not represented
+// in the DOM. Properties with this flag must be defined in an #ifndef
+// CSS_PROP_LIST_EXCLUDE_INTERNAL section of nsCSSPropList.h.
+#define CSS_PROPERTY_INTERNAL (1<<28)
+
+// This property has values that can establish a containing block for
+// fixed positioned and absolutely positioned elements.
+// This should be set for any properties that can cause an element to be
+// such a containing block, as implemented in
+// nsStyleDisplay::IsFixedPosContainingBlock.
+#define CSS_PROPERTY_FIXPOS_CB (1<<29)
+
+// This property has values that can establish a containing block for
+// absolutely positioned elements.
+// This should be set for any properties that can cause an element to be
+// such a containing block, as implemented in
+// nsStyleDisplay::IsAbsPosContainingBlock.
+// It does not need to be set for properties that also have
+// CSS_PROPERTY_FIXPOS_CB set.
+#define CSS_PROPERTY_ABSPOS_CB (1<<30)
+
+/**
+ * Types of animatable values.
+ */
+enum nsStyleAnimType {
+ // requires a custom implementation in
+ // StyleAnimationValue::ExtractComputedValue
+ eStyleAnimType_Custom,
+
+ // nsStyleCoord with animatable values
+ eStyleAnimType_Coord,
+
+ // same as Coord, except for one side of an nsStyleSides
+ // listed in the same order as the NS_STYLE_* constants
+ eStyleAnimType_Sides_Top,
+ eStyleAnimType_Sides_Right,
+ eStyleAnimType_Sides_Bottom,
+ eStyleAnimType_Sides_Left,
+
+ // similar, but for the *pair* of coord members of an nsStyleCorners
+ // for the relevant corner
+ eStyleAnimType_Corner_TopLeft,
+ eStyleAnimType_Corner_TopRight,
+ eStyleAnimType_Corner_BottomRight,
+ eStyleAnimType_Corner_BottomLeft,
+
+ // nscoord values
+ eStyleAnimType_nscoord,
+
+ // float values
+ eStyleAnimType_float,
+
+ // nscolor values
+ eStyleAnimType_Color,
+
+ // StyleComplexColor values
+ eStyleAnimType_ComplexColor,
+
+ // nsStyleSVGPaint values
+ eStyleAnimType_PaintServer,
+
+ // RefPtr<nsCSSShadowArray> values
+ eStyleAnimType_Shadow,
+
+ // discrete values
+ eStyleAnimType_Discrete,
+
+ // property not animatable
+ eStyleAnimType_None
+};
+
+// Empty class derived from nsIAtom so that function signatures can
+// require an atom from the atom list.
+class nsICSSProperty : public nsIAtom {};
+
+class nsCSSProps {
+public:
+ typedef mozilla::CSSEnabledState EnabledState;
+
+ struct KTableEntry
+ {
+ // KTableEntry objects can be initialized either with an int16_t value
+ // or a value of an enumeration type that can fit within an int16_t.
+
+ constexpr KTableEntry(nsCSSKeyword aKeyword, int16_t aValue)
+ : mKeyword(aKeyword)
+ , mValue(aValue)
+ {
+ }
+
+ template<typename T,
+ typename = typename std::enable_if<std::is_enum<T>::value>::type>
+ constexpr KTableEntry(nsCSSKeyword aKeyword, T aValue)
+ : mKeyword(aKeyword)
+ , mValue(static_cast<int16_t>(aValue))
+ {
+ static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
+ "aValue must be an enum that fits within mValue");
+ }
+
+ nsCSSKeyword mKeyword;
+ int16_t mValue;
+ };
+
+ static void AddRefTable(void);
+ static void ReleaseTable(void);
+
+ // Looks up the property with name aProperty and returns its corresponding
+ // nsCSSPropertyID value. If aProperty is the name of a custom property,
+ // then eCSSPropertyExtra_variable will be returned.
+ static nsCSSPropertyID LookupProperty(const nsAString& aProperty,
+ EnabledState aEnabled);
+ static nsCSSPropertyID LookupProperty(const nsACString& aProperty,
+ EnabledState aEnabled);
+ // As above, but looked up using a property's IDL name.
+ // eCSSPropertyExtra_variable won't be returned from these methods.
+ static nsCSSPropertyID LookupPropertyByIDLName(
+ const nsAString& aPropertyIDLName,
+ EnabledState aEnabled);
+ static nsCSSPropertyID LookupPropertyByIDLName(
+ const nsACString& aPropertyIDLName,
+ EnabledState aEnabled);
+
+ // Returns whether aProperty is a custom property name, i.e. begins with
+ // "--". This assumes that the CSS Variables pref has been enabled.
+ static bool IsCustomPropertyName(const nsAString& aProperty);
+ static bool IsCustomPropertyName(const nsACString& aProperty);
+
+ static inline bool IsShorthand(nsCSSPropertyID aProperty) {
+ MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
+ "out of range");
+ return (aProperty >= eCSSProperty_COUNT_no_shorthands);
+ }
+
+ // Must be given a longhand property.
+ static bool IsInherited(nsCSSPropertyID aProperty);
+
+ // Same but for @font-face descriptors
+ static nsCSSFontDesc LookupFontDesc(const nsAString& aProperty);
+ static nsCSSFontDesc LookupFontDesc(const nsACString& aProperty);
+
+ // For @counter-style descriptors
+ static nsCSSCounterDesc LookupCounterDesc(const nsAString& aProperty);
+ static nsCSSCounterDesc LookupCounterDesc(const nsACString& aProperty);
+
+ // For predefined counter styles which need to be lower-cased during parse
+ static bool IsPredefinedCounterStyle(const nsAString& aStyle);
+ static bool IsPredefinedCounterStyle(const nsACString& aStyle);
+
+ // Given a property enum, get the string value
+ static const nsAFlatCString& GetStringValue(nsCSSPropertyID aProperty);
+ static const nsAFlatCString& GetStringValue(nsCSSFontDesc aFontDesc);
+ static const nsAFlatCString& GetStringValue(nsCSSCounterDesc aCounterDesc);
+
+ // Given a CSS Property and a Property Enum Value
+ // Return back a const nsString& representation of the
+ // value. Return back nullstr if no value is found
+ static const nsAFlatCString& LookupPropertyValue(nsCSSPropertyID aProperty, int32_t aValue);
+
+ // Get a color name for a predefined color value like buttonhighlight or activeborder
+ // Sets the aStr param to the name of the propertyID
+ static bool GetColorName(int32_t aPropID, nsCString &aStr);
+
+ // Returns the index of |aKeyword| in |aTable|, if it exists there;
+ // otherwise, returns -1.
+ // NOTE: Generally, clients should call FindKeyword() instead of this method.
+ static int32_t FindIndexOfKeyword(nsCSSKeyword aKeyword,
+ const KTableEntry aTable[]);
+
+ // Find |aKeyword| in |aTable|, if found set |aValue| to its corresponding value.
+ // If not found, return false and do not set |aValue|.
+ static bool FindKeyword(nsCSSKeyword aKeyword, const KTableEntry aTable[],
+ int32_t& aValue);
+ // Return the first keyword in |aTable| that has the corresponding value |aValue|.
+ // Return |eCSSKeyword_UNKNOWN| if not found.
+ static nsCSSKeyword ValueToKeywordEnum(int32_t aValue,
+ const KTableEntry aTable[]);
+ template<typename T,
+ typename = typename std::enable_if<std::is_enum<T>::value>::type>
+ static nsCSSKeyword ValueToKeywordEnum(T aValue,
+ const KTableEntry aTable[])
+ {
+ static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
+ "aValue must be an enum that fits within KTableEntry::mValue");
+ return ValueToKeywordEnum(static_cast<int16_t>(aValue), aTable);
+ }
+ // Ditto but as a string, return "" when not found.
+ static const nsAFlatCString& ValueToKeyword(int32_t aValue,
+ const KTableEntry aTable[]);
+ template<typename T,
+ typename = typename std::enable_if<std::is_enum<T>::value>::type>
+ static const nsAFlatCString& ValueToKeyword(T aValue,
+ const KTableEntry aTable[])
+ {
+ static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
+ "aValue must be an enum that fits within KTableEntry::mValue");
+ return ValueToKeyword(static_cast<int16_t>(aValue), aTable);
+ }
+
+ static const nsStyleStructID kSIDTable[eCSSProperty_COUNT_no_shorthands];
+ static const KTableEntry* const kKeywordTableTable[eCSSProperty_COUNT_no_shorthands];
+ static const nsStyleAnimType kAnimTypeTable[eCSSProperty_COUNT_no_shorthands];
+ static const ptrdiff_t
+ kStyleStructOffsetTable[eCSSProperty_COUNT_no_shorthands];
+
+private:
+ static const uint32_t kFlagsTable[eCSSProperty_COUNT];
+
+public:
+ static inline bool PropHasFlags(nsCSSPropertyID aProperty, uint32_t aFlags)
+ {
+ MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
+ "out of range");
+ MOZ_ASSERT(!(aFlags & CSS_PROPERTY_PARSE_PROPERTY_MASK),
+ "The CSS_PROPERTY_PARSE_* values are not bitflags; don't pass "
+ "them to PropHasFlags. You probably want PropertyParseType "
+ "instead.");
+ return (nsCSSProps::kFlagsTable[aProperty] & aFlags) == aFlags;
+ }
+
+ static inline uint32_t PropertyParseType(nsCSSPropertyID aProperty)
+ {
+ MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
+ "out of range");
+ return nsCSSProps::kFlagsTable[aProperty] &
+ CSS_PROPERTY_PARSE_PROPERTY_MASK;
+ }
+
+ static inline uint32_t ValueRestrictions(nsCSSPropertyID aProperty)
+ {
+ MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
+ "out of range");
+ return nsCSSProps::kFlagsTable[aProperty] &
+ CSS_PROPERTY_VALUE_RESTRICTION_MASK;
+ }
+
+private:
+ // Lives in nsCSSParser.cpp for the macros it depends on.
+ static const uint32_t kParserVariantTable[eCSSProperty_COUNT_no_shorthands];
+
+public:
+ static inline uint32_t ParserVariant(nsCSSPropertyID aProperty) {
+ MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
+ "out of range");
+ return nsCSSProps::kParserVariantTable[aProperty];
+ }
+
+private:
+ // A table for shorthand properties. The appropriate index is the
+ // property ID minus eCSSProperty_COUNT_no_shorthands.
+ static const nsCSSPropertyID *const
+ kSubpropertyTable[eCSSProperty_COUNT - eCSSProperty_COUNT_no_shorthands];
+
+public:
+ static inline
+ const nsCSSPropertyID * SubpropertyEntryFor(nsCSSPropertyID aProperty) {
+ MOZ_ASSERT(eCSSProperty_COUNT_no_shorthands <= aProperty &&
+ aProperty < eCSSProperty_COUNT,
+ "out of range");
+ return nsCSSProps::kSubpropertyTable[aProperty -
+ eCSSProperty_COUNT_no_shorthands];
+ }
+
+ // Returns an eCSSProperty_UNKNOWN-terminated array of the shorthand
+ // properties containing |aProperty|, sorted from those that contain
+ // the most properties to those that contain the least.
+ static const nsCSSPropertyID * ShorthandsContaining(nsCSSPropertyID aProperty) {
+ MOZ_ASSERT(gShorthandsContainingPool, "uninitialized");
+ MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
+ "out of range");
+ return gShorthandsContainingTable[aProperty];
+ }
+private:
+ // gShorthandsContainingTable is an array of the return values for
+ // ShorthandsContaining (arrays of nsCSSPropertyID terminated by
+ // eCSSProperty_UNKNOWN) pointing into memory in
+ // gShorthandsContainingPool (which contains all of those arrays in a
+ // single allocation, and is the one pointer that should be |free|d).
+ static nsCSSPropertyID *gShorthandsContainingTable[eCSSProperty_COUNT_no_shorthands];
+ static nsCSSPropertyID* gShorthandsContainingPool;
+ static bool BuildShorthandsContainingTable();
+
+private:
+ static const size_t gPropertyCountInStruct[nsStyleStructID_Length];
+ static const size_t gPropertyIndexInStruct[eCSSProperty_COUNT_no_shorthands];
+public:
+ /**
+ * Return the number of properties that must be cascaded when
+ * nsRuleNode builds the nsStyle* for aSID.
+ */
+ static size_t PropertyCountInStruct(nsStyleStructID aSID) {
+ MOZ_ASSERT(0 <= aSID && aSID < nsStyleStructID_Length,
+ "out of range");
+ return gPropertyCountInStruct[aSID];
+ }
+ /**
+ * Return an index for aProperty that is unique within its SID and in
+ * the range 0 <= index < PropertyCountInStruct(aSID).
+ */
+ static size_t PropertyIndexInStruct(nsCSSPropertyID aProperty) {
+ MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
+ "out of range");
+ return gPropertyIndexInStruct[aProperty];
+ }
+
+private:
+ // A table for logical property groups. Indexes are
+ // nsCSSPropertyLogicalGroup values.
+ static const nsCSSPropertyID* const
+ kLogicalGroupTable[eCSSPropertyLogicalGroup_COUNT];
+
+public:
+ /**
+ * Returns an array of longhand physical properties which can be set by
+ * the argument, which must be a logical longhand property. The returned
+ * array is terminated by an eCSSProperty_UNKNOWN value. For example,
+ * given eCSSProperty_margin_block_start, returns an array of the four
+ * properties eCSSProperty_margin_top, eCSSProperty_margin_right,
+ * eCSSProperty_margin_bottom and eCSSProperty_margin_left, followed
+ * by the sentinel.
+ *
+ * When called with a property that has the CSS_PROPERTY_LOGICAL_AXIS
+ * flag, the returned array will have two values preceding the sentinel;
+ * otherwise it will have four.
+ *
+ * (Note that the running time of this function is proportional to the
+ * number of logical longhand properties that exist. If we start
+ * getting too many of these properties, we should make kLogicalGroupTable
+ * be a simple array of eCSSProperty_COUNT length.)
+ */
+ static const nsCSSPropertyID* LogicalGroup(nsCSSPropertyID aProperty);
+
+private:
+ static bool gPropertyEnabled[eCSSProperty_COUNT_with_aliases];
+
+private:
+ // Defined in the generated nsCSSPropsGenerated.inc.
+ static const char* const kIDLNameTable[eCSSProperty_COUNT];
+
+public:
+ /**
+ * Returns the IDL name of the specified property, which must be a
+ * longhand, logical or shorthand property. The IDL name is the property
+ * name with any hyphen-lowercase character pairs replaced by an
+ * uppercase character:
+ * https://drafts.csswg.org/cssom/#css-property-to-idl-attribute
+ *
+ * As a special case, the string "cssFloat" is returned for the float
+ * property. nullptr is returned for internal properties.
+ */
+ static const char* PropertyIDLName(nsCSSPropertyID aProperty)
+ {
+ MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
+ "out of range");
+ return kIDLNameTable[aProperty];
+ }
+
+private:
+ static const int32_t kIDLNameSortPositionTable[eCSSProperty_COUNT];
+
+public:
+ /**
+ * Returns the position of the specified property in a list of all
+ * properties sorted by their IDL name.
+ */
+ static int32_t PropertyIDLNameSortPosition(nsCSSPropertyID aProperty)
+ {
+ MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
+ "out of range");
+ return kIDLNameSortPositionTable[aProperty];
+ }
+
+ static bool IsEnabled(nsCSSPropertyID aProperty) {
+ MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_with_aliases,
+ "out of range");
+ return gPropertyEnabled[aProperty];
+ }
+
+ // A table for the use counter associated with each CSS property. If a
+ // property does not have a use counter defined in UseCounters.conf, then
+ // its associated entry is |eUseCounter_UNKNOWN|.
+ static const mozilla::UseCounter gPropertyUseCounter[eCSSProperty_COUNT_no_shorthands];
+
+public:
+
+ static mozilla::UseCounter UseCounterFor(nsCSSPropertyID aProperty) {
+ MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
+ "out of range");
+ return gPropertyUseCounter[aProperty];
+ }
+
+ static bool IsEnabled(nsCSSPropertyID aProperty, EnabledState aEnabled)
+ {
+ if (IsEnabled(aProperty)) {
+ return true;
+ }
+ if (aEnabled == EnabledState::eIgnoreEnabledState) {
+ return true;
+ }
+ if ((aEnabled & EnabledState::eInUASheets) &&
+ PropHasFlags(aProperty, CSS_PROPERTY_ENABLED_IN_UA_SHEETS))
+ {
+ return true;
+ }
+ if ((aEnabled & EnabledState::eInChrome) &&
+ PropHasFlags(aProperty, CSS_PROPERTY_ENABLED_IN_CHROME))
+ {
+ return true;
+ }
+ return false;
+ }
+
+public:
+ static void AddRefAtoms();
+ static nsICSSProperty* AtomForProperty(nsCSSPropertyID aProperty)
+ {
+ MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT);
+ return gPropertyAtomTable[aProperty];
+ }
+
+#define CSS_PROP(name_, id_, ...) static nsICSSProperty* id_;
+#define CSS_PROP_SHORTHAND(name_, id_, ...) CSS_PROP(name_, id_, ...)
+#define CSS_PROP_LIST_INCLUDE_LOGICAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_INCLUDE_LOGICAL
+#undef CSS_PROP_SHORTHAND
+#undef CSS_PROP
+
+private:
+ static nsICSSProperty* gPropertyAtomTable[eCSSProperty_COUNT];
+
+public:
+
+// Storing the enabledstate_ value in an nsCSSPropertyID variable is a small hack
+// to avoid needing a separate variable declaration for its real type
+// (CSSEnabledState), which would then require using a block and
+// therefore a pair of macros by consumers for the start and end of the loop.
+#define CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(it_, prop_, enabledstate_) \
+ for (const nsCSSPropertyID *it_ = nsCSSProps::SubpropertyEntryFor(prop_), \
+ es_ = (nsCSSPropertyID)((enabledstate_) | \
+ CSSEnabledState(0)); \
+ *it_ != eCSSProperty_UNKNOWN; ++it_) \
+ if (nsCSSProps::IsEnabled(*it_, (mozilla::CSSEnabledState) es_))
+
+ // Keyword/Enum value tables
+ static const KTableEntry kAnimationDirectionKTable[];
+ static const KTableEntry kAnimationFillModeKTable[];
+ static const KTableEntry kAnimationIterationCountKTable[];
+ static const KTableEntry kAnimationPlayStateKTable[];
+ static const KTableEntry kAnimationTimingFunctionKTable[];
+ static const KTableEntry kAppearanceKTable[];
+ static const KTableEntry kAzimuthKTable[];
+ static const KTableEntry kBackfaceVisibilityKTable[];
+ static const KTableEntry kTransformStyleKTable[];
+ static const KTableEntry kImageLayerAttachmentKTable[];
+ static const KTableEntry kImageLayerOriginKTable[];
+ static const KTableEntry kImageLayerPositionKTable[];
+ static const KTableEntry kImageLayerRepeatKTable[];
+ static const KTableEntry kImageLayerRepeatPartKTable[];
+ static const KTableEntry kImageLayerSizeKTable[];
+ static const KTableEntry kImageLayerCompositeKTable[];
+ static const KTableEntry kImageLayerModeKTable[];
+ // Not const because we modify its entries when the pref
+ // "layout.css.background-clip.text" changes:
+ static KTableEntry kBackgroundClipKTable[];
+ static const KTableEntry kBlendModeKTable[];
+ static const KTableEntry kBorderCollapseKTable[];
+ static const KTableEntry kBorderImageRepeatKTable[];
+ static const KTableEntry kBorderImageSliceKTable[];
+ static const KTableEntry kBorderStyleKTable[];
+ static const KTableEntry kBorderWidthKTable[];
+ static const KTableEntry kBoxAlignKTable[];
+ static const KTableEntry kBoxDecorationBreakKTable[];
+ static const KTableEntry kBoxDirectionKTable[];
+ static const KTableEntry kBoxOrientKTable[];
+ static const KTableEntry kBoxPackKTable[];
+ static const KTableEntry kClipPathGeometryBoxKTable[];
+ static const KTableEntry kCounterRangeKTable[];
+ static const KTableEntry kCounterSpeakAsKTable[];
+ static const KTableEntry kCounterSymbolsSystemKTable[];
+ static const KTableEntry kCounterSystemKTable[];
+ static const KTableEntry kDominantBaselineKTable[];
+ static const KTableEntry kShapeRadiusKTable[];
+ static const KTableEntry kFillRuleKTable[];
+ static const KTableEntry kFilterFunctionKTable[];
+ static const KTableEntry kImageRenderingKTable[];
+ static const KTableEntry kShapeOutsideShapeBoxKTable[];
+ static const KTableEntry kShapeRenderingKTable[];
+ static const KTableEntry kStrokeLinecapKTable[];
+ static const KTableEntry kStrokeLinejoinKTable[];
+ static const KTableEntry kStrokeContextValueKTable[];
+ static const KTableEntry kVectorEffectKTable[];
+ static const KTableEntry kTextAnchorKTable[];
+ static const KTableEntry kTextRenderingKTable[];
+ static const KTableEntry kColorAdjustKTable[];
+ static const KTableEntry kColorInterpolationKTable[];
+ static const KTableEntry kColumnFillKTable[];
+ static const KTableEntry kBoxPropSourceKTable[];
+ static const KTableEntry kBoxShadowTypeKTable[];
+ static const KTableEntry kBoxSizingKTable[];
+ static const KTableEntry kCaptionSideKTable[];
+ // Not const because we modify its entries when the pref
+ // "layout.css.float-logical-values.enabled" changes:
+ static KTableEntry kClearKTable[];
+ static const KTableEntry kColorKTable[];
+ static const KTableEntry kContentKTable[];
+ static const KTableEntry kControlCharacterVisibilityKTable[];
+ static const KTableEntry kCursorKTable[];
+ static const KTableEntry kDirectionKTable[];
+ // Not const because we modify its entries when various
+ // "layout.css.*.enabled" prefs changes:
+ static KTableEntry kDisplayKTable[];
+ static const KTableEntry kElevationKTable[];
+ static const KTableEntry kEmptyCellsKTable[];
+ // -- tables for parsing the {align,justify}-{content,items,self} properties --
+ static const KTableEntry kAlignAllKeywords[];
+ static const KTableEntry kAlignOverflowPosition[]; // <overflow-position>
+ static const KTableEntry kAlignSelfPosition[]; // <self-position>
+ static const KTableEntry kAlignLegacy[]; // 'legacy'
+ static const KTableEntry kAlignLegacyPosition[]; // 'left/right/center'
+ static const KTableEntry kAlignAutoNormalStretchBaseline[]; // 'auto/normal/stretch/baseline'
+ static const KTableEntry kAlignNormalStretchBaseline[]; // 'normal/stretch/baseline'
+ static const KTableEntry kAlignNormalBaseline[]; // 'normal/baseline'
+ static const KTableEntry kAlignContentDistribution[]; // <content-distribution>
+ static const KTableEntry kAlignContentPosition[]; // <content-position>
+ // -- tables for auto-completion of the {align,justify}-{content,items,self} properties --
+ static const KTableEntry kAutoCompletionAlignJustifySelf[];
+ static const KTableEntry kAutoCompletionAlignItems[];
+ static const KTableEntry kAutoCompletionAlignJustifyContent[];
+ // ------------------------------------------------------------------
+ static const KTableEntry kFlexDirectionKTable[];
+ static const KTableEntry kFlexWrapKTable[];
+ // Not const because we modify its entries when the pref
+ // "layout.css.float-logical-values.enabled" changes:
+ static KTableEntry kFloatKTable[];
+ static const KTableEntry kFloatEdgeKTable[];
+ static const KTableEntry kFontDisplayKTable[];
+ static const KTableEntry kFontKTable[];
+ static const KTableEntry kFontKerningKTable[];
+ static const KTableEntry kFontSizeKTable[];
+ static const KTableEntry kFontSmoothingKTable[];
+ static const KTableEntry kFontStretchKTable[];
+ static const KTableEntry kFontStyleKTable[];
+ static const KTableEntry kFontSynthesisKTable[];
+ static const KTableEntry kFontVariantKTable[];
+ static const KTableEntry kFontVariantAlternatesKTable[];
+ static const KTableEntry kFontVariantAlternatesFuncsKTable[];
+ static const KTableEntry kFontVariantCapsKTable[];
+ static const KTableEntry kFontVariantEastAsianKTable[];
+ static const KTableEntry kFontVariantLigaturesKTable[];
+ static const KTableEntry kFontVariantNumericKTable[];
+ static const KTableEntry kFontVariantPositionKTable[];
+ static const KTableEntry kFontWeightKTable[];
+ static const KTableEntry kGridAutoFlowKTable[];
+ static const KTableEntry kGridTrackBreadthKTable[];
+ static const KTableEntry kHyphensKTable[];
+ static const KTableEntry kImageOrientationKTable[];
+ static const KTableEntry kImageOrientationFlipKTable[];
+ static const KTableEntry kIsolationKTable[];
+ static const KTableEntry kIMEModeKTable[];
+ static const KTableEntry kLineHeightKTable[];
+ static const KTableEntry kListStylePositionKTable[];
+ static const KTableEntry kListStyleKTable[];
+ static const KTableEntry kMaskTypeKTable[];
+ static const KTableEntry kMathVariantKTable[];
+ static const KTableEntry kMathDisplayKTable[];
+ static const KTableEntry kContainKTable[];
+ static const KTableEntry kContextOpacityKTable[];
+ static const KTableEntry kContextPatternKTable[];
+ static const KTableEntry kObjectFitKTable[];
+ static const KTableEntry kOrientKTable[];
+ static const KTableEntry kOutlineStyleKTable[];
+ static const KTableEntry kOverflowKTable[];
+ static const KTableEntry kOverflowSubKTable[];
+ static const KTableEntry kOverflowClipBoxKTable[];
+ static const KTableEntry kOverflowWrapKTable[];
+ static const KTableEntry kPageBreakKTable[];
+ static const KTableEntry kPageBreakInsideKTable[];
+ static const KTableEntry kPageMarksKTable[];
+ static const KTableEntry kPageSizeKTable[];
+ static const KTableEntry kPitchKTable[];
+ static const KTableEntry kPointerEventsKTable[];
+ static const KTableEntry kPositionKTable[];
+ static const KTableEntry kRadialGradientShapeKTable[];
+ static const KTableEntry kRadialGradientSizeKTable[];
+ static const KTableEntry kRadialGradientLegacySizeKTable[];
+ static const KTableEntry kResizeKTable[];
+ static const KTableEntry kRubyAlignKTable[];
+ static const KTableEntry kRubyPositionKTable[];
+ static const KTableEntry kScrollBehaviorKTable[];
+ static const KTableEntry kScrollSnapTypeKTable[];
+ static const KTableEntry kSpeakKTable[];
+ static const KTableEntry kSpeakHeaderKTable[];
+ static const KTableEntry kSpeakNumeralKTable[];
+ static const KTableEntry kSpeakPunctuationKTable[];
+ static const KTableEntry kSpeechRateKTable[];
+ static const KTableEntry kStackSizingKTable[];
+ static const KTableEntry kTableLayoutKTable[];
+ // Not const because we modify its entries when the pref
+ // "layout.css.text-align-unsafe-value.enabled" changes:
+ static KTableEntry kTextAlignKTable[];
+ static KTableEntry kTextAlignLastKTable[];
+ static const KTableEntry kTextCombineUprightKTable[];
+ static const KTableEntry kTextDecorationLineKTable[];
+ static const KTableEntry kTextDecorationStyleKTable[];
+ static const KTableEntry kTextEmphasisPositionKTable[];
+ static const KTableEntry kTextEmphasisStyleFillKTable[];
+ static const KTableEntry kTextEmphasisStyleShapeKTable[];
+ static const KTableEntry kTextOrientationKTable[];
+ static const KTableEntry kTextOverflowKTable[];
+ static const KTableEntry kTextTransformKTable[];
+ static const KTableEntry kTouchActionKTable[];
+ static const KTableEntry kTopLayerKTable[];
+ static const KTableEntry kTransformBoxKTable[];
+ static const KTableEntry kTransitionTimingFunctionKTable[];
+ static const KTableEntry kUnicodeBidiKTable[];
+ static const KTableEntry kUserFocusKTable[];
+ static const KTableEntry kUserInputKTable[];
+ static const KTableEntry kUserModifyKTable[];
+ static const KTableEntry kUserSelectKTable[];
+ static const KTableEntry kVerticalAlignKTable[];
+ static const KTableEntry kVisibilityKTable[];
+ static const KTableEntry kVolumeKTable[];
+ static const KTableEntry kWhitespaceKTable[];
+ static const KTableEntry kWidthKTable[]; // also min-width, max-width
+ static const KTableEntry kWindowDraggingKTable[];
+ static const KTableEntry kWindowShadowKTable[];
+ static const KTableEntry kWordBreakKTable[];
+ static const KTableEntry kWritingModeKTable[];
+};
+
+#endif /* nsCSSProps_h___ */