/*

 * Copyright © 2018  Ebrahim Byagowi

 *

 *  This is part of HarfBuzz, a text shaping library.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and its documentation for any purpose, provided that the

 * above copyright notice and the following two paragraphs appear in

 * all copies of this software.

 *

 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR

 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES

 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN

 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH

 * DAMAGE.

 *

 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,

 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

 * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS

 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO

 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 */

#ifndef HB_AAT_LAYOUT_JUST_TABLE_HH

#define HB_AAT_LAYOUT_JUST_TABLE_HH

#include "hb-aat-layout-common.hh"

#include "hb-ot-layout.hh"

#include "hb-open-type.hh"

#include "hb-aat-layout-morx-table.hh"

/*

 * just -- Justification

 * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6just.html

 */

#define HB_AAT_TAG_just HB_TAG('j','u','s','t')

namespace AAT {

using namespace OT;

struct ActionSubrecordHeader

{

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (likely (c->check_struct (this)));

  }

  HBUINT16      actionClass;    /* The JustClass value associated with this

                                 * ActionSubrecord. */

  HBUINT16      actionType;     /* The type of postcompensation action. */

  HBUINT16      actionLength;   /* Length of this ActionSubrecord record, which

                                 * must be a multiple of 4. */

  public:

  DEFINE_SIZE_STATIC (6);

};

struct DecompositionAction

{

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (likely (c->check_struct (this)));

  }

  ActionSubrecordHeader

                header;

  Fixed         lowerLimit;     /* If the distance factor is less than this value,

                                 * then the ligature is decomposed. */

  Fixed         upperLimit;     /* If the distance factor is greater than this value,

                                 * then the ligature is decomposed. */

  HBUINT16      order;          /* Numerical order in which this ligature will

                                 * be decomposed; you may want infrequent ligatures

                                 * to decompose before more frequent ones. The ligatures

                                 * on the line of text will decompose in increasing

                                 * value of this field. */

  ArrayOf<HBUINT16>

                decomposedglyphs;

                                /* Number of 16-bit glyph indexes that follow;

                                 * the ligature will be decomposed into these glyphs.

                                 *

                                 * Array of decomposed glyphs. */

  public:

  DEFINE_SIZE_ARRAY (18, decomposedglyphs);

};

struct UnconditionalAddGlyphAction

{

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this));

  }

  protected:

  ActionSubrecordHeader

                header;

  GlyphID       addGlyph;       /* Glyph that should be added if the distance factor

                                 * is growing. */

  public:

  DEFINE_SIZE_STATIC (8);

};

struct ConditionalAddGlyphAction

{

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (likely (c->check_struct (this)));

  }

  protected:

  ActionSubrecordHeader

                header;

  Fixed         substThreshold; /* Distance growth factor (in ems) at which

                                 * this glyph is replaced and the growth factor

                                 * recalculated. */

  GlyphID       addGlyph;       /* Glyph to be added as kashida. If this value is

                                 * 0xFFFF, no extra glyph will be added. Note that

                                 * generally when a glyph is added, justification

                                 * will need to be redone. */

  GlyphID       substGlyph;     /* Glyph to be substituted for this glyph if the

                                 * growth factor equals or exceeds the value of

                                 * substThreshold. */

  public:

  DEFINE_SIZE_STATIC (14);

};

struct DuctileGlyphAction

{

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (likely (c->check_struct (this)));

  }

  protected:

  ActionSubrecordHeader

                header;

  HBUINT32      variationAxis;  /* The 4-byte tag identifying the ductile axis.

                                 * This would normally be 0x64756374 ('duct'),

                                 * but you may use any axis the font contains. */

  Fixed         minimumLimit;   /* The lowest value for the ductility axis tha

                                 * still yields an acceptable appearance. Normally

                                 * this will be 1.0. */

  Fixed         noStretchValue; /* This is the default value that corresponds to

                                 * no change in appearance. Normally, this will

                                 * be 1.0. */

  Fixed         maximumLimit;   /* The highest value for the ductility axis that

                                 * still yields an acceptable appearance. */

  public:

  DEFINE_SIZE_STATIC (22);

};

