PascalType.FontFace.SFNT.pas

unit PascalType.FontFace.SFNT;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  Version: MPL 1.1 or LGPL 2.1 with linking exception                       //
//                                                                            //
//  The contents of this file are subject to the Mozilla Public License       //
//  Version 1.1 (the "License"); you may not use this file except in          //
//  compliance with the License. You may obtain a copy of the License at      //
//  http://www.mozilla.org/MPL/                                               //
//                                                                            //
//  Software distributed under the License is distributed on an "AS IS"       //
//  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the   //
//  License for the specific language governing rights and limitations under  //
//  the License.                                                              //
//                                                                            //
//  Alternatively, the contents of this file may be used under the terms of   //
//  the Free Pascal modified version of the GNU Lesser General Public         //
//  License Version 2.1 (the "FPC modified LGPL License"), in which case the  //
//  provisions of this license are applicable instead of those above.         //
//  Please see the file LICENSE.txt for additional information concerning     //
//  this license.                                                             //
//                                                                            //
//  The code is part of the PascalType Project                                //
//                                                                            //
//  The initial developer of this code is Christian-W. Budde                  //
//                                                                            //
//  Portions created by Christian-W. Budde are Copyright (C) 2010-2017        //
//  by Christian-W. Budde. All Rights Reserved.                               //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

interface

{$I PT_Compiler.inc}

{$IFDEF CPUx86_64}
  {$DEFINE PUREPASCAL}
{$ENDIF}

uses
  Generics.Collections,
  Classes, SysUtils, Types,
  PascalType.Types,
  PascalType.Classes,
  PascalType.Unicode,
  PascalType.GlyphString,
  PascalType.FontFace,
  PascalType.Tables,
  PascalType.Tables.OpenType.GDEF,
  PascalType.Tables.TrueType.Directory,
  PascalType.Tables.TrueType.head,
  PascalType.Tables.TrueType.name,
  PascalType.Tables.TrueType.glyf,
  PascalType.Tables.TrueType.cmap,
  PascalType.Tables.TrueType.maxp,
  PascalType.Tables.TrueType.hmtx,
  PascalType.Tables.TrueType.hhea,
  PascalType.Tables.TrueType.vhea,
  PascalType.Tables.TrueType.vmtx,
  PascalType.Tables.TrueType.os2,
  PascalType.Tables.TrueType.post,
  PascalType.Tables.TrueType.Panose,
  PascalType.Tables.TrueType.gvar,
  PascalType.Tables.OpenType.HVAR,
  PascalType.Tables.OpenType.VVAR,
  PascalType.Tables.OpenType.MVAR,
  PascalType.Tables.OpenType.STAT,
  PascalType.Tables.OpenType.PostScript.CFF,
  PascalType.Tables.OpenType.Common.ValueRecord,
  PascalType.Tables.Apple,
  PascalType.Variation;

type
  TTrueTypeGlyphMetric = record
    HorizontalMetric: THorizontalMetric;
    VerticalMetric: TVerticalMetric;
  end;

type
  TCustomPascalTypeFontFace = class;

//------------------------------------------------------------------------------
//
//              TFontGlyphString
//
//------------------------------------------------------------------------------
// A glyph string with knowledge about the font
//------------------------------------------------------------------------------
  TFontGlyph = class(TPascalTypeGlyph)
  end;

  TFontGlyphString = class(TPascalTypeGlyphString)
  private
    FFont: TCustomPascalTypeFontFace;
  protected
    function GetGlyphClassID(AGlyph: TPascalTypeGlyph): integer; override;
    function GetGlyphByCodePoint(ACodePoint: TPascalTypeCodePoint): Integer; override;
    function GetMarkAttachmentType(AGlyph: TPascalTypeGlyph): integer; override;
    function IsInMarkFilteringSet(AGlyph: TPascalTypeGlyph; ASetIndex: integer): boolean; override;
    class function GetGlyphClass: TPascalTypeGlyphClass; override;
    procedure ApplyVariation(AGlyph: TPascalTypeGlyph; const AValueRecord: TOpenTypeValueRecord); override;
  public
    constructor Create(AFont: TCustomPascalTypeFontFace; const ACodePoints: TPascalTypeCodePoints); overload;
    constructor Create(AFont: TCustomPascalTypeFontFace; const ACodePoints: TPascalTypeCodePoints; AClusterLevel: TClusterLevel); overload; virtual;

    procedure HideDefaultIgnorables; override;

    property Font: TCustomPascalTypeFontFace read FFont;
  end;

  TFontGlyphStringClass = class of TFontGlyphString;


//------------------------------------------------------------------------------
//
//              TCustomPascalTypeFontFace
//
//------------------------------------------------------------------------------
// A TrueType/OpenType font
//------------------------------------------------------------------------------
  TCustomPascalTypeFontFace = class abstract(TCustomPascalTypeFontFacePersistent, IPascalTypeFontFace)
  strict protected const
{$IFDEF MSWINDOWS}
    PreferredPlatform = piMicrosoft; // This is strange. Why wouldn't we always prefer Unicode?
    PreferredLanguage = 1033;
{$ELSE}
    PreferredPlatform = piUnicode;
    PreferredLanguage = 3;
{$ENDIF}

  strict protected type
    TTableList = TObjectList<TCustomPascalTypeNamedTable>;
    TTableLookup = TDictionary<TPascalTypeTag, TCustomPascalTypeNamedTable>;

  strict private
    FVersion: Cardinal;
    FRootTable: TCustomPascalTypeTable;

    // We keep the tables in two lists in order to avoid going through
    // TDictionary.Values.ToArray when we just need a list of tables.
    FTables: TTableList;
    FTableLookup: TTableLookup;

    // Required table shortcuts
    FHeaderTable: TPascalTypeHeaderTable;
    FHorizontalHeader: TPascalTypeHorizontalHeaderTable;
    FMaximumProfile: TPascalTypeMaximumProfileTable;
    FNameTable: TPascalTypeNameTable;
    FPostScriptTable: TPascalTypePostscriptTable;

    // Optional table shortcuts
    FVerticalHeader: TPascalTypeVerticalHeaderTable;
    FGlyphDefinitionTable: TOpenTypeGlyphDefinitionTable;
    FCFFTable: TPascalTypeCompactFontFormatTable;

    // Variations
    FVariationTable: TPascalTypeFontVariationTable;
    FMetricsVariationTable: TPascalTypeMetricsVariationTable;
    FStyleAttributesTable: TPascalTypeStyleAttributesTable;
    FVariationEngine: TPascalTypeVariationEngine;

  private
    function GetVariationCoordinates: TArray<TFixedPoint>;
    procedure SetVariationCoordinates(const Value: TArray<TFixedPoint>);
    function GetVariationEngine: TPascalTypeVariationEngine;
    function GetFontName: string;
    function GetFontStyle: TFontStyles;
    function GetFontFamilyName: string;
    function GetFontSubFamilyName: string;
    function GetFontVersion: string;
    function GetUniqueIdentifier: string;
    function GetTable(Index: integer): TCustomPascalTypeNamedTable;
    function GetTableCount: Integer;

  protected
    procedure Loaded; virtual;
    procedure DoClear; virtual;
    procedure DoClearCache; virtual;
    procedure ClearCache;
    procedure DirectoryTableLoaded(DirectoryTable: TPascalTypeDirectoryTable); virtual;
    procedure LoadTablesFromStream(Stream: TStream; const TableList: TPascalTypeDirectoryTableList); virtual;
    function LoadTableFromStream(Stream: TStream; const TableEntry: TDirectoryTableEntry): TCustomPascalTypeNamedTable; virtual;
    function GetGlyphStringClass: TFontGlyphStringClass; virtual;
    procedure TableAdded(ATable: TCustomPascalTypeNamedTable); virtual;
    procedure AddTable(ATable: TCustomPascalTypeNamedTable); overload;
    function GetTypographicAscender: SmallInt; virtual;
    function GetTypographicDescender: SmallInt; virtual;
    function GetTypographicLineGap: SmallInt; virtual;

    // Variations
    function GetAxisValue(Index: integer): Single;
    procedure SetAxisValue(Index: integer; Value: Single);
    function GetAxisValueByTag(const Tag: TPascalTypeTag): Single;
    procedure SetAxisValueByTag(const Tag: TPascalTypeTag; Value: Single);
    function GetAxisValueByName(const Name: string): Single;
    procedure SetAxisValueByName(const Name: string; Value: Single);


    property RootTable: TCustomPascalTypeTable read FRootTable;
    property AllTables: TTableList read FTables;
    property TableLookup: TTableLookup read FTableLookup;

