PascalType.Tables.OpenType.PostScript.VORG.pas

unit PascalType.Tables.OpenType.PostScript.VORG;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  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.Defaults,
  Generics.Collections,
  Classes,
  SysUtils,
  PascalType.Types,
  PascalType.Classes,
  PascalType.Tables;

type
  TVertOriginYMetrics = packed record
    GlyphIndex: Word; // Glyph index.
    VertOriginY: SmallInt; // Y coordinate, in the font's design coordinate system, of the vertical origin of glyph with index glyphIndex.
  end;

  TPascalTypeVerticalOriginTable = class(TCustomPascalTypeNamedTable)
  private class var
    FComparer: IComparer<TVertOriginYMetrics>;

  private
    class destructor Destroy;

  private
    FMajorVersion      : Word; // Major version (starting at 1). Set to 1.
    FMinorVersion      : Word; // Minor version (starting at 0). Set to 0.
    FDefaultVertOriginY: SmallInt; // The y coordinate of a glyph's vertical origin, in the font's design coordinate system, to be used if no entry is present for the glyph in the vertOriginYMetrics array.
    FVertOriginYMetrics: TArray<TVertOriginYMetrics>;

  public
    constructor Create(AParent: TCustomPascalTypeTable); override;

    class function GetTableType: TTableType; override;

    procedure Assign(Source: TPersistent); override;

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

    function GetYOrigin(GlyphIndex: Word): SmallInt;

    property DefaultVertOriginY: SmallInt read FDefaultVertOriginY write FDefaultVertOriginY;
  end;

implementation

{ TPascalTypeVerticalOriginTable }

constructor TPascalTypeVerticalOriginTable.Create(AParent: TCustomPascalTypeTable);
begin
  inherited;
  FMajorVersion := 1;
end;

class destructor TPascalTypeVerticalOriginTable.Destroy;
begin
  FComparer := nil;
end;

procedure TPascalTypeVerticalOriginTable.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPascalTypeVerticalOriginTable then
  begin
    FMajorVersion := TPascalTypeVerticalOriginTable(Source).FMajorVersion;
    FMinorVersion := TPascalTypeVerticalOriginTable(Source).FMinorVersion;
    FDefaultVertOriginY := TPascalTypeVerticalOriginTable(Source).FDefaultVertOriginY;
    FVertOriginYMetrics := Copy(TPascalTypeVerticalOriginTable(Source).FVertOriginYMetrics);
  end;
end;

class function TPascalTypeVerticalOriginTable.GetTableType: TTableType;
begin
  Result := 'VORG';
end;

procedure TPascalTypeVerticalOriginTable.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  Index: Integer;
begin
  inherited;

  // +----------+-----------------------+-------------------------------------------------------------------------+
  // | Type     | Name                  | Description                                                             |
  // +==========+=======================+=========================================================================+
  // | uint16   | majorVersion          | Major version (=1).                                                     |
  // +----------+-----------------------+-------------------------------------------------------------------------+
  // | uint16   | minorVersion          | Minor version (=0).                                                     |
  // +----------+-----------------------+-------------------------------------------------------------------------+
  // | int16    | defaultVertOriginY      | The default vertical origin y-coordinate.                             |
  // +----------+-----------------------+-------------------------------------------------------------------------+
  // | uint16   | numVertOriginYMetrics   | Number of vertical origin y-coordinate metrics.                       |
  // +----------+-----------------------+-------------------------------------------------------------------------+

  // read major version
  FMajorVersion := BigEndianValue.ReadWord(Stream);

  // read minor version
  FMinorVersion := BigEndianValue.ReadWord(Stream);

  // read default vertical origin
  FDefaultVertOriginY := BigEndianValue.ReadSmallInt(Stream);

  // read vertical origin y-metrics
  SetLength(FVertOriginYMetrics, BigEndianValue.ReadWord(Stream));

  for Index := 0 to High(FVertOriginYMetrics) do
  begin
    // read glyph index
    FVertOriginYMetrics[Index].GlyphIndex := BigEndianValue.ReadWord(Stream);

    // read vertical y origin
    FVertOriginYMetrics[Index].VertOriginY := BigEndianValue.ReadSmallInt(Stream);
  end;
end;

procedure TPascalTypeVerticalOriginTable.SaveToStream(Stream: TStream);
var
  Index: Integer;
begin
  inherited;

  // write major version
  BigEndianValue.WriteWord(Stream, FMajorVersion);

  // write minor version
  BigEndianValue.WriteWord(Stream, FMinorVersion);

  // write default vertical origin
  BigEndianValue.WriteSmallInt(Stream, FDefaultVertOriginY);

  // write vertical origin y-metrics
  BigEndianValue.WriteWord(Stream, Length(FVertOriginYMetrics));

  for Index := 0 to High(FVertOriginYMetrics) do
  begin
    // write glyph index
    BigEndianValue.WriteWord(Stream, FVertOriginYMetrics[Index].GlyphIndex);

    // write vertical y origin
    BigEndianValue.WriteSmallInt(Stream, FVertOriginYMetrics[Index].VertOriginY);
  end;
end;

function TPascalTypeVerticalOriginTable.GetYOrigin(GlyphIndex: Word): SmallInt;
begin
  if (FComparer = nil) then
    FComparer := TComparer<TVertOriginYMetrics>.Construct(
      function(const ATableItem, ASearchItem: TVertOriginYMetrics): integer
      begin
        Result := integer(ATableItem.GlyphIndex) - integer(ASearchItem.GlyphIndex);
      end);

  var SearchItem: TVertOriginYMetrics;
  SearchItem.GlyphIndex := GlyphIndex;
  var Index: integer;

  if (TArray.BinarySearch<TVertOriginYMetrics>(FVertOriginYMetrics, SearchItem, Index, FComparer)) then
    Result := FVertOriginYMetrics[Index].VertOriginY
  else
    Result := FDefaultVertOriginY;
end;

initialization

  PascalTypeTableClasses.RegisterTables([TPascalTypeVerticalOriginTable]);

end.