/* 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/. */

#include "gfxMathTable.h"

#include "harfbuzz/hb.h"

#include "harfbuzz/hb-ot.h"

#define FloatToFixed(f) (65536 * (f))

#define FixedToFloat(f) ((f) * (1.0 / 65536.0))

using namespace mozilla;

gfxMathTable::gfxMathTable(hb_face_t *aFace, gfxFloat aSize)

{

  mMathVariantCache.vertical = false;

  mHBFont = hb_font_create(aFace);

  if (mHBFont) {

    hb_font_set_ppem(mHBFont, aSize, aSize);

    uint32_t scale = FloatToFixed(aSize);

    hb_font_set_scale(mHBFont, scale, scale);

  }

  mMathVariantCache.glyphID = 0;

  ClearCache();

}

gfxMathTable::~gfxMathTable()

{

  if (mHBFont) {

      hb_font_destroy(mHBFont);

  }

}

gfxFloat

gfxMathTable::Constant(MathConstant aConstant) const

{

  int32_t value = hb_ot_math_get_constant(mHBFont, static_cast<hb_ot_math_constant_t>(aConstant));

  if (aConstant == ScriptPercentScaleDown ||

      aConstant == ScriptScriptPercentScaleDown ||

      aConstant == RadicalDegreeBottomRaisePercent) {

    return value / 100.0;

  }

  return FixedToFloat(value);

}

gfxFloat

gfxMathTable::ItalicsCorrection(uint32_t aGlyphID) const

{

  return FixedToFloat(hb_ot_math_get_glyph_italics_correction(mHBFont, aGlyphID));

}

uint32_t

gfxMathTable::VariantsSize(uint32_t aGlyphID, bool aVertical,

                           uint16_t aSize) const

{

  UpdateMathVariantCache(aGlyphID, aVertical);

  if (aSize < kMaxCachedSizeCount) {

    return mMathVariantCache.sizes[aSize];

  }

  // If the size index exceeds the cache size, we just read the value with

  // hb_ot_math_get_glyph_variants.

  hb_direction_t direction = aVertical ? HB_DIRECTION_BTT : HB_DIRECTION_LTR;

  hb_ot_math_glyph_variant_t variant;

  unsigned int count = 1;

  hb_ot_math_get_glyph_variants(mHBFont, aGlyphID, direction, aSize, &count,

                                &variant);

  return count > 0 ? variant.glyph : 0;

}

bool

gfxMathTable::VariantsParts(uint32_t aGlyphID, bool aVertical,

                            uint32_t aGlyphs[4]) const

{

  UpdateMathVariantCache(aGlyphID, aVertical);

  memcpy(aGlyphs, mMathVariantCache.parts, sizeof(mMathVariantCache.parts));

  return mMathVariantCache.arePartsValid;

}

void

gfxMathTable::ClearCache() const

{

  memset(mMathVariantCache.sizes, 0, sizeof(mMathVariantCache.sizes));

  memset(mMathVariantCache.parts, 0, sizeof(mMathVariantCache.parts));

  mMathVariantCache.arePartsValid = false;

}

void

gfxMathTable::UpdateMathVariantCache(uint32_t aGlyphID, bool aVertical) const

{

  if (aGlyphID == mMathVariantCache.glyphID &&

      aVertical == mMathVariantCache.vertical)

    return;

  mMathVariantCache.glyphID = aGlyphID;

  mMathVariantCache.vertical = aVertical;

  ClearCache();

  // Cache the first size variants.

  hb_direction_t direction = aVertical ? HB_DIRECTION_BTT : HB_DIRECTION_LTR;

  hb_ot_math_glyph_variant_t variant[kMaxCachedSizeCount];

  unsigned int count = kMaxCachedSizeCount;

  hb_ot_math_get_glyph_variants(mHBFont, aGlyphID, direction, 0, &count,

                                variant);

  for (unsigned int i = 0; i < count; i++) {

    mMathVariantCache.sizes[i] = variant[i].glyph;

  }

  // Try and cache the parts of the glyph assembly.

  // XXXfredw The structure of the Open Type Math table is a bit more general

  // than the one currently used by the nsMathMLChar code, so we try to fallback

  // in reasonable way. We use the approach of the copyComponents function in

  // github.com/mathjax/MathJax-dev/blob/master/fonts/OpenTypeMath/fontUtil.py

  //

  // The nsMathMLChar code can use at most 3 non extender pieces (aGlyphs[0],

  // aGlyphs[1] and aGlyphs[2]) and the extenders between these pieces should

  // all be the same (aGlyphs[4]). Also, the parts of vertical assembly are

  // stored from bottom to top in the Open Type MATH table while they are

  // stored from top to bottom in nsMathMLChar.

  hb_ot_math_glyph_part_t parts[5];

  count = MOZ_ARRAY_LENGTH(parts);

  unsigned int offset = 0;

  if (hb_ot_math_get_glyph_assembly(mHBFont, aGlyphID, direction, offset, &count, parts, NULL) > MOZ_ARRAY_LENGTH(parts))

    return; // Not supported: Too many pieces.

  if (count <= 0)

    return; // Not supported: No pieces.

  // Count the number of non extender pieces

  uint16_t nonExtenderCount = 0;

  for (uint16_t i = 0; i < count; i++) {

    if (!(parts[i].flags & HB_MATH_GLYPH_PART_FLAG_EXTENDER)) {

      nonExtenderCount++;

    }

  }

  if (nonExtenderCount > 3) {

    // Not supported: too many pieces

    return;

  }

  // Now browse the list of pieces

  // 0 = look for a left/bottom glyph

  // 1 = look for an extender between left/bottom and mid

  // 2 = look for a middle glyph

  // 3 = look for an extender between middle and right/top

  // 4 = look for a right/top glyph

  // 5 = no more piece expected

  uint8_t state = 0;

  // First extender char found.

  uint32_t extenderChar = 0;

  for (uint16_t i = 0; i < count; i++) {

    bool isExtender = parts[i].flags & HB_MATH_GLYPH_PART_FLAG_EXTENDER;

    uint32_t glyph = parts[i].glyph;

    if ((state == 1 || state == 2) && nonExtenderCount < 3) {

      // do not try to find a middle glyph

      state += 2;

    }

    if (isExtender) {

      if (!extenderChar) {

        extenderChar = glyph;

        mMathVariantCache.parts[3] = extenderChar;

      } else if (extenderChar != glyph)  {

        // Not supported: different extenders

        return;

      }

      if (state == 0) { // or state == 1

        // ignore left/bottom piece and multiple successive extenders

        state = 1;

      } else if (state == 2) { // or state == 3

        // ignore middle piece and multiple successive extenders

        state = 3;

      } else if (state >= 4) {

        // Not supported: unexpected extender

        return;

      }

      continue;

    }

    if (state == 0) {

      // copy left/bottom part

      mMathVariantCache.parts[aVertical ? 2 : 0] = glyph;

      state = 1;

      continue;

    }

    if (state == 1 || state == 2) {

      // copy middle part

      mMathVariantCache.parts[1] = glyph;

      state = 3;

      continue;

    }

    if (state == 3 || state == 4) {

      // copy right/top part

      mMathVariantCache.parts[aVertical ? 0 : 2] = glyph;

      state = 5;

    }

  }

  mMathVariantCache.arePartsValid = true;

}