{$IFDEF ChecksumTest}
    procedure ValidateChecksum(Stream: TStream; TableEntry: TDirectoryTableEntry); virtual;
{$ENDIF}
  public
    // IPascalTypeFontFace
    function GetTableByName(const ATableName: TPascalTypeTag): TCustomPascalTypeNamedTable; virtual;
    function GetTableByTableClass(ATableClass: TCustomPascalTypeNamedTableClass): TCustomPascalTypeNamedTable; virtual;
    function GetGlyphName(GlyphID: TGlyphID): string; virtual;
    function GetAdvanceWidth(GlyphIndex: Word): Word; virtual;
    function GetAdvanceHeight(GlyphIndex: Word): Word; virtual;
    function GetVerticalOrigin(GlyphIndex: Word): TPoint; virtual;
    function GetHasVariations: boolean;
    property HasVariations: boolean read GetHasVariations;
    function GetVariationsActive: boolean;
    property VariationsActive: boolean read GetVariationsActive;
    function GetVariationItemDelta(OuterIndex, InnerIndex: Word): Single;
    function GetVariationMetricDelta(const Tag: TPascalTypeTag): Single;
    function GetVariationNormalizedCoordinates: TArray<TFixedPoint>;
    property VariationNormalizedCoordinates: TArray<TFixedPoint> read GetVariationNormalizedCoordinates;
{$if defined(PhantomPoints)}
    function GetGlyphPointCount(GlyphID: TGlyphID): Integer; virtual;
{$ifend}

  public
    constructor Create; virtual;
    destructor Destroy; override;

    procedure Clear;

    procedure LoadFromStream(Stream: TStream); override;

    function CreateGlyphString(const ACodePoints: TPascalTypeCodePoints): TFontGlyphString; overload;
    function CreateGlyphString(const ACodePoints: TPascalTypeCodePoints; AClusterLevel: TClusterLevel): TFontGlyphString; overload; virtual;

    function AddTable(const ATableClass: TCustomPascalTypeNamedTableClass): TCustomPascalTypeNamedTable; overload;
    function AddTable(const ATableType: TPascalTypeTag): TCustomPascalTypeNamedTable; overload;

    function ContainsTable(const ATableType: TPascalTypeTag): Boolean;

    function GetGlyphByCodePoint(ACodePoint: TPascalTypeCodePoint): Integer; overload; virtual; abstract;
    function GetGlyphByCodePoint(ACodePoint, ANextCodePoint: TPascalTypeCodePoint; var AIndex: Integer): Integer; overload; virtual; abstract;
    function GetGlyphByCodePoint(ACodePoint: Word): Integer; overload;
    function HasGlyphByCodePoint(ACodePoint: TPascalTypeCodePoint): boolean;
    function GetGlyphByCharacter(ACharacter: WideChar): Integer; overload;
    function GetGlyphByCharacter(ACharacter: AnsiChar): Integer; overload;

  public
    function GetGlyphExtentsY(GlyphID: TGlyphID; var YMin, YMax: SmallInt): Boolean;
    function GetGlyphExtents(GlyphID: TGlyphID; var XMin, YMin, XMax, YMax: SmallInt): Boolean; virtual;

    // Font file version/type
    property Version: Cardinal read FVersion;

    property Tables[Index: integer]: TCustomPascalTypeNamedTable read GetTable;
    property TableCount: integer read GetTableCount;

    // Required tables
    property HeaderTable: TPascalTypeHeaderTable read FHeaderTable;
    property HorizontalHeader: TPascalTypeHorizontalHeaderTable read FHorizontalHeader;
    property MaximumProfile: TPascalTypeMaximumProfileTable read FMaximumProfile;
    property NameTable: TPascalTypeNameTable read FNameTable;
    property PostScriptTable: TPascalTypePostscriptTable read FPostScriptTable;

    // Optional tables
    property VerticalHeader: TPascalTypeVerticalHeaderTable read FVerticalHeader;
    property GlyphDefinitionTable: TOpenTypeGlyphDefinitionTable read FGlyphDefinitionTable;
    property CFFTable: TPascalTypeCompactFontFormatTable read FCFFTable;

    // Variation properties
    property VariationCoordinates: TArray<TFixedPoint> read GetVariationCoordinates write SetVariationCoordinates;
    property VariationEngine: TPascalTypeVariationEngine read GetVariationEngine;
    property VariationTable: TPascalTypeFontVariationTable read FVariationTable;

    function FindAxisByTag(const Tag: TPascalTypeTag): integer;
    function FindAxisByName(const Name: string; PreferredPlatform: TPlatformID = piUnicode; PreferredLanguage: Word = 0): integer;
    function GetAxisCount: Integer;
    function GetAxisTag(Index: Integer): TPascalTypeTag;
    function GetAxisName(Index: Integer; PreferredPlatform: TPlatformID = piUnicode; PreferredLanguage: Word = 0): string;
    function GetAxisRange(Index: Integer; out MinValue, MaxValue, DefaultValue: Single): Boolean;
    function IsAxisVisible(Index: Integer): Boolean;
    function GetInstanceCount: Integer;
    function GetInstanceName(Index: Integer; PreferredPlatform: TPlatformID = piUnicode; PreferredLanguage: Word = 0): string;

    procedure SetInstance(const Name: string; PreferredPlatform: TPlatformID = piUnicode; PreferredLanguage: Word = 0);

    property AxisValue[const Tag: TPascalTypeTag]: Single read GetAxisValueByTag write SetAxisValueByTag;
    property AxisValueByName[const Name: string]: Single read GetAxisValueByName write SetAxisValueByName;
    property AxisValueByIndex[Index: integer]: Single read GetAxisValue write SetAxisValue;

    // Basic font properties
    property FontFamilyName: string read GetFontFamilyName;
    property FontName: string read GetFontName;
    property FontStyle: TFontStyles read GetFontStyle;
    property FontSubFamilyName: string read GetFontSubFamilyName;
    property FontVersion: string read GetFontVersion;
    property UniqueIdentifier: string read GetUniqueIdentifier;

    // Font metrics
    property TypographicAscender: SmallInt read GetTypographicAscender;
    property TypographicDescender: SmallInt read GetTypographicDescender;
    property TypographicLineGap: SmallInt read GetTypographicLineGap;
  end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFontFace
//
//------------------------------------------------------------------------------
// Complete font reader (maybe someday also a writer)
//------------------------------------------------------------------------------
  TPascalTypeFontFace = class(TCustomPascalTypeFontFace)
  public
    const MaxCompositeGlyphDepth = 32; // Max recursion depth when resolving composite glyphs

  strict private
    // Shortcuts to required tables
    FHorizontalMetrics: TPascalTypeHorizontalMetricsTable;
    FCharacterMap: TPascalTypeCharacterMapTable;
    FOS2Table: TPascalTypeOS2Table;

    // Only required for vertical
    FVerticalMetrics: TPascalTypeVerticalMetricsTable;

    // Not required, but pretty important
    FGlyphData: TTrueTypeFontGlyphDataTable;

  private type
    TPathCacheEntry = record
      Path: TPascalTypePath;
      XMin, YMin, XMax, YMax: SmallInt;
    end;

    TPathCache = TDictionary<Word, TPathCacheEntry>;

  private
    FPathCache: TPathCache;

  private
    function GetGlyphData(Index: Integer): TCustomTrueTypeFontGlyphData;
    function GetPanose: TCustomPascalTypePanoseTable;
    function GetBoundingBox: TRect;
    function GetGlyphCount: Word;

  protected
    function DoGetGlyphPath(GlyphIndex: Word; Depth: integer): TPascalTypePath;
    procedure GetGlyphPathCacheEntry(GlyphIndex: Word; var CacheEntry: TPathCacheEntry);
    procedure Loaded; override;
    procedure DoClear; override;
    procedure DoClearCache; override;
    procedure TableAdded(ATable: TCustomPascalTypeNamedTable); override;

  public
    destructor Destroy; override;


    function CreateLayoutEngine: TObject; override;

    procedure SaveToStream(Stream: TStream); override;

    function GetGlyphMetric(GlyphIndex: Word): TTrueTypeGlyphMetric;
    function GetAdvanceWidth(GlyphIndex: Word): Word; override;
    function GetAdvanceHeight(GlyphIndex: Word): Word; override;
    function GetVerticalOrigin(GlyphIndex: Word): TPoint; override;

  protected
    function GetTypographicAscender: SmallInt; override;
    function GetTypographicDescender: SmallInt; override;
    function GetTypographicLineGap: SmallInt; override;

  public
    function GetKerning(Last, Next: Word): Word;

    function GetGlyphByCodePoint(ACodePoint: TPascalTypeCodePoint): Integer; override;
    function GetGlyphByCodePoint(ACodePoint, ANextCodePoint: TPascalTypeCodePoint; var AIndex: Integer): Integer; override;

    function GetGlyphExtents(GlyphID: TGlyphID; var XMin, YMin, XMax, YMax: SmallInt): Boolean; override;
{$if defined(PhantomPoints)}
    function GetGlyphPointCount(GlyphID: TGlyphID): Integer; override;
{$ifend}

    function GetGlyphPath(GlyphIndex: Word): TPascalTypePath; // TODO : Use TFloatPoint

    property GlyphData[Index: Integer]: TCustomTrueTypeFontGlyphData read GetGlyphData;

    // Redirected sub properties
    property Panose: TCustomPascalTypePanoseTable read GetPanose;
    property BoundingBox: TRect read GetBoundingBox;
    property GlyphCount: Word read GetGlyphCount;

    // Required tables
    property HeaderTable;
    property HorizontalHeader;
    property MaximumProfile;
    property NameTable;
    property PostScriptTable;
    property GlyphTable: TTrueTypeFontGlyphDataTable read FGlyphData;
    property HorizontalMetrics: TPascalTypeHorizontalMetricsTable read FHorizontalMetrics;
    property VerticalMetrics: TPascalTypeVerticalMetricsTable read FVerticalMetrics;
    property CharacterMap: TPascalTypeCharacterMapTable read FCharacterMap;
    property OS2Table: TPascalTypeOS2Table read FOS2Table;
  end;


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

implementation

uses
  Math,
  PascalType.Math,
  PascalType.Tables.TrueType,
  PascalType.Tables.OpenType.PostScript,
  PascalType.Tables.OpenType.PostScript.CFF2,
  PascalType.Tables.OpenType.PostScript.VORG,
  PascalType.Tables.OpenType.ClassDefinition,
  PascalType.Shaper.Layout.OpenType,
  PascalType.ResourceStrings;

function CalculateCheckSum(Data: Pointer; Count: Integer): Cardinal; overload;
{$IFDEF PUREPASCAL}
begin
  Result := 0;
  while (Count > 0) do
  begin
{$IFOPT Q+}{$DEFINE Q_PLUS}{$OVERFLOWCHECKS OFF}{$ENDIF}
    Result := Result + Swap32(PCardinal(Data)^);
{$IFDEF Q_PLUS}{$OVERFLOWCHECKS ON}{$UNDEF Q_PLUS}{$ENDIF}
    Inc(PCardinal(Data));
    Dec(Count);
  end;
{$ELSE}
asm
  MOV     ECX, EDX
  XOR     EDX, EDX
  LEA     EAX, EAX + ECX * 4
  NEG     ECX
  JNL     @Done

  PUSH    EBX

@Start:
  MOV     EBX, [EAX + ECX * 4].DWord
  BSWAP   EBX
  ADD     EDX, EBX

  ADD     ECX, 1
  JS      @Start

  POP     EBX

@Done:
  MOV     EAX, EDX
  {$ENDIF}
end;

function CalculateCheckSum(Stream: TStream; Size: Cardinal): Cardinal; overload;
begin
  // Ensure that at least one cardinal is in the stream
  if (Size < 4) then
    Exit(0);

  Assert(Size <= (Stream.Size - Stream.Position));

  // set position to beginning of the stream
//  Stream.Position := 0;

  if (Stream is TMemoryStream) then
  begin
    Result := CalculateCheckSum(PByte(TMemoryStream(Stream).Memory) + Stream.Position, Size div SizeOf(Cardinal))
  end else
  begin
    Result := 0;

    // read subsequent cardinals
    while (Size >= SizeOf(Cardinal)) do
    begin
{$IFOPT Q+}{$DEFINE Q_PLUS}{$OVERFLOWCHECKS OFF}{$ENDIF}
      Result := Result + BigEndianValue.ReadCardinal(Stream);
{$IFDEF Q_PLUS}{$OVERFLOWCHECKS ON}{$UNDEF Q_PLUS}{$ENDIF}
      Dec(Size, SizeOf(Cardinal));
    end;
  end;
end;

function CalculateCheckSum(Stream: TStream): Cardinal; overload;
begin
  Result := CalculateCheckSum(Stream, Stream.Size-Stream.Position);
end;


//------------------------------------------------------------------------------
//
//              TFontGlyphString
//
//------------------------------------------------------------------------------
constructor TFontGlyphString.Create(AFont: TCustomPascalTypeFontFace; const ACodePoints: TPascalTypeCodePoints);
begin
  Create(AFont, ACodePoints, PascalTypeDefaultClusterLevel);