struct RepeatedAddGlyphAction

{

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (likely (c->check_struct (this)));

  }

  protected:

  ActionSubrecordHeader

                header;

  HBUINT16      flags;          /* Currently unused; set to 0. */

  GlyphID       glyph;          /* Glyph that should be added if the distance factor

                                 * is growing. */

  public:

  DEFINE_SIZE_STATIC (10);

};

struct ActionSubrecord

{

  unsigned int get_length () const { return u.header.actionLength; }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    if (unlikely (!c->check_struct (this)))

      return_trace (false);

    switch (u.header.actionType)

    {

    case 0:  return_trace (u.decompositionAction.sanitize (c));

    case 1:  return_trace (u.unconditionalAddGlyphAction.sanitize (c));

    case 2:  return_trace (u.conditionalAddGlyphAction.sanitize (c));

    // case 3: return_trace (u.stretchGlyphAction.sanitize (c));

    case 4:  return_trace (u.decompositionAction.sanitize (c));

    case 5:  return_trace (u.decompositionAction.sanitize (c));

    default: return_trace (true);

    }

  }

  protected:

  union {

  ActionSubrecordHeader         header;

  DecompositionAction           decompositionAction;

  UnconditionalAddGlyphAction   unconditionalAddGlyphAction;

  ConditionalAddGlyphAction     conditionalAddGlyphAction;

  /* StretchGlyphAction stretchGlyphAction; -- Not supported by CoreText */

  DuctileGlyphAction            ductileGlyphAction;

  RepeatedAddGlyphAction        repeatedAddGlyphAction;

  } u;                          /* Data. The format of this data depends on

                                 * the value of the actionType field. */

  public:

  DEFINE_SIZE_UNION (6, header);

};

struct PostcompensationActionChain

{

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    if (unlikely (!c->check_struct (this)))

      return_trace (false);

    unsigned int offset = min_size;

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

    {

      const ActionSubrecord& subrecord = StructAtOffset<ActionSubrecord> (this, offset);

      if (unlikely (!subrecord.sanitize (c))) return_trace (false);

      offset += subrecord.get_length ();

    }

    return_trace (true);

  }

  protected:

  HBUINT32      count;

  public:

  DEFINE_SIZE_STATIC (4);

};

struct JustWidthDeltaEntry

{

  enum Flags

  {

    Reserved1           =0xE000,/* Reserved. You should set these bits to zero. */

    UnlimiteGap         =0x1000,/* The glyph can take unlimited gap. When this

                                 * glyph participates in the justification process,

                                 * it and any other glyphs on the line having this

                                 * bit set absorb all the remaining gap. */

    Reserved2           =0x0FF0,/* Reserved. You should set these bits to zero. */

    Priority            =0x000F /* The justification priority of the glyph. */

  };

  enum Priority

  {

    Kashida             = 0,    /* Kashida priority. This is the highest priority

                                 * during justification. */

    Whitespace          = 1,    /* Whitespace priority. Any whitespace glyphs (as

                                 * identified in the glyph properties table) will

                                 * get this priority. */

    InterCharacter      = 2,    /* Inter-character priority. Give this to any

                                 * remaining glyphs. */

    NullPriority        = 3     /* Null priority. You should set this priority for

                                 * glyphs that only participate in justification

                                 * after the above priorities. Normally all glyphs

                                 * have one of the previous three values. If you

                                 * don't want a glyph to participate in justification,

                                 * and you don't want to set its factors to zero,

                                 * you may instead assign it to the null priority. */

  };

  protected:

  Fixed         beforeGrowLimit;/* The ratio by which the advance width of the

                                 * glyph is permitted to grow on the left or top side. */

  Fixed         beforeShrinkLimit;

                                /* The ratio by which the advance width of the

                                 * glyph is permitted to shrink on the left or top side. */

  Fixed         afterGrowLimit; /* The ratio by which the advance width of the glyph

                                 * is permitted to shrink on the left or top side. */

  Fixed         afterShrinkLimit;

                                /* The ratio by which the advance width of the glyph

                                 * is at most permitted to shrink on the right or

                                 * bottom side. */

