layout/mathml/nsMathMLOperators.h

   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 #ifndef nsMathMLOperators_h___
   7 #define nsMathMLOperators_h___
   8
   9 #include "nsCoord.h"
  10
  11 enum nsStretchDirection {
  12   NS_STRETCH_DIRECTION_UNSUPPORTED = -1,
  13   NS_STRETCH_DIRECTION_DEFAULT     =  0,
  14   NS_STRETCH_DIRECTION_HORIZONTAL  =  1,
  15   NS_STRETCH_DIRECTION_VERTICAL    =  2
  16 };
  17
  18 typedef uint32_t nsOperatorFlags;
  19 enum {
  20   // define the bits used to handle the operator
  21   NS_MATHML_OPERATOR_MUTABLE            = 1<<30,
  22   NS_MATHML_OPERATOR_EMBELLISH_ANCESTOR = 1<<29,
  23   NS_MATHML_OPERATOR_EMBELLISH_ISOLATED = 1<<28,
  24   NS_MATHML_OPERATOR_CENTERED           = 1<<27,
  25   NS_MATHML_OPERATOR_INVISIBLE          = 1<<26,
  26
  27   // define the bits used in the Operator Dictionary
  28
  29   // the very last two bits tell us the form
  30   NS_MATHML_OPERATOR_FORM               = 0x3,
  31   NS_MATHML_OPERATOR_FORM_INFIX         = 1,
  32   NS_MATHML_OPERATOR_FORM_PREFIX        = 2,
  33   NS_MATHML_OPERATOR_FORM_POSTFIX       = 3,
  34
  35   // the next 2 bits tell us the direction
  36   NS_MATHML_OPERATOR_DIRECTION            = 0x3<<2,
  37   NS_MATHML_OPERATOR_DIRECTION_HORIZONTAL = 1<<2,
  38   NS_MATHML_OPERATOR_DIRECTION_VERTICAL   = 2<<2,
  39
  40   // other bits used in the Operator Dictionary
  41   NS_MATHML_OPERATOR_STRETCHY           = 1<<4,
  42   NS_MATHML_OPERATOR_FENCE              = 1<<5,
  43   NS_MATHML_OPERATOR_ACCENT             = 1<<6,
  44   NS_MATHML_OPERATOR_LARGEOP            = 1<<7,
  45   NS_MATHML_OPERATOR_SEPARATOR          = 1<<8,
  46   NS_MATHML_OPERATOR_MOVABLELIMITS      = 1<<9,
  47   NS_MATHML_OPERATOR_SYMMETRIC          = 1<<10,
  48   NS_MATHML_OPERATOR_INTEGRAL           = 1<<11,
  49   NS_MATHML_OPERATOR_MIRRORABLE         = 1<<12,
  50
  51   // Additional bits not stored in the dictionary
  52   NS_MATHML_OPERATOR_MINSIZE_ABSOLUTE   = 1<<13,
  53   NS_MATHML_OPERATOR_MAXSIZE_ABSOLUTE   = 1<<14,
  54   NS_MATHML_OPERATOR_LSPACE_ATTR     = 1<<15,
  55   NS_MATHML_OPERATOR_RSPACE_ATTR    = 1<<16
  56 };
  57
  58 #define NS_MATHML_OPERATOR_SIZE_INFINITY NS_IEEEPositiveInfinity()
  59
  60 // Style invariant characters (chars have their own intrinsic predefined style)
  61 enum eMATHVARIANT {
  62   eMATHVARIANT_NONE = -1,
  63   eMATHVARIANT_normal = 0,
  64   eMATHVARIANT_bold,
  65   eMATHVARIANT_italic,
  66   eMATHVARIANT_bold_italic,
  67   eMATHVARIANT_sans_serif,
  68   eMATHVARIANT_bold_sans_serif,
  69   eMATHVARIANT_sans_serif_italic,
  70   eMATHVARIANT_sans_serif_bold_italic,
  71   eMATHVARIANT_monospace,
  72   eMATHVARIANT_script,
  73   eMATHVARIANT_bold_script,
  74   eMATHVARIANT_fraktur,
  75   eMATHVARIANT_bold_fraktur,
  76   eMATHVARIANT_double_struck,
  77   eMATHVARIANT_COUNT
  78 };
  79
  80 class nsMathMLOperators {
  81 public:
  82   static void AddRefTable(void);
  83   static void ReleaseTable(void);
  84   static void CleanUp();
  85
  86   // LookupOperator:
  87   // Given the string value of an operator and its form (last two bits of flags),
  88   // this method returns true if the operator is found in the Operator Dictionary.
  89   // Attributes of the operator are returned in the output parameters.
  90   // If the operator is not found under the supplied form but is found under a
  91   // different form, the method returns true as well. The caller can test the
  92   // output parameter aFlags to know exactly under which form the operator was
  93   // found in the Operator Dictionary.
  94   static bool
  95   LookupOperator(const nsString&       aOperator,
  96                  const nsOperatorFlags aForm,
  97                  nsOperatorFlags*      aFlags,
  98                  float*                aLeadingSpace,
  99                  float*                aTrailingSpace);
 100
 101    // LookupOperators:
 102    // Helper to return all the forms under which an operator is listed in the
 103    // Operator Dictionary. The caller must pass arrays of size 4, and use
 104    // aFlags[NS_MATHML_OPERATOR_FORM_{INFIX|POSTFIX|PREFIX}],
 105    // aLeadingSpace[], etc, to access the attributes of the operator under a
 106    // particular form. If the operator wasn't found under a form, its entry
 107    // aFlags[form] is set to zero.
 108    static void
 109    LookupOperators(const nsString&       aOperator,
 110                    nsOperatorFlags*      aFlags,
 111                    float*                aLeadingSpace,
 112                    float*                aTrailingSpace);
 113
 114   // IsMutableOperator:
 115   // Return true if the operator exists and is stretchy or largeop
 116   static bool
 117   IsMutableOperator(const nsString& aOperator);
 118
 119   // Helper functions used by the nsMathMLChar class.
 120   static bool
 121   IsMirrorableOperator(const nsString& aOperator);
 122
 123   // Helper function used by the nsMathMLChar class.
 124   static nsStretchDirection GetStretchyDirection(const nsString& aOperator);
 125
 126   // Return the variant type of one Unicode Mathematical Alphanumeric Symbol
 127   // character (which may be represented by a surrogate pair), or return
 128   // eMATHVARIANT_NONE if aChar is not such a character.
 129   static eMATHVARIANT LookupInvariantChar(const nsAString& aChar);
 130
 131   // Return the styled Mathematical Alphanumeric Symbol character
 132   // corresponding to a BMP character and a mathvariant value, or return aChar
 133   // if there is no such corresponding character.
 134   // Note the result may be dependent on aChar, and should be considered a
 135   // temporary.
 136   static const nsDependentSubstring
 137   TransformVariantChar(const PRUnichar& aChar, eMATHVARIANT aVariant);
 138 };
 139
 140 ////////////////////////////////////////////////////////////////////////////
 141 // Macros that retrieve the bits used to handle operators
 142
 143 #define NS_MATHML_OPERATOR_IS_MUTABLE(_flags) \
 144   (NS_MATHML_OPERATOR_MUTABLE == ((_flags) & NS_MATHML_OPERATOR_MUTABLE))
 145
 146 #define NS_MATHML_OPERATOR_HAS_EMBELLISH_ANCESTOR(_flags) \
 147   (NS_MATHML_OPERATOR_EMBELLISH_ANCESTOR == ((_flags) & NS_MATHML_OPERATOR_EMBELLISH_ANCESTOR))
 148
 149 #define NS_MATHML_OPERATOR_EMBELLISH_IS_ISOLATED(_flags) \
 150   (NS_MATHML_OPERATOR_EMBELLISH_ISOLATED == ((_flags) & NS_MATHML_OPERATOR_EMBELLISH_ISOLATED))
 151
 152 #define NS_MATHML_OPERATOR_IS_CENTERED(_flags) \
 153   (NS_MATHML_OPERATOR_CENTERED == ((_flags) & NS_MATHML_OPERATOR_CENTERED))
 154
 155 #define NS_MATHML_OPERATOR_IS_INVISIBLE(_flags) \
 156   (NS_MATHML_OPERATOR_INVISIBLE == ((_flags) & NS_MATHML_OPERATOR_INVISIBLE))
 157
 158 #define NS_MATHML_OPERATOR_GET_FORM(_flags) \
 159   ((_flags) & NS_MATHML_OPERATOR_FORM)
 160
 161 #define NS_MATHML_OPERATOR_GET_DIRECTION(_flags) \
 162   ((_flags) & NS_MATHML_OPERATOR_DIRECTION)
 163
 164 #define NS_MATHML_OPERATOR_FORM_IS_INFIX(_flags) \
 165   (NS_MATHML_OPERATOR_FORM_INFIX == ((_flags) & NS_MATHML_OPERATOR_FORM))
 166
 167 #define NS_MATHML_OPERATOR_FORM_IS_PREFIX(_flags) \
 168   (NS_MATHML_OPERATOR_FORM_PREFIX == ((_flags) & NS_MATHML_OPERATOR_FORM))
 169
 170 #define NS_MATHML_OPERATOR_FORM_IS_POSTFIX(_flags) \
 171   (NS_MATHML_OPERATOR_FORM_POSTFIX == ((_flags) & NS_MATHML_OPERATOR_FORM))
 172
 173 #define NS_MATHML_OPERATOR_IS_DIRECTION_VERTICAL(_flags) \
 174   (NS_MATHML_OPERATOR_DIRECTION_VERTICAL == ((_flags) & NS_MATHML_OPERATOR_DIRECTION))
 175
 176 #define NS_MATHML_OPERATOR_IS_DIRECTION_HORIZONTAL(_flags) \
 177   (NS_MATHML_OPERATOR_DIRECTION_HORIZONTAL == ((_flags) & NS_MATHML_OPERATOR_DIRECTION))
 178
 179 #define NS_MATHML_OPERATOR_IS_STRETCHY(_flags) \
 180   (NS_MATHML_OPERATOR_STRETCHY == ((_flags) & NS_MATHML_OPERATOR_STRETCHY))
 181
 182 #define NS_MATHML_OPERATOR_IS_FENCE(_flags) \
 183   (NS_MATHML_OPERATOR_FENCE == ((_flags) & NS_MATHML_OPERATOR_FENCE))
 184
 185 #define NS_MATHML_OPERATOR_IS_ACCENT(_flags) \
 186   (NS_MATHML_OPERATOR_ACCENT == ((_flags) & NS_MATHML_OPERATOR_ACCENT))
 187
 188 #define NS_MATHML_OPERATOR_IS_LARGEOP(_flags) \
 189   (NS_MATHML_OPERATOR_LARGEOP == ((_flags) & NS_MATHML_OPERATOR_LARGEOP))
 190
 191 #define NS_MATHML_OPERATOR_IS_SEPARATOR(_flags) \
 192   (NS_MATHML_OPERATOR_SEPARATOR == ((_flags) & NS_MATHML_OPERATOR_SEPARATOR))
 193
 194 #define NS_MATHML_OPERATOR_IS_MOVABLELIMITS(_flags) \
 195   (NS_MATHML_OPERATOR_MOVABLELIMITS == ((_flags) & NS_MATHML_OPERATOR_MOVABLELIMITS))
 196
 197 #define NS_MATHML_OPERATOR_IS_SYMMETRIC(_flags) \
 198   (NS_MATHML_OPERATOR_SYMMETRIC == ((_flags) & NS_MATHML_OPERATOR_SYMMETRIC))
 199
 200 #define NS_MATHML_OPERATOR_IS_INTEGRAL(_flags) \
 201   (NS_MATHML_OPERATOR_INTEGRAL == ((_flags) & NS_MATHML_OPERATOR_INTEGRAL))
 202
 203 #define NS_MATHML_OPERATOR_IS_MIRRORABLE(_flags) \
 204   (NS_MATHML_OPERATOR_MIRRORABLE == ((_flags) & NS_MATHML_OPERATOR_MIRRORABLE))
 205
 206 #define NS_MATHML_OPERATOR_MINSIZE_IS_ABSOLUTE(_flags) \
 207   (NS_MATHML_OPERATOR_MINSIZE_ABSOLUTE == ((_flags) & NS_MATHML_OPERATOR_MINSIZE_ABSOLUTE))
 208
 209 #define NS_MATHML_OPERATOR_MAXSIZE_IS_ABSOLUTE(_flags) \
 210   (NS_MATHML_OPERATOR_MAXSIZE_ABSOLUTE == ((_flags) & NS_MATHML_OPERATOR_MAXSIZE_ABSOLUTE))
 211
 212 #define NS_MATHML_OPERATOR_HAS_LSPACE_ATTR(_flags) \
 213   (NS_MATHML_OPERATOR_LSPACE_ATTR == ((_flags) & NS_MATHML_OPERATOR_LSPACE_ATTR))
 214
 215 #define NS_MATHML_OPERATOR_HAS_RSPACE_ATTR(_flags) \
 216   (NS_MATHML_OPERATOR_RSPACE_ATTR == ((_flags) & NS_MATHML_OPERATOR_RSPACE_ATTR))
 217
 218 #endif /* nsMathMLOperators_h___ */