end;

constructor TFontGlyphString.Create(AFont: TCustomPascalTypeFontFace; const ACodePoints: TPascalTypeCodePoints; AClusterLevel: TClusterLevel);
begin
  FFont := AFont;
  inherited Create(ACodePoints, AClusterLevel);
end;

function TFontGlyphString.GetGlyphClassID(AGlyph: TPascalTypeGlyph): integer;
begin
  if (Font.GlyphDefinitionTable <> nil) and (Font.GlyphDefinitionTable.GlyphClassDefinition <> nil) then
    Result := Font.GlyphDefinitionTable.GlyphClassDefinition.ClassByGlyphID(AGlyph.GlyphID)
  else
    Result := inherited GetGlyphClassID(AGlyph);

  // HarfBuzz/USE: Spacing marks (category Mc) are treated as bases.
  // This ensures they correctly retain their advance width and are not skipped by IgnoreMarks.
  if (Result = GlyphClassMark) then
  begin
    for var CodePoint in AGlyph.CodePoints do
      if (PascalTypeUnicode.IsSpacingMark(CodePoint)) then
      begin
        Result := GlyphClassBase;
        break;
      end;
  end;
end;

function TFontGlyphString.GetMarkAttachmentType(AGlyph: TPascalTypeGlyph): integer;
begin
  if (Font.GlyphDefinitionTable <> nil) and (Font.GlyphDefinitionTable.MarkAttachmentClassDefinition <> nil) then
    Result := Font.GlyphDefinitionTable.MarkAttachmentClassDefinition.ClassByGlyphID(AGlyph.GlyphID)
  else
    Result := inherited GetMarkAttachmentType(AGlyph);
end;

function TFontGlyphString.IsInMarkFilteringSet(AGlyph: TPascalTypeGlyph; ASetIndex: integer): boolean;
begin
  if (Font.GlyphDefinitionTable <> nil) and (Font.GlyphDefinitionTable.MarkGlyphSet <> nil) then
    Result := Font.GlyphDefinitionTable.MarkGlyphSet.IsInSet(ASetIndex, AGlyph.GlyphID)
  else
    Result := inherited IsInMarkFilteringSet(AGlyph, ASetIndex);
end;

function TFontGlyphString.GetGlyphByCodePoint(ACodePoint: TPascalTypeCodePoint): Integer;
begin
  Result := Font.GetGlyphByCodePoint(ACodePoint);
end;

class function TFontGlyphString.GetGlyphClass: TPascalTypeGlyphClass;
begin
  Result := TFontGlyph;
end;

procedure TFontGlyphString.HideDefaultIgnorables;
begin
  if (sfRemoveDefaultIgnorables in Options) then
    inherited
  else
  if (sfHideDefaultIgnorables in Options) then
  begin
    var i := 0;
    while (i < Count) do
    begin
      var Glyph := Glyphs[i];
      // Only hide if the glyph has not been substituted.
      // If the font has a substitution for a default ignorable (e.g. U+200D to a specific glyph via 'rlig'),
      // we want to keep that substituted glyph.
      if (not Glyph.IsSubstituted) and (PascalTypeUnicode.IsDefaultIgnorableEx(Glyph.CodePoint)) then
      begin
        if (InvisibleGlyph <> GlyphNotDef) then
        begin
          Glyph.GlyphID := InvisibleGlyph;
          Glyph.XAdvance := 0;
          Glyph.YAdvance := 0;
          Inc(i);
        end else
        begin
          // Since the space character doesn't exist in the font we cannot use it
          // to replace default ignorables. Instead we simply delete them.
          // This matches the behavior of Harfbuzz (see: hb_ot_hide_default_ignorables).
          Delete(i);
          // Don't increment i because current index now points to next glyph
        end;
      end else
        Inc(i);
    end;
  end;
end;


//------------------------------------------------------------------------------
//
//              TPascalTypeTableRoot
//
//------------------------------------------------------------------------------
// Root table. Just used to provide access to the font from the tables.
//------------------------------------------------------------------------------
type
  TPascalTypeTableRoot = class(TCustomPascalTypeTable)
  private
    FFontFace: IPascalTypeFontFace;
  protected
    function GetFontFace: IPascalTypeFontFace; override;
  public
    constructor Create(const AFontFace: IPascalTypeFontFace); reintroduce;
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    procedure SaveToStream(Stream: TStream); override;
  end;

constructor TPascalTypeTableRoot.Create(const AFontFace: IPascalTypeFontFace);
begin
  inherited Create;
  FFontFace := AFontFace;
end;

function TPascalTypeTableRoot.GetFontFace: IPascalTypeFontFace;
begin
  Result := FFontFace;
end;

procedure TPascalTypeTableRoot.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  raise EPascalTypeError.Create(RCStrNotImplemented);
end;

procedure TPascalTypeTableRoot.SaveToStream(Stream: TStream);
begin
  raise EPascalTypeError.Create(RCStrNotImplemented);
end;


{ TFontGlyphString }

procedure TFontGlyphString.ApplyVariation(AGlyph: TPascalTypeGlyph; const AValueRecord: TOpenTypeValueRecord);
begin
  if (Font = nil) or (not Font.VariationsActive) then
    exit;

  if (AValueRecord.xPlaVarIndex <> $FFFFFFFF) then
    AGlyph.XOffset := AGlyph.XOffset + Round(Font.GetVariationItemDelta(AValueRecord.xPlaVarIndex shr 16, AValueRecord.xPlaVarIndex and $FFFF));

  if (AValueRecord.yPlaVarIndex <> $FFFFFFFF) then
    AGlyph.YOffset := AGlyph.YOffset + Round(Font.GetVariationItemDelta(AValueRecord.yPlaVarIndex shr 16, AValueRecord.yPlaVarIndex and $FFFF));

  if (AValueRecord.xAdvVarIndex <> $FFFFFFFF) then
    AGlyph.XAdvance := AGlyph.XAdvance + Round(Font.GetVariationItemDelta(AValueRecord.xAdvVarIndex shr 16, AValueRecord.xAdvVarIndex and $FFFF));

  if (AValueRecord.yAdvVarIndex <> $FFFFFFFF) then
    AGlyph.YAdvance := AGlyph.YAdvance + Round(Font.GetVariationItemDelta(AValueRecord.yAdvVarIndex shr 16, AValueRecord.yAdvVarIndex and $FFFF));
end;


//------------------------------------------------------------------------------
//
//              TCustomPascalTypeFontFace
//
//------------------------------------------------------------------------------
constructor TCustomPascalTypeFontFace.Create;
begin
  inherited;
  FRootTable := TPascalTypeTableRoot.Create(Self);
  FTables := TTableList.Create;
  FTableLookup := TTableLookup.Create;
end;

destructor TCustomPascalTypeFontFace.Destroy;
begin
  FVariationEngine.Free;
  FTableLookup.Free;
  FTables.Free;
  FRootTable.Free;
  inherited;
end;

function TCustomPascalTypeFontFace.GetHasVariations: boolean;
begin
  Result := (FVariationTable <> nil);
end;

function TCustomPascalTypeFontFace.GetVariationsActive: boolean;
begin
  Result := (FVariationEngine <> nil) and (FVariationEngine.Active);
end;

function TCustomPascalTypeFontFace.GetVariationItemDelta(OuterIndex, InnerIndex: Word): Single;
begin
  if (HasVariations) then
    Result := VariationEngine.GetItemDelta(OuterIndex, InnerIndex)
  else
    Result := 0;
end;

function TCustomPascalTypeFontFace.GetVariationMetricDelta(const Tag: TPascalTypeTag): Single;
begin
  if (HasVariations) then
    Result := VariationEngine.GetMetricDelta(Tag)
  else
    Result := 0;
end;

function TCustomPascalTypeFontFace.GetVariationNormalizedCoordinates: TArray<TFixedPoint>;
begin
  if (HasVariations) then
    Result := VariationEngine.NormalizedCoordinates
  else
    Result := nil;
end;

function TCustomPascalTypeFontFace.GetVariationCoordinates: TArray<TFixedPoint>;
begin
  if (HasVariations) then
    Result := VariationEngine.UserCoordinates
  else
    Result := nil;
end;

procedure TCustomPascalTypeFontFace.SetVariationCoordinates(const Value: TArray<TFixedPoint>);
begin
  if (HasVariations) then
  begin
    VariationEngine.SetUserCoordinates(Value);
    ClearCache; // Clear caches when variations change
  end;
end;

function TCustomPascalTypeFontFace.GetVariationEngine: TPascalTypeVariationEngine;
begin
  if (FVariationEngine = nil) and (FVariationTable <> nil) then
    FVariationEngine := TPascalTypeVariationEngine.Create(Self);
  Result := FVariationEngine;
end;

function TCustomPascalTypeFontFace.FindAxisByTag(const Tag: TPascalTypeTag): integer;
begin
  if (HasVariations) then
    Result := VariationEngine.FindAxisByTag(Tag)
  else
    Result := -1;
end;

function TCustomPascalTypeFontFace.FindAxisByName(const Name: string; PreferredPlatform: TPlatformID; PreferredLanguage: Word): integer;
begin
  if (HasVariations) then
    Result := VariationEngine.FindAxisByName(Name, PreferredPlatform, PreferredLanguage)
  else
    Result := -1;
end;

function TCustomPascalTypeFontFace.GetAxisCount: Integer;
begin
  if (FVariationTable <> nil) then
    Result := FVariationTable.AxisCount
  else
    Result := 0;
end;

function TCustomPascalTypeFontFace.GetAxisTag(Index: Integer): TPascalTypeTag;
begin
  if (FVariationTable <> nil) and (Index >= 0) and (Index < FVariationTable.AxisCount) then
    Result := FVariationTable.Axis[Index].AxisTag
  else
    Result := 0;
end;

function TCustomPascalTypeFontFace.GetAxisName(Index: Integer; PreferredPlatform: TPlatformID; PreferredLanguage: Word): string;
begin
  if (FVariationTable <> nil) and (Index >= 0) and (Index < FVariationTable.AxisCount) then
  begin
    if NameTable.TryGetName(TNameID(FVariationTable.Axis[Index].NameID), PreferredPlatform, PreferredLanguage, Result) then
      Exit;

    if (PreferredPlatform <> piUnicode) then
    begin
      if NameTable.TryGetName(TNameID(FVariationTable.Axis[Index].NameID), piUnicode, 0, Result) then
        Exit;
    end;

    if (PreferredPlatform <> piMicrosoft) and (PreferredLanguage <> 1033) then
    begin
      if NameTable.TryGetName(TNameID(FVariationTable.Axis[Index].NameID), piMicrosoft, 1033, Result) then
        Exit;
    end;
  end;
  Result := '';
