DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (33b7b8e81b4b)

VCS Links

MathConstant

MathVariantCacheEntry

gfxMathTable

Macros

Line Code
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
/* 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 GFX_MATH_TABLE_H
#define GFX_MATH_TABLE_H

#include "gfxFont.h"

/**
 * Used by |gfxFont| to represent the MATH table of an OpenType font.
 * Each |gfxFont| owns at most one |gfxMathTable| instance.
 */
class gfxMathTable
{
public:
    /**
     * @param aFace The HarfBuzz face containing the math table.
     * @param aSize The font size to pass to HarfBuzz.
     */
    gfxMathTable(hb_face_t *aFace, gfxFloat aSize);

    /**
     * Releases our reference to the MATH table and cleans up everything else.
     */
    ~gfxMathTable();

    enum MathConstant {
        // The order of the constants must match the order of the fields
        // defined in the MATH table.
        ScriptPercentScaleDown,
        ScriptScriptPercentScaleDown,
        DelimitedSubFormulaMinHeight,
        DisplayOperatorMinHeight,
        MathLeading,
        AxisHeight,
        AccentBaseHeight,
        FlattenedAccentBaseHeight,
        SubscriptShiftDown,
        SubscriptTopMax,
        SubscriptBaselineDropMin,
        SuperscriptShiftUp,
        SuperscriptShiftUpCramped,
        SuperscriptBottomMin,
        SuperscriptBaselineDropMax,
        SubSuperscriptGapMin,
        SuperscriptBottomMaxWithSubscript,
        SpaceAfterScript,
        UpperLimitGapMin,
        UpperLimitBaselineRiseMin,
        LowerLimitGapMin,
        LowerLimitBaselineDropMin,
        StackTopShiftUp,
        StackTopDisplayStyleShiftUp,
        StackBottomShiftDown,
        StackBottomDisplayStyleShiftDown,
        StackGapMin,
        StackDisplayStyleGapMin,
        StretchStackTopShiftUp,
        StretchStackBottomShiftDown,
        StretchStackGapAboveMin,
        StretchStackGapBelowMin,
        FractionNumeratorShiftUp,
        FractionNumeratorDisplayStyleShiftUp,
        FractionDenominatorShiftDown,
        FractionDenominatorDisplayStyleShiftDown,
        FractionNumeratorGapMin,
        FractionNumDisplayStyleGapMin,
        FractionRuleThickness,
        FractionDenominatorGapMin,
        FractionDenomDisplayStyleGapMin,
        SkewedFractionHorizontalGap,
        SkewedFractionVerticalGap,
        OverbarVerticalGap,
        OverbarRuleThickness,
        OverbarExtraAscender,
        UnderbarVerticalGap,
        UnderbarRuleThickness,
        UnderbarExtraDescender,
        RadicalVerticalGap,
        RadicalDisplayStyleVerticalGap,
        RadicalRuleThickness,
        RadicalExtraAscender,
        RadicalKernBeforeDegree,
        RadicalKernAfterDegree,
        RadicalDegreeBottomRaisePercent
    };

    /**
     * Returns the value of the specified constant from the MATH table.
     */
    gfxFloat Constant(MathConstant aConstant) const;

    /**
     * Returns the value of the specified constant in app units.
     */
    nscoord Constant(MathConstant aConstant,
                     uint32_t aAppUnitsPerDevPixel) const
    {
        return NSToCoordRound(Constant(aConstant) * aAppUnitsPerDevPixel);
    }

    /**
     *  If the MATH table contains an italic correction for that glyph, this
     *  function returns the corresponding value. Otherwise it returns 0.
     */
    gfxFloat
    ItalicsCorrection(uint32_t aGlyphID) const;

    /**
     * @param aGlyphID  glyph index of the character we want to stretch
     * @param aVertical direction of the stretching (vertical/horizontal)
     * @param aSize     the desired size variant
     *
     * Returns the glyph index of the desired size variant or 0 if there is not
     * any such size variant.
     */
    uint32_t VariantsSize(uint32_t aGlyphID, bool aVertical,
                          uint16_t aSize) const;

    /**
     * @param aGlyphID  glyph index of the character we want to stretch
     * @param aVertical direction of the stretching (vertical/horizontal)
     * @param aGlyphs   pre-allocated buffer of 4 elements where the glyph
     * indexes (or 0 for absent parts) will be stored. The parts are stored in
     * the order expected by the nsMathMLChar: Top (or Left), Middle, Bottom
     * (or Right), Glue.
     *
     * Tries to fill-in aGlyphs with the relevant glyph indexes and returns
     * whether the operation was successful. The function returns false if
     * there is not any assembly for the character we want to stretch or if
     * the format is not supported by the nsMathMLChar code.
     *
     */
    bool VariantsParts(uint32_t aGlyphID, bool aVertical,
                       uint32_t aGlyphs[4]) const;

private:
    // size-specific font object, owned by the gfxMathTable
    hb_font_t *mHBFont;

    static const unsigned int kMaxCachedSizeCount = 10;
    struct MathVariantCacheEntry {
      uint32_t glyphID;
      bool vertical;
      uint32_t sizes[kMaxCachedSizeCount];
      uint32_t parts[4];
      bool arePartsValid;
    };
    mutable MathVariantCacheEntry mMathVariantCache;
    void ClearCache() const;
    void UpdateMathVariantCache(uint32_t aGlyphID, bool aVertical) const;
};

#endif