Changeset 472 for GraphicTest/Packages/bgrabitmap/bgratypewriter.pas

Timestamp:

Apr 9, 2015, 9:58:36 PM (9 years ago)

Author:

chronos

Message:

• Fixed: Use csOpaque control style also to Image, PaintBox and OpenGLControl.
• Modified: Change size of test frame with SpinEdits as delayed using timer.
• Updated: BRGABitmap package to version 8.1.

File:

• GraphicTest/Packages/bgrabitmap/bgratypewriter.pas (modified) (25 diffs)

GraphicTest/Packages/bgrabitmap/bgratypewriter.pas

@@ -19 +19 @@
   protected
     FIdentifier: string;
+    procedure WriteHeader(AStream: TStream; AName: string; AContentSize: longint);
+    class procedure ReadHeader(AStream: TStream; out AName: string; out AContentSize: longint);
+    function ContentSize: integer; virtual;
+    function HeaderName: string; virtual;
+    procedure WriteContent(AStream: TStream); virtual;
+    procedure ReadContent(AStream: TStream); virtual;
   public
     Width,Height: single;
     constructor Create(AIdentifier: string); virtual;
-    procedure Path(ADest: TBGRACanvas2D; AMatrix: TAffineMatrix); virtual; abstract;
+    constructor Create(AStream: TStream); virtual;
+    procedure Path({%H-}ADest: IBGRAPath; {%H-}AMatrix: TAffineMatrix); virtual;
     property Identifier: string read FIdentifier;
-  end;
+    procedure SaveToStream(AStream: TStream);
+    class function LoadFromStream(AStream: TStream): TBGRAGlyph;
+  end;
+
+  TGlyphPointCurveMode= (cmAuto, cmCurve, cmAngle);
 
   { TBGRAPolygonalGlyph }
@@ -34 +45 @@
     FQuadraticCurves: boolean;
     Points: array of TPointF;
+    CurveMode: array of TGlyphPointCurveMode;
     Curves: array of record
       isCurvedToNext,isCurvedToPrevious: boolean;
@@ -40 +52 @@
     function MaybeCurve(start1,end1,start2,end2: integer): boolean;
     procedure ComputeQuadraticCurves;
+    function ContentSize: integer; override;
+    function HeaderName: string; override;
+    procedure WriteContent(AStream: TStream); override;
+    procedure ReadContent(AStream: TStream); override;
+    procedure Init;
   public
     Offset: TPointF;
+    Closed: boolean;
+    MinimumDotProduct: single;
     constructor Create(AIdentifier: string); override;
-    procedure SetPoints(const APoints: array of TPointF);
-    procedure Path(ADest: TBGRACanvas2D; AMatrix: TAffineMatrix); override;
+    constructor Create(AStream: TStream); override;
+    procedure SetPoints(const APoints: array of TPointF); overload;
+    procedure SetPoints(const APoints: array of TPointF; const ACurveMode: array of TGlyphPointCurveMode); overload;
+    procedure Path(ADest: IBGRAPath; AMatrix: TAffineMatrix); override;
     property QuadraticCurves: boolean read FQuadraticCurves write SetQuadraticCurves;
+  end;
+
+  TBGRACustomTypeWriterHeader = record
+    HeaderName: String;
+    NbGlyphs: integer;
   end;
 
@@ -59 +85 @@
     function GetGlyph(AIdentifier: string): TBGRAGlyph; virtual;
     procedure SetGlyph(AIdentifier: string; AValue: TBGRAGlyph);
-    procedure TextPath(ADest: TBGRACanvas2D; AText: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft);
+    procedure TextPath(ADest: TBGRACanvas2D; ATextUTF8: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment; ADrawEachChar: boolean);
     procedure GlyphPath(ADest: TBGRACanvas2D; AIdentifier: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft);
     procedure DrawLastPath(ADest: TBGRACanvas2D);