end;

function TCustomPascalTypeFontFace.GetAxisRange(Index: Integer; out MinValue, MaxValue, DefaultValue: Single): Boolean;
begin
  if (FVariationTable <> nil) and (Index >= 0) and (Index < FVariationTable.AxisCount) then
  begin
    MinValue := FVariationTable.Axis[Index].MinValue.AsSingle;
    MaxValue := FVariationTable.Axis[Index].MaxValue.AsSingle;
    DefaultValue := FVariationTable.Axis[Index].DefaultValue.AsSingle;
    Result := True;
  end else
  begin
    MinValue := 0;
    MaxValue := 0;
    DefaultValue := 0;
    Result := False;
  end;
end;

function TCustomPascalTypeFontFace.IsAxisVisible(Index: Integer): Boolean;
const
  HIDDEN_AXIS = $0001;
begin
  if (FVariationTable <> nil) and (Index >= 0) and (Index < FVariationTable.AxisCount) then
    Result := (FVariationTable.Axis[Index].Flags and HIDDEN_AXIS) = 0
  else
    Result := False;
end;

function TCustomPascalTypeFontFace.GetInstanceCount: Integer;
begin
  if (FVariationTable <> nil) then
    Result := FVariationTable.InstanceCount
  else
    Result := 0;
end;

function TCustomPascalTypeFontFace.GetInstanceName(Index: Integer; PreferredPlatform: TPlatformID; PreferredLanguage: Word): string;
begin
  if (FVariationTable <> nil) and (Index >= 0) and (Index < FVariationTable.InstanceCount) then
  begin
    if NameTable.TryGetName(TNameID(FVariationTable.VariationInstance[Index].NameID), PreferredPlatform, PreferredLanguage, Result) then
      Exit;

    if (PreferredPlatform <> piUnicode) then
    begin
      if NameTable.TryGetName(TNameID(FVariationTable.VariationInstance[Index].NameID), piUnicode, 0, Result) then
        Exit;
    end;

    if (PreferredPlatform <> piMicrosoft) and (PreferredLanguage <> 1033) then
    begin
      if NameTable.TryGetName(TNameID(FVariationTable.VariationInstance[Index].NameID), piMicrosoft, 1033, Result) then
        Exit;
    end;
  end;
  Result := '';
end;

procedure TCustomPascalTypeFontFace.SetInstance(const Name: string; PreferredPlatform: TPlatformID; PreferredLanguage: Word);
begin
  if (HasVariations) then
  begin
    VariationEngine.SetInstance(Name, PreferredPlatform, PreferredLanguage);
    ClearCache;
  end;
end;

function TCustomPascalTypeFontFace.GetAxisValue(Index: integer): Single;
begin
  if (HasVariations) then
    Result := VariationEngine.GetAxisValue(Index)
  else
    Result := 0;
end;

procedure TCustomPascalTypeFontFace.SetAxisValue(Index: integer; Value: Single);
begin
  if (HasVariations) then
  begin
    VariationEngine.SetAxisValue(Index, Value);
    ClearCache;
  end;
end;

function TCustomPascalTypeFontFace.GetAxisValueByTag(const Tag: TPascalTypeTag): Single;
begin
  if (HasVariations) then
    Result := VariationEngine.GetAxisValue(Tag)
  else
    Result := 0;
end;

procedure TCustomPascalTypeFontFace.SetAxisValueByTag(const Tag: TPascalTypeTag; Value: Single);
begin
  if (HasVariations) then
  begin
    VariationEngine.SetAxisValue(Tag, Value);
    ClearCache;
  end;
end;

function TCustomPascalTypeFontFace.GetAxisValueByName(const Name: string): Single;
begin
  if (HasVariations) then
    Result := VariationEngine.GetAxisValue(Name)
  else
    Result := 0;
end;

procedure TCustomPascalTypeFontFace.SetAxisValueByName(const Name: string; Value: Single);
begin
  if (HasVariations) then
  begin
    VariationEngine.SetAxisValue(Name, Value);
    ClearCache;
  end;
end;

function TCustomPascalTypeFontFace.GetTable(Index: integer): TCustomPascalTypeNamedTable;
begin
  Result := FTables[Index];
end;

function TCustomPascalTypeFontFace.GetTableCount: Integer;
begin
  Result := FTables.Count;
end;

procedure TCustomPascalTypeFontFace.DirectoryTableLoaded(DirectoryTable: TPascalTypeDirectoryTable);
begin
  if (Version = sfntVersionAppleTT) then
  begin
    if (not DirectoryTable.Contains(ttLoca)) then
      raise EPascalTypeError.Create(RCStrNoIndexToLocationTable);

    if (not DirectoryTable.Contains(ttGlyf)) then
      raise EPascalTypeError.Create(RCStrNoGlyphDataTable);
  end;
end;

procedure TCustomPascalTypeFontFace.TableAdded(ATable: TCustomPascalTypeNamedTable);
begin
  case ATable.TableType.AsCardinal of
    ttHead:
      FHeaderTable := ATable as TPascalTypeHeaderTable;

    ttMaxp:
      FMaximumProfile := ATable as TPascalTypeMaximumProfileTable;

    ttHhea:
      FHorizontalHeader := ATable as TPascalTypeHorizontalHeaderTable;

    ttVhea:
      FVerticalHeader := ATable as TPascalTypeVerticalHeaderTable;

    ttName:
      FNameTable := ATable as TPascalTypeNameTable;

    ttPost:
      FPostScriptTable := ATable as TPascalTypePostscriptTable;

    ttGDEF:
      FGlyphDefinitionTable := ATable as TOpenTypeGlyphDefinitionTable;

    ttFvar:
      FVariationTable := ATable as TPascalTypeFontVariationTable;

    ttMVAR:
      FMetricsVariationTable := ATable as TPascalTypeMetricsVariationTable;

    ttSTAT:
      FStyleAttributesTable := ATable as TPascalTypeStyleAttributesTable;

    ttCFF:
      FCFFTable := ATable as TPascalTypeCompactFontFormatTable;
  end;
end;

procedure TCustomPascalTypeFontFace.AddTable(ATable: TCustomPascalTypeNamedTable);
begin
  // Add to lookup first in case there's a duplicate table type
  TableLookup.Add(ATable.TableType, ATable);

  // Transfer ownership to list
  FTables.Add(ATable);

  try

    TableAdded(ATable);

  except
    TableLookup.Remove(ATable.TableType);
    FTables.Extract(ATable);
    raise;
  end;
end;

function TCustomPascalTypeFontFace.AddTable(const ATableClass: TCustomPascalTypeNamedTableClass): TCustomPascalTypeNamedTable;
begin
  Result := ATableClass.Create(RootTable);
  try
    AddTable(Result);
  except
    Result.Free;
    raise;
  end;
end;

function TCustomPascalTypeFontFace.AddTable(const ATableType: TPascalTypeTag): TCustomPascalTypeNamedTable;
var
  TableClass: TCustomPascalTypeNamedTableClass;
  UnknownTableType: boolean;
begin
  TableClass := PascalTypeTableClasses.FindTableByType(ATableType);

  UnknownTableType := (TableClass = nil);
  if (UnknownTableType) then
    TableClass := TPascalTypeUnknownTable;

  Result := TableClass.Create(RootTable);
  try
    if (UnknownTableType) then
      TPascalTypeUnknownTable(Result).TableType := ATableType;

    AddTable(Result);
  except
    Result.Free;
    raise;
  end;
end;

function TCustomPascalTypeFontFace.LoadTableFromStream(Stream: TStream; const TableEntry: TDirectoryTableEntry): TCustomPascalTypeNamedTable;
var
  TableClass: TCustomPascalTypeNamedTableClass;
  Table: TCustomPascalTypeNamedTable;
  UnknownTableType: boolean;
begin
  Result := nil;

  Stream.Position := TableEntry.Offset;

{$IFDEF ChecksumTest}
  ValidateChecksum(Stream, TableEntry.Length);
{$ENDIF}

  TableClass := PascalTypeTableClasses.FindTableByType(TableEntry.TableType);

  UnknownTableType := (TableClass = nil);
  if (UnknownTableType) then
    TableClass := TPascalTypeUnknownTable;

  Table := TableClass.Create(RootTable);
  try
    if (UnknownTableType) then
      TPascalTypeUnknownTable(Table).TableType := TableEntry.TableType;

    try

      Table.LoadFromStream(Stream, TableEntry.Length);

    except
{$IFDEF IgnoreIncompleteOptionalTables}
      on E: EPascalTypeTableIncomplete do
      begin
        if (TableClass = TPascalTypeHeaderTable) or
          (TableClass = TPascalTypeHorizontalHeaderTable) or
          (TableClass = TPascalTypeHorizontalMetricsTable) or
          (TableClass = TPascalTypePostscriptTable) or
          (TableClass = TPascalTypeMaximumProfileTable) or
          (TableClass = TPascalTypeNameTable) then
          raise; // Table is mandatory; fail with an error

        exit; // Table is optional; We can survive without it
      end;
{$ELSE}
      raise
{$ENDIF}
    end;

    AddTable(Table);

    // Return value and clear Table so it's not freed in finally
    Result := Table;
    Table := nil;

  finally
    // Free table unless it is now owned by FTables
    Table.Free;
  end;
end;

function TCustomPascalTypeFontFace.GetFontFamilyName: string;
begin
  if (not FNameTable.TryGetName(niTypographicFamily, PreferredPlatform, PreferredLanguage, Result)) then
    FNameTable.TryGetName(niFamily, PreferredPlatform, PreferredLanguage, Result, Result);
end;

function TCustomPascalTypeFontFace.GetFontSubFamilyName: string;
begin
  if (not FNameTable.TryGetName(niTypographicSubfamily, PreferredPlatform, PreferredLanguage, Result)) then
    FNameTable.TryGetName(niSubfamily, PreferredPlatform, PreferredLanguage, Result, Result);
end;

function TCustomPascalTypeFontFace.GetFontVersion: string;
begin
  FNameTable.TryGetName(niVersion, PreferredPlatform, PreferredLanguage, Result);
end;

function TCustomPascalTypeFontFace.GetUniqueIdentifier: string;
begin
  FNameTable.TryGetName(niUniqueIdentifier, PreferredPlatform, PreferredLanguage, Result);
end;

function TCustomPascalTypeFontFace.GetFontName: string;
begin
  FNameTable.TryGetName(niFullName, PreferredPlatform, PreferredLanguage, Result);
end;

function TCustomPascalTypeFontFace.GetFontStyle: TFontStyles;
begin
  Result := [];
  if msItalic in FHeaderTable.MacStyle then
    Include(Result, fsItalic);

  if msBold in FHeaderTable.MacStyle then
    Include(Result, fsBold);

  if msUnderline in FHeaderTable.MacStyle then
    Include(Result, fsUnderline);
