Bugzilla

#include "nsCSSRendering.h"

#include "nsCSSRendering.h"

#include "prprf.h"         // For PR_snprintf()

#include "prprf.h"         // For PR_snprintf()

#include "nsDisplayList.h"

#include "nsDisplayList.h"

#include "nsMathMLOperators.h"

#include "nsMathMLOperators.h"

#include <algorithm>

#include <algorithm>

using namespace mozilla;

using namespace mozilla;

//#define NOISY_SEARCH 1

//#define NOISY_SEARCH 1

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

static const nsGlyphCode kNullGlyph = {{{0, 0}}, 0};

static const nsGlyphCode kNullGlyph = {{{0, 0}}, 0};

typedef enum {eExtension_base, eExtension_variants, eExtension_parts}

typedef enum {eExtension_base, eExtension_variants, eExtension_parts}

  nsMathfontPrefExtension;

  nsMathfontPrefExtension;

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

// nsGlyphTable is a class that provides an interface for accessing glyphs

// nsGlyphTable is a class that provides an interface for accessing glyphs

// of stretchy chars. It acts like a table that stores the variants of bigger

// of stretchy chars. It acts like a table that stores the variants of bigger

// sizes (if any) and the partial glyphs needed to build extensible symbols.

// sizes (if any) and the partial glyphs needed to build extensible symbols.

//

//

//

//

// A table consists of "nsGlyphCode"s which are viewed either as Unicode

// A table consists of "nsGlyphCode"s which are viewed either as Unicode

// General format of MathFont Property Files from which glyph data are

// General format of MathFont Property Files from which glyph data are

// retrieved:

// retrieved:

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

// Each font should have its set of glyph data. For example, the glyph data for

// Each font should have its set of glyph data. For example, the glyph data for

// the "Symbol" font and the "MT Extra" font are in "mathfontSymbol.properties"

// the "Symbol" font and the "MT Extra" font are in "mathfontSymbol.properties"

// and "mathfontMTExtra.properties", respectively. The mathfont property file

// and "mathfontMTExtra.properties", respectively. The mathfont property file

// is a set of all the stretchy MathML characters that can be rendered with that

// is a set of all the stretchy MathML characters that can be rendered with that

// font using larger and/or partial glyphs. The entry of each stretchy character

// font using larger and/or partial glyphs. The entry of each stretchy character

// in the mathfont property file gives, in that order, the 4 partial glyphs:

// in the mathfont property file gives, in that order, the 4 partial glyphs:

// Top (or Left), Middle, Bottom (or Right), Glue; and the variants of bigger

// Top (or Left), Middle, Bottom (or Right), Glue; and the variants of bigger

// sizes (if any).

// sizes (if any).

// A position that is not relevant to a particular character is indicated there

// A position that is not relevant to a particular character is indicated there

// with the UNICODE REPLACEMENT CHARACTER 0xFFFD.

// with the UNICODE REPLACEMENT CHARACTER 0xFFFD.

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

#define NS_TABLE_STATE_ERROR       -1

#define NS_TABLE_STATE_ERROR       -1

#define NS_TABLE_STATE_EMPTY        0

#define NS_TABLE_STATE_EMPTY        0

#define NS_TABLE_STATE_READY        1

#define NS_TABLE_STATE_READY        1

// helper to trim off comments from data in a MathFont Property File

// helper to trim off comments from data in a MathFont Property File

static void

static void

Clean(nsString& aValue)

Clean(nsString& aValue)

{

{

  uriStr.AssignLiteral("resource://gre/res/fonts/mathfont");

  uriStr.AssignLiteral("resource://gre/res/fonts/mathfont");

  uriStr.Append(aName);

  uriStr.Append(aName);

  uriStr.StripWhitespace(); // that may come from aName

  uriStr.StripWhitespace(); // that may come from aName

  uriStr.AppendLiteral(".properties");

  uriStr.AppendLiteral(".properties");

  return NS_LoadPersistentPropertiesFromURISpec(getter_AddRefs(aProperties), 

  return NS_LoadPersistentPropertiesFromURISpec(getter_AddRefs(aProperties), 

                                                NS_ConvertUTF16toUTF8(uriStr));

                                                NS_ConvertUTF16toUTF8(uriStr));

}

}

  }

  }

    NS_ASSERTION(!aGlyphCode.IsGlyphID(),

    NS_ASSERTION(!aGlyphCode.IsGlyphID(),

    return mFontName[aGlyphCode.font];

    return mFontName[aGlyphCode.font];

  }

  }

  }

  }

  }

  }

