PascalType.Tables.Apple.Bitmap.pas

unit PascalType.Tables.Apple.Bitmap;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  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
  Classes,
  SysUtils,
  PascalType.Types,
  PascalType.Classes,
  PascalType.Tables,
  PascalType.Tables.Shared,
  PascalType.Tables.TrueType.head,
  PascalType.Tables.Apple;

type
  // table 'bdat'

  // not entirely implemented, for more details see
  // http://developer.apple.com/fonts/TTRefMan/RM06/Chap6bdat.html
  TPascalTypeBitmapDataTable = class(TCustomPascalTypeNamedVersionTable)
  public
    class function GetTableType: TTableType; override;

    procedure Assign(Source: TPersistent); override;

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


  // table 'bhed'

  // not entirely implemented, for more details see
  // http://developer.apple.com/fonts/TTRefMan/RM06/Chap6bhed.html
  TPascalTypeBitmapHeaderTable = class(TPascalTypeHeaderTable)
  public
    class function GetTableType: TTableType; override;
  end;


  // table 'bloc'

  // not entirely implemented, for more details see
  // http://developer.apple.com/fonts/TTRefMan/RM06/Chap6bloc.html
  TPascalTypeBitmapLocationTable = class(TCustomPascalTypeNamedVersionTable)
  private
    FBitmapSizeList: TPascalTypeTableList<TPascalTypeBitmapSizeTable>;
    function GetBitmapSizeTable(Index: Integer): TPascalTypeBitmapSizeTable;
    function GetBitmapSizeTableCount: Integer;
  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 BitmapSizeTableCount: Integer read GetBitmapSizeTableCount;
    property BitmapSizeTable[Index: Integer]: TPascalTypeBitmapSizeTable read GetBitmapSizeTable;
  end;

implementation

uses
  PascalType.ResourceStrings;

{ TPascalTypeBitmapDataTable }

procedure TPascalTypeBitmapDataTable.Assign(Source: TPersistent);
begin
  inherited;

  if Source is Self.ClassType then
    // TPascalTypeBitmapDataTable(Source)
    ;
end;

class function TPascalTypeBitmapDataTable.GetTableType: TTableType;
begin
  Result := 'bdat';
end;

procedure TPascalTypeBitmapDataTable.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;

  // +----------+---------+-------------------------------------------------------------------------+
  // | Type     | Name    | Description                                                             |
  // +==========+=========+=========================================================================+
  // | Fixed    | version | Table version number (=0x00010000 or 0x00020000).                       |
  // +----------+---------+-------------------------------------------------------------------------+
end;

procedure TPascalTypeBitmapDataTable.SaveToStream(Stream: TStream);
begin
  inherited;
  raise EPascalTypeNotImplemented.Create(RCStrNotImplemented);
end;


{ TPascalTypeBitmapHeaderTable }

class function TPascalTypeBitmapHeaderTable.GetTableType: TTableType;
begin
  Result := 'bhed';
end;


{ TPascalTypeBitmapLocationTable }

constructor TPascalTypeBitmapLocationTable.Create(AParent: TCustomPascalTypeTable);
begin
  inherited;
  FBitmapSizeList := TPascalTypeTableList<TPascalTypeBitmapSizeTable>.Create;
end;

destructor TPascalTypeBitmapLocationTable.Destroy;
begin
  FreeAndNil(FBitmapSizeList);
  inherited;
end;

procedure TPascalTypeBitmapLocationTable.Assign(Source: TPersistent);
begin
  inherited;

  if Source is TPascalTypeBitmapLocationTable then
    FBitmapSizeList.Assign(TPascalTypeBitmapLocationTable(Source).FBitmapSizeList);
end;

function TPascalTypeBitmapLocationTable.GetBitmapSizeTable(Index: Integer): TPascalTypeBitmapSizeTable;
begin
  if (Index < 0) or (Index >= FBitmapSizeList.Count) then
    raise EPascalTypeError.CreateFmt(RCStrIndexOutOfBounds, [Index]);
  Result := FBitmapSizeList[Index];
end;

function TPascalTypeBitmapLocationTable.GetBitmapSizeTableCount: Integer;
begin
  Result := FBitmapSizeList.Count;
end;

class function TPascalTypeBitmapLocationTable.GetTableType: TTableType;
begin
  Result := 'bloc';
end;

procedure TPascalTypeBitmapLocationTable.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  BitmapSizeCount: Cardinal;
  i: Integer;
  BitmapSizeTable: TPascalTypeBitmapSizeTable;
begin
  inherited;

  // +----------+----------+-------------------------------------------------------------------------+
  // | Type     | Name     | Description                                                             |
  // +==========+==========+=========================================================================+
  // | Fixed    | version  | Table version number (=0x00010000 or 0x00020000).                       |
  // +----------+----------+-------------------------------------------------------------------------+
  // | uint32   | numSizes | Number of strikeout sizes.                                              |
  // +----------+----------+-------------------------------------------------------------------------+

  // read number of BitmapSize tables
  BitmapSizeCount := BigEndianValue.ReadCardinal(Stream);

  // read bitmap size tables
  for i := 0 to BitmapSizeCount - 1 do
  begin
    // create bitmap size table
    // add bitmap size table
    BitmapSizeTable := FBitmapSizeList.Add;

    // load bitmap size table
    BitmapSizeTable.LoadFromStream(Stream);
  end;
end;

procedure TPascalTypeBitmapLocationTable.SaveToStream(Stream: TStream);
var
  i: Integer;
begin
  inherited;

  // write number of BitmapSize tables
  BigEndianValue.WriteCardinal(Stream, FBitmapSizeList.Count);

  // write bitmap size tables
  for i := 0 to FBitmapSizeList.Count - 1 do
    // save bitmap size table to stream
    FBitmapSizeList[i].SaveToStream(Stream);
end;

initialization
  PascalTypeTableClasses.RegisterTables([
    TPascalTypeBitmapDataTable,
    TPascalTypeBitmapHeaderTable,
    TPascalTypeBitmapLocationTable]);

end.