end;

function TCustomPascalTypeFontFace.ContainsTable(const ATableType: TPascalTypeTag): Boolean;
begin
  Result := FTableLookup.ContainsKey(ATableType);
end;

function TCustomPascalTypeFontFace.GetTableByTableClass(ATableClass: TCustomPascalTypeNamedTableClass): TCustomPascalTypeNamedTable;
begin
  for Result in FTables do
    if (Result.ClassType = ATableClass) then
      exit;
  Result := nil;
end;

function TCustomPascalTypeFontFace.GetTableByName(const ATableName: TPascalTypeTag): TCustomPascalTypeNamedTable;
begin
  if (not FTableLookup.TryGetValue(ATableName, Result)) then
    Result := nil;
end;

procedure TCustomPascalTypeFontFace.DoClearCache;
begin
end;

procedure TCustomPascalTypeFontFace.ClearCache;
begin
  BeginUpdate;
  try
    Notify(fnClearCache);

    DoClearCache;

    Changed;
  finally
    EndUpdate;
  end;
end;

procedure TCustomPascalTypeFontFace.DoClear;
begin
  ClearCache;

  FTableLookup.Clear;
  FTables.Clear;

  FHeaderTable := nil;
  FHorizontalHeader := nil;
  FVerticalHeader := nil;
  FGlyphDefinitionTable := nil;
  FMaximumProfile := nil;
  FNameTable := nil;
  FPostScriptTable := nil;

  FVariationTable := nil;
  FMetricsVariationTable := nil;
  FStyleAttributesTable := nil;
  FreeAndNil(FVariationEngine);
end;

procedure TCustomPascalTypeFontFace.Clear;
begin
  BeginUpdate;
  try
    Notify(fnClear);

    DoClear;

    Changed;
  finally
    EndUpdate;
  end;
end;

procedure TCustomPascalTypeFontFace.Loaded;
begin
  // Verify that required tables are present
  if (HeaderTable = nil) then
    raise EPascalTypeError.Create(RCStrNoHeaderTable);

  if (HorizontalHeader = nil) then
    raise EPascalTypeError.Create(RCStrNoHorizontalHeaderTable);

  if (MaximumProfile = nil) then
    raise EPascalTypeError.Create(RCStrNoMaximumProfileTable);

  if (NameTable = nil) then
    raise EPascalTypeError.Create(RCStrNoNameTable);

  if (PostScriptTable = nil) then
    raise EPascalTypeError.Create(RCStrNoPostscriptTable);
end;

procedure TCustomPascalTypeFontFace.LoadTablesFromStream(Stream: TStream; const TableList: TPascalTypeDirectoryTableList);
var
  i: integer;
begin
  // Load tables
  for i := 0 to High(TableList) do
  begin
    if (TableLookup.ContainsKey(TableList[i].TableType)) then
      continue;

    LoadTableFromStream(Stream, TableList[i]);
  end;
end;

procedure TCustomPascalTypeFontFace.LoadFromStream(Stream: TStream);
var
  DirectoryTable: TPascalTypeDirectoryTable;
  i: integer;
  Index: integer;
const
  Preload: array of TTableName = ['head', 'maxp', 'loca'];
begin
  BeginUpdate;
  try

    Clear;

    DirectoryTable := TPascalTypeDirectoryTable.Create(FRootTable);
    try
      DirectoryTable.LoadFromStream(Stream, Stream.Size);

      FVersion := DirectoryTable.Version.AsCardinal;

      // Directory table has been read, notify
      DirectoryTableLoaded(DirectoryTable);

      // Preload tables that other tables depend on
      for i := 0 to High(Preload) do
      begin
        Index := DirectoryTable.IndexOfTableEntry(Preload[i]);
        if (Index <> -1) then
          LoadTableFromStream(Stream, DirectoryTable.TableList[Index]);
      end;

      LoadTablesFromStream(Stream, DirectoryTable.TableList);

    finally
      DirectoryTable.Free;
    end;

    // Verify required tables and map table shortcuts
    Loaded;

    Changed;
  finally
    EndUpdate;
  end;
end;

{$IFDEF ChecksumTest}

procedure TCustomPascalTypeFontFace.ValidateChecksum(Stream: TStream;
  TableEntry: TDirectoryTableEntry);
var
  Checksum: Cardinal;
begin
  Stream.Position := 0;

  // calculate checksum of strem
  Checksum := CalculateCheckSum(Stream);

  if CompareTableType(TableEntry.TableType, 'head') then
  begin
    // ignore checksum adjustment
    Stream.Position := 8;
{$IFOPT Q+}{$DEFINE Q_PLUS}{$OVERFLOWCHECKS OFF}{$ENDIF}
    Checksum := Checksum - BigEndianValue.ReadCardinal(Stream);
{$IFDEF Q_PLUS}{$OVERFLOWCHECKS ON}{$UNDEF Q_PLUS}{$ENDIF}
  end;

  // check checksum
  if (Checksum <> TableEntry.Checksum) then
    raise EPascalTypeChecksumError.CreateFmt(RCStrChecksumError,
      [string(TableEntry.TableType)]);
end;
{$ENDIF}

function TCustomPascalTypeFontFace.GetGlyphStringClass: TFontGlyphStringClass;
begin
  Result := TFontGlyphString;
end;

function TCustomPascalTypeFontFace.CreateGlyphString(const ACodePoints: TPascalTypeCodePoints): TFontGlyphString;
begin
  Result := CreateGlyphString(ACodePoints, PascalTypeDefaultClusterLevel);
end;

function TCustomPascalTypeFontFace.CreateGlyphString(const ACodePoints: TPascalTypeCodePoints; AClusterLevel: TClusterLevel): TFontGlyphString;
begin
  Result := GetGlyphStringClass.Create(Self, ACodePoints, AClusterLevel);

  // Map Unicode CodePoints to Glyph IDs
  var i := 0;
  while (i < Result.Count) do
  begin
    var Glyph := Result[i];

    if (i < Result.Count - 1) then
    begin
      var NextGlyph := Result[i + 1];

      // Unicode Variation Sequences are always <Base, VS>
      // We only try lookahead if both glyphs currently represent exactly one codepoint
      if (Length(Glyph.CodePoints) = 1) and (Length(NextGlyph.CodePoints) = 1) then
      begin
        var Consumed := i;
        var GlyphID := GetGlyphByCodePoint(Glyph.CodePoints[0], NextGlyph.CodePoints[0], Consumed);

        if (Consumed > i) then
        begin
          // UVS Match found!
          Glyph.GlyphID := GlyphID;
          Glyph.IsSubstituted := True;

          // The variation selector should be hidden.
          // We set its advance to 0 to prevent it from affecting layout, and mark
          // it as not substituted to ensure it is hidden or removed in the final pass.
          if (Result.InvisibleGlyph = GlyphNotDef) then
            Result.InvisibleGlyph := GetGlyphByCodePoint(32);

          if (Result.InvisibleGlyph <> GlyphNotDef) then
            NextGlyph.GlyphID := Result.InvisibleGlyph
          else
            NextGlyph.GlyphID := GetGlyphByCodePoint(NextGlyph.CodePoint);

          NextGlyph.XAdvance := 0;
          NextGlyph.YAdvance := 0;
          NextGlyph.IsSubstituted := False; // Allow the VS to be cleaned up by HideDefaultIgnorables

          i := Consumed + 1; // Move past the consumed VS
          continue;
        end;
      end;
    end;

    // Standard mapping
    Glyph.GlyphID := GetGlyphByCodePoint(Glyph.CodePoint);
    Glyph.IsSubstituted := False;
    Inc(i);
  end;
end;


function TCustomPascalTypeFontFace.GetGlyphByCodePoint(ACodePoint: Word): Integer;
begin
  Result := GetGlyphByCodePoint(TPascalTypeCodePoint(ACodePoint));
end;

function TCustomPascalTypeFontFace.GetGlyphByCharacter(ACharacter: WideChar): Integer;
begin
  Result := GetGlyphByCodePoint(TPascalTypeCodePoint(ACharacter));
end;

function TCustomPascalTypeFontFace.GetGlyphByCharacter(ACharacter: AnsiChar): Integer;
begin
  Result := GetGlyphByCodePoint(TPascalTypeCodePoint(ACharacter));
end;

function TCustomPascalTypeFontFace.HasGlyphByCodePoint(ACodePoint: TPascalTypeCodePoint): boolean;
begin
  Result := (GetGlyphByCodePoint(ACodePoint) <> GlyphNotDef);
end;

function TCustomPascalTypeFontFace.GetAdvanceWidth(GlyphIndex: Word): Word;
begin
  if (HorizontalHeader <> nil) then
    Result := HorizontalHeader.AdvanceWidthMax // Better than nothing :-(
  else
    Result := 0; // Font hasn't been loaded
end;

function TCustomPascalTypeFontFace.GetAdvanceHeight(GlyphIndex: Word): Word;
begin
  if (HeaderTable <> nil) then
    // Fallback to EM square if no vertical metrics
    Result := HeaderTable.UnitsPerEm
  else
    Result := 0; // Font hasn't been loaded
end;

function TCustomPascalTypeFontFace.GetVerticalOrigin(GlyphIndex: Word): TPoint;
begin
  // Centered horizontally by default
  Result.X := GetAdvanceWidth(GlyphIndex) div 2;

  if (HeaderTable <> nil) then
    Result.Y := HeaderTable.YMax // Simplified fallback
  else
    Result.Y := 0; // Font hasn't been loaded
end;

function TCustomPascalTypeFontFace.GetTypographicAscender: SmallInt;
begin
  if (HorizontalHeader <> nil) then
    Result := HorizontalHeader.Ascent
  else
    Result := 0;
end;

function TCustomPascalTypeFontFace.GetTypographicDescender: SmallInt;
begin
  if (HorizontalHeader <> nil) then
    Result := HorizontalHeader.Descent
  else
    Result := 0;
end;

function TCustomPascalTypeFontFace.GetTypographicLineGap: SmallInt;
begin
  if (HorizontalHeader <> nil) then
    Result := HorizontalHeader.LineGap
  else
    Result := 0;
end;

function TCustomPascalTypeFontFace.GetGlyphExtentsY(GlyphID: TGlyphID; var YMin, YMax: SmallInt): Boolean;
var
  XMin, XMax: SmallInt;
begin
  Result := GetGlyphExtents(GlyphID, XMin, YMin, XMax, YMax);
end;

function TCustomPascalTypeFontFace.GetGlyphExtents(GlyphID: TGlyphID; var XMin, YMin, XMax, YMax: SmallInt): Boolean;
begin
  Result := False;
end;

{$if defined(PhantomPoints)}
function TCustomPascalTypeFontFace.GetGlyphPointCount(GlyphID: TGlyphID): Integer;
begin
  Result := 0;