@@ -66 +92 @@
     procedure AddGlyph(AGlyph: TBGRAGlyph);
     function GetGlyphMatrix(AGlyph: TBGRAGlyph; X,Y: Single; AAlign: TBGRATypeWriterAlignment): TAffineMatrix;
-    function GetTextMatrix(AText: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment): TAffineMatrix;
+    function GetTextMatrix(ATextUTF8: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment): TAffineMatrix;
     property Glyph[AIdentifier: string]: TBGRAGlyph read GetGlyph write SetGlyph;
+    function CustomHeaderSize: integer; virtual;
+    procedure WriteCustomHeader(AStream: TStream); virtual;
+    function ReadCustomTypeWriterHeader(AStream: TStream): TBGRACustomTypeWriterHeader;
+    procedure ReadAdditionalHeader({%H-}AStream: TStream); virtual;
+    function HeaderName: string; virtual;
   public
     OutlineMode: TBGRATypeWriterOutlineMode;
+    DrawGlyphsSimultaneously : boolean;
     constructor Create;
+    procedure SaveGlyphsToFile(AFilenameUTF8: string);
+    procedure SaveGlyphsToStream(AStream: TStream);
+    procedure LoadGlyphsFromFile(AFilenameUTF8: string);
+    procedure LoadGlyphsFromStream(AStream: TStream);
     procedure DrawGlyph(ADest: TBGRACanvas2D; AIdentifier: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft);
-    procedure DrawText(ADest: TBGRACanvas2D; AText: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft);
+    procedure DrawText(ADest: TBGRACanvas2D; ATextUTF8: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft); virtual;
+    procedure CopyTextPathTo(ADest: IBGRAPath; ATextUTF8: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft); virtual;
     function GetGlyphBox(AIdentifier: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft): TAffineBox;
-    function GetTextBox(AText: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft): TAffineBox;
-    function GetTextGlyphBoxes(AText: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft): TGlyphBoxes;
+    function GetTextBox(ATextUTF8: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft): TAffineBox;
+    function GetTextGlyphBoxes(ATextUTF8: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft): TGlyphBoxes;
+    procedure NeedGlyphRange(AUnicodeFrom, AUnicodeTo: Cardinal);
+    procedure NeedGlyphAnsiRange;
     destructor Destroy; override;
   end;
 
+function ComputeEasyBezier(APoints: array of TPointF; AClosed: boolean; AMinimumDotProduct: single = 0.707): ArrayOfTPointF; overload;
+function ComputeEasyBezier(APoints: array of TPointF; ACurveMode: array of TGlyphPointCurveMode; AClosed: boolean; AMinimumDotProduct: single = 0.707): ArrayOfTPointF; overload;
+
 implementation
 
-uses LCLProc;
+uses LCLProc, lazutf8classes;
+
+{$i winstream.inc}
+
+function ComputeEasyBezier(APoints: array of TPointF; AClosed: boolean; AMinimumDotProduct: single = 0.707): ArrayOfTPointF;
+var
+  glyph: TBGRAPolygonalGlyph;
+  canvas2D: TBGRACanvas2D;
+  i: integer;
+begin
+  if length(APoints) <= 2 then
+  begin
+    setlength(result, length(APoints));
+    for i := 0 to high(result) do
+      result[i] := APoints[i];
+    exit;
+  end;
+  glyph := TBGRAPolygonalGlyph.Create('');
+  glyph.QuadraticCurves := true;
+  glyph.Closed:= AClosed;
+  glyph.MinimumDotProduct := AMinimumDotProduct;
+  glyph.SetPoints(APoints);
+  canvas2D := TBGRACanvas2D.Create(nil);
+  canvas2D.pixelCenteredCoordinates := true;
+  glyph.Path(canvas2D,AffineMatrixIdentity);
+  glyph.Free;
+  result := canvas2D.currentPath;
+  canvas2D.free;
+end;
+
+function ComputeEasyBezier(APoints: array of TPointF;
+  ACurveMode: array of TGlyphPointCurveMode; AClosed: boolean;
+  AMinimumDotProduct: single): ArrayOfTPointF;
+var
+  glyph: TBGRAPolygonalGlyph;
+  canvas2D: TBGRACanvas2D;
+  i: integer;
+begin
+  if length(APoints) <= 2 then
+  begin
+    setlength(result, length(APoints));
+    for i := 0 to high(result) do
+      result[i] := APoints[i];
+    exit;
+  end;
+  glyph := TBGRAPolygonalGlyph.Create('');
+  glyph.QuadraticCurves := true;
+  glyph.Closed:= AClosed;
+  glyph.MinimumDotProduct := AMinimumDotProduct;
+  glyph.SetPoints(APoints, ACurveMode);
+  canvas2D := TBGRACanvas2D.Create(nil);
+  canvas2D.pixelCenteredCoordinates := true;
+  glyph.Path(canvas2D,AffineMatrixIdentity);
+  glyph.Free;
+  result := canvas2D.currentPath;
+  canvas2D.free;
+end;
 
 { TBGRAPolygonalGlyph }
