PascalType.Tables.OpenType.GDEF.pas

unit PascalType.Tables.OpenType.GDEF;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//                      'GDEF' table type                                     //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  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}

uses
  Generics.Collections,
  Generics.Defaults,
  Classes,
  PascalType.Types,
  PascalType.Classes,
  PascalType.Tables,
  PascalType.Tables.OpenType,
  PascalType.Tables.OpenType.ClassDefinition,
  PascalType.Tables.OpenType.Common,
  PascalType.Tables.OpenType.Common.Variation;

//------------------------------------------------------------------------------
//
//              TOpenTypeGlyphDefinitionTable
//
//------------------------------------------------------------------------------
type
  TOpenTypeGlyphDefinitionTable = class(TCustomOpenTypeVersionedNamedTable)
  private
    FGlyphClassDef      : TCustomOpenTypeClassDefinitionTable; // Class definition table for glyph type
    FAttachmentListOffset : Word;                                // Offset to list of glyphs with attachment points-from beginning of GDEF header (may be NULL)
    FLigatureCaretListOffset : Word;                                // Offset to list of positioning points for ligature carets-from beginning of GDEF header (may be NULL)
    FMarkAttachClassDef : TCustomOpenTypeClassDefinitionTable; // Class definition table for mark attachment type (may be nil)
    FMarkGlyphSetsDef   : TOpenTypeMarkGlyphSetTable;          // Table of mark set definitions (may be nil)
    FItemVariationStore : TItemVariationStore;
  public
    constructor Create(AParent: TCustomPascalTypeTable); override;
    destructor Destroy; override;

    class function GetTableType: TTableType; override;

    procedure Assign(Source: TPersistent); override;

    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    procedure SaveToStream(Stream: TStream); override;

    property GlyphClassDefinition: TCustomOpenTypeClassDefinitionTable read FGlyphClassDef;
    property MarkAttachmentClassDefinition: TCustomOpenTypeClassDefinitionTable read FMarkAttachClassDef;
    property MarkGlyphSet: TOpenTypeMarkGlyphSetTable read FMarkGlyphSetsDef;
    property ItemVariationStore: TItemVariationStore read FItemVariationStore;
  end;


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

implementation

uses
  SysUtils,
  PascalType.ResourceStrings;

//------------------------------------------------------------------------------
//
//              TOpenTypeGlyphDefinitionTable
//
//------------------------------------------------------------------------------
constructor TOpenTypeGlyphDefinitionTable.Create(AParent: TCustomPascalTypeTable);
const
  CGlyphDefinitionDefaultVersion: TFixedPoint = (Fixed: $00010002);
begin
  inherited;
  Version := CGlyphDefinitionDefaultVersion;
end;

destructor TOpenTypeGlyphDefinitionTable.Destroy;
begin
  FreeAndNil(FGlyphClassDef);
  FreeAndNil(FMarkAttachClassDef);
  FreeAndNil(FMarkGlyphSetsDef);
  FreeAndNil(FItemVariationStore);
  inherited;
end;

procedure TOpenTypeGlyphDefinitionTable.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TOpenTypeGlyphDefinitionTable then
  begin
    FAttachmentListOffset := TOpenTypeGlyphDefinitionTable(Source).FAttachmentListOffset;
    FLigatureCaretListOffset := TOpenTypeGlyphDefinitionTable(Source).FLigatureCaretListOffset;

    if (TOpenTypeGlyphDefinitionTable(Source).FMarkGlyphSetsDef <> nil) then
    begin
      if (FMarkGlyphSetsDef = nil) then
        FMarkGlyphSetsDef := TOpenTypeMarkGlyphSetTable.Create(Self);
      FMarkGlyphSetsDef.Assign(TOpenTypeGlyphDefinitionTable(Source).FMarkGlyphSetsDef);
    end else
      FreeAndNil(FMarkGlyphSetsDef);

    if (TOpenTypeGlyphDefinitionTable(Source).FGlyphClassDef <> nil) then
    begin
      if (FGlyphClassDef <> nil) and (FGlyphClassDef.ClassType <> TOpenTypeGlyphDefinitionTable(Source).FGlyphClassDef.ClassType) then
        FreeAndNil(FGlyphClassDef);
      if (FGlyphClassDef = nil) then
        FGlyphClassDef := TOpenTypeClassDefinitionTableClass(TOpenTypeGlyphDefinitionTable(Source).FGlyphClassDef.ClassType).Create(Self);
      FGlyphClassDef.Assign(TOpenTypeGlyphDefinitionTable(Source).FGlyphClassDef);
    end else
      FreeAndNil(FGlyphClassDef);

    if (TOpenTypeGlyphDefinitionTable(Source).FMarkAttachClassDef <> nil) then
    begin
      if (FMarkAttachClassDef <> nil) and (FMarkAttachClassDef.ClassType <> TOpenTypeGlyphDefinitionTable(Source).FMarkAttachClassDef.ClassType) then
        FreeAndNil(FMarkAttachClassDef);
      if (FMarkAttachClassDef = nil) then
        FMarkAttachClassDef := TOpenTypeClassDefinitionTableClass(TOpenTypeGlyphDefinitionTable(Source).FMarkAttachClassDef.ClassType).Create(Self);
      FMarkAttachClassDef.Assign(TOpenTypeGlyphDefinitionTable(Source).FMarkAttachClassDef);
    end else
      FreeAndNil(FMarkAttachClassDef);
  end;
