123 lines
4.7 KiB
C++
123 lines
4.7 KiB
C++
/* 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"
|
|
|
|
struct Coverage;
|
|
struct GlyphAssembly;
|
|
struct MATHTableHeader;
|
|
struct MathConstants;
|
|
struct MathGlyphConstruction;
|
|
struct MathGlyphInfo;
|
|
struct MathVariants;
|
|
|
|
/**
|
|
* Used by |gfxFontEntry| to represent the MATH table of an OpenType font.
|
|
* Each |gfxFontEntry| owns at most one |gfxMathTable| instance.
|
|
*/
|
|
class gfxMathTable
|
|
{
|
|
public:
|
|
/**
|
|
* @param aMathTable The MATH table from the OpenType font
|
|
*
|
|
* The gfxMathTable object takes over ownership of the blob references
|
|
* that are passed in, and will hb_blob_destroy() them when finished;
|
|
* the caller should -not- destroy this reference.
|
|
*/
|
|
explicit gfxMathTable(hb_blob_t* aMathTable);
|
|
|
|
/**
|
|
* Releases our reference to the MATH table and cleans up everything else.
|
|
*/
|
|
~gfxMathTable();
|
|
|
|
/**
|
|
* Returns the value of the specified constant from the MATH table.
|
|
*/
|
|
int32_t GetMathConstant(gfxFontEntry::MathConstant aConstant);
|
|
|
|
/**
|
|
* If the MATH table contains an italic correction for that glyph, this
|
|
* function gets the value and returns true. Otherwise it returns false.
|
|
*/
|
|
bool
|
|
GetMathItalicsCorrection(uint32_t aGlyphID, int16_t* aItalicCorrection);
|
|
|
|
/**
|
|
* @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 GetMathVariantsSize(uint32_t aGlyphID, bool aVertical,
|
|
uint16_t aSize);
|
|
|
|
/**
|
|
* @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 GetMathVariantsParts(uint32_t aGlyphID, bool aVertical,
|
|
uint32_t aGlyphs[4]);
|
|
|
|
protected:
|
|
friend class gfxFontEntry;
|
|
// This allows gfxFontEntry to verify the validity of the main headers
|
|
// before starting to use the MATH table.
|
|
bool HasValidHeaders();
|
|
|
|
private:
|
|
// HarfBuzz blob where the MATH table is stored.
|
|
hb_blob_t* mMathTable;
|
|
|
|
// Cached values for the latest (mGlyphID, mVertical) pair that has been
|
|
// accessed and the corresponding glyph construction. These are verified
|
|
// by SelectGlyphConstruction and updated if necessary.
|
|
// mGlyphConstruction will be set to nullptr if no construction is defined
|
|
// for the glyph. If non-null, its mGlyphAssembly and mVariantCount fields
|
|
// may be safely read, but no further validation will have been done.
|
|
const MathGlyphConstruction* mGlyphConstruction;
|
|
uint32_t mGlyphID;
|
|
bool mVertical;
|
|
void SelectGlyphConstruction(uint32_t aGlyphID, bool aVertical);
|
|
|
|
// Access to some structures of the MATH table.
|
|
// These accessors just return a pointer, but do NOT themselves check the
|
|
// validity of anything. Until we've checked that HasValidHeaders (which
|
|
// does validate them) returns true, they might return pointers that cannot
|
|
// even safely be dereferenced. GetGlyphAssembly may return nullptr if the
|
|
// given glyph has no assembly defined.
|
|
const MATHTableHeader* GetMATHTableHeader();
|
|
const MathConstants* GetMathConstants();
|
|
const MathGlyphInfo* GetMathGlyphInfo();
|
|
const MathVariants* GetMathVariants();
|
|
const GlyphAssembly* GetGlyphAssembly(uint32_t aGlyphID, bool aVertical);
|
|
|
|
// Verify whether a structure or an offset belongs to the math data and can
|
|
// be read safely.
|
|
bool ValidStructure(const char* aStructStart, uint16_t aStructSize);
|
|
bool ValidOffset(const char* aOffsetStart, uint16_t aOffset);
|
|
|
|
// Get the coverage index of a glyph index from an Open Type coverage table
|
|
// or -1 if the glyph index is not found.
|
|
int32_t GetCoverageIndex(const Coverage* aCoverage, uint32_t aGlyph);
|
|
};
|
|
|
|
#endif
|