@@ -109 +207 @@
   if lv <> 0 then v *= 1/lv;
 
-  result := u*v > 0.707;
+  result := u*v > MinimumDotProduct;
 end;
 
@@ -119 +217 @@
   FirstPointIndex := 0;
   for i := 0 to high(points) do
+    Curves[i].isCurvedToPrevious := false;
+  for i := 0 to high(points) do
   begin
     Curves[i].isCurvedToNext := false;
-    Curves[i].isCurvedToPrevious := false;
     Curves[i].Center := EmptyPointF;
     Curves[i].ControlPoint := EmptyPointF;
@@ -138 +237 @@
       Curves[i].Center := (points[i]+points[NextPt])*0.5;
       Curves[i].NextCenter := (points[NextPt]+points[NextPt2])*0.5;
-
-      Curves[i].isCurvedToNext:= MaybeCurve(i,NextPt,NextPt,NextPt2);
-      Curves[NextPt].isCurvedToPrevious := Curves[i].isCurvedToNext;
       Curves[i].ControlPoint := points[NextPt];
+
+      if (i < high(points)-1) or Closed then
+      begin
+        case CurveMode[nextPt] of
+          cmAuto: Curves[i].isCurvedToNext:= MaybeCurve(i,NextPt,NextPt,NextPt2);
+          cmCurve: Curves[i].isCurvedToNext:= true;
+          else Curves[i].isCurvedToNext:= false;
+        end;
+        Curves[NextPt].isCurvedToPrevious := Curves[i].isCurvedToNext;
+      end;
     end;
   end;
+end;
+
+function TBGRAPolygonalGlyph.ContentSize: integer;
+begin
+  Result:= (inherited ContentSize) + sizeof(single)*2 + 4 + sizeof(single)*2*length(Points);
+end;
+
+function TBGRAPolygonalGlyph.HeaderName: string;
+begin
+  Result:='TBGRAPolygonalGlyph';
+end;
+
+procedure TBGRAPolygonalGlyph.WriteContent(AStream: TStream);
+var i: integer;
+begin
+  inherited WriteContent(AStream);
+  WinWritePointF(AStream, Offset);
+  WinWriteLongint(AStream,length(Points));
+  for i := 0 to high(Points) do
+    WinWritePointF(AStream, Points[i]);
+end;
+
+procedure TBGRAPolygonalGlyph.ReadContent(AStream: TStream);
+var i: integer;
+  tempPts: array of TPointF;
+begin
+  inherited ReadContent(AStream);
+  Offset := WinReadPointF(AStream);
+  SetLength(tempPts, WinReadLongint(AStream));
+  for i := 0 to high(tempPts) do
+    tempPts[i] := WinReadPointF(AStream);
+  SetPoints(tempPts);
+end;
+
+procedure TBGRAPolygonalGlyph.Init;
+begin
+  Closed := True;
+  MinimumDotProduct := 0.707;
 end;
 