end;
{$ifend}

function TCustomPascalTypeFontFace.GetGlyphName(GlyphID: TGlyphID): string;
begin
  if (FCFFTable <> nil) and FCFFTable.TryGetGlyphName(GlyphID, Result) then
    Exit;

  if (FPostScriptTable <> nil) then
  begin
    case FPostScriptTable.Version.Value of
      1:
        if (GlyphID < 258) then
          Exit(DefaultGlyphName(GlyphID));

      2:
        if (FPostScriptTable.PostscriptV2Table <> nil) and (GlyphID < FPostScriptTable.PostscriptV2Table.GlyphIndexCount) then
          Exit(FPostScriptTable.PostscriptV2Table.GlyphIndexToString(GlyphID));
    end;
  end;
  Result := 'gid' + IntToStr(GlyphID);
end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFontFace
//
//------------------------------------------------------------------------------
destructor TPascalTypeFontFace.Destroy;
begin
  FPathCache.Free;

  inherited;
end;

function TPascalTypeFontFace.CreateLayoutEngine: TObject;
begin
  Result := TPascalTypeOpenTypeLayoutEngine.Create(Self);
end;

function TPascalTypeFontFace.GetAdvanceWidth(GlyphIndex: Word): Word;
var
  CFFTable: TPascalTypeCompactFontFormatTable;
begin
  if (FHorizontalMetrics <> nil) then
  begin
    if (GlyphIndex < FHorizontalMetrics.HorizontalMetricCount) then
      Result := FHorizontalMetrics.HorizontalMetric[GlyphIndex].AdvanceWidth
    else
      Result := FHorizontalMetrics.HorizontalMetric[FHorizontalMetrics.HorizontalMetricCount - 1].AdvanceWidth;

    if (VariationsActive) then
    begin
      var Delta := VariationEngine.GetAdvanceWidthDelta(GlyphIndex);
      if (Delta <> 0) then
        Result := Word(Max(0, Trunc(Result + Delta + 0.5)));
    end;
  end else
  begin
    CFFTable := TPascalTypeCompactFontFormatTable(GetTableByName('CFF '));
    if (CFFTable <> nil) then
      Result := Round(CFFTable.GetGlyphWidth(GlyphIndex))
    else
      Result := inherited; // Fallback
  end;
end;

function TPascalTypeFontFace.GetAdvanceHeight(GlyphIndex: Word): Word;
begin
  (*
    Vertical Advance Fallback

    HarfBuzz eventually falls back to the EM size (UPEM) for vertical advances
    when the vmtx table is missing.

    It does seem though that it gives the font extents a try first.
    https://github.com/harfbuzz/harfbuzz/blob/78f11ed7260897c967e7fcbc25acff113ca93737/src/hb-ot-font.cc#L506
  *)


  // 1) Try 'vmtx' first
  if (VerticalMetrics <> nil) then
  begin
    if (GlyphIndex < VerticalMetrics.VerticalMetricCount) then
      Result := VerticalMetrics.VerticalMetric[GlyphIndex].AdvanceHeight
    else
      Result := VerticalMetrics.VerticalMetric[VerticalMetrics.VerticalMetricCount - 1].AdvanceHeight;

    if (VariationsActive) then
    begin
      var Delta := VariationEngine.GetAdvanceHeightDelta(GlyphIndex);
      if (Delta <> 0) then
        Result := Word(Max(0, Trunc(Result + Delta + 0.5)));
    end;

    exit;
  end;

  // 2) Do not apply fallbacks to marks
  if (GlyphDefinitionTable <> nil) and (GlyphDefinitionTable.GlyphClassDefinition <> nil) then
  begin
    if (GlyphDefinitionTable.GlyphClassDefinition.ClassByGlyphID(GlyphIndex) = GlyphClassMark) then // Mark
      Exit(0);
  end;

  // 3) Fallback to horizontal metrics (ascent - descent)
  // 3.1) 'OS/2' table
  if (OS2Table <> nil) then
  begin
    if (fsfUseTypoMetrics in OS2Table.FontSelectionFlags) then
      Result := OS2Table.TypographicAscender - OS2Table.TypographicDescender
    else
      Result := OS2Table.WindowsAscent + OS2Table.WindowsDescent;
    exit;
  end;

  // 3.1) 'hhea' table
  if (HorizontalHeader <> nil) then
    Result := HorizontalHeader.Ascent - HorizontalHeader.Descent
  else
    // 4) Fallback to 'head' EM square
    Result := inherited;
end;

function TPascalTypeFontFace.GetTypographicAscender: SmallInt;
begin
  if (FOS2Table <> nil) then
    Result := FOS2Table.TypographicAscender
  else
    Result := inherited;
end;

function TPascalTypeFontFace.GetTypographicDescender: SmallInt;
begin
  if (FOS2Table <> nil) then
    Result := FOS2Table.TypographicDescender
  else
    Result := inherited;
end;

function TPascalTypeFontFace.GetTypographicLineGap: SmallInt;
begin
  if (FOS2Table <> nil) then
    Result := FOS2Table.TypographicLineGap
  else
    Result := inherited;
end;

function TPascalTypeFontFace.GetVerticalOrigin(GlyphIndex: Word): TPoint;
begin
  (*
  ** Vertical Origin X
  *)

  // Centered horizontally by default
  Result.X := GetAdvanceWidth(GlyphIndex) div 2;


  (*
  ** Vertical Origin Y
  **
  ** To quote Harfbuzz: "The vertical origin business is messy..."
  ** https://github.com/harfbuzz/harfbuzz/blob/78f11ed7260897c967e7fcbc25acff113ca93737/src/hb-ot-font.cc#L657
  *)

  // 1) Consult 'VORG' table (primarily for CFF)
  var VerticalOriginTable := TPascalTypeVerticalOriginTable(GetTableByName('VORG'));
  if (VerticalOriginTable <> nil) then
  begin
    Result.Y := VerticalOriginTable.GetYOrigin(GlyphIndex);

    if (VariationsActive) then
      Result.Y := Result.Y + Round(VariationEngine.GetVORGDelta(GlyphIndex));

    exit;
  end;

  var YMin: SmallInt;
  var YMax: SmallInt;
  var HasBounds := GetGlyphExtentsY(GlyphIndex, YMin, YMax);

  // 2) Consult 'vmtx' table
  if HasBounds and (FVerticalMetrics <> nil) and (FVerticalMetrics.VerticalMetricCount > 0) then
  begin
    Result.Y := YMax + FVerticalMetrics.VerticalMetric[Min(GlyphIndex, FVerticalMetrics.VerticalMetricCount-1)].TopSideBearing;

    if (VariationsActive) then
      Result.Y := Result.Y + Round(VariationEngine.GetTSBDelta(GlyphIndex));

    exit;
  end;

  // 3) Fallback: Centering algorithm (HarfBuzz style)
  if HasBounds then
  begin
    Result.Y := YMax + (integer(GetAdvanceHeight(GlyphIndex)) - (integer(YMax) - integer(YMin))) div 2;
    exit;
  end;

  // 4) Fallback for CFF (and TrueType missing metrics)
  // 4.1) 'OS/2' table
  if (OS2Table <> nil) then
  begin
    if (fsfUseTypoMetrics in OS2Table.FontSelectionFlags) then
      Result.Y := OS2Table.TypographicAscender
    else
      Result.Y := OS2Table.WindowsAscent;
  end else
  // 4.1) 'hhea' table
  if (HorizontalHeader <> nil) then
    Result.Y := HorizontalHeader.Ascent
  else
    // 5) Fallback to 'head' YMax
    Result := inherited;
end;

function TPascalTypeFontFace.GetBoundingBox: TRect;
begin
  Result.Left := HeaderTable.XMin;
  Result.Top := HeaderTable.YMax;
  Result.Right := HeaderTable.XMax;
  Result.Bottom := HeaderTable.YMin;
end;

function TPascalTypeFontFace.GetGlyphCount: Word;
begin
  Result := MaximumProfile.NumGlyphs;
end;

function TPascalTypeFontFace.GetGlyphData(Index: Integer): TCustomTrueTypeFontGlyphData;
begin
  if (GlyphTable <> nil) and (Index >= 0) and (Index < GlyphTable.GlyphDataCount) then
    Result := GlyphTable.GlyphData[Index]
  else
    Result := nil;
end;

function TPascalTypeFontFace.GetGlyphByCodePoint(ACodePoint: TPascalTypeCodePoint): Integer;
begin
  if (CharacterMap <> nil) then
    Result := CharacterMap.GetGlyphByCharacter(ACodePoint)
  else
    Result := GlyphNotDef; // Font hasn't been loaded
end;

function TPascalTypeFontFace.GetGlyphByCodePoint(ACodePoint, ANextCodePoint: TPascalTypeCodePoint;
  var AIndex: Integer): Integer;
begin
  if (CharacterMap <> nil) then
    Result := CharacterMap.GetGlyphByCharacter(ACodePoint, ANextCodePoint, AIndex)
  else
    Result := GlyphNotDef; // Font hasn't been loaded
end;

function TPascalTypeFontFace.GetGlyphExtents(GlyphID: TGlyphID; var XMin, YMin, XMax, YMax: SmallInt): Boolean;
begin
  // 1) Try 'glyf' table first if available
  // If variations are active, we prefer to calculate extents from the varied path
  // to ensure accuracy (e.g. gvar point movements).
  if (not VariationsActive) then
  begin
    var Glyph := GlyphData[GlyphID];
    if (Glyph <> nil) then
    begin
      XMin := Glyph.XMin;
      YMin := Glyph.YMin;
      XMax := Glyph.XMax;
      YMax := Glyph.YMax;
      Exit(True);
    end;
  end;

  // 2) Fallback to path (for CFF fonts)
  var CacheEntry: TPathCacheEntry;
  GetGlyphPathCacheEntry(GlyphID, CacheEntry);

  if (CacheEntry.Path = nil) then
    Exit(False);

  // Calculate extents if cache doesn't have them
  if (CacheEntry.YMax < CacheEntry.YMin) then
  begin

    Result := False;

    for var Contour in CacheEntry.Path do
      for var Point in Contour do
      begin
        if (Result) then
        begin
          XMin := Min(XMin, SmallInt(Floor(Point.XPos)));
          YMin := Min(YMin, SmallInt(Floor(Point.YPos)));
          XMax := Max(XMax, SmallInt(Ceil(Point.XPos)));
          YMax := Max(YMax, SmallInt(Ceil(Point.YPos)));
        end else
        begin
          XMin := Floor(Point.XPos);
          YMin := Floor(Point.YPos);
          XMax := Ceil(Point.XPos);
          YMax := Ceil(Point.YPos);
          Result := True;
        end;
      end;

    if (Result) then
    begin
      CacheEntry.XMin := XMin;
      CacheEntry.YMin := YMin;
      CacheEntry.XMax := XMax;
      CacheEntry.YMax := YMax;
      FPathCache[GlyphID] := CacheEntry;
    end;
  end else
  begin
    XMin := CacheEntry.XMin;
    YMin := CacheEntry.YMin;
    XMax := CacheEntry.XMax;
    YMax := CacheEntry.YMax;
    Result := True;
  end;