private:

private:

  // mFontName[0] is the primary font associated to this table. The others 

  // mFontName[0] is the primary font associated to this table. The others 

  // are possible "external" fonts for glyphs not in the primary font

  // are possible "external" fonts for glyphs not in the primary font

  // but which are needed to stretch certain characters in the table

  // but which are needed to stretch certain characters in the table

  nsTArray<nsString> mFontName;

  nsTArray<nsString> mFontName;

  // Tri-state variable for error/empty/ready

  // Tri-state variable for error/empty/ready

  int32_t mState;

  int32_t mState;

  // The set of glyph data in this table, as provided by the MathFont Property

  // The set of glyph data in this table, as provided by the MathFont Property

  // File

  // File

  nsCOMPtr<nsIPersistentProperties> mGlyphProperties;

  nsCOMPtr<nsIPersistentProperties> mGlyphProperties;

  // mCharCache will retain the 'key' -- which is a Unicode point, while

  // mCharCache will retain the 'key' -- which is a Unicode point, while

  // mGlyphCache will retain the 'value', which is a consecutive list of

  // mGlyphCache will retain the 'value', which is a consecutive list of

  // nsGlyphCodes, i.e., the pairs of 'code@font' needed by the char -- in

  // nsGlyphCodes, i.e., the pairs of 'code@font' needed by the char -- in

  // which 'code@0' can be specified

  // which 'code@0' can be specified

  // without the optional '@0'. However, to ease subsequent processing,

  // without the optional '@0'. However, to ease subsequent processing,

  // mGlyphCache excludes the '@' symbol and explicitly inserts all optional '0'

  // mGlyphCache excludes the '@' symbol and explicitly inserts all optional '0'

  // that indicates the primary font identifier. Specifically therefore, the

  // that indicates the primary font identifier. Specifically therefore, the

  // k-th glyph is characterized by :

  // k-th glyph is characterized by :

  // 1) mGlyphCache[3*k],mGlyphCache[3*k+1] : its Unicode point

  // 1) mGlyphCache[3*k],mGlyphCache[3*k+1] : its Unicode point

  // 2) mGlyphCache[3*k+2] : the numeric identifier of the font where it comes

  // 2) mGlyphCache[3*k+2] : the numeric identifier of the font where it comes

  // from.

  // from.

  // A font identifier of '0' means the default primary font associated to this

  // A font identifier of '0' means the default primary font associated to this

  // table. Other digits map to the "external" fonts that may have been

  // table. Other digits map to the "external" fonts that may have been

  // specified in the MathFont Property File.

  // specified in the MathFont Property File.

  nsString  mGlyphCache;

  nsString  mGlyphCache;

};

};

nsGlyphCode

nsGlyphCode