@@ -150 +294 @@
   inherited Create(AIdentifier);
   Offset := PointF(0,0);
+  Init;
+end;
+
+constructor TBGRAPolygonalGlyph.Create(AStream: TStream);
+begin
+  inherited Create(AStream);
+  Init;
 end;
 
@@ -158 +309 @@
   for i := 0 to high(points) do
     points[i] := APoints[i];
+  setlength(CurveMode, length(APoints));
+  for i := 0 to high(CurveMode) do
+    CurveMode[i] := cmAuto;
   Curves := nil;
 end;
 
-procedure TBGRAPolygonalGlyph.Path(ADest: TBGRACanvas2D; AMatrix: TAffineMatrix);
+procedure TBGRAPolygonalGlyph.SetPoints(const APoints: array of TPointF;
+  const ACurveMode: array of TGlyphPointCurveMode);
+var i: integer;
+begin
+  if length(APoints) <> length(ACurveMode) then
+    raise exception.Create('Dimension mismatch');
+  SetLength(Points,length(APoints));
+  for i := 0 to high(points) do
+    points[i] := APoints[i];
+  setlength(CurveMode, length(ACurveMode));
+  for i := 0 to high(CurveMode) do
+    CurveMode[i] := ACurveMode[i];
+  Curves := nil;
+end;
+
+procedure TBGRAPolygonalGlyph.Path(ADest: IBGRAPath; AMatrix: TAffineMatrix);
 var i: integer;
   nextMove: boolean;
   startCoord: TPointF;
+
 begin
   if Points = nil then exit;
@@ -171 +341 @@
   nextMove := true;
   AMatrix := AMatrix*AffineMatrixTranslation(Offset.X,Offset.Y);
+
   for i := 0 to high(Points) do
     if isEmptyPointF(Points[i]) then
@@ -206 +377 @@
         nextMove := false;
       end else
+      begin
         ADest.lineTo(AMatrix*Points[i]);
+      end;
     end;
-  if not nextmove then ADest.closePath;
+  if not nextmove then
+    ADest.closePath;
 end;
 
 { TBGRAGlyph }
 
+procedure TBGRAGlyph.WriteHeader(AStream: TStream; AName: string;
+  AContentSize: longint);
+begin
+  WinWriteByte(AStream, length(AName));
+  AStream.Write(AName[1],length(AName));
+  WinWriteLongint(AStream, AContentSize);
+end;
+
+class procedure TBGRAGlyph.ReadHeader(AStream: TStream; out AName: string; out
+  AContentSize: longint);
+var NameLength: integer;
+begin
+  NameLength := WinReadByte(AStream);
+  setlength(AName,NameLength);
+  AStream.Read(AName[1],length(AName));
+  AContentSize := WinReadLongint(AStream);
+end;
+
+function TBGRAGlyph.ContentSize: integer;
+begin
+  result := 4+length(FIdentifier)+sizeof(single)*2;
+end;
+
+function TBGRAGlyph.HeaderName: string;
+begin
+  result := 'TBGRAGlyph';
+end;
+
+procedure TBGRAGlyph.WriteContent(AStream: TStream);
+begin
+  WinWriteLongint(AStream,length(FIdentifier));
+  AStream.Write(FIdentifier[1],length(FIdentifier));
+  WinWriteSingle(AStream,Width);
+  WinWriteSingle(AStream,Height);
+end;
+
+procedure TBGRAGlyph.ReadContent(AStream: TStream);
+var lIdentifierLength: integer;
+begin
+  lIdentifierLength:= WinReadLongint(AStream);
+  setlength(FIdentifier, lIdentifierLength);
+  AStream.Read(FIdentifier[1],length(FIdentifier));
+  Width := WinReadSingle(AStream);
+  Height := WinReadSingle(AStream);
+end;
+
 constructor TBGRAGlyph.Create(AIdentifier: string);
 begin
   FIdentifier:= AIdentifier;