  HBUINT16      growFlags;      /* Flags controlling the grow case. */

  HBUINT16      shrinkFlags;    /* Flags controlling the shrink case. */

  public:

  DEFINE_SIZE_STATIC (20);

};

struct WidthDeltaPair

{

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (likely (c->check_struct (this)));

  }

  protected:

  HBUINT32      justClass;      /* The justification category associated

                                 * with the wdRecord field. Only 7 bits of

                                 * this field are used. (The other bits are

                                 * used as padding to guarantee longword

                                 * alignment of the following record). */

  JustWidthDeltaEntry

                wdRecord;       /* The actual width delta record. */

  public:

  DEFINE_SIZE_STATIC (24);

};

typedef OT::LArrayOf<WidthDeltaPair> WidthDeltaCluster;

struct JustificationCategory

{

  typedef void EntryData;

  enum Flags

  {

    SetMark             =0x8000,/* If set, make the current glyph the marked

                                 * glyph. */

    DontAdvance         =0x4000,/* If set, don't advance to the next glyph before

                                 * going to the new state. */

    MarkCategory        =0x3F80,/* The justification category for the marked

                                 * glyph if nonzero. */

    CurrentCategory     =0x007F /* The justification category for the current

                                 * glyph if nonzero. */

  };

  bool sanitize (hb_sanitize_context_t *c, const void *base) const

  {

    TRACE_SANITIZE (this);

    return_trace (likely (c->check_struct (this) &&

                          morphHeader.sanitize (c) &&

                          stHeader.sanitize (c)));

  }

  protected:

  ChainSubtable<ObsoleteTypes>

                morphHeader;    /* Metamorphosis-style subtable header. */

  StateTable<ObsoleteTypes, EntryData>

                stHeader;       /* The justification insertion state table header */

  public:

  DEFINE_SIZE_STATIC (30);

};

struct JustificationHeader

{

  bool sanitize (hb_sanitize_context_t *c, const void *base) const

  {

    TRACE_SANITIZE (this);

    return_trace (likely (c->check_struct (this) &&

                          justClassTable.sanitize (c, base, base) &&

                          wdcTable.sanitize (c, base) &&

                          pcTable.sanitize (c, base) &&

                          lookupTable.sanitize (c, base)));

  }

  protected:

  OffsetTo<JustificationCategory>

                justClassTable; /* Offset to the justification category state table. */

  OffsetTo<WidthDeltaCluster>

                wdcTable;       /* Offset from start of justification table to start

                                 * of the subtable containing the width delta factors

                                 * for the glyphs in your font.

                                 *

                                 * The width delta clusters table. */

  OffsetTo<PostcompensationActionChain>

                pcTable;        /* Offset from start of justification table to start

                                 * of postcompensation subtable (set to zero if none).

                                 *

                                 * The postcompensation subtable, if present in the font. */

  Lookup<OffsetTo<WidthDeltaCluster> >

                lookupTable;    /* Lookup table associating glyphs with width delta

                                 * clusters. See the description of Width Delta Clusters

                                 * table for details on how to interpret the lookup values. */

  public:

  DEFINE_SIZE_MIN (8);

};

struct just

{

  static constexpr hb_tag_t tableTag = HB_AAT_TAG_just;

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (likely (c->check_struct (this) &&

                          version.major == 1 &&

                          horizData.sanitize (c, this, this) &&

                          vertData.sanitize (c, this, this)));

  }

  protected:

  FixedVersion<>version;        /* Version of the justification table

                                 * (0x00010000u for version 1.0). */

  HBUINT16      format;         /* Format of the justification table (set to 0). */

  OffsetTo<JustificationHeader>

                horizData;      /* Byte offset from the start of the justification table

                                 * to the header for tables that contain justification

                                 * information for horizontal text.

                                 * If you are not including this information,

                                 * store 0. */

  OffsetTo<JustificationHeader>

                vertData;       /* ditto, vertical */

  public:

  DEFINE_SIZE_STATIC (10);

};

} /* namespace AAT */

#endif /* HB_AAT_LAYOUT_JUST_TABLE_HH */