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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
|
/* -*- 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/. */
#ifndef CSSEditUtils_h
#define CSSEditUtils_h
#include "ChangeStyleTransaction.h" // for ChangeStyleTransaction
#include "EditorForwards.h"
#include "nsCOMPtr.h" // for already_AddRefed
#include "nsStringFwd.h"
#include "nsTArray.h" // for nsTArray
#include "nscore.h" // for nsAString, nsresult, nullptr
class nsComputedDOMStyle;
class nsAtom;
class nsIContent;
class nsINode;
class nsStaticAtom;
class nsStyledElement;
namespace mozilla {
namespace dom {
class Element;
} // namespace dom
using nsProcessValueFunc = void (*)(const nsAString* aInputString,
nsAString& aOutputString,
const char* aDefaultValueString,
const char* aPrependString,
const char* aAppendString);
class CSSEditUtils final {
public:
// To prevent the class being instantiated
CSSEditUtils() = delete;
enum nsCSSEditableProperty {
eCSSEditableProperty_NONE = 0,
eCSSEditableProperty_background_color,
eCSSEditableProperty_background_image,
eCSSEditableProperty_border,
eCSSEditableProperty_caption_side,
eCSSEditableProperty_color,
eCSSEditableProperty_float,
eCSSEditableProperty_font_family,
eCSSEditableProperty_font_size,
eCSSEditableProperty_font_style,
eCSSEditableProperty_font_weight,
eCSSEditableProperty_height,
eCSSEditableProperty_list_style_type,
eCSSEditableProperty_margin_left,
eCSSEditableProperty_margin_right,
eCSSEditableProperty_text_align,
eCSSEditableProperty_text_decoration,
eCSSEditableProperty_vertical_align,
eCSSEditableProperty_whitespace,
eCSSEditableProperty_width
};
// Nb: keep these fields in an order that minimizes padding.
struct CSSEquivTable {
nsCSSEditableProperty cssProperty;
bool gettable;
bool caseSensitiveValue;
nsProcessValueFunc processValueFunctor;
const char* defaultValue;
const char* prependValue;
const char* appendValue;
};
/**
* Adds/remove a CSS declaration to the STYLE attribute carried by a given
* element.
*
* @param aHTMLEditor [IN] An HTMLEditor instance
* @param aStyledElement [IN] A DOM styled element.
* @param aProperty [IN] An atom containing the CSS property to set.
* @param aValue [IN] A string containing the value of the CSS
* property.
*/
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static nsresult
SetCSSPropertyWithTransaction(HTMLEditor& aHTMLEditor,
nsStyledElement& aStyledElement,
nsAtom& aProperty, const nsAString& aValue) {
return SetCSSPropertyInternal(aHTMLEditor, aStyledElement, aProperty,
aValue, false);
}
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static nsresult
SetCSSPropertyPixelsWithTransaction(HTMLEditor& aHTMLEditor,
nsStyledElement& aStyledElement,
nsAtom& aProperty, int32_t aIntValue);
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static nsresult
SetCSSPropertyPixelsWithoutTransaction(HTMLEditor& aHTMLEditor,
nsStyledElement& aStyledElement,
const nsAtom& aProperty,
int32_t aIntValue);
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static nsresult
RemoveCSSPropertyWithTransaction(HTMLEditor& aHTMLEditor,
nsStyledElement& aStyledElement,
nsAtom& aProperty,
const nsAString& aPropertyValue) {
return RemoveCSSPropertyInternal(aHTMLEditor, aStyledElement, aProperty,
aPropertyValue, false);
}
/**
* Gets the specified/computed style value of a CSS property for a given
* node (or its element ancestor if it is not an element).
*
* @param aContent [IN] A DOM node.
* @param aProperty [IN] An atom containing the CSS property to get.
* @param aPropertyValue [OUT] The retrieved value of the property.
*/
static nsresult GetSpecifiedProperty(nsIContent& aContent,
nsAtom& aCSSProperty, nsAString& aValue);
MOZ_CAN_RUN_SCRIPT static nsresult GetComputedProperty(nsIContent& aContent,
nsAtom& aCSSProperty,
nsAString& aValue);
/**
* Removes a CSS property from the specified declarations in STYLE attribute
* and removes the node if it is an useless span.
*
* @param aHTMLEditor [IN] An HTMLEditor instance
* @param aStyledElement [IN] The styled element we want to remove a style
* from.
* @param aProperty [IN] The CSS property atom to remove.
* @param aPropertyValue [IN] The value of the property we have to remove
* if the property accepts more than one value.
* @return A candidate point to put caret.
*/
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static Result<EditorDOMPoint, nsresult>
RemoveCSSInlineStyleWithTransaction(HTMLEditor& aHTMLEditor,
nsStyledElement& aStyledElement,
nsAtom* aProperty,
const nsAString& aPropertyValue);
/**
* Get the default browser background color if we need it for
* GetCSSBackgroundColorState().
*
* @param aColor [OUT] The default color as it is defined in prefs.
*/
static void GetDefaultBackgroundColor(nsAString& aColor);
/**
* Returns the list of values for the CSS equivalences to
* the passed HTML style for the passed node.
*
* @param aElement [IN] A DOM node.
* @param aStyle [IN] The style to get the values.
* @param aValueString [OUT] The list of CSS values.
*/
MOZ_CAN_RUN_SCRIPT static nsresult GetComputedCSSEquivalentTo(
dom::Element& aElement, const EditorElementStyle& aStyle,
nsAString& aOutValue);
/**
* Does the node aNode (or his parent if it is not an element node) carries
* the CSS equivalent styles to the HTML style for this node ?
*
* @param aHTMLEditor [IN] An HTMLEditor instance
* @param aContent [IN] A DOM node.
* @param aStyle [IN] The style to check.
* @param aInOutValue [IN/OUT] Input value is used for initial value of the
* result, out value is the list of CSS values.
* @return A boolean being true if the css properties are
* not same as initial value.
*/
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static Result<bool, nsresult>
IsComputedCSSEquivalentTo(const HTMLEditor& aHTMLEditor, nsIContent& aContent,
const EditorInlineStyle& aStyle,
nsAString& aInOutValue);
[[nodiscard]] MOZ_CAN_RUN_SCRIPT_BOUNDARY static Result<bool, nsresult>
IsSpecifiedCSSEquivalentTo(const HTMLEditor& aHTMLEditor,
nsIContent& aContent,
const EditorInlineStyle& aStyle,
nsAString& aInOutValue);
/**
* This is a kind of Is*CSSEquivalentTo.
* Is*CSSEquivalentTo returns whether the properties aren't same as initial
* value. But this method returns whether the properties aren't set.
* If node is <span style="font-weight: normal"/>,
* - Is(Computed|Specified)CSSEquivalentTo returns false.
* - Have(Computed|Specified)CSSEquivalentStyles returns true.
*
* @param aHTMLEditor [IN] An HTMLEditor instance
* @param aContent [IN] A DOM node.
* @param aStyle [IN] The style to check.
* @return A boolean being true if the css properties are
* not set.
*/
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static Result<bool, nsresult>
HaveComputedCSSEquivalentStyles(const HTMLEditor& aHTMLEditor,
nsIContent& aContent,
const EditorInlineStyle& aStyle);
[[nodiscard]] MOZ_CAN_RUN_SCRIPT_BOUNDARY static Result<bool, nsresult>
HaveSpecifiedCSSEquivalentStyles(const HTMLEditor& aHTMLEditor,
nsIContent& aContent,
const EditorInlineStyle& aStyle);
/**
* Adds to the node the CSS inline styles equivalent to the HTML style
* and return the number of CSS properties set by the call.
*
* @param aHTMLEditor [IN} An HTMLEditor instance
* @param aNode [IN] A DOM node.
* @param aStyleToSet [IN] The style to set. Can be EditorInlineStyle.
* @param aValue [IN] The attribute or style value of aStyleToSet.
*
* @return The number of CSS properties set by the call.
*/
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static Result<size_t, nsresult>
SetCSSEquivalentToStyle(WithTransaction aWithTransaction,
HTMLEditor& aHTMLEditor,
nsStyledElement& aStyledElement,
const EditorElementStyle& aStyleToSet,
const nsAString* aValue);
/**
* Removes from the node the CSS inline styles equivalent to the HTML style.
*
* @param aHTMLEditor [IN} An HTMLEditor instance
* @param aStyledElement [IN] A DOM Element (must not be null).
* @param aStyleToRemove [IN] The style to remove. Can be EditorInlineStyle.
* @param aAttribute [IN] An atom to an attribute name or nullptr if
* irrelevant.
* @param aValue [IN] The attribute value.
*/
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static nsresult RemoveCSSEquivalentToStyle(
WithTransaction aWithTransaction, HTMLEditor& aHTMLEditor,
nsStyledElement& aStyledElement, const EditorElementStyle& aStyleToRemove,
const nsAString* aValue);
/**
* Parses a "xxxx.xxxxxuuu" string where x is a digit and u an alpha char.
*
* @param aString [IN] Input string to parse.
* @param aValue [OUT] Numeric part.
* @param aUnit [OUT] Unit part.
*/
static void ParseLength(const nsAString& aString, float* aValue,
nsAtom** aUnit);
/**
* DoStyledElementsHaveSameStyle compares two elements and checks if they have
* the same specified CSS declarations in the STYLE attribute. The answer is
* always false if at least one of them carries an ID or a class.
*
* @param aStyledElement [IN] A styled element.
* @param aOtherStyledElement [IN] The other styled element.
* @return true if the two elements are considered to
* have same styles.
*/
static bool DoStyledElementsHaveSameStyle(
nsStyledElement& aStyledElement, nsStyledElement& aOtherStyledElement);
/**
* Gets the computed style for a given element. Can return null.
*/
static already_AddRefed<nsComputedDOMStyle> GetComputedStyle(
dom::Element* aElement);
private:
enum class StyleType { Specified, Computed };
/**
* Retrieves the CSS property atom from an enum.
*
* @param aProperty The enum value for the property.
* @return The corresponding atom.
*/
static nsStaticAtom* GetCSSPropertyAtom(nsCSSEditableProperty aProperty);
struct CSSDeclaration {
nsStaticAtom& mProperty;
nsString const mValue;
};
/**
* Retrieves the CSS declarations for aEquivTable.
*
* @param aEquivTable The equivalence table.
* @param aValue Optional. If specified, may return only
* matching declarations to this value (depends on
* the style, check how is aInputString of
* nsProcessValueFunc for the details).
* @param aHandlingFor What's the purpose of calling this.
* @param aOutCSSDeclarations [OUT] The array of CSS declarations.
*/
enum class HandlingFor { GettingStyle, SettingStyle, RemovingStyle };
static void GetCSSDeclarations(const CSSEquivTable* aEquivTable,
const nsAString* aValue,
HandlingFor aHandlingFor,
nsTArray<CSSDeclaration>& aOutCSSDeclarations);
/**
* Retrieves the CSS declarations equivalent to the given aStyle/aValue on
* aElement.
*
* @param aElement The DOM node.
* @param aStyle The style to get equivelent CSS properties and
* values.
* @param aValue Optional. If specified, may return only
* matching declarations to this value (depends on
* the style, check how is aInputString of
* nsProcessValueFunc for the details).
* @param aHandlingFor What's the purpose of calling this.
* @param aOutCSSDeclarations [OUT] The array of CSS declarations.
*/
static void GetCSSDeclarations(dom::Element& aElement,
const EditorElementStyle& aStyle,
const nsAString* aValue,
HandlingFor aHandlingFor,
nsTArray<CSSDeclaration>& aOutCSSDeclarations);
/**
* Back-end for GetSpecifiedProperty and GetComputedProperty.
*
* @param aNode [IN] A DOM node.
* @param aProperty [IN] A CSS property.
* @param aValue [OUT] The retrieved value for this property.
*/
MOZ_CAN_RUN_SCRIPT static nsresult GetComputedCSSInlinePropertyBase(
nsIContent& aContent, nsAtom& aCSSProperty, nsAString& aValue);
static nsresult GetSpecifiedCSSInlinePropertyBase(nsIContent& aContent,
nsAtom& aCSSProperty,
nsAString& aValue);
/**
* Those methods are wrapped with corresponding methods which do not have
* "Internal" in their names. Don't use these methods directly even if
* you want to use one of them in this class.
* Note that these methods may run scrip only when StyleType is Computed.
*/
MOZ_CAN_RUN_SCRIPT static nsresult GetCSSEquivalentTo(
dom::Element& aElement, const EditorElementStyle& aStyle,
nsAString& aOutValue, StyleType aStyleType);
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static Result<bool, nsresult>
IsCSSEquivalentTo(const HTMLEditor& aHTMLEditor, nsIContent& aContent,
const EditorInlineStyle& aStyle, nsAString& aInOutValue,
StyleType aStyleType);
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static Result<bool, nsresult>
HaveCSSEquivalentStyles(const HTMLEditor& aHTMLEditor, nsIContent& aContent,
const EditorInlineStyle& aStyle,
StyleType aStyleType);
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static nsresult RemoveCSSPropertyInternal(
HTMLEditor& aHTMLEditor, nsStyledElement& aStyledElement,
nsAtom& aProperty, const nsAString& aPropertyValue,
bool aSuppressTxn = false);
[[nodiscard]] MOZ_CAN_RUN_SCRIPT static nsresult SetCSSPropertyInternal(
HTMLEditor& aHTMLEditor, nsStyledElement& aStyledElement,
nsAtom& aProperty, const nsAString& aValue, bool aSuppressTxn = false);
/**
* Answers true if the given aStyle on aElement or an element whose name is
* aTagName has a CSS equivalence in this implementation.
*
* @param aTagName [IN] Tag name of an element.
* @param aElement [IN] An element.
* @param aStyle [IN] The style you want to check.
* @return A boolean saying if the tag/attribute has a CSS
* equiv.
*/
[[nodiscard]] static bool IsCSSEditableStyle(
const nsAtom& aTagName, const EditorElementStyle& aStyle);
[[nodiscard]] static bool IsCSSEditableStyle(
const dom::Element& aElement, const EditorElementStyle& aStyle);
friend class EditorElementStyle; // for IsCSSEditableStyle
};
#define NS_EDITOR_INDENT_INCREMENT_IN 0.4134f
#define NS_EDITOR_INDENT_INCREMENT_CM 1.05f
#define NS_EDITOR_INDENT_INCREMENT_MM 10.5f
#define NS_EDITOR_INDENT_INCREMENT_PT 29.76f
#define NS_EDITOR_INDENT_INCREMENT_PC 2.48f
#define NS_EDITOR_INDENT_INCREMENT_EM 3
#define NS_EDITOR_INDENT_INCREMENT_EX 6
#define NS_EDITOR_INDENT_INCREMENT_PX 40
#define NS_EDITOR_INDENT_INCREMENT_PERCENT 4
} // namespace mozilla
#endif // #ifndef CSSEditUtils_h
|