+end;
+
+constructor TBGRAGlyph.Create(AStream: TStream);
+begin
+  ReadContent(AStream);
+end;
+
+procedure TBGRAGlyph.Path(ADest: IBGRAPath; AMatrix: TAffineMatrix);
+begin
+  //nothing
+end;
+
+procedure TBGRAGlyph.SaveToStream(AStream: TStream);
+begin
+  WriteHeader(AStream, HeaderName, ContentSize);
+  WriteContent(AStream);
+end;
+
+class function TBGRAGlyph.LoadFromStream(AStream: TStream) : TBGRAGlyph;
+var lName: string;
+  lContentSize: integer;
+  EndPosition: Int64;
+begin
+  ReadHeader(AStream,lName,lContentSize);
+  EndPosition := AStream.Position + lContentSize;
+  if lName = 'TBGRAPolygonalGlyph' then
+    result := TBGRAPolygonalGlyph.Create(AStream)
+  else if lName = 'TBGRAGlyph' then
+    result := TBGRAGlyph.Create(AStream)
+  else
+    raise exception.Create('Unknown glyph type (' + lName + ')');
+  AStream.Position:= EndPosition;
 end;
 
@@ -272 +524 @@
   TypeWriterMatrix := AffineMatrixIdentity;
   OutlineMode:= twoFill;
+  DrawGlyphsSimultaneously := false;
 end;
 
@@ -281 +534 @@
 end;
 