end;

{$if defined(PhantomPoints)}
function TPascalTypeFontFace.GetGlyphPointCount(GlyphID: TGlyphID): Integer;
begin
  Result := 0;

  var Glyph := GlyphData[GlyphID];

  if (Glyph <> nil) then
  begin
    if Glyph.IsComposite then
      Result := Glyph.GlyphCount
    else
    begin
      for var i := 0 to Glyph.ContourCount - 1 do
        Result := Result + TTrueTypeFontSimpleGlyphData(Glyph).Contour[i].PointCount;
    end;
  end;
end;
{$ifend}

function TPascalTypeFontFace.GetGlyphMetric(GlyphIndex: Word): TTrueTypeGlyphMetric;

  procedure DoGetGlyphMetric(GlyphIndex: Word; var MetricIndex: Word; Depth: integer);
  var
    Glyph: TCustomTrueTypeFontGlyphData;
    i: integer;
    CompositeGlyphData: TTrueTypeFontCompositeGlyphData;
  begin
    if (Depth > MaxCompositeGlyphDepth) then
{$ifdef FailOnCompositeGlyphTooDeep}
      raise EPascalTypeError.Create(RCStrRecursionLimitExceeded);
{$else FailOnCompositeGlyphTooDeep}
      exit;
{$endif FailOnCompositeGlyphTooDeep}

    Glyph := GlyphTable.GlyphData[GlyphIndex];

    // If glyph is a simple glyph then we will just use its index as the metric index.
    if (Glyph is TTrueTypeFontSimpleGlyphData) then
      // The default MetricIndex value has already been set by the caller.
      exit;

    // If glyph is a composite glyph, then we will either use its index or one of
    // its components index as the metric index.
    if Glyph is TTrueTypeFontCompositeGlyphData then
    begin
      // The default MetricIndex value has already been set by the caller.
      CompositeGlyphData := TTrueTypeFontCompositeGlyphData(Glyph);

      // Recursively process composite glyph components
      for i := 0 to CompositeGlyphData.GlyphCount-1 do
        if (CompositeGlyphData.Glyph[i].Flags and TPascalTypeCompositeGlyph.GLYF_USE_MY_METRICS <> 0) then
        begin
          // We will use the index of the component. Set MetricIndex and recurse.
          MetricIndex := CompositeGlyphData.Glyph[i].GlyphIndex;

          DoGetGlyphMetric(CompositeGlyphData.Glyph[i].GlyphIndex, MetricIndex, Depth + 1);

          // In theory multiple components could set USE_MY_METRICS but we
          // ignore that as it doesn't make sense.
          exit;
        end;
    end;
  end;

var
  MetricIndex: Word;
  VerticalMetricsTable: TPascalTypeVerticalMetricsTable;
begin
  Result := Default(TTrueTypeGlyphMetric);
  if (GlyphTable = nil) then
    exit;

  MetricIndex := GlyphIndex;
  DoGetGlyphMetric(GlyphIndex, MetricIndex, 0);

  Result.HorizontalMetric := FHorizontalMetrics.HorizontalMetric[MetricIndex];

  VerticalMetricsTable := TPascalTypeVerticalMetricsTable(GetTableByName(TPascalTypeVerticalMetricsTable.GetTableType));
  // TODO : Fall back to something for vertical metric if 'vmtx' isn't present
  if (VerticalMetricsTable <> nil) then
    Result.VerticalMetric := VerticalMetricsTable.VerticalMetric[MetricIndex];
end;

function TPascalTypeFontFace.DoGetGlyphPath(GlyphIndex: Word; Depth: integer): TPascalTypePath;

  procedure AppendPath(var Path: TPascalTypePath; const Append: TPascalTypePath);
  var
    NewIndex: integer;
    Contour: TPascalTypeContour;
  begin
    if (Length(Append) = 0) then
      exit;

    NewIndex := Length(Path);

    SetLength(Path, Length(Path) + Length(Append));

    for Contour in Append do
    begin
      Path[NewIndex] := Contour;
      Inc(NewIndex);
    end;
  end;

  function AffineTransformation(const Path: TPascalTypePath; const AffineTransformationMatrix: TSmallScaleMatrix; ScaleOffset: boolean): TPascalTypePath;
  const
    q: Single = 33.0 / 35536.0;
  var
    i, j: integer;
    m0, n0: Single;
    m, n: Single;
    TempX: Single;
    OffsetX, OffsetY: Single;
    Contour: TPascalTypeContour;
  begin
    SetLength(Result, Length(Path));

    // See: https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6glyf.html#COMPOUNDGLYPHS

    m0 := Max(Abs(AffineTransformationMatrix[0,0]), Abs(AffineTransformationMatrix[0,1]));
    n0 := Max(Abs(AffineTransformationMatrix[1,0]), Abs(AffineTransformationMatrix[1,1]));

    OffsetX := AffineTransformationMatrix[0,2];
    OffsetY := AffineTransformationMatrix[1,2];

    if (m0 <> 0) and (n0 <> 0) then
    begin
      if (ScaleOffset) then
      begin
        if (Abs(AffineTransformationMatrix[0,0]) - Abs(AffineTransformationMatrix[1,0]) <= q) then
          m := 2 * m0
        else
          m := m0;

        if (Abs(AffineTransformationMatrix[0,1]) - Abs(AffineTransformationMatrix[1,1]) <= q) then
          n := 2 * n0
        else
          n := n0;

        OffsetX := OffsetX * m;
        OffsetY := OffsetY * n;
      end;

      // Transform all points in path
      for i := 0 to High(Path) do
      begin
        Contour := Copy(Path[i]);
        Result[i] := Contour;
        for j := 0 to High(Contour) do
        begin
          if (ScaleOffset) then
          begin
            Contour[j].XPos := Contour[j].XPos + OffsetX;
            Contour[j].YPos := Contour[j].YPos + OffsetY;
            TempX :=           AffineTransformationMatrix[0,0] * Contour[j].XPos + AffineTransformationMatrix[1,0] * Contour[j].YPos;
            Contour[j].YPos := AffineTransformationMatrix[0,1] * Contour[j].XPos + AffineTransformationMatrix[1,1] * Contour[j].YPos;
            Contour[j].XPos := TempX;
          end else
          begin
            TempX :=           AffineTransformationMatrix[0,0] * Contour[j].XPos + AffineTransformationMatrix[1,0] * Contour[j].YPos + OffsetX;
            Contour[j].YPos := AffineTransformationMatrix[0,1] * Contour[j].XPos + AffineTransformationMatrix[1,1] * Contour[j].YPos + OffsetY;
            Contour[j].XPos := TempX;
          end;
        end;
      end;

    end else
    if (OffsetX <> 0) or (OffsetY <> 0) then
    begin
      // Simple translation
      for i := 0 to High(Path) do
      begin
        Contour := Copy(Path[i]);
        Result[i] := Contour;
        for j := 0 to High(Contour) do
        begin
          Contour[j].XPos := Contour[j].XPos + OffsetX;
          Contour[j].YPos := Contour[j].YPos + OffsetY;
        end;
      end;
    end;
  end;

  function Translate(var Path: TPascalTypePath; OffsetX, OffsetY: Single): TPascalTypePath;
  var
    i, j: integer;
    Contour: TPascalTypeContour;
  begin
    SetLength(Result, Length(Path));
    // Simple translation
    for i := 0 to High(Path) do
    begin
      Contour := Copy(Path[i]);
      Result[i] := Contour;
      for j := 0 to High(Contour) do
      begin
        Contour[j].XPos := Contour[j].XPos + OffsetX;
        Contour[j].YPos := Contour[j].YPos + OffsetY;
      end;
    end;
  end;

  function GetPointFromPath(const Path: TPascalTypePath; PointIndex: integer): TFloatPoint;
  begin
    Result.X := 0;
    Result.Y := 0;
    var CurrentIndex := 0;
    for var i := 0 to High(Path) do
    begin
      if (PointIndex < CurrentIndex + Length(Path[i])) then
      begin
        var p := Path[i][PointIndex - CurrentIndex];
        Result.X := p.XPos;
        Result.Y := p.YPos;
        break;
      end;

      Inc(CurrentIndex, Length(Path[i]));
    end;
  end;

  function GetCompositeGlyphPath(ParentGlyph: TTrueTypeFontCompositeGlyphData; const ADeltas: TArray<TFloatPoint>): TPascalTypePath;
  var
    i: integer;
    CompositeGlyph: TPascalTypeCompositeGlyph;
    GlyphPath: TPascalTypePath;
    ScaleOffset: boolean;
  begin
    SetLength(Result, 0);
    // Decompose compound ParentGlyph
    for i := 0 to ParentGlyph.GlyphCount-1 do
    begin
      CompositeGlyph := ParentGlyph.Glyph[i];

      // Recurse
      GlyphPath := DoGetGlyphPath(CompositeGlyph.GlyphIndex, Depth + 1);

      if (CompositeGlyph.HasAffineTransformationMatrix) then
      begin
        // Apple uses GLYF_SCALED_COMPONENT_OFFSET: First translate, then scale
        // Microsoft uses GLYF_UNSCALED_COMPONENT_OFFSET: First scale, then translate
        if (CompositeGlyph.Flags and TPascalTypeCompositeGlyph.GLYF_SCALED_COMPONENT_OFFSET <> 0) then
          ScaleOffset := True
        else
        if (CompositeGlyph.Flags and TPascalTypeCompositeGlyph.GLYF_UNSCALED_COMPONENT_OFFSET <> 0) then
          ScaleOffset := False
        else
{$IF Defined(MSWINDOWS)}
          ScaleOffset := False;
{$ELSEIF Defined(OSX)}
          ScaleOffset := True;
{$ELSE}
          ScaleOffset := False;
{$IFEND}

        GlyphPath := AffineTransformation(GlyphPath, CompositeGlyph.AffineTransformationMatrix, ScaleOffset);
      end else
      begin
        var OffsetX, OffsetY: Single;

        if (CompositeGlyph.Flags and TPascalTypeCompositeGlyph.GLYF_ARGS_ARE_XY_VALUES <> 0) then
        begin
          OffsetX := CompositeGlyph.OffsetX;
          OffsetY := CompositeGlyph.OffsetY;

          if (ADeltas <> nil) and (i < Length(ADeltas)) then
          begin
            OffsetX := OffsetX + ADeltas[i].X;
            OffsetY := OffsetY + ADeltas[i].Y;
          end;
        end else
        begin
          // Point-to-point alignment
          var ChildPoint := GetPointFromPath(GlyphPath, CompositeGlyph.ChildGlyphPointIndex);
          var ParentPoint := GetPointFromPath(Result, CompositeGlyph.ParentGlyphPointIndex);
          OffsetX := ParentPoint.X - ChildPoint.X;
          OffsetY := ParentPoint.Y - ChildPoint.Y;
        end;

        GlyphPath := Translate(GlyphPath, OffsetX, OffsetY);
      end;

      AppendPath(Result, GlyphPath);
    end;
  end;

var
  Glyph: TCustomTrueTypeFontGlyphData;
begin
  if (Depth > MaxCompositeGlyphDepth) then
{$ifdef FailOnCompositeGlyphTooDeep}
    raise EPascalTypeError.Create(RCStrRecursionLimitExceeded);
{$else FailOnCompositeGlyphTooDeep}
    Exit(nil);
{$endif FailOnCompositeGlyphTooDeep}

  Glyph := TCustomTrueTypeFontGlyphData(GlyphData[GlyphIndex]);

  if (Glyph is TTrueTypeFontSimpleGlyphData) then
  begin
    var SimpleGlyph := TTrueTypeFontSimpleGlyphData(Glyph);
    Result := SimpleGlyph.Path;

    // Apply variations
    if (VariationsActive) and (Length(VariationEngine.NormalizedCoordinates) > 0) then
    begin
      var NumPoints := 0;
      var ContourEndPoints: TArray<Integer>;
      SetLength(ContourEndPoints, Length(Result));
      for var i := 0 to High(Result) do
      begin
        Inc(NumPoints, Length(Result[i]));
        ContourEndPoints[i] := NumPoints - 1;
      end;

      var DefaultPoints: TArray<TFloatPoint>;
      SetLength(DefaultPoints, NumPoints + NUM_PHANTOM_POINTS);
      var PointIndex := 0;
      for var i := 0 to High(Result) do
        for var j := 0 to High(Result[i]) do
        begin
          DefaultPoints[PointIndex].X := Result[i][j].XPos;
          DefaultPoints[PointIndex].Y := Result[i][j].YPos;
          Inc(PointIndex);
        end;
      // Phantom points are indices NumPoints to NumPoints+3.
      // We don't have their default coordinates easily available here without calling other methods,
      // but IUP typically only applies to outline points.
      // Set them to 0 for now.
      for var i := NumPoints to NumPoints + NUM_PHANTOM_POINTS - 1 do
      begin
        DefaultPoints[i].X := 0;
        DefaultPoints[i].Y := 0;
      end;

      var Deltas := VariationEngine.GetGlyphDeltas(GlyphIndex, DefaultPoints, ContourEndPoints);

      if (Deltas <> nil) then
      begin
        // Copy path before modifying
        // TODO : Why not just modify Result in-place?
        var NewPath: TPascalTypePath;
        SetLength(NewPath, Length(Result));
        PointIndex := 0;
        for var i := 0 to High(Result) do
        begin
          NewPath[i] := Copy(Result[i]);
          for var j := 0 to High(NewPath[i]) do
          begin
            NewPath[i][j].XPos := NewPath[i][j].XPos + Deltas[PointIndex].X;
            NewPath[i][j].YPos := NewPath[i][j].YPos + Deltas[PointIndex].Y;
            Inc(PointIndex);
          end;
        end;
        Result := NewPath;
      end;
    end;
  end else
  if Glyph is TTrueTypeFontCompositeGlyphData then
  begin
    var CompositeGlyphData := TTrueTypeFontCompositeGlyphData(Glyph);
    var Deltas: TArray<TFloatPoint> := nil;
    if (VariationsActive) and (Length(VariationEngine.NormalizedCoordinates) > 0) then
    begin
       var DummyDefaultPoints: TArray<TFloatPoint>;
       SetLength(DummyDefaultPoints, CompositeGlyphData.GlyphCount + NUM_PHANTOM_POINTS);
       Deltas := VariationEngine.GetGlyphDeltas(GlyphIndex, DummyDefaultPoints, nil);
    end;

    // Recursively fetch glyph contours
    Result := GetCompositeGlyphPath(CompositeGlyphData, Deltas);
  end else
    Result := nil;
end;

procedure TPascalTypeFontFace.GetGlyphPathCacheEntry(GlyphIndex: Word; var CacheEntry: TPathCacheEntry);
begin
  if (FPathCache <> nil) then
  begin
    if (FPathCache.TryGetValue(GlyphIndex, CacheEntry)) then
      exit;
  end;

  // Signal that Min/Max isn't valid
  CacheEntry.XMin := High(SmallInt);
  CacheEntry.YMin := High(SmallInt);
  CacheEntry.XMax := Low(SmallInt);
  CacheEntry.YMax := Low(SmallInt);

  if (GlyphTable <> nil) then
    CacheEntry.Path := DoGetGlyphPath(GlyphIndex, 0)
  else
  begin
    var CFFTable := TPascalTypeCompactFontFormatTable(GetTableByName('CFF '));

    if (CFFTable <> nil) then
      CacheEntry.Path := CFFTable.GetGlyphPath(GlyphIndex)
    else
    begin
      var CFF2Table := TPascalTypeCompactFontFormat2Table(GetTableByName('CFF2'));

      if (CFF2Table <> nil) then
        CacheEntry.Path := CFF2Table.GetGlyphPath(GlyphIndex)
      else
        CacheEntry.Path := nil;
    end;

    // CFF scaling (parity with glyf's design units)
    if (CacheEntry.Path <> nil) and (HeaderTable <> nil) then
    begin
      var UnitsPerEm := HeaderTable.UnitsPerEm;

      if (UnitsPerEm <> 1000) then
      begin
        var Scale: Single := UnitsPerEm / 1000;

        for var i := 0 to High(CacheEntry.Path) do
          for var j := 0 to High(CacheEntry.Path[i]) do
          begin
            CacheEntry.Path[i][j].XPos := CacheEntry.Path[i][j].XPos * Scale;
            CacheEntry.Path[i][j].YPos := CacheEntry.Path[i][j].YPos * Scale;
          end;
      end;
    end;
  end;

  // Add path (valid or not) to cache
  if (FPathCache = nil) then
    FPathCache := TPathCache.Create;

  FPathCache.Add(GlyphIndex, CacheEntry);
end;

function TPascalTypeFontFace.GetGlyphPath(GlyphIndex: Word): TPascalTypePath;
begin
  var CacheEntry: TPathCacheEntry;
  GetGlyphPathCacheEntry(GlyphIndex, CacheEntry);
  Result := CacheEntry.Path;
end;

function TPascalTypeFontFace.GetKerning(Last, Next: Word): Word;
// var
// KernTable : TPascalType
begin
  Result := 0;
  // GetTableByName()
end;

function TPascalTypeFontFace.GetPanose: TCustomPascalTypePanoseTable;
begin
  if (FOS2Table <> nil) then
    Result := FOS2Table.Panose
  else
    Result := nil;
end;

procedure TPascalTypeFontFace.TableAdded(ATable: TCustomPascalTypeNamedTable);
begin
  inherited;

  case ATable.TableType.AsCardinal of
    ttHmtx:
      FHorizontalMetrics := ATable as TPascalTypeHorizontalMetricsTable;

    ttVmtx:
      FVerticalMetrics := ATable as TPascalTypeVerticalMetricsTable;

    ttCmap:
      FCharacterMap := ATable as TPascalTypeCharacterMapTable;

    ttGlyf:
      FGlyphData := ATable as TTrueTypeFontGlyphDataTable;

    ttOS2:
      FOS2Table := ATable as TPascalTypeOS2Table;
  end;
end;

procedure TPascalTypeFontFace.DoClear;
begin
  inherited;

  FGlyphData := nil;
  FHorizontalMetrics := nil;
  FCharacterMap := nil;
  FOS2Table := nil;
  FVerticalMetrics := nil;
end;

procedure TPascalTypeFontFace.DoClearCache;
begin
  inherited;

  if (FPathCache <> nil) then
    FPathCache.Clear;
end;

procedure TPascalTypeFontFace.Loaded;
begin
  inherited;

  if (Version = sfntVersionTrueType) and (OS2Table = nil) then
    raise EPascalTypeError.Create(RCStrNoOS2Table);

  if (HorizontalMetrics = nil) then
    raise EPascalTypeError.Create(RCStrNoHorizontalMetricsTable);

  if (CharacterMap = nil) then
    raise EPascalTypeError.Create(RCStrNoCharacterMapTable);

  // Strangely, the glyf table is optional
  (*
  if (GlyphTable = nil) then
    raise EPascalTypeError.Create(RCStrNoGlyphDataTable);
  *)
end;

procedure TPascalTypeFontFace.SaveToStream(Stream: TStream);
(*
var
  StartPos: Int64;
  DirectoryTable: TPascalTypeDirectoryTable;
  TableIndex    : Integer;
  NamedTable    : TCustomPascalTypeNamedTable;
  MemoryStream  : TMemoryStream;
*)
begin
(* TODO
  StartPos := Stream.Position;
  // create directory table
  DirectoryTable := TPascalTypeDirectoryTable.Create(RootTable);

  try
    DirectoryTable.ClearAndBuildRequiredEntries;

    // build directory table
    for TableIndex := 0 to AllTables.Count-1 do
      DirectoryTable.AddTableEntry(AllTables[TableIndex].TableType);

    // write temporary directory to determine its size
    DirectoryTable.SaveToStream(Stream);

    // build directory table
    for TableIndex := 0 to AllTables.Count-1 do
    begin
      NamedTable := GetTableByName(DirectoryTable.TableList[TableIndex].TableType);
      Assert(NamedTable <> nil);

      DirectoryTable.TableList[TableIndex].Offset := Stream.Position;

      MemoryStream := TMemoryStream.Create;
      try
        NamedTable.SaveToStream(MemoryStream);

        // store original stream length
        DirectoryTable.TableList[TableIndex].Length := MemoryStream.Size;

        // extend to a modulo 4 size
        // TODO : Bad idea; The memory isn't cleared
        MemoryStream.Size := 4 * ((DirectoryTable.TableList[TableIndex].Length + 3) div 4);

        // calculate checksum
        MemoryStream.Position := 0;
        DirectoryTable.TableList[TableIndex].Checksum := CalculateCheckSum(MemoryStream, MemoryStream.Size div SizeOf(Cardinal));

        // copy streams
        MemoryStream.Position := 0;
        Stream.CopyFrom(MemoryStream, DirectoryTable.TableList[TableIndex].Length);
      finally
        MemoryStream.Free;
      end;
    end;

    // reset stream position
    Stream.Position := StartPos;

    // write final directory
    DirectoryTable.SaveToStream(Stream);
  finally
    DirectoryTable.Free;
  end;
*)
end;

end.