end;

class function TOpenTypeGlyphDefinitionTable.GetTableType: TTableType;
begin
  Result.AsAnsiChar := 'GDEF';
end;

procedure TOpenTypeGlyphDefinitionTable.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  var StartPos := Stream.Position;

  inherited;

  // +----------+---------------------------+--------------------------------------------------------------------------+
  // | Type     | Name                      | Description                                                              |
  // +==========+===========================+==========================================================================+
  // | uint16   | majorVersion              | Major version of the GDEF table - set to 1.                              |
  // +----------+---------------------------+--------------------------------------------------------------------------+
  // | uint16   | minorVersion              | Minor version of the GDEF table - set to 0, 2, or 3.                     |
  // +----------+---------------------------+--------------------------------------------------------------------------+
  // | Offset16 | glyphClassDefOffset       | Offset to class definition table for glyph type.                         |
  // +----------+---------------------------+--------------------------------------------------------------------------+
  // | Offset16 | attachListOffset          | Offset to list of glyphs with attachment points.                         |
  // +----------+---------------------------+--------------------------------------------------------------------------+
  // | Offset16 | ligCaretListOffset        | Offset to list of positioning points for ligature carets.                |
  // +----------+---------------------------+--------------------------------------------------------------------------+
  // | Offset16 | markAttachClassDefOffset  | Offset to class definition table for mark attachment type.               |
  // +----------+---------------------------+--------------------------------------------------------------------------+

  // Check version already read
  if Version.Value <> 1 then
    raise EPascalTypeError.Create(RCStrUnsupportedVersion);

  // Check if table is complete
  if Stream.Position + 4*SizeOf(Word) > Stream.Size then
    raise EPascalTypeError.Create(RCStrTableIncomplete);

  // Glyph class definition offset
  var GlyphClassDefinitionOffset := BigEndianValue.ReadWord(Stream);

  // Attachment list offset
  FAttachmentListOffset := BigEndianValue.ReadWord(Stream);

  // Ligature caret list offset
  FLigatureCaretListOffset := BigEndianValue.ReadWord(Stream);

  // Mark attachment class definition offset
  var MarkAttachmentClassDefOffset := BigEndianValue.ReadWord(Stream);

  var MarkGlyphSetsDefinitionsOffset: Word;
  var ItemVariationStoreOffset: Word;

  if (Version.Fract >= 2) then
  begin
    // Mark glyph set definitions offset
    MarkGlyphSetsDefinitionsOffset := BigEndianValue.ReadWord(Stream);

    if (Version.Fract >= 3) then
    begin
      // Item variation store offset
      ItemVariationStoreOffset := BigEndianValue.ReadWord(Stream);
    end else
      ItemVariationStoreOffset := 0;

  end else
  begin
    MarkGlyphSetsDefinitionsOffset := 0;
    ItemVariationStoreOffset := 0;
  end;


  FreeAndNil(FGlyphClassDef);
  if GlyphClassDefinitionOffset <> 0 then
  begin
    Stream.Position := StartPos + GlyphClassDefinitionOffset;

    var Value16 := BigEndianValue.ReadWord(Stream);
    Stream.Seek(-SizeOf(Word), soFromCurrent);

    var ClassDefinitionClass := TCustomOpenTypeClassDefinitionTable.ClassByFormat(TClassDefinitionFormat(Value16));

    if (ClassDefinitionClass = nil) then
      raise EPascalTypeError.Create(RCStrUnknownClassDefinition);

    FGlyphClassDef := ClassDefinitionClass.Create(Self);

    if (FGlyphClassDef <> nil) then
      FGlyphClassDef.LoadFromStream(Stream);
  end;


  FreeAndNil(FMarkAttachClassDef);
  if MarkAttachmentClassDefOffset <> 0 then
  begin
    Stream.Position := StartPos + MarkAttachmentClassDefOffset;

    var Value16 := BigEndianValue.ReadWord(Stream);
    Stream.Seek(-SizeOf(Word), soFromCurrent);

    var ClassDefinitionClass := TCustomOpenTypeClassDefinitionTable.ClassByFormat(TClassDefinitionFormat(Value16));

    if (ClassDefinitionClass = nil) then
      raise EPascalTypeError.Create(RCStrUnknownClassDefinition);

    FMarkAttachClassDef := ClassDefinitionClass.Create(Self);

    if (FMarkAttachClassDef <> nil) then
      FMarkAttachClassDef.LoadFromStream(Stream);
  end;


  if MarkGlyphSetsDefinitionsOffset <> 0 then
  begin
    Stream.Position := StartPos + MarkGlyphSetsDefinitionsOffset;

    if (FMarkGlyphSetsDef = nil) then
      FMarkGlyphSetsDef := TOpenTypeMarkGlyphSetTable.Create(Self);

    FMarkGlyphSetsDef.LoadFromStream(Stream);
  end else
    FreeAndNil(FMarkGlyphSetsDef);

  if ItemVariationStoreOffset <> 0 then
  begin
    Stream.Position := StartPos + ItemVariationStoreOffset;

    if (FItemVariationStore = nil) then
      FItemVariationStore := TItemVariationStore.Create(Self);

    FItemVariationStore.LoadFromStream(Stream);
  end else
    FreeAndNil(FItemVariationStore);