-procedure TBGRACustomTypeWriter.DrawText(ADest: TBGRACanvas2D; AText: string;
+procedure TBGRACustomTypeWriter.DrawText(ADest: TBGRACanvas2D; ATextUTF8: string;
   X, Y: Single; AAlign: TBGRATypeWriterAlignment);
 begin
-  TextPath(ADest, AText, X,Y, AAlign);
-  DrawLastPath(ADest);
+  TextPath(ADest, ATextUTF8, X,Y, AAlign, (OutlineMode <> twoPath) and not DrawGlyphsSimultaneously);
+end;
+
+procedure TBGRACustomTypeWriter.CopyTextPathTo(ADest: IBGRAPath; ATextUTF8: string; X,Y: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft);
+var
+  pstr: pchar;
+  left,charlen: integer;
+  nextchar: string;
+  g: TBGRAGlyph;
+  m,m2: TAffineMatrix;
+begin
+  if ATextUTF8 = '' then exit;
+  m := GetTextMatrix(ATextUTF8, X,Y,AAlign);
+  m2 := m;
+
+  pstr := @ATextUTF8[1];
+  left := length(ATextUTF8);
+  while left > 0 do
+  begin
+    charlen := UTF8CharacterLength(pstr);
+    setlength(nextchar, charlen);
+    move(pstr^, nextchar[1], charlen);
+    inc(pstr,charlen);
+    dec(left,charlen);
+
+    g := GetGlyph(nextchar);
+    if g <> nil then
+    begin
+      if AAlign in [twaLeft,twaMiddle,twaRight] then
+        m2 := m*AffineMatrixTranslation(0,-g.Height/2) else
+      if AAlign in [twaBottomLeft,twaBottom,twaBottomRight] then
+        m2 := m*AffineMatrixTranslation(0,-g.Height)
+      else
+        m2 := m;
+      g.Path(ADest, m2);
+      m := m*AffineMatrixTranslation(g.Width,0);
+    end;
+  end;
 end;
 
@@ -301 +590 @@
 end;
 
-function TBGRACustomTypeWriter.GetTextBox(AText: string; X, Y: Single;
+function TBGRACustomTypeWriter.GetTextBox(ATextUTF8: string; X, Y: Single;
   AAlign: TBGRATypeWriterAlignment): TAffineBox;
 var
@@ -313 +602 @@
 
 begin
-  if AText = '' then result := TAffineBox.EmptyBox else
-  begin
-    m := GetTextMatrix(AText,X,Y,AAlign);
+  if ATextUTF8 = '' then result := TAffineBox.EmptyBox else
+  begin
+    m := GetTextMatrix(ATextUTF8,X,Y,AAlign);
     minY := 0;
     maxY := 0;
     totalWidth := 0;
 
-    pstr := @AText[1];
-    left := length(AText);
+    pstr := @ATextUTF8[1];
+    left := length(ATextUTF8);
     while left > 0 do
     begin
@@ -359 +648 @@
 end;
 
-function TBGRACustomTypeWriter.GetTextGlyphBoxes(AText: string; X, Y: Single;
+function TBGRACustomTypeWriter.GetTextGlyphBoxes(ATextUTF8: string; X, Y: Single;
   AAlign: TBGRATypeWriterAlignment): TGlyphBoxes;
 var
@@ -372 +661 @@
 
 begin
-  if AText = '' then result := nil else
-  begin
-    setlength(result, UTF8Length(AText));
-
-    m := GetTextMatrix(AText,X,Y,AAlign);
-
-    pstr := @AText[1];
-    left := length(AText);
+  if ATextUTF8 = '' then result := nil else
+  begin
+    setlength(result, UTF8Length(ATextUTF8));
+
+    m := GetTextMatrix(ATextUTF8,X,Y,AAlign);
+
+    pstr := @ATextUTF8[1];
+    left := length(ATextUTF8);
     numChar := 0;
     while left > 0 do
@@ -418 +707 @@
 end;
 
-procedure TBGRACustomTypeWriter.TextPath(ADest: TBGRACanvas2D; AText: string; X,
-  Y: Single; AAlign: TBGRATypeWriterAlignment);
+procedure TBGRACustomTypeWriter.NeedGlyphRange(AUnicodeFrom, AUnicodeTo: Cardinal);
+var c: cardinal;
+begin
+  for c := AUnicodeFrom to AUnicodeTo do
+    GetGlyph(UnicodeToUTF8(c));
+end;
+
+procedure TBGRACustomTypeWriter.NeedGlyphAnsiRange;
+var i: integer;
+begin
+  for i := 0 to 255 do
+    GetGlyph(AnsiToUtf8(chr(i)));
+end;
+
+procedure TBGRACustomTypeWriter.TextPath(ADest: TBGRACanvas2D; ATextUTF8: string; X,
+  Y: Single; AAlign: TBGRATypeWriterAlignment; ADrawEachChar: boolean);
 var
   pstr: pchar;
@@ -427 +730 @@
   m,m2: TAffineMatrix;
 begin
-  ADest.beginPath;
-  if AText = '' then exit;
-  m := GetTextMatrix(AText, X,Y,AAlign);
+  if not ADrawEachChar then ADest.beginPath;
+  if ATextUTF8 = '' then exit;
+  m := GetTextMatrix(ATextUTF8, X,Y,AAlign);
   m2 := m;
 
-  pstr := @AText[1];
-  left := length(AText);
+  pstr := @ATextUTF8[1];
+  left := length(ATextUTF8);
   while left > 0 do
   begin
@@ -451 +754 @@
       else
         m2 := m;
+      if ADrawEachChar then ADest.beginPath;
       g.Path(ADest, m2);
+      if ADrawEachChar then DrawLastPath(ADest);
       m := m*AffineMatrixTranslation(g.Width,0);
     end;
@@ -497 +802 @@
 end;
 
+procedure TBGRACustomTypeWriter.SaveGlyphsToStream(AStream: TStream);
+var Enumerator: TAvgLvlTreeNodeEnumerator;
+begin
+  WinWriteLongint(AStream,CustomHeaderSize);
+  WriteCustomHeader(AStream);
+
+  Enumerator := FGlyphs.GetEnumerator;
+  while Enumerator.MoveNext do
+    TBGRAGlyph(Enumerator.Current.Data).SaveToStream(AStream);
+  Enumerator.Free;
+end;
+
+procedure TBGRACustomTypeWriter.LoadGlyphsFromFile(AFilenameUTF8: string);
+var Stream: TFileStreamUTF8;
+begin
+  Stream := nil;
+  try
+    Stream := TFileStreamUTF8.Create(AFilenameUTF8, fmOpenRead);
+    LoadGlyphsFromStream(Stream);
+  finally
+    Stream.Free;
+  end;
+end;
+
+procedure TBGRACustomTypeWriter.LoadGlyphsFromStream(AStream: TStream);
+var Header: TBGRACustomTypeWriterHeader;
+  i: integer;
+  g: TBGRAGlyph;
+  HeaderSize: integer;
+  GlyphStartPosition: Int64;
+begin
+  HeaderSize := WinReadLongint(AStream);
+  GlyphStartPosition:= AStream.Position+HeaderSize;
+  Header := ReadCustomTypeWriterHeader(AStream);
+  if header.HeaderName <> HeaderName then
+    raise exception.Create('Invalid file format ("'+header.HeaderName+'" should be "'+HeaderName+'")');
+  ReadAdditionalHeader(AStream);
+  AStream.Position:= GlyphStartPosition;
+  for i := 0 to Header.NbGlyphs-1 do
+  begin
+    g := TBGRAGlyph.LoadFromStream(AStream);
+    AddGlyph(g);
+  end;
+end;
+
+procedure TBGRACustomTypeWriter.SaveGlyphsToFile(AFilenameUTF8: string);
+var Stream: TFileStreamUTF8;
+begin
+  Stream := nil;
+  try
+    Stream := TFileStreamUTF8.Create(AFilenameUTF8, fmCreate or fmOpenWrite);
+    SaveGlyphsToStream(Stream);
+  finally
+    Stream.Free;
+  end;
+end;
+
 function TBGRACustomTypeWriter.GetGlyphMatrix(AGlyph: TBGRAGlyph; X, Y: Single;
   AAlign: TBGRATypeWriterAlignment): TAffineMatrix;
@@ -514 +876 @@
 end;
 
-function TBGRACustomTypeWriter.GetTextMatrix(AText: string; X, Y: Single;
+function TBGRACustomTypeWriter.GetTextMatrix(ATextUTF8: string; X, Y: Single;
   AAlign: TBGRATypeWriterAlignment): TAffineMatrix;
 var
@@ -528 +890 @@
   begin
     totalWidth := 0;
-    pstr := @AText[1];
-    left := length(AText);
+    pstr := @ATextUTF8[1];
+    left := length(ATextUTF8);
     while left > 0 do
     begin
@@ -548 +910 @@
 end;
 
+function TBGRACustomTypeWriter.CustomHeaderSize: integer;
+begin
+  result := 1+length(HeaderName)+4;
+end;
+
+procedure TBGRACustomTypeWriter.WriteCustomHeader(AStream: TStream);
+var lHeaderName: string;
+begin
+  lHeaderName:= HeaderName;
+  WinWriteByte(AStream,length(lHeaderName));
+  AStream.Write(lHeaderName[1],length(lHeaderName));
+  WinWriteLongint(AStream,FGlyphs.Count);
+end;
+
+function TBGRACustomTypeWriter.ReadCustomTypeWriterHeader(AStream: TStream
+  ): TBGRACustomTypeWriterHeader;
+begin
+  setlength(result.HeaderName, WinReadByte(AStream));
+  AStream.Read(result.HeaderName[1],length(result.HeaderName));
+  result.NbGlyphs:= WinReadLongint(AStream);
+end;
+
+procedure TBGRACustomTypeWriter.ReadAdditionalHeader(AStream: TStream);
+begin
+  //nothing
+end;
+
+function TBGRACustomTypeWriter.HeaderName: string;
+begin
+  result := 'TBGRACustomTypeWriter';
+end;
+
 destructor TBGRACustomTypeWriter.Destroy;
 begin