1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
/* -*- 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/. */
/* atom list for CSS pseudo-elements */
#include "nsCSSPseudoElements.h"
#include "mozilla/ArrayUtils.h"
#include "nsCSSAnonBoxes.h"
#include "nsDOMString.h"
#include "nsGkAtomConsts.h"
#include "nsStaticAtomUtils.h"
using namespace mozilla;
// Flags data for each of the pseudo-elements.
/* static */ const uint32_t nsCSSPseudoElements::kPseudoElementFlags[] = {
#define CSS_PSEUDO_ELEMENT(name_, value_, flags_) flags_,
#include "nsCSSPseudoElementList.h"
#undef CSS_PSEUDO_ELEMENT
};
/* static */
nsStaticAtom* nsCSSPseudoElements::GetAtomBase() {
return const_cast<nsStaticAtom*>(
nsGkAtoms::GetAtomByIndex(kAtomIndex_PseudoElements));
}
bool nsCSSPseudoElements::IsPseudoElement(nsAtom* aAtom) {
return nsStaticAtomUtils::IsMember(aAtom, GetAtomBase(),
kAtomCount_PseudoElements);
}
/* static */
bool nsCSSPseudoElements::IsCSS2PseudoElement(nsAtom* aAtom) {
// We don't implement this using PseudoElementHasFlags because callers
// want to pass things that could be anon boxes.
MOZ_ASSERT(IsPseudoElement(aAtom), "must be pseudo element");
bool result = aAtom == nsCSSPseudoElements::after() ||
aAtom == nsCSSPseudoElements::before() ||
aAtom == nsCSSPseudoElements::firstLetter() ||
aAtom == nsCSSPseudoElements::firstLine();
NS_ASSERTION(
result == PseudoElementHasFlags(
GetPseudoType(aAtom, EnabledState::IgnoreEnabledState),
CSS_PSEUDO_ELEMENT_IS_CSS2),
"result doesn't match flags");
return result;
}
/* static */
PseudoStyleType nsCSSPseudoElements::GetPseudoType(nsAtom* aAtom,
EnabledState aEnabledState) {
Maybe<uint32_t> index = nsStaticAtomUtils::Lookup(aAtom, GetAtomBase(),
kAtomCount_PseudoElements);
if (index.isSome()) {
auto type = static_cast<Type>(*index);
return IsEnabled(type, aEnabledState) ? type : Type::NotPseudo;
}
return Type::NotPseudo;
}
/* static */
nsAtom* nsCSSPseudoElements::GetPseudoAtom(Type aType) {
MOZ_ASSERT(PseudoStyle::IsPseudoElement(aType), "Unexpected type");
size_t index = kAtomIndex_PseudoElements + static_cast<size_t>(aType);
return nsGkAtoms::GetAtomByIndex(index);
}
/* static */
already_AddRefed<nsAtom> nsCSSPseudoElements::GetPseudoAtom(
const nsAString& aPseudoElement) {
if (DOMStringIsNull(aPseudoElement) || aPseudoElement.IsEmpty() ||
aPseudoElement.First() != char16_t(':')) {
return nullptr;
}
// deal with two-colon forms of aPseudoElt
nsAString::const_iterator start, end;
aPseudoElement.BeginReading(start);
aPseudoElement.EndReading(end);
NS_ASSERTION(start != end, "aPseudoElement is not empty!");
++start;
bool haveTwoColons = true;
if (start == end || *start != char16_t(':')) {
--start;
haveTwoColons = false;
}
RefPtr<nsAtom> pseudo = NS_Atomize(Substring(start, end));
MOZ_ASSERT(pseudo);
// There aren't any non-CSS2 pseudo-elements with a single ':'
if (!haveTwoColons &&
(!IsPseudoElement(pseudo) || !IsCSS2PseudoElement(pseudo))) {
// XXXbz I'd really rather we threw an exception or something, but
// the DOM spec sucks.
return nullptr;
}
return pseudo.forget();
}
/* static */
bool nsCSSPseudoElements::PseudoElementSupportsUserActionState(
const Type aType) {
return PseudoElementHasFlags(aType,
CSS_PSEUDO_ELEMENT_SUPPORTS_USER_ACTION_STATE);
}
/* static */
nsString nsCSSPseudoElements::PseudoTypeAsString(Type aPseudoType) {
switch (aPseudoType) {
case PseudoStyleType::before:
return u"::before"_ns;
case PseudoStyleType::after:
return u"::after"_ns;
case PseudoStyleType::marker:
return u"::marker"_ns;
default:
MOZ_ASSERT(aPseudoType == PseudoStyleType::NotPseudo,
"Unexpected pseudo type");
return u""_ns;
}
}
#ifdef DEBUG
/* static */
void nsCSSPseudoElements::AssertAtoms() {
nsStaticAtom* base = GetAtomBase();
# define CSS_PSEUDO_ELEMENT(name_, value_, flags_) \
{ \
RefPtr<nsAtom> atom = NS_Atomize(value_); \
size_t index = static_cast<size_t>(PseudoStyleType::name_); \
MOZ_ASSERT(atom == nsGkAtoms::PseudoElement_##name_, \
"Static atom for " #name_ " has incorrect value"); \
MOZ_ASSERT(atom == &base[index], \
"Static atom for " #name_ " not at expected index"); \
}
# include "nsCSSPseudoElementList.h"
# undef CSS_PSEUDO_ELEMENT
}
#endif
|