{

{

  if (mState == NS_TABLE_STATE_ERROR) return kNullGlyph;

  if (mState == NS_TABLE_STATE_ERROR) return kNullGlyph;

  // Load glyph properties if this is the first time we have been here

  // Load glyph properties if this is the first time we have been here

  if (mState == NS_TABLE_STATE_EMPTY) {

  if (mState == NS_TABLE_STATE_EMPTY) {

    nsresult rv = LoadProperties(mFontName[0], mGlyphProperties);

    nsresult rv = LoadProperties(mFontName[0], mGlyphProperties);

#ifdef DEBUG

#ifdef DEBUG

    nsAutoCString uriStr;

    nsAutoCString uriStr;

    uriStr.AssignLiteral("resource://gre/res/fonts/mathfont");

    uriStr.AssignLiteral("resource://gre/res/fonts/mathfont");

  if (index+2 >= mGlyphCache.Length()) return kNullGlyph;

  if (index+2 >= mGlyphCache.Length()) return kNullGlyph;

  nsGlyphCode ch;

  nsGlyphCode ch;

  ch.code[0] = mGlyphCache.CharAt(index);

  ch.code[0] = mGlyphCache.CharAt(index);

  ch.code[1] = mGlyphCache.CharAt(index + 1);

  ch.code[1] = mGlyphCache.CharAt(index + 1);

  ch.font = mGlyphCache.CharAt(index + 2);

  ch.font = mGlyphCache.CharAt(index + 2);

  return ch.code[0] == char16_t(0xFFFD) ? kNullGlyph : ch;

  return ch.code[0] == char16_t(0xFFFD) ? kNullGlyph : ch;

}

}

gfxTextRun*

gfxTextRun*

{

{

  return aFontGroup->

  return aFontGroup->

    MakeTextRun(aGlyph.code, aGlyph.Length(), aThebesContext,

    MakeTextRun(aGlyph.code, aGlyph.Length(), aThebesContext,

                aAppUnitsPerDevPixel, 0);

                aAppUnitsPerDevPixel, 0);

}

}

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

// This is the list of all the applicable glyph tables.

// This is the list of all the applicable glyph tables.

// We will maintain a single global instance that will only reveal those

// We will maintain a single global instance that will only reveal those

// glyph tables that are associated to fonts currently installed on the

// glyph tables that are associated to fonts currently installed on the

// user' system. The class is an XPCOM shutdown observer to allow us to

// user' system. The class is an XPCOM shutdown observer to allow us to

// free its allocated data at shutdown

// free its allocated data at shutdown

class nsGlyphTableList : public nsIObserver

class nsGlyphTableList : public nsIObserver

{

{

public:

public:

  NS_DECL_ISUPPORTS

  NS_DECL_ISUPPORTS

  NS_DECL_NSIOBSERVER

  NS_DECL_NSIOBSERVER

  nsGlyphTableList()

  nsGlyphTableList()

    : mUnicodeTable(NS_LITERAL_STRING("Unicode"))

    : mUnicodeTable(NS_LITERAL_STRING("Unicode"))

  {

  {

    MOZ_COUNT_CTOR(nsGlyphTableList);

    MOZ_COUNT_CTOR(nsGlyphTableList);

  }

  }

  virtual ~nsGlyphTableList()

  virtual ~nsGlyphTableList()

  nsGlyphTable*

  nsGlyphTable*

  AddGlyphTable(const nsString& aPrimaryFontName);

  AddGlyphTable(const nsString& aPrimaryFontName);

  // Find the glyph table in the list corresponding to the given font family.

  // Find the glyph table in the list corresponding to the given font family.

  nsGlyphTable*

  nsGlyphTable*

  GetGlyphTableFor(const nsAString& aFamily);

  GetGlyphTableFor(const nsAString& aFamily);

private:

private:

  }

  }

  }

  }

  // List of glyph tables;

  // List of glyph tables;

};

};

NS_IMPL_ISUPPORTS1(nsGlyphTableList, nsIObserver)

NS_IMPL_ISUPPORTS1(nsGlyphTableList, nsIObserver)

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

// Here is the global list of applicable glyph tables that we will be using

// Here is the global list of applicable glyph tables that we will be using

static nsGlyphTableList* gGlyphTableList = nullptr;

static nsGlyphTableList* gGlyphTableList = nullptr;

nsGlyphTableList::AddGlyphTable(const nsString& aPrimaryFontName)

nsGlyphTableList::AddGlyphTable(const nsString& aPrimaryFontName)

{

{

  // See if there is already a special table for this family.

  // See if there is already a special table for this family.

  nsGlyphTable* glyphTable = GetGlyphTableFor(aPrimaryFontName);

  nsGlyphTable* glyphTable = GetGlyphTableFor(aPrimaryFontName);

  if (glyphTable != &mUnicodeTable)

  if (glyphTable != &mUnicodeTable)

    return glyphTable;

    return glyphTable;

  // allocate a table

  // allocate a table

  return glyphTable;

  return glyphTable;

}

}

nsGlyphTable*

nsGlyphTable*

nsGlyphTableList::GetGlyphTableFor(const nsAString& aFamily)

nsGlyphTableList::GetGlyphTableFor(const nsAString& aFamily)

{

{

    const nsAString& fontName = glyphTable->PrimaryFontName();

    const nsAString& fontName = glyphTable->PrimaryFontName();

    // TODO: would be nice to consider StripWhitespace and other aliasing

    // TODO: would be nice to consider StripWhitespace and other aliasing

    if (fontName.Equals(aFamily, nsCaseInsensitiveStringComparator())) {

    if (fontName.Equals(aFamily, nsCaseInsensitiveStringComparator())) {

      return glyphTable;

      return glyphTable;

    }

    }

  }

  }

  // Fall back to default Unicode table

  // Fall back to default Unicode table

  return &mUnicodeTable;

  return &mUnicodeTable;

                          aThebesContext, nullptr);

                          aThebesContext, nullptr);

  nsBoundingMetrics bm;

  nsBoundingMetrics bm;

  bm.leftBearing = NSToCoordFloor(metrics.mBoundingBox.X());

  bm.leftBearing = NSToCoordFloor(metrics.mBoundingBox.X());

  bm.rightBearing = NSToCoordCeil(metrics.mBoundingBox.XMost());

  bm.rightBearing = NSToCoordCeil(metrics.mBoundingBox.XMost());

  bm.ascent = NSToCoordCeil(-metrics.mBoundingBox.Y());

  bm.ascent = NSToCoordCeil(-metrics.mBoundingBox.Y());

  bm.descent = NSToCoordCeil(metrics.mBoundingBox.YMost());

  bm.descent = NSToCoordCeil(metrics.mBoundingBox.YMost());

  bm.width = NSToCoordRound(metrics.mAdvanceWidth);

  bm.width = NSToCoordRound(metrics.mAdvanceWidth);

  return bm;

  return bm;

}

}

class nsMathMLChar::StretchEnumContext {

class nsMathMLChar::StretchEnumContext {

public:

public:

  StretchEnumContext(nsMathMLChar*        aChar,

  StretchEnumContext(nsMathMLChar*        aChar,

                     nsPresContext*       aPresContext,

                     nsPresContext*       aPresContext,

      mTryVariants(true),

      mTryVariants(true),

      mTryParts(true),

      mTryParts(true),

      mGlyphFound(aGlyphFound) {}

      mGlyphFound(aGlyphFound) {}

  static bool

  static bool

  EnumCallback(const nsString& aFamily, bool aGeneric, void *aData);

  EnumCallback(const nsString& aFamily, bool aGeneric, void *aData);

private:

private:

  nsMathMLChar* mChar;

  nsMathMLChar* mChar;

  nsPresContext* mPresContext;

  nsPresContext* mPresContext;

  gfxContext* mThebesContext;

  gfxContext* mThebesContext;

  const nsStretchDirection mDirection;

  const nsStretchDirection mDirection;

  const nscoord mTargetSize;

  const nscoord mTargetSize;

  const uint32_t mStretchHint;

  const uint32_t mStretchHint;

  nsBoundingMetrics& mBoundingMetrics;

  nsBoundingMetrics& mBoundingMetrics;

  bool&       mGlyphFound;

  bool&       mGlyphFound;

};

};

// 2. See if there are any glyphs of the appropriate size.

// 2. See if there are any glyphs of the appropriate size.

// Returns true if the size is OK, false to keep searching.

// Returns true if the size is OK, false to keep searching.

// Always updates the char if a better match is found.

// Always updates the char if a better match is found.

bool

bool

{

{

  // Use our stretchy style context now that stretching is in progress

  // Use our stretchy style context now that stretching is in progress

  nsStyleContext *sc = mChar->mStyleContext;

  nsStyleContext *sc = mChar->mStyleContext;

  nsFont font = sc->StyleFont()->mFont;

  nsFont font = sc->StyleFont()->mFont;

  // Ensure SetFontFamily will set the font

  // Ensure SetFontFamily will set the font

  font.name.Truncate();

  font.name.Truncate();

  bool isVertical = (mDirection == NS_STRETCH_DIRECTION_VERTICAL);

  bool isVertical = (mDirection == NS_STRETCH_DIRECTION_VERTICAL);

  bool largeop = (NS_STRETCH_LARGEOP & mStretchHint) != 0;

  bool largeop = (NS_STRETCH_LARGEOP & mStretchHint) != 0;

  bool largeopOnly =

  bool largeopOnly =

    largeop && (NS_STRETCH_VARIABLE_MASK & mStretchHint) == 0;

    largeop && (NS_STRETCH_VARIABLE_MASK & mStretchHint) == 0;

  bool maxWidth = (NS_STRETCH_MAXWIDTH & mStretchHint) != 0;

  bool maxWidth = (NS_STRETCH_MAXWIDTH & mStretchHint) != 0;

  nscoord bestSize =

  nscoord bestSize =

    isVertical ? mBoundingMetrics.ascent + mBoundingMetrics.descent

    isVertical ? mBoundingMetrics.ascent + mBoundingMetrics.descent

               : mBoundingMetrics.rightBearing - mBoundingMetrics.leftBearing;

               : mBoundingMetrics.rightBearing - mBoundingMetrics.leftBearing;

  bool haveBetter = false;

  bool haveBetter = false;

  // start at size = 1 (size = 0 is the char at its normal size)

  // start at size = 1 (size = 0 is the char at its normal size)

  int32_t size = 1;

  int32_t size = 1;

#ifdef NOISY_SEARCH

#ifdef NOISY_SEARCH

  printf("  searching in %s ...\n",

  printf("  searching in %s ...\n",

           NS_LossyConvertUTF16toASCII(aFamily).get());

           NS_LossyConvertUTF16toASCII(aFamily).get());

#endif

#endif

    if (!mChar->SetFontFamily(mPresContext, aGlyphTable, ch, aFamily, font,

    if (!mChar->SetFontFamily(mPresContext, aGlyphTable, ch, aFamily, font,

      // if largeopOnly is set, break now

      // if largeopOnly is set, break now

      if (largeopOnly) break;

      if (largeopOnly) break;

      ++size;

      ++size;

      continue;

      continue;

    }

    }

    nsAutoPtr<gfxTextRun> textRun;

    nsAutoPtr<gfxTextRun> textRun;

    nsBoundingMetrics bm = MeasureTextRun(mThebesContext, textRun);

    nsBoundingMetrics bm = MeasureTextRun(mThebesContext, textRun);

    nscoord charSize =

    nscoord charSize =

      isVertical ? bm.ascent + bm.descent

      isVertical ? bm.ascent + bm.descent

      : bm.rightBearing - bm.leftBearing;

      : bm.rightBearing - bm.leftBearing;

    if (largeopOnly ||

    if (largeopOnly ||

        IsSizeBetter(charSize, bestSize, mTargetSize, mStretchHint)) {

        IsSizeBetter(charSize, bestSize, mTargetSize, mStretchHint)) {

      mGlyphFound = true;

      mGlyphFound = true;

    else {

    else {

#ifdef NOISY_SEARCH

#ifdef NOISY_SEARCH

      printf("    size:%d Rejected!\n", size);

      printf("    size:%d Rejected!\n", size);

#endif

#endif

      if (haveBetter)

      if (haveBetter)

        break; // Not making an futher progress, stop searching

        break; // Not making an futher progress, stop searching

    }

    }

    ++size;

    ++size;

  }

  }

  return haveBetter &&

  return haveBetter &&

    (largeopOnly ||

    (largeopOnly ||

     IsSizeOK(mPresContext, bestSize, mTargetSize, mStretchHint));

     IsSizeOK(mPresContext, bestSize, mTargetSize, mStretchHint));

}

}

// 3. Build by parts.

// 3. Build by parts.

// Returns true if the size is OK, false to keep searching.

// Returns true if the size is OK, false to keep searching.

// Always updates the char if a better match is found.

// Always updates the char if a better match is found.

bool

bool

                                           const nsAString& aFamily)

                                           const nsAString& aFamily)

{

{

  // Use our stretchy style context now that stretching is in progress

  // Use our stretchy style context now that stretching is in progress

  nsFont font = mChar->mStyleContext->StyleFont()->mFont;

  nsFont font = mChar->mStyleContext->StyleFont()->mFont;

  // Ensure SetFontFamily will set the font

  // Ensure SetFontFamily will set the font

  font.name.Truncate();

  font.name.Truncate();

  // Compute the bounding metrics of all partial glyphs

  // Compute the bounding metrics of all partial glyphs

  nsAutoPtr<gfxTextRun> textRun[4];

  nsAutoPtr<gfxTextRun> textRun[4];

  nsGlyphCode chdata[4];

  nsGlyphCode chdata[4];

  nsBoundingMetrics bmdata[4];

  nsBoundingMetrics bmdata[4];

  nscoord sizedata[4];

  nscoord sizedata[4];

  bool isVertical = (mDirection == NS_STRETCH_DIRECTION_VERTICAL);

  bool isVertical = (mDirection == NS_STRETCH_DIRECTION_VERTICAL);

  bool maxWidth = (NS_STRETCH_MAXWIDTH & mStretchHint) != 0;

  bool maxWidth = (NS_STRETCH_MAXWIDTH & mStretchHint) != 0;

  for (int32_t i = 0; i < 4; i++) {

  for (int32_t i = 0; i < 4; i++) {

    chdata[i] = ch;

    chdata[i] = ch;

    if (ch.Exists()) {

    if (ch.Exists()) {

      if (!mChar->SetFontFamily(mPresContext, aGlyphTable, ch, aFamily, font,

      if (!mChar->SetFontFamily(mPresContext, aGlyphTable, ch, aFamily, font,

        return false;

        return false;

      nsBoundingMetrics bm = MeasureTextRun(mThebesContext, textRun[i]);

      nsBoundingMetrics bm = MeasureTextRun(mThebesContext, textRun[i]);

      // TODO: For the generic Unicode table, ideally we should check that the

      // TODO: For the generic Unicode table, ideally we should check that the

      // glyphs are actually found and that they each come from the same

      // glyphs are actually found and that they each come from the same

      // font.

      // font.

      bmdata[i] = bm;

      bmdata[i] = bm;

      sizedata[i] = isVertical ? bm.ascent + bm.descent

      sizedata[i] = isVertical ? bm.ascent + bm.descent

                               : bm.rightBearing - bm.leftBearing;

                               : bm.rightBearing - bm.leftBearing;

// This is called for each family, whether it exists or not

// This is called for each family, whether it exists or not

bool

bool

nsMathMLChar::StretchEnumContext::EnumCallback(const nsString& aFamily,

nsMathMLChar::StretchEnumContext::EnumCallback(const nsString& aFamily,

                                               bool aGeneric, void *aData)

                                               bool aGeneric, void *aData)

{

{

  StretchEnumContext* context = static_cast<StretchEnumContext*>(aData);

  StretchEnumContext* context = static_cast<StretchEnumContext*>(aData);

  // Check font family if it is not a generic one

  // Check font family if it is not a generic one

  // We test with the kNullGlyph

  // We test with the kNullGlyph

  nsStyleContext *sc = context->mChar->mStyleContext;

  nsStyleContext *sc = context->mChar->mStyleContext;

  nsFont font = sc->StyleFont()->mFont;

  nsFont font = sc->StyleFont()->mFont;

  nsRefPtr<gfxFontGroup> fontGroup;

  nsRefPtr<gfxFontGroup> fontGroup;

  if (!aGeneric && !context->mChar->SetFontFamily(context->mPresContext,

  if (!aGeneric && !context->mChar->SetFontFamily(context->mPresContext,

                                                  nullptr, kNullGlyph, aFamily,

                                                  nullptr, kNullGlyph, aFamily,

                                                  font, &fontGroup))

                                                  font, &fontGroup))

     return true; // Could not set the family

     return true; // Could not set the family

  // If the unicode table is being used, then search all font families.  If a

  // If the unicode table is being used, then search all font families.  If a

  // special table is being used then the font in this family should have the

  // special table is being used then the font in this family should have the

  // specified glyphs.

  // specified glyphs.

  const nsAString& family = glyphTable == &gGlyphTableList->mUnicodeTable ?

  const nsAString& family = glyphTable == &gGlyphTableList->mUnicodeTable ?

    context->mFamilies : aFamily;

    context->mFamilies : aFamily;

}

}

nsresult

nsresult

nsMathMLChar::StretchInternal(nsPresContext*           aPresContext,

nsMathMLChar::StretchInternal(nsPresContext*           aPresContext,

                              gfxContext*              aThebesContext,

                              gfxContext*              aThebesContext,

                              nsStretchDirection&      aStretchDirection,

                              nsStretchDirection&      aStretchDirection,

                              const nsBoundingMetrics& aContainerSize,

                              const nsBoundingMetrics& aContainerSize,

                              nsBoundingMetrics&       aDesiredStretchSize,

                              nsBoundingMetrics&       aDesiredStretchSize,

      }

      }

    }

    }

  }

  }

  // We do not have a char variant for this largeop in display mode, so we

  // We do not have a char variant for this largeop in display mode, so we

  // apply a scale transform to the base char.

  // apply a scale transform to the base char.

  if (!glyphFound && largeop) {

  if (!glyphFound && largeop) {

    float scale;

    float scale;

    // increase the width if it is not largeopFactor times larger

    // increase the width if it is not largeopFactor times larger

    // than the initial one.

    // than the initial one.

    if ((aDesiredStretchSize.rightBearing - aDesiredStretchSize.leftBearing) <

    if ((aDesiredStretchSize.rightBearing - aDesiredStretchSize.leftBearing) <

        largeopFactor * (initialSize.rightBearing - initialSize.leftBearing)) {

        largeopFactor * (initialSize.rightBearing - initialSize.leftBearing)) {

      scale = (largeopFactor *

      scale = (largeopFactor *

               (initialSize.rightBearing - initialSize.leftBearing)) /

               (initialSize.rightBearing - initialSize.leftBearing)) /

        (aDesiredStretchSize.rightBearing - aDesiredStretchSize.leftBearing);

        (aDesiredStretchSize.rightBearing - aDesiredStretchSize.leftBearing);

      aDesiredStretchSize.rightBearing *= scale;

      aDesiredStretchSize.rightBearing *= scale;

      aDesiredStretchSize.width *= scale;

      aDesiredStretchSize.width *= scale;

    }

    }

    // increase the height if it is not largeopFactor times larger

    // increase the height if it is not largeopFactor times larger

    // than the initial one.

    // than the initial one.

    if (NS_STRETCH_INTEGRAL & aStretchHint) {

    if (NS_STRETCH_INTEGRAL & aStretchHint) {

      // integrals are drawn taller

      // integrals are drawn taller

    }

    }

    if ((aDesiredStretchSize.ascent + aDesiredStretchSize.descent) <

    if ((aDesiredStretchSize.ascent + aDesiredStretchSize.descent) <

        largeopFactor * (initialSize.ascent + initialSize.descent)) {

        largeopFactor * (initialSize.ascent + initialSize.descent)) {

      scale = (largeopFactor *

      scale = (largeopFactor *

               (initialSize.ascent + initialSize.descent)) /

               (initialSize.ascent + initialSize.descent)) /

        (aDesiredStretchSize.ascent + aDesiredStretchSize.descent);

        (aDesiredStretchSize.ascent + aDesiredStretchSize.descent);

      if (!maxWidth) {

      if (!maxWidth) {

        mScaleY *= scale;

        mScaleY *= scale;

  // the Get/Set AdditionalStyleContext() APIs. Owners of MathMLChars

  // the Get/Set AdditionalStyleContext() APIs. Owners of MathMLChars

  // should honor these APIs.

  // should honor these APIs.

  nsStyleContext* GetStyleContext() const;

  nsStyleContext* GetStyleContext() const;

  void SetStyleContext(nsStyleContext* aStyleContext);

  void SetStyleContext(nsStyleContext* aStyleContext);

protected:

protected:

  friend class nsGlyphTable;

  friend class nsGlyphTable;

  nsString           mData;

  nsString           mData;

private:

private:

  nsRect             mRect;

  nsRect             mRect;

  nsStretchDirection mDirection;

  nsStretchDirection mDirection;

  nsBoundingMetrics  mBoundingMetrics;

  nsBoundingMetrics  mBoundingMetrics;

  nsStyleContext*    mStyleContext;

  nsStyleContext*    mStyleContext;

  // mGlyphs/mBmData are arrays describing the glyphs used to draw the operator.

  // mGlyphs/mBmData are arrays describing the glyphs used to draw the operator.