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
|
/* -*- 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/. */
#ifndef nsMathMLOperators_h___
#define nsMathMLOperators_h___
#include <stdint.h>
#include "nsStringFwd.h"
enum nsStretchDirection {
NS_STRETCH_DIRECTION_UNSUPPORTED = -1,
NS_STRETCH_DIRECTION_DEFAULT = 0,
NS_STRETCH_DIRECTION_HORIZONTAL = 1,
NS_STRETCH_DIRECTION_VERTICAL = 2
};
typedef uint32_t nsOperatorFlags;
enum {
// define the bits used to handle the operator
NS_MATHML_OPERATOR_MUTABLE = 1 << 30,
NS_MATHML_OPERATOR_EMBELLISH_ANCESTOR = 1 << 29,
NS_MATHML_OPERATOR_EMBELLISH_ISOLATED = 1 << 28,
NS_MATHML_OPERATOR_CENTERED = 1 << 27,
NS_MATHML_OPERATOR_INVISIBLE = 1 << 26,
// define the bits used in the Operator Dictionary
// the very last two bits tell us the form
NS_MATHML_OPERATOR_FORM = 0x3,
NS_MATHML_OPERATOR_FORM_INFIX = 1,
NS_MATHML_OPERATOR_FORM_PREFIX = 2,
NS_MATHML_OPERATOR_FORM_POSTFIX = 3,
// the next 2 bits tell us the direction
NS_MATHML_OPERATOR_DIRECTION = 0x3 << 2,
NS_MATHML_OPERATOR_DIRECTION_HORIZONTAL = 1 << 2,
NS_MATHML_OPERATOR_DIRECTION_VERTICAL = 2 << 2,
// other bits used in the Operator Dictionary
NS_MATHML_OPERATOR_STRETCHY = 1 << 4,
NS_MATHML_OPERATOR_FENCE = 1 << 5,
NS_MATHML_OPERATOR_ACCENT = 1 << 6,
NS_MATHML_OPERATOR_LARGEOP = 1 << 7,
NS_MATHML_OPERATOR_SEPARATOR = 1 << 8,
NS_MATHML_OPERATOR_MOVABLELIMITS = 1 << 9,
NS_MATHML_OPERATOR_SYMMETRIC = 1 << 10,
NS_MATHML_OPERATOR_INTEGRAL = 1 << 11,
NS_MATHML_OPERATOR_MIRRORABLE = 1 << 12,
// Additional bits not stored in the dictionary
NS_MATHML_OPERATOR_MINSIZE_ABSOLUTE = 1 << 13,
NS_MATHML_OPERATOR_MAXSIZE_ABSOLUTE = 1 << 14,
NS_MATHML_OPERATOR_LSPACE_ATTR = 1 << 15,
NS_MATHML_OPERATOR_RSPACE_ATTR = 1 << 16
};
#define NS_MATHML_OPERATOR_SIZE_INFINITY (mozilla::PositiveInfinity<float>())
class nsMathMLOperators {
public:
static void AddRefTable(void);
static void ReleaseTable(void);
static void CleanUp();
// LookupOperator:
// Given the string value of an operator and its form (last two bits of
// flags), this method returns true if the operator is found in the Operator
// Dictionary. Attributes of the operator are returned in the output
// parameters. If the operator is not found under the supplied form but is
// found under a different form, the method returns true as well. The caller
// can test the output parameter aFlags to know exactly under which form the
// operator was found in the Operator Dictionary.
static bool LookupOperator(const nsString& aOperator,
const nsOperatorFlags aForm,
nsOperatorFlags* aFlags, float* aLeadingSpace,
float* aTrailingSpace);
// LookupOperators:
// Helper to return all the forms under which an operator is listed in the
// Operator Dictionary. The caller must pass arrays of size 4, and use
// aFlags[NS_MATHML_OPERATOR_FORM_{INFIX|POSTFIX|PREFIX}],
// aLeadingSpace[], etc, to access the attributes of the operator under a
// particular form. If the operator wasn't found under a form, its entry
// aFlags[form] is set to zero.
static void LookupOperators(const nsString& aOperator,
nsOperatorFlags* aFlags, float* aLeadingSpace,
float* aTrailingSpace);
// Helper functions used by the nsMathMLChar class.
static bool IsMirrorableOperator(const nsString& aOperator);
// Helper function used by the nsMathMLChar class.
static nsStretchDirection GetStretchyDirection(const nsString& aOperator);
};
////////////////////////////////////////////////////////////////////////////
// Macros that retrieve the bits used to handle operators
#define NS_MATHML_OPERATOR_IS_MUTABLE(_flags) \
(NS_MATHML_OPERATOR_MUTABLE == ((_flags)&NS_MATHML_OPERATOR_MUTABLE))
#define NS_MATHML_OPERATOR_HAS_EMBELLISH_ANCESTOR(_flags) \
(NS_MATHML_OPERATOR_EMBELLISH_ANCESTOR == \
((_flags)&NS_MATHML_OPERATOR_EMBELLISH_ANCESTOR))
#define NS_MATHML_OPERATOR_EMBELLISH_IS_ISOLATED(_flags) \
(NS_MATHML_OPERATOR_EMBELLISH_ISOLATED == \
((_flags)&NS_MATHML_OPERATOR_EMBELLISH_ISOLATED))
#define NS_MATHML_OPERATOR_IS_CENTERED(_flags) \
(NS_MATHML_OPERATOR_CENTERED == ((_flags)&NS_MATHML_OPERATOR_CENTERED))
#define NS_MATHML_OPERATOR_IS_INVISIBLE(_flags) \
(NS_MATHML_OPERATOR_INVISIBLE == ((_flags)&NS_MATHML_OPERATOR_INVISIBLE))
#define NS_MATHML_OPERATOR_GET_FORM(_flags) ((_flags)&NS_MATHML_OPERATOR_FORM)
#define NS_MATHML_OPERATOR_GET_DIRECTION(_flags) \
((_flags)&NS_MATHML_OPERATOR_DIRECTION)
#define NS_MATHML_OPERATOR_FORM_IS_INFIX(_flags) \
(NS_MATHML_OPERATOR_FORM_INFIX == ((_flags)&NS_MATHML_OPERATOR_FORM))
#define NS_MATHML_OPERATOR_FORM_IS_PREFIX(_flags) \
(NS_MATHML_OPERATOR_FORM_PREFIX == ((_flags)&NS_MATHML_OPERATOR_FORM))
#define NS_MATHML_OPERATOR_FORM_IS_POSTFIX(_flags) \
(NS_MATHML_OPERATOR_FORM_POSTFIX == ((_flags)&NS_MATHML_OPERATOR_FORM))
#define NS_MATHML_OPERATOR_IS_DIRECTION_VERTICAL(_flags) \
(NS_MATHML_OPERATOR_DIRECTION_VERTICAL == \
((_flags)&NS_MATHML_OPERATOR_DIRECTION))
#define NS_MATHML_OPERATOR_IS_DIRECTION_HORIZONTAL(_flags) \
(NS_MATHML_OPERATOR_DIRECTION_HORIZONTAL == \
((_flags)&NS_MATHML_OPERATOR_DIRECTION))
#define NS_MATHML_OPERATOR_IS_STRETCHY(_flags) \
(NS_MATHML_OPERATOR_STRETCHY == ((_flags)&NS_MATHML_OPERATOR_STRETCHY))
#define NS_MATHML_OPERATOR_IS_FENCE(_flags) \
(NS_MATHML_OPERATOR_FENCE == ((_flags)&NS_MATHML_OPERATOR_FENCE))
#define NS_MATHML_OPERATOR_IS_ACCENT(_flags) \
(NS_MATHML_OPERATOR_ACCENT == ((_flags)&NS_MATHML_OPERATOR_ACCENT))
#define NS_MATHML_OPERATOR_IS_LARGEOP(_flags) \
(NS_MATHML_OPERATOR_LARGEOP == ((_flags)&NS_MATHML_OPERATOR_LARGEOP))
#define NS_MATHML_OPERATOR_IS_SEPARATOR(_flags) \
(NS_MATHML_OPERATOR_SEPARATOR == ((_flags)&NS_MATHML_OPERATOR_SEPARATOR))
#define NS_MATHML_OPERATOR_IS_MOVABLELIMITS(_flags) \
(NS_MATHML_OPERATOR_MOVABLELIMITS == \
((_flags)&NS_MATHML_OPERATOR_MOVABLELIMITS))
#define NS_MATHML_OPERATOR_IS_SYMMETRIC(_flags) \
(NS_MATHML_OPERATOR_SYMMETRIC == ((_flags)&NS_MATHML_OPERATOR_SYMMETRIC))
#define NS_MATHML_OPERATOR_IS_INTEGRAL(_flags) \
(NS_MATHML_OPERATOR_INTEGRAL == ((_flags)&NS_MATHML_OPERATOR_INTEGRAL))
#define NS_MATHML_OPERATOR_IS_MIRRORABLE(_flags) \
(NS_MATHML_OPERATOR_MIRRORABLE == ((_flags)&NS_MATHML_OPERATOR_MIRRORABLE))
#define NS_MATHML_OPERATOR_MINSIZE_IS_ABSOLUTE(_flags) \
(NS_MATHML_OPERATOR_MINSIZE_ABSOLUTE == \
((_flags)&NS_MATHML_OPERATOR_MINSIZE_ABSOLUTE))
#define NS_MATHML_OPERATOR_MAXSIZE_IS_ABSOLUTE(_flags) \
(NS_MATHML_OPERATOR_MAXSIZE_ABSOLUTE == \
((_flags)&NS_MATHML_OPERATOR_MAXSIZE_ABSOLUTE))
#define NS_MATHML_OPERATOR_HAS_LSPACE_ATTR(_flags) \
(NS_MATHML_OPERATOR_LSPACE_ATTR == ((_flags)&NS_MATHML_OPERATOR_LSPACE_ATTR))
#define NS_MATHML_OPERATOR_HAS_RSPACE_ATTR(_flags) \
(NS_MATHML_OPERATOR_RSPACE_ATTR == ((_flags)&NS_MATHML_OPERATOR_RSPACE_ATTR))
#endif /* nsMathMLOperators_h___ */
|