end;

procedure TOpenTypeGlyphDefinitionTable.SaveToStream(Stream: TStream);
begin
  inherited;

  // remember start position as position minus version aready written
  var StartPos := Stream.Position - 4;

  // reset offset array to zero
  var Offsets : array [0..4] of Word;
  FillChar(Offsets[0], 5 * SizeOf(Word), 0);

  // skip directory for now
  Stream.Seek(SizeOf(Offsets), soCurrent);

  // write glyph class definition
  if (FGlyphClassDef <> nil) then
  begin
    Offsets[0] := Word(Stream.Position - StartPos);
    FGlyphClassDef.SaveToStream(Stream);
  end;

  (*
    // write attachment list
    if (FAttachmentListOffset <> nil) then
    begin
    Offsets[1] := Word(Stream.Position - StartPos);
    FAttachmentListOffset.SaveToStream(Stream);
    end;

    // write ligature caret list
    if (FLigatureCaretListOffset <> nil) then
    begin
    Offsets[2] := Word(Stream.Position - StartPos);
    FLigatureCaretListOffset.SaveToStream(Stream);
    end;
  *)

  // write mark attachment class definition
  if (FMarkAttachClassDef <> nil) then
  begin
    Offsets[3] := Word(Stream.Position - StartPos);
    FMarkAttachClassDef.SaveToStream(Stream);
  end;

  // write mark glyph set definition
  if (FMarkGlyphSetsDef <> nil) then
  begin
    Offsets[4] := Word(Stream.Position - StartPos);
    FMarkGlyphSetsDef.SaveToStream(Stream);
  end;

  // skip directory for now
  Stream.Position := StartPos + SizeOf(TFixedPoint);

  // write directory

  // write glyph class definition
  BigEndianValue.WriteWord(Stream, Offsets[0]);

  // write attach list
  BigEndianValue.WriteWord(Stream, Offsets[1]);

  // write ligature caret list
  BigEndianValue.WriteWord(Stream, Offsets[2]);

  // write mark attach class definition
  BigEndianValue.WriteWord(Stream, Offsets[3]);

  // write mark glyph set
  BigEndianValue.WriteWord(Stream, Offsets[4]);
end;

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

initialization

  PascalTypeTableClasses.RegisterTable(TOpenTypeGlyphDefinitionTable);

end.