The Tor Browser / file comparison

comparison: layout/style/StyleRule.h

layout/style/StyleRule.h

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:02c69a90c6e8
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 /*
7 * representation of CSS style rules (selectors+declaration) and CSS
8 * selectors
9 */
10
11 #ifndef mozilla_css_StyleRule_h__
12 #define mozilla_css_StyleRule_h__
13
14 #include "mozilla/Attributes.h"
15 #include "mozilla/MemoryReporting.h"
16 #include "mozilla/css/Rule.h"
17
18 #include "nsString.h"
19 #include "nsCOMPtr.h"
20 #include "nsCSSPseudoElements.h"
21 #include "nsCSSPseudoClasses.h"
22
23 class nsIAtom;
24 class nsCSSStyleSheet;
25 struct nsCSSSelectorList;
26 class nsCSSCompressedDataBlock;
27
28 struct nsAtomList {
29 public:
30 nsAtomList(nsIAtom* aAtom);
31 nsAtomList(const nsString& aAtomValue);
32 ~nsAtomList(void);
33
34 /** Do a deep clone. Should be used only on the first in the linked list. */
35 nsAtomList* Clone() const { return Clone(true); }
36
37 size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
38
39 nsCOMPtr<nsIAtom> mAtom;
40 nsAtomList* mNext;
41 private:
42 nsAtomList* Clone(bool aDeep) const;
43
44 nsAtomList(const nsAtomList& aCopy) MOZ_DELETE;
45 nsAtomList& operator=(const nsAtomList& aCopy) MOZ_DELETE;
46 };
47
48 struct nsPseudoClassList {
49 public:
50 nsPseudoClassList(nsCSSPseudoClasses::Type aType);
51 nsPseudoClassList(nsCSSPseudoClasses::Type aType, const char16_t *aString);
52 nsPseudoClassList(nsCSSPseudoClasses::Type aType, const int32_t *aIntPair);
53 nsPseudoClassList(nsCSSPseudoClasses::Type aType,
54 nsCSSSelectorList *aSelectorList /* takes ownership */);
55 ~nsPseudoClassList(void);
56
57 /** Do a deep clone. Should be used only on the first in the linked list. */
58 nsPseudoClassList* Clone() const { return Clone(true); }
59
60 size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
61
62 union {
63 // For a given value of mType, we have either:
64 // a. no value, which means mMemory is always null
65 // (if none of the conditions for (b), (c), or (d) is true)
66 // b. a string value, which means mString/mMemory is non-null
67 // (if nsCSSPseudoClasses::HasStringArg(mType))
68 // c. an integer pair value, which means mNumbers/mMemory is non-null
69 // (if nsCSSPseudoClasses::HasNthPairArg(mType))
70 // d. a selector list, which means mSelectors is non-null
71 // (if nsCSSPseudoClasses::HasSelectorListArg(mType))
72 void* mMemory; // mString and mNumbers use NS_Alloc/NS_Free
73 char16_t* mString;
74 int32_t* mNumbers;
75 nsCSSSelectorList* mSelectors;
76 } u;
77 nsCSSPseudoClasses::Type mType;
78 nsPseudoClassList* mNext;
79 private:
80 nsPseudoClassList* Clone(bool aDeep) const;
81
82 nsPseudoClassList(const nsPseudoClassList& aCopy) MOZ_DELETE;
83 nsPseudoClassList& operator=(const nsPseudoClassList& aCopy) MOZ_DELETE;
84 };
85
86 #define NS_ATTR_FUNC_SET 0 // [attr]
87 #define NS_ATTR_FUNC_EQUALS 1 // [attr=value]
88 #define NS_ATTR_FUNC_INCLUDES 2 // [attr~=value] (space separated)
89 #define NS_ATTR_FUNC_DASHMATCH 3 // [attr|=value] ('-' truncated)
90 #define NS_ATTR_FUNC_BEGINSMATCH 4 // [attr^=value] (begins with)
91 #define NS_ATTR_FUNC_ENDSMATCH 5 // [attr$=value] (ends with)
92 #define NS_ATTR_FUNC_CONTAINSMATCH 6 // [attr*=value] (contains substring)
93
94 struct nsAttrSelector {
95 public:
96 nsAttrSelector(int32_t aNameSpace, const nsString& aAttr);
97 nsAttrSelector(int32_t aNameSpace, const nsString& aAttr, uint8_t aFunction,
98 const nsString& aValue, bool aCaseSensitive);
99 nsAttrSelector(int32_t aNameSpace, nsIAtom* aLowercaseAttr,
100 nsIAtom* aCasedAttr, uint8_t aFunction,
101 const nsString& aValue, bool aCaseSensitive);
102 ~nsAttrSelector(void);
103
104 /** Do a deep clone. Should be used only on the first in the linked list. */
105 nsAttrSelector* Clone() const { return Clone(true); }
106
107 nsString mValue;
108 nsAttrSelector* mNext;
109 nsCOMPtr<nsIAtom> mLowercaseAttr;
110 nsCOMPtr<nsIAtom> mCasedAttr;
111 int32_t mNameSpace;
112 uint8_t mFunction;
113 bool mCaseSensitive; // If we are in an HTML document,
114 // is the value case sensitive?
115 private:
116 nsAttrSelector* Clone(bool aDeep) const;
117
118 nsAttrSelector(const nsAttrSelector& aCopy) MOZ_DELETE;
119 nsAttrSelector& operator=(const nsAttrSelector& aCopy) MOZ_DELETE;
120 };
121
122 struct nsCSSSelector {
123 public:
124 nsCSSSelector(void);
125 ~nsCSSSelector(void);
126
127 /** Do a deep clone. Should be used only on the first in the linked list. */
128 nsCSSSelector* Clone() const { return Clone(true, true); }
129
130 void Reset(void);
131 void SetNameSpace(int32_t aNameSpace);
132 void SetTag(const nsString& aTag);
133 void AddID(const nsString& aID);
134 void AddClass(const nsString& aClass);
135 void AddPseudoClass(nsCSSPseudoClasses::Type aType);
136 void AddPseudoClass(nsCSSPseudoClasses::Type aType, const char16_t* aString);
137 void AddPseudoClass(nsCSSPseudoClasses::Type aType, const int32_t* aIntPair);
138 // takes ownership of aSelectorList
139 void AddPseudoClass(nsCSSPseudoClasses::Type aType,
140 nsCSSSelectorList* aSelectorList);
141 void AddAttribute(int32_t aNameSpace, const nsString& aAttr);
142 void AddAttribute(int32_t aNameSpace, const nsString& aAttr, uint8_t aFunc,
143 const nsString& aValue, bool aCaseSensitive);
144 void SetOperator(char16_t aOperator);
145
146 inline bool HasTagSelector() const {
147 return !!mCasedTag;
148 }
149
150 inline bool IsPseudoElement() const {
151 return mLowercaseTag && !mCasedTag;
152 }
153
154 // Calculate the specificity of this selector (not including its mNext!).
155 int32_t CalcWeight() const;
156
157 void ToString(nsAString& aString, nsCSSStyleSheet* aSheet,
158 bool aAppend = false) const;
159
160 private:
161 void AddPseudoClassInternal(nsPseudoClassList *aPseudoClass);
162 nsCSSSelector* Clone(bool aDeepNext, bool aDeepNegations) const;
163
164 void AppendToStringWithoutCombinators(nsAString& aString,
165 nsCSSStyleSheet* aSheet) const;
166 void AppendToStringWithoutCombinatorsOrNegations(nsAString& aString,
167 nsCSSStyleSheet* aSheet,
168 bool aIsNegated)
169 const;
170 // Returns true if this selector can have a namespace specified (which
171 // happens if and only if the default namespace would apply to this
172 // selector).
173 bool CanBeNamespaced(bool aIsNegated) const;
174 // Calculate the specificity of this selector (not including its mNext
175 // or its mNegations).
176 int32_t CalcWeightWithoutNegations() const;
177
178 public:
179 // Get and set the selector's pseudo type
180 nsCSSPseudoElements::Type PseudoType() const {
181 return static_cast<nsCSSPseudoElements::Type>(mPseudoType);
182 }
183 void SetPseudoType(nsCSSPseudoElements::Type aType) {
184 NS_ASSERTION(static_cast<int32_t>(aType) >= INT16_MIN &&
185 static_cast<int32_t>(aType) <= INT16_MAX,
186 "Out of bounds - this will overflow mPseudoType");
187 mPseudoType = static_cast<int16_t>(aType);
188 }
189
190 size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
191
192 // For case-sensitive documents, mLowercaseTag is the same as mCasedTag,
193 // but in case-insensitive documents (HTML) mLowercaseTag is lowercase.
194 // Also, for pseudo-elements mCasedTag will be null but mLowercaseTag
195 // contains their name.
196 nsCOMPtr<nsIAtom> mLowercaseTag;
197 nsCOMPtr<nsIAtom> mCasedTag;
198 nsAtomList* mIDList;
199 nsAtomList* mClassList;
200 nsPseudoClassList* mPseudoClassList; // atom for the pseudo, string for
201 // the argument to functional pseudos
202 nsAttrSelector* mAttrList;
203 nsCSSSelector* mNegations;
204 nsCSSSelector* mNext;
205 int32_t mNameSpace;
206 char16_t mOperator;
207 private:
208 // int16_t to make sure it packs well with mOperator
209 int16_t mPseudoType;
210
211 nsCSSSelector(const nsCSSSelector& aCopy) MOZ_DELETE;
212 nsCSSSelector& operator=(const nsCSSSelector& aCopy) MOZ_DELETE;
213 };
214
215 /**
216 * A selector list is the unit of selectors that each style rule has.
217 * For example, "P B, H1 B { ... }" would be a selector list with two
218 * items (where each |nsCSSSelectorList| object's |mSelectors| has
219 * an |mNext| for the P or H1). We represent them as linked lists.
220 */
221 class inDOMUtils;
222
223 struct nsCSSSelectorList {
224 nsCSSSelectorList(void);
225 ~nsCSSSelectorList(void);
226
227 /**
228 * Create a new selector and push it onto the beginning of |mSelectors|,
229 * setting its |mNext| to the current value of |mSelectors|. If there is an
230 * earlier selector, set its |mOperator| to |aOperator|; else |aOperator|
231 * must be char16_t(0).
232 * Returns the new selector.
233 * The list owns the new selector.
234 * The caller is responsible for updating |mWeight|.
235 */
236 nsCSSSelector* AddSelector(char16_t aOperator);
237
238 /**
239 * Should be used only on the first in the list
240 */
241 void ToString(nsAString& aResult, nsCSSStyleSheet* aSheet);
242
243 /**
244 * Do a deep clone. Should be used only on the first in the list.
245 */
246 nsCSSSelectorList* Clone() const { return Clone(true); }
247
248 size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
249
250 nsCSSSelector* mSelectors;
251 int32_t mWeight;
252 nsCSSSelectorList* mNext;
253 protected:
254 friend class inDOMUtils;
255 nsCSSSelectorList* Clone(bool aDeep) const;
256
257 private:
258 nsCSSSelectorList(const nsCSSSelectorList& aCopy) MOZ_DELETE;
259 nsCSSSelectorList& operator=(const nsCSSSelectorList& aCopy) MOZ_DELETE;
260 };
261
262 // 464bab7a-2fce-4f30-ab44-b7a5f3aae57d
263 #define NS_CSS_STYLE_RULE_IMPL_CID \
264 { 0x464bab7a, 0x2fce, 0x4f30, \
265 { 0xab, 0x44, 0xb7, 0xa5, 0xf3, 0xaa, 0xe5, 0x7d } }
266
267 namespace mozilla {
268 namespace css {
269
270 class Declaration;
271 class DOMCSSStyleRule;
272
273 class StyleRule;
274
275 class ImportantRule : public nsIStyleRule {
276 public:
277 ImportantRule(Declaration *aDeclaration);
278
279 NS_DECL_ISUPPORTS
280
281 // nsIStyleRule interface
282 virtual void MapRuleInfoInto(nsRuleData* aRuleData) MOZ_OVERRIDE;
283 #ifdef DEBUG
284 virtual void List(FILE* out = stdout, int32_t aIndent = 0) const MOZ_OVERRIDE;
285 #endif
286
287 protected:
288 virtual ~ImportantRule();
289
290 // Not an owning reference; the StyleRule that owns this
291 // ImportantRule also owns the mDeclaration, and any rule node
292 // pointing to this rule keeps that StyleRule alive as well.
293 Declaration* mDeclaration;
294
295 friend class StyleRule;
296 };
297
298 class StyleRule MOZ_FINAL : public Rule
299 {
300 public:
301 StyleRule(nsCSSSelectorList* aSelector,
302 Declaration *aDeclaration);
303 private:
304 // for |Clone|
305 StyleRule(const StyleRule& aCopy);
306 // for |DeclarationChanged|
307 StyleRule(StyleRule& aCopy,
308 Declaration *aDeclaration);
309 public:
310 NS_DECLARE_STATIC_IID_ACCESSOR(NS_CSS_STYLE_RULE_IMPL_CID)
311
312 NS_DECL_ISUPPORTS
313
314 // null for style attribute
315 nsCSSSelectorList* Selector() { return mSelector; }
316
317 uint32_t GetLineNumber() const { return mLineNumber; }
318 uint32_t GetColumnNumber() const { return mColumnNumber; }
319 void SetLineNumberAndColumnNumber(uint32_t aLineNumber,
320 uint32_t aColumnNumber)
321 { mLineNumber = aLineNumber; mColumnNumber = aColumnNumber; }
322
323 Declaration* GetDeclaration() const { return mDeclaration; }
324
325 /**
326 * Return a new |nsIStyleRule| instance that replaces the current
327 * one, with |aDecl| replacing the previous declaration. Due to the
328 * |nsIStyleRule| contract of immutability, this must be called if
329 * the declaration is modified.
330 *
331 * |DeclarationChanged| handles replacing the object in the container
332 * sheet or group rule if |aHandleContainer| is true.
333 */
334 already_AddRefed<StyleRule>
335 DeclarationChanged(Declaration* aDecl, bool aHandleContainer);
336
337 nsIStyleRule* GetImportantRule() const { return mImportantRule; }
338
339 /**
340 * The rule processor must call this method before calling
341 * nsRuleWalker::Forward on this rule during rule matching.
342 */
343 void RuleMatched();
344
345 // hooks for DOM rule
346 void GetCssText(nsAString& aCssText);
347 void SetCssText(const nsAString& aCssText);
348 void GetSelectorText(nsAString& aSelectorText);
349 void SetSelectorText(const nsAString& aSelectorText);
350
351 virtual int32_t GetType() const;
352
353 virtual already_AddRefed<Rule> Clone() const;
354
355 virtual nsIDOMCSSRule* GetDOMRule();
356
357 virtual nsIDOMCSSRule* GetExistingDOMRule();
358
359 // The new mapping function.
360 virtual void MapRuleInfoInto(nsRuleData* aRuleData) MOZ_OVERRIDE;
361
362 #ifdef DEBUG
363 virtual void List(FILE* out = stdout, int32_t aIndent = 0) const MOZ_OVERRIDE;
364 #endif
365
366 virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
367
368 private:
369 ~StyleRule();
370
371 private:
372 nsCSSSelectorList* mSelector; // null for style attribute
373 Declaration* mDeclaration;
374 ImportantRule* mImportantRule; // initialized by RuleMatched
375 DOMCSSStyleRule* mDOMRule;
376 // Keep the same type so that MSVC packs them.
377 uint32_t mLineNumber;
378 uint32_t mColumnNumber : 31;
379 uint32_t mWasMatched : 1;
380
381 private:
382 StyleRule& operator=(const StyleRule& aCopy) MOZ_DELETE;
383 };
384
385 NS_DEFINE_STATIC_IID_ACCESSOR(StyleRule, NS_CSS_STYLE_RULE_IMPL_CID)
386
387 } // namespace css
388 } // namespace mozilla
389
390 #endif /* mozilla_css_StyleRule_h__ */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial