Changeset 521 for GraphicTest

GraphicTest

Property svn:ignore

old	new
8	8	GraphicTest.lps
9	9	GraphicTest.dbg
	10	heaptrclog.trc

GraphicTest/GraphicTest.lpi

-              r494
+              r521
 <CONFIG>
   <ProjectOptions>
     <Version Value="9"/>
+    <Version Value="11"/>
     <General>
       <SessionStorage Value="InProjectDir"/>
 …
             <IncludeFiles Value="$(ProjOutDir)"/>
             <OtherUnitFiles Value="Methods"/>
             <UnitOutputDirectory Value="lib/$(TargetCPU)-$(TargetOS)"/>
+            <UnitOutputDirectory Value="lib/$(TargetCPU)-$(TargetOS)-$(BuildMode)"/>
           </SearchPaths>
           <Parsing>
 …
             </Options>
           </Linking>
+          <Other>
+            <CompilerMessages>
+              <IgnoredMessages idx5024="True"/>
+            </CompilerMessages>
+          </Other>
         </CompilerOptions>
       </Item2>
+      <SharedMatrixOptions Count="2">
+        <Item1 ID="838068306737" Targets="GR32_L, bgrabitmappack" Modes="Debug" Value="-g -gl -gh -CirotR -O1"/>
+        <Item2 ID="108912769980" Targets="GR32_L, bgrabitmappack" Modes="Release" Value="-CX -XX -O3"/>
+      </SharedMatrixOptions>
     </BuildModes>
     <PublishOptions>
       <Version Value="2"/>
-      <IncludeFileFilter Value="*.(pas|pp|inc|lfm|lpr|lrs|lpi|lpk|sh|xml)"/>
-      <ExcludeFileFilter Value="*.(bak|ppu|o|so);*~;backup"/>
     </PublishOptions>
     <RunParams>
+      <local>
+        <FormatVersion Value="1"/>
+      </local>
+      <FormatVersion Value="2"/>
+      <Modes Count="1">
+        <Mode0 Name="default"/>
+      </Modes>
     </RunParams>
     <RequiredPackages Count="5">
 …
       <IncludeFiles Value="$(ProjOutDir)"/>
       <OtherUnitFiles Value="Methods"/>
       <UnitOutputDirectory Value="lib/$(TargetCPU)-$(TargetOS)"/>
+      <UnitOutputDirectory Value="lib/$(TargetCPU)-$(TargetOS)-$(BuildMode)"/>
     </SearchPaths>
     <Parsing>
 …
     </CodeGeneration>
     <Linking>
+      <Debugging>
+        <UseHeaptrc Value="True"/>
+      </Debugging>
       <Options>
         <Win32>
 …
     </Linking>
     <Other>
+      <CompilerMessages>
+        <IgnoredMessages idx5024="True"/>
+      </CompilerMessages>
       <CustomOptions Value="-dopengl"/>
     </Other>

GraphicTest/GraphicTest.lpr

-              r494
+              r521
   {$ENDIF}{$ENDIF}
   Interfaces, // this includes the LCL widgetset
   Forms, openglcontext, UMainForm, UPlatform, UDrawMethod, UFastBitmap,
+  Forms, SysUtils, openglcontext, UMainForm, UPlatform, UDrawMethod, UFastBitmap,
   UDrawForm, bgrabitmappack,
   {$IFDEF GRAPHICS32}GR32_L,{$ENDIF}
 …
 {$R *.res}
+{$if declared(UseHeapTrace)}
+const
+  HeapTraceLog = 'heaptrclog.trc';
+{$ENDIF}
 begin
+  {$if declared(UseHeapTrace)}
+  // Heap trace
+  DeleteFile(ExtractFilePath(ParamStr(0)) + HeapTraceLog);
+  SetHeapTraceOutput(ExtractFilePath(ParamStr(0)) + HeapTraceLog);
+  {$ENDIF}
   RequireDerivedFormResource := True;
   Application.Initialize;

GraphicTest/Packages/Graphics32/Packages/GR32_L.lpk

-              r452
+              r521
 <?xml version="1.0"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <CONFIG>
   <Package Version="4">
 …
         <IncludeFiles Value=".."/>
         <OtherUnitFiles Value=".."/>
         <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)\$(LCLWidgetType)"/>
+        <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)-$(BuildMode)\$(LCLWidgetType)"/>
       </SearchPaths>
       <Parsing>
 …
         </SyntaxOptions>
       </Parsing>
+      <Other>
+        <CompilerMessages>
+          <UseMsgFile Value="True"/>
+        </CompilerMessages>
+        <CompilerPath Value="$(CompPath)"/>
+      </Other>
+      <CodeGeneration>
+        <Optimizations>
+          <OptimizationLevel Value="0"/>
+        </Optimizations>
+      </CodeGeneration>
+      <Linking>
+        <Debugging>
+          <GenerateDebugInfo Value="False"/>
+        </Debugging>
+      </Linking>
     </CompilerOptions>
     <Description Value="Graphics32 is a library designed for fast 32-bit graphics handling on Delphi and Kylix. Optimized for 32-bit pixel formats, it provides fast operations with pixels and graphic primitives, and in most cases Graphics32 outperforms the standard TCanvas classes. It is almost a hundred times faster in per-pixel access and about 2–5 times faster in drawing lines.
 …
     <PublishOptions>
       <Version Value="2"/>
-      <IgnoreBinaries Value="False"/>
     </PublishOptions>
     <CustomOptions Items="ExternHelp" Version="2">

GraphicTest/Packages/bgrabitmap/basiccolorspace.inc

-              r494
+              r521
   // TExpandedPixel -> TBGRAPixel
+  GammaCompressionTab: packed array[0..65535] of byte;
+  GammaCompressionTab : packed array[0..65535] of byte;          //rounded value
+  GammaCompressionTabFrac : packed array[0..65535] of shortint;  //fractional part of value from -0.5 to +0.5
 procedure BGRASetGamma(AGamma: single = 1.7);
 …
   {** Returns the lightness of an gamma-expanded pixel. The lightness is the
      perceived brightness, 0 being black and 65535 being white }
   function GetLightness(const c: TExpandedPixel): word; inline;
+  function GetLightness(const c: TExpandedPixel): word; inline; overload;
   {** Sets the lightness of a gamma-expanded pixel }
   function SetLightness(const c: TExpandedPixel; lightness: word): TExpandedPixel;
+  function SetLightness(const c: TExpandedPixel; lightness: word): TExpandedPixel; overload;
   {** Sets the lightness of a gamma expanded pixel, provided you already know the current
      value of lightness ''curLightness''. It is a bit faster than the previous function }
   function SetLightness(const c: TExpandedPixel; lightness: word; curLightness: word): TExpandedPixel;
+  function SetLightness(const c: TExpandedPixel; lightness: word; curLightness: word): TExpandedPixel; overload;
   {** Returns the importance of the color. It is similar to saturation
       in HSL colorspace, except it is gamma corrected. A value of zero indicates
 …
     {** Hue of the pixel. Extremum values 0 and 65535 are red }
     hue: word;
     {** Saturation of the color. 0 is gray and 65535 is the brightest color }
+    {** Saturation of the color. 0 is gray and 65535 is the brightest color (including white) }
     saturation: word;
     {** Lightness of the color. 0 is black, 32768 is normal, and 65535 is white }
 …
   {* Pixel color defined in corrected HSL colorspace. G stands for corrected hue
      and B stands for actual brightness. Values range from 0 to 65535 }
+  TGSBAPixel = THSLAPixel;
+  TGSBAPixel = packed record
+    {** Hue of the pixel. Extremum values 0 and 65535 are red }
+    hue: word;
+    {** Saturation of the color. 0 is gray and 65535 is the brightest color (excluding white) }
+    saturation: word;
+    {** Actual perceived brightness. 0 is black, 32768 is normal, and 65535 is white }
+    lightness: word;
+    {** Opacity of the pixel. 0 is transparent and 65535 is opaque }
+    alpha: word;
+  end;
   {** Converts a pixel from sRGB to correct HSL color space }
 …
   function HtoG(hue: word): word;
   {** Converts a pixel from corrected HSL to sRGB }
+  function GSBAToBGRA(c: TGSBAPixel): TBGRAPixel;
+  function GSBAToBGRA(c: TGSBAPixel): TBGRAPixel; overload;
+  function GSBAToBGRA(const c: THSLAPixel): TBGRAPixel; overload;
   {** Converts a pixel from correct HSL to gamma expanded RGB }
+  function GSBAToExpanded(c: TGSBAPixel): TExpandedPixel;
+  function GSBAToExpanded(c: TGSBAPixel): TExpandedPixel; overload;
+  function GSBAToExpanded(const c: THSLAPixel): TExpandedPixel; overload;
   {** Converts a pixel from correct HSL to usual HSL }
+  function GSBAToHSLA(c: TGSBAPixel): THSLAPixel;
+  function GSBAToHSLA(const c: TGSBAPixel): THSLAPixel; overload;
+  function GSBAToHSLA(const c: THSLAPixel): THSLAPixel; overload;
+  function HSLAToGSBA(const c: THSLAPixel): TGSBAPixel;
 type
   { TBGRAPixelHelper }
   TBGRAPixelHelper = record helper for TBGRAPixel
+  { TBGRAPixelBasicHelper }
+  TBGRAPixelBasicHelper = record helper for TBGRAPixel
     function ToExpanded: TExpandedPixel;
     procedure FromExpanded(const AValue: TExpandedPixel);
 …
     procedure FromHSLAPixel(const AValue: THSLAPixel);
     function ToGSBAPixel: TGSBAPixel;
+    procedure FromGSBAPixel(const AValue: TGSBAPixel);
+    procedure FromGSBAPixel(const AValue: TGSBAPixel); overload;
+    procedure FromGSBAPixel(const AValue: THSLAPixel); overload;
     function ToColorF(AGammaExpansion: boolean): TColorF;
     procedure FromColorF(const AValue: TColorF; AGammaCompression: boolean);
   end;
+  { TExpandedPixelHelper }
+  TExpandedPixelHelper = record helper for TExpandedPixel
+  { TExpandedPixelBasicHelper }
+  TExpandedPixelBasicHelper = record helper for TExpandedPixel
+    function ToFPColor(AGammaCompression: boolean = true): TFPColor;
+    procedure FromFPColor(const AValue: TFPColor; AGammaExpansion: boolean = true);
+    function ToColor: TColor;
+    procedure FromColor(const AValue: TColor);
+    function ToBGRAPixel: TBGRAPixel;
+    procedure FromBGRAPixel(AValue: TBGRAPixel);
+    function ToHSLAPixel: THSLAPixel;
+    procedure FromHSLAPixel(const AValue: THSLAPixel);
+    function ToGSBAPixel: TGSBAPixel;
+    procedure FromGSBAPixel(const AValue: TGSBAPixel); overload;
+    procedure FromGSBAPixel(const AValue: THSLAPixel); overload;
+  end;
+operator := (const AValue: TExpandedPixel): TColor;
+operator := (const AValue: TColor): TExpandedPixel;
+Operator := (const Source: TExpandedPixel): TBGRAPixel;
+Operator := (const Source: TBGRAPixel): TExpandedPixel;
+type
+  { TFPColorBasicHelper }
+  TFPColorBasicHelper = record helper for TFPColor
+    function ToColor: TColor;
+    procedure FromColor(const AValue: TColor);
+    function ToBGRAPixel: TBGRAPixel;
+    procedure FromBGRAPixel(AValue: TBGRAPixel);
+    function ToExpanded(AGammaExpansion: boolean = true): TExpandedPixel;
+    procedure FromExpanded(const AValue: TExpandedPixel; AGammaCompression: boolean = true);
+  end;
+  { THSLAPixelBasicHelper }
+  THSLAPixelBasicHelper = record helper for THSLAPixel
+    function ToColor: TColor;
+    procedure FromColor(const AValue: TColor);
+    function ToBGRAPixel: TBGRAPixel;
+    procedure FromBGRAPixel(AValue: TBGRAPixel);
+    function ToGSBAPixel: TGSBAPixel;
+    procedure FromGSBAPixel(AValue: TGSBAPixel);
+    function ToExpanded: TExpandedPixel;
+    procedure FromExpanded(AValue: TExpandedPixel);
+  end;
+Operator := (const Source: THSLAPixel): TBGRAPixel;
+Operator := (const Source: TBGRAPixel): THSLAPixel;
+Operator := (const Source: THSLAPixel): TExpandedPixel;
+Operator := (const Source: TExpandedPixel): THSLAPixel;
+operator := (const AValue: TColor): THSLAPixel;
+operator := (const AValue: THSLAPixel): TColor;
+type
+  { TGSBAPixelBasicHelper }
+  TGSBAPixelBasicHelper = record helper for TGSBAPixel
+    function ToColor: TColor;
+    procedure FromColor(const AValue: TColor);
     function ToBGRAPixel: TBGRAPixel;
     procedure FromBGRAPixel(AValue: TBGRAPixel);
     function ToHSLAPixel: THSLAPixel;
     procedure FromHSLAPixel(AValue: THSLAPixel);
-  end;
-  { THSLAPixelHelper }
-  THSLAPixelHelper = record helper for THSLAPixel
-    function ToBGRAPixel: TBGRAPixel;
-    procedure FromBGRAPixel(AValue: TBGRAPixel);
     function ToExpanded: TExpandedPixel;
     procedure FromExpanded(AValue: TExpandedPixel);
   end;
+Operator := (Source: TExpandedPixel): TBGRAPixel;
+Operator := (const Source: TGSBAPixel): TBGRAPixel;
+Operator := (const Source: TBGRAPixel): TGSBAPixel;
+Operator := (const Source: TGSBAPixel): TExpandedPixel;
+Operator := (const Source: TExpandedPixel): TGSBAPixel;
+operator := (const AValue: TColor): TGSBAPixel;
+operator := (const AValue: TGSBAPixel): TColor;
+Operator := (const Source: TGSBAPixel): THSLAPixel; //no conversion, just copying for backward compatibility (use ToHSLAPixel instead for conversion)
+Operator := (const Source: THSLAPixel): TGSBAPixel; //no conversion, just copying for backward compatibility (use ToGSBAPixel instead for conversion)
 {$ENDIF}
 …
       nextpos := round(power(i+0.5, GammaExpFactor) * GammaLinearFactor);
     GammaExpansionTab[i] := midpos;
+    for j := prevpos to nextpos-1 do
+    for j := prevpos to midpos-1 do
+    begin
       GammaCompressionTab[j] := i;
+      GammaCompressionTabFrac[j] := -128 + (j-prevpos)*128 div (midpos-prevpos);
+    end;
+    for j := midpos to nextpos-1 do
+    begin
+      GammaCompressionTab[j] := i;
+      GammaCompressionTabFrac[j] := (j-midpos)*128 div (nextpos-midpos);
+    end;
   end;
   GammaCompressionTab[0] := 0;
 …
   Result.blue  := GammaCompressionTab[blue];
   Result.alpha := alpha shr 8;
+end;
+function GammaExpansionW(ACompressed: word): word;
+var
+  intPart: Integer;
+  f,fracPart: Single;
+begin
+  if ACompressed = 0 then
+    result := 0
+  else if ACompressed = $ffff then
+    result := $ffff
+  else
+  begin
+    f := ACompressed/$101;
+    intPart := trunc(f);
+    fracPart := f - intPart;
+    if fracPart = 0 then
+      result := GammaExpansionTab[intPart]
+    else
+      result := round(GammaExpansionTab[intPart]*(1-fracPart)+GammaExpansionTab[intPart+1]*fracPart);
+  end;
+end;
+function GammaCompressionW(AExpanded: word): word;
+begin
+  if AExpanded = 0 then
+    result := 0
+  else if AExpanded = $ffff then
+    result := $ffff
+  else
+  begin
+    result := GammaCompressionTab[AExpanded];
+    result := (result shl 8) + result;
+    result += GammaCompressionTabFrac[AExpanded];
+  end;
 end;
 …
 var lightness: UInt32Or64;
     red,green,blue: Int32or64;
+    hsla: THSLAPixel;
 begin
   red   := GammaExpansionTab[c.red];
   green := GammaExpansionTab[c.green];
   blue  := GammaExpansionTab[c.blue];
   result.alpha := c.alpha shl 8 + c.alpha;
+  hsla.alpha := c.alpha shl 8 + c.alpha;
   lightness := (red * redWeightShl10 + green * greenWeightShl10 +
     blue * blueWeightShl10 + 512) shr 10;
+  ExpandedToHSLAInline(red,green,blue,result);
+  ExpandedToHSLAInline(red,green,blue,hsla);
+  result := TGSBAPixel(hsla);
   if result.lightness > 32768 then
     result.saturation := result.saturation* UInt32or64(not result.lightness) div 32767;
 …
 var lightness: UInt32Or64;
     red,green,blue: Int32or64;
+    hsla: THSLAPixel;
 begin
   red   := ec.red;
   green := ec.green;
   blue  := ec.blue;
   result.alpha := ec.alpha;
+  hsla.alpha := ec.alpha;
   lightness := (red * redWeightShl10 + green * greenWeightShl10 +
     blue * blueWeightShl10 + 512) shr 10;
+  ExpandedToHSLAInline(red,green,blue,result);
+  ExpandedToHSLAInline(red,green,blue,hsla);
+  result := TGSBAPixel(hsla);
   if result.lightness > 32768 then
     result.saturation := result.saturation* UInt32or64(not result.lightness) div 32767;
 …
   lightness := c.lightness;
   c.lightness := 32768;
   ec := HSLAToExpanded(c);
+  ec := HSLAToExpanded(THSLAPixel(c));
   result := GammaCompression(SetLightness(ec, lightness));
+end;
+function GSBAToBGRA(const c: THSLAPixel): TBGRAPixel;
+begin
+  result := GSBAToBGRA(TGSBAPixel(c));
 end;
 …
   lightness := c.lightness;
   c.lightness := 32768;
+  result := SetLightness(HSLAToExpanded(c),lightness);
+end;
+function GSBAToHSLA(c: TGSBAPixel): THSLAPixel;
+begin
+  result := BGRAToHSLA(GSBAToBGRA(c));
+end;
+{ TBGRAPixelHelper }
+function TBGRAPixelHelper.ToExpanded: TExpandedPixel;
+  result := SetLightness(HSLAToExpanded(THSLAPixel(c)),lightness);
+end;
+function GSBAToExpanded(const c: THSLAPixel): TExpandedPixel;
+begin
+  result := GSBAToExpanded(TGSBAPixel(c));
+end;
+function GSBAToHSLA(const c: TGSBAPixel): THSLAPixel;
+begin
+  result := ExpandedToHSLA(GSBAToExpanded(c));
+end;
+function GSBAToHSLA(const c: THSLAPixel): THSLAPixel;
+begin
+  result := ExpandedToHSLA(GSBAToExpanded(TGSBAPixel(c)));
+end;
+function HSLAToGSBA(const c: THSLAPixel): TGSBAPixel;
+begin
+  result := ExpandedToGSBA(HSLAToExpanded(c));
+end;
+{ TBGRAPixelBasicHelper }
+function TBGRAPixelBasicHelper.ToExpanded: TExpandedPixel;
 begin
   result := GammaExpansion(self);
 end;
 procedure TBGRAPixelHelper.FromExpanded(const AValue: TExpandedPixel);
+procedure TBGRAPixelBasicHelper.FromExpanded(const AValue: TExpandedPixel);
 begin
   Self := GammaCompression(AValue);
 end;
 function TBGRAPixelHelper.ToHSLAPixel: THSLAPixel;
+function TBGRAPixelBasicHelper.ToHSLAPixel: THSLAPixel;
 begin
   result := BGRAToHSLA(Self);
 end;
 procedure TBGRAPixelHelper.FromHSLAPixel(const AValue: THSLAPixel);
+procedure TBGRAPixelBasicHelper.FromHSLAPixel(const AValue: THSLAPixel);
 begin
   Self := HSLAToBGRA(AValue);
 end;
 function TBGRAPixelHelper.ToGSBAPixel: TGSBAPixel;
+function TBGRAPixelBasicHelper.ToGSBAPixel: TGSBAPixel;
 begin
   result := BGRAToGSBA(Self);
 end;
 procedure TBGRAPixelHelper.FromGSBAPixel(const AValue: TGSBAPixel);
+procedure TBGRAPixelBasicHelper.FromGSBAPixel(const AValue: TGSBAPixel);
 begin
   Self := GSBAToBGRA(AValue);
 end;
+function TBGRAPixelHelper.ToColorF(AGammaExpansion: boolean): TColorF;
+procedure TBGRAPixelBasicHelper.FromGSBAPixel(const AValue: THSLAPixel);
+begin
+  Self := GSBAToBGRA(AValue);
+end;
+function TBGRAPixelBasicHelper.ToColorF(AGammaExpansion: boolean): TColorF;
 begin
   result := BGRAToColorF(Self,AGammaExpansion);
 end;
 procedure TBGRAPixelHelper.FromColorF(const AValue: TColorF;
+procedure TBGRAPixelBasicHelper.FromColorF(const AValue: TColorF;
     AGammaCompression: boolean);
 begin
 …
 end;
+{ TExpandedPixelHelper }
+function TExpandedPixelHelper.ToBGRAPixel: TBGRAPixel;
+{ TExpandedPixelBasicHelper }
+function TExpandedPixelBasicHelper.ToFPColor(AGammaCompression: boolean): TFPColor;
+begin
+  if AGammaCompression then
+  begin
+    result.red := GammaCompressionW(self.red);
+    result.green := GammaCompressionW(self.green);
+    result.blue := GammaCompressionW(self.blue);
+  end else
+  begin
+    result.red := self.red;
+    result.green := self.green;
+    result.blue := self.blue;
+  end;
+  result.alpha := self.alpha;
+end;
+procedure TExpandedPixelBasicHelper.FromFPColor(const AValue: TFPColor;
+  AGammaExpansion: boolean);
+begin
+  if AGammaExpansion then
+  begin
+    self.red := GammaExpansionW(AValue.red);
+    self.green := GammaExpansionW(AValue.green);
+    self.blue := GammaExpansionW(AValue.blue);
+  end else
+  begin
+    self.red := AValue.red;
+    self.green := AValue.green;
+    self.blue := AValue.blue;
+  end;
+  self.alpha := AValue.alpha;
+end;
+function TExpandedPixelBasicHelper.ToColor: TColor;
+begin
+  result := BGRAToColor(GammaCompression(self));
+end;
+procedure TExpandedPixelBasicHelper.FromColor(const AValue: TColor);
+begin
+  self := GammaExpansion(ColorToBGRA(AValue));
+end;
+function TExpandedPixelBasicHelper.ToBGRAPixel: TBGRAPixel;
 begin
   result := GammaCompression(Self);
 end;
 procedure TExpandedPixelHelper.FromBGRAPixel(AValue: TBGRAPixel);
+procedure TExpandedPixelBasicHelper.FromBGRAPixel(AValue: TBGRAPixel);
 begin
   Self := GammaExpansion(AValue);
 end;
 function TExpandedPixelHelper.ToHSLAPixel: THSLAPixel;
+function TExpandedPixelBasicHelper.ToHSLAPixel: THSLAPixel;
 begin
   result := ExpandedToHSLA(Self);
 end;
 procedure TExpandedPixelHelper.FromHSLAPixel(AValue: THSLAPixel);
+procedure TExpandedPixelBasicHelper.FromHSLAPixel(const AValue: THSLAPixel);
 begin
   Self := HSLAToExpanded(AValue);
 end;
+operator :=(Source: TExpandedPixel): TBGRAPixel;
+function TExpandedPixelBasicHelper.ToGSBAPixel: TGSBAPixel;
+begin
+  result := ExpandedToGSBA(Self);
+end;
+procedure TExpandedPixelBasicHelper.FromGSBAPixel(const AValue: TGSBAPixel);
+begin
+  Self := GSBAToExpanded(AValue);
+end;
+procedure TExpandedPixelBasicHelper.FromGSBAPixel(const AValue: THSLAPixel);
+begin
+  Self := GSBAToExpanded(AValue);
+end;
+operator := (const AValue: TExpandedPixel): TColor;
+begin Result := BGRAToColor(GammaCompression(AValue)); end;
+operator := (const AValue: TColor): TExpandedPixel;
+begin Result := GammaExpansion(ColorToBGRA(ColorToRGB(AValue))) end;
+operator :=(const Source: TExpandedPixel): TBGRAPixel;
 begin
   result := GammaCompression(Source);
 end;
+{ THSLAPixelHelper }
+function THSLAPixelHelper.ToBGRAPixel: TBGRAPixel;
+operator :=(const Source: TBGRAPixel): TExpandedPixel;
+begin
+  result := GammaExpansion(Source);
+end;
+{ TFPColorBasicHelper }
+function TFPColorBasicHelper.ToColor: TColor;
+begin
+  result := FPColorToTColor(self);
+end;
+procedure TFPColorBasicHelper.FromColor(const AValue: TColor);
+begin
+  self := TColorToFPColor(AValue);
+end;
+function TFPColorBasicHelper.ToBGRAPixel: TBGRAPixel;
+begin
+  result := FPColorToBGRA(self);
+end;
+procedure TFPColorBasicHelper.FromBGRAPixel(AValue: TBGRAPixel);
+begin
+  self := BGRAToFPColor(AValue);
+end;
+function TFPColorBasicHelper.ToExpanded(AGammaExpansion: boolean): TExpandedPixel;
+begin
+  result.FromFPColor(self, AGammaExpansion);
+end;
+procedure TFPColorBasicHelper.FromExpanded(const AValue: TExpandedPixel;
+  AGammaCompression: boolean);
+begin
+  self := AValue.ToFPColor(AGammaCompression);
+end;
+{ THSLAPixelBasicHelper }
+function THSLAPixelBasicHelper.ToColor: TColor;
+begin
+  result := BGRAToColor(HSLAToBGRA(self));
+end;
+procedure THSLAPixelBasicHelper.FromColor(const AValue: TColor);
+begin
+  self := BGRAToHSLA(ColorToBGRA(AValue));
+end;
+function THSLAPixelBasicHelper.ToBGRAPixel: TBGRAPixel;
 begin
   result := HSLAToBGRA(self);
 end;
 procedure THSLAPixelHelper.FromBGRAPixel(AValue: TBGRAPixel);
+procedure THSLAPixelBasicHelper.FromBGRAPixel(AValue: TBGRAPixel);
 begin
   self := BGRAToHSLA(AValue);
 end;
+function THSLAPixelHelper.ToExpanded: TExpandedPixel;
+function THSLAPixelBasicHelper.ToGSBAPixel: TGSBAPixel;
+begin
+  result := HSLAToGSBA(self);
+end;
+procedure THSLAPixelBasicHelper.FromGSBAPixel(AValue: TGSBAPixel);
+begin
+  self := GSBAToHSLA(AValue);
+end;
+function THSLAPixelBasicHelper.ToExpanded: TExpandedPixel;
 begin
   result := HSLAToExpanded(Self);
 end;
 procedure THSLAPixelHelper.FromExpanded(AValue: TExpandedPixel);
+procedure THSLAPixelBasicHelper.FromExpanded(AValue: TExpandedPixel);
 begin
   Self := ExpandedToHSLA(AValue);
 end;
+operator :=(const Source: THSLAPixel): TBGRAPixel;
+begin
+  result := HSLAToBGRA(Source);
+end;
+operator :=(const Source: TBGRAPixel): THSLAPixel;
+begin
+  result := BGRAToHSLA(Source);
+end;
+operator :=(const Source: THSLAPixel): TExpandedPixel;
+begin
+  result := HSLAToExpanded(Source);
+end;
+operator:=(const Source: TExpandedPixel): THSLAPixel;
+begin
+  result := ExpandedToHSLA(Source);
+end;
+operator := (const AValue: TColor): THSLAPixel;
+begin Result := BGRAToHSLA(ColorToBGRA(ColorToRGB(AValue))) end;
+operator := (const AValue: THSLAPixel): TColor;
+begin Result := BGRAToColor(HSLAToBGRA(AValue)) end;
+{ TGSBAPixelBasicHelper }
+function TGSBAPixelBasicHelper.ToColor: TColor;
+begin
+  result := BGRAToColor(GSBAToBGRA(self));
+end;
+procedure TGSBAPixelBasicHelper.FromColor(const AValue: TColor);
+begin
+  self := BGRAToGSBA(ColorToBGRA(AValue));
+end;
+function TGSBAPixelBasicHelper.ToBGRAPixel: TBGRAPixel;
+begin
+  result := GSBAToBGRA(self);
+end;
+procedure TGSBAPixelBasicHelper.FromBGRAPixel(AValue: TBGRAPixel);
+begin
+  self := BGRAToGSBA(AValue);
+end;
+function TGSBAPixelBasicHelper.ToHSLAPixel: THSLAPixel;
+begin
+  result := GSBAToHSLA(self);
+end;
+procedure TGSBAPixelBasicHelper.FromHSLAPixel(AValue: THSLAPixel);
+begin
+  self := HSLAToGSBA(AValue);
+end;
+function TGSBAPixelBasicHelper.ToExpanded: TExpandedPixel;
+begin
+  result := GSBAToExpanded(self);
+end;
+procedure TGSBAPixelBasicHelper.FromExpanded(AValue: TExpandedPixel);
+begin
+  self := ExpandedToGSBA(AValue);
+end;
+operator :=(const Source: TGSBAPixel): TBGRAPixel;
+begin
+  result := GSBAToBGRA(Source);
+end;
+operator :=(const Source: TBGRAPixel): TGSBAPixel;
+begin
+  result := BGRAToGSBA(Source);
+end;
+operator :=(const Source: TGSBAPixel): TExpandedPixel;
+begin
+  result := GSBAToExpanded(Source);
+end;
+operator:=(const Source: TExpandedPixel): TGSBAPixel;
+begin
+  result := ExpandedToGSBA(Source);
+end;
+operator := (const AValue: TColor): TGSBAPixel;
+begin Result := BGRAToGSBA(ColorToBGRA(ColorToRGB(AValue))) end;
+operator := (const AValue: TGSBAPixel): TColor;
+begin Result := BGRAToColor(GSBAToBGRA(AValue)) end;
+operator :=(const Source: TGSBAPixel): THSLAPixel;
+begin
+  result := THSLAPixel(Pointer(@Source)^);
+end;
+operator:=(const Source: THSLAPixel): TGSBAPixel;
+begin
+  result := TGSBAPixel(Pointer(@Source)^);
+end;
 {$ENDIF}

GraphicTest/Packages/bgrabitmap/bglvirtualscreen.pas

-              r494
+              r521
   TBGLElapseEvent = procedure (Sender: TObject; BGLContext: TBGLContext; ElapsedMs: integer) of object;
   TBGLFramesPerSecondEvent = procedure (Sender: TObject; BGLContext: TBGLContext; FramesPerSecond: integer) of object;
+  TBGLUseContextCallback = procedure (Sender: TObject; BGLContext: TBGLContext; Data: Pointer) of object;
   { TCustomBGLVirtualScreen }
 …
     procedure QueryLoadTextures; virtual;
     procedure UnloadTextures; virtual;
+    procedure UseContext(ACallback: TBGLUseContextCallback; AData: Pointer = nil);
     constructor Create(TheOwner: TComponent); override;
     destructor Destroy; override;
 …
 end;
+procedure TCustomBGLVirtualScreen.UseContext(ACallback: TBGLUseContextCallback; AData: Pointer);
+var
+  ctx: TBGLContext;
+begin
+  if not MakeCurrent then
+    raise exception.Create('Unable to switch to the OpenGL context');
+  ctx := PrepareBGLContext;
+  try
+    ACallback(self, ctx, AData);
+  finally
+    ReleaseBGLContext(ctx);
+  end;
+end;
 procedure TCustomBGLVirtualScreen.RedrawContent(ctx: TBGLContext);
 var

GraphicTest/Packages/bgrabitmap/bgraanimatedgif.pas

-              r494
+              r521
     procedure CheckFrameIndex(AIndex: integer);
+    function GetAverageDelayMs: integer;
     function GetCount: integer;
     function GetFrameDelayMs(AIndex: integer): integer;
 …
     EraseColor:     TColor;
     BackgroundMode: TGifBackgroundMode;
+    constructor Create(filenameUTF8: string);
+    constructor Create(stream: TStream);
+    constructor Create; override;
+    LoopCount:      Word;
+    LoopDone:       Integer;
+    constructor Create(filenameUTF8: string); overload;
+    constructor Create(stream: TStream); overload;
+    constructor Create(stream: TStream; AMaxImageCount: integer); overload;
+    constructor Create; overload; override;
     function Duplicate: TBGRAAnimatedGif;
     function AddFrame(AImage: TFPCustomImage; X,Y: integer; ADelayMs: integer;
       ADisposeMode: TDisposeMode = dmErase; AHasLocalPalette: boolean = false) : integer;
     procedure InsertFrame(AIndex: integer; AImage: TBGRABitmap; X,Y: integer; ADelayMs: integer;
+    procedure InsertFrame(AIndex: integer; AImage: TFPCustomImage; X,Y: integer; ADelayMs: integer;
       ADisposeMode: TDisposeMode = dmErase; AHasLocalPalette: boolean = false);
+    procedure DeleteFrame(AIndex: integer; AEnsureNextFrameDoesNotChange: boolean);
+    //add a frame that replaces completely the previous one
+    function AddFullFrame(AImage: TFPCustomImage; ADelayMs: integer;
+                          AHasLocalPalette: boolean = true): integer;
+    procedure InsertFullFrame(AIndex: integer;
+                              AImage: TFPCustomImage; ADelayMs: integer;
+                              AHasLocalPalette: boolean = true);
+    procedure ReplaceFullFrame(AIndex: integer;
+                              AImage: TFPCustomImage; ADelayMs: integer;
+                              AHasLocalPalette: boolean = true);
     {TGraphic}
+    procedure LoadFromStream(Stream: TStream); override;
+    procedure SaveToStream(Stream: TStream); override;
+    procedure LoadFromStream(Stream: TStream); overload; override;
+    procedure LoadFromStream(Stream: TStream; AMaxImageCount: integer); overload;
+    procedure LoadFromResource(AFilename: string);
+    procedure SaveToStream(Stream: TStream); overload; override;
     procedure LoadFromFile(const AFilenameUTF8: string); override;
     procedure SaveToFile(const AFilenameUTF8: string); override;
 …
     procedure SetSize(AWidth,AHeight: integer); virtual;
     procedure SaveToStream(Stream: TStream; AQuantizer: TBGRAColorQuantizerAny;
       ADitheringAlgorithm: TDitheringAlgorithm); virtual; overload;
+      ADitheringAlgorithm: TDitheringAlgorithm); overload; virtual;
     procedure Clear; override;
     destructor Destroy; override;
 …
     property AspectRatio: single read FAspectRatio write SetAspectRatio;
     property TotalAnimationTimeMs: Int64 read FTotalAnimationTime;
+    property AverageDelayMs: integer read GetAverageDelayMs;
   end;
 …
   data.BackgroundColor := BackgroundColor;
   data.Images := FImages;
+  data.LoopCount := LoopCount;
   GIFSaveToStream(data, Stream, AQuantizer, ADitheringAlgorithm);
 end;
 …
       Inc(nextImage);
       if nextImage >= Count then
+        nextImage := 0;
+      begin
+        if (LoopCount > 0) and (LoopDone >= LoopCount-1) then
+        begin
+          LoopDone := LoopCount;
+          dec(nextImage);
+          break;
+        end else
+        begin
+          nextImage := 0;
+          inc(LoopDone);
+        end;
+      end;
       if nextImage = previousImage then
       begin
+        Inc(nextImage);
+        if nextImage >= Count then
+          nextImage := 0;
+        if not ((LoopCount > 0) and (LoopDone >= LoopCount-1)) then
+        begin
+          Inc(nextImage);
+          if nextImage >= Count then
+            nextImage := 0;
+        end;
         break;
       end;
 …
 end;
+function TBGRAAnimatedGif.GetAverageDelayMs: integer;
+var sum: int64;
+  i: Integer;
+begin
+  if Count > 0 then
+  begin
+    sum := 0;
+    for i := 0 to Count-1 do
+      inc(sum, FrameDelayMs[i]);
+    result := sum div Count;
+  end else
+    result := 100; //default
+end;
 function TBGRAAnimatedGif.GetCount: integer;
 begin
 …
 end;
+constructor TBGRAAnimatedGif.Create(stream: TStream; AMaxImageCount: integer);
+begin
+  inherited Create;
+  Init;
+  LoadFromStream(stream, AMaxImageCount);
+end;
 constructor TBGRAAnimatedGif.Create;
 begin
 …
 end;
 procedure TBGRAAnimatedGif.InsertFrame(AIndex: integer; AImage: TBGRABitmap; X,
+procedure TBGRAAnimatedGif.InsertFrame(AIndex: integer; AImage: TFPCustomImage; X,
   Y: integer; ADelayMs: integer; ADisposeMode: TDisposeMode;
   AHasLocalPalette: boolean);
 …
   with FImages[AIndex] do
   begin
     Image := AImage.Duplicate as TBGRABitmap;
+    Image := TBGRABitmap.Create(AImage);
     Position := Point(x,y);
     DelayMs := ADelayMs;
 …
 end;
+function TBGRAAnimatedGif.AddFullFrame(AImage: TFPCustomImage;
+  ADelayMs: integer; AHasLocalPalette: boolean): integer;
+begin
+  if (AImage.Width <> Width) or (AImage.Height <> Height) then
+    raise exception.Create('Size mismatch');
+  if Count > 0 then
+    FrameDisposeMode[Count-1] := dmErase;
+  result := AddFrame(AImage, 0,0, ADelayMs, dmErase, AHasLocalPalette);
+end;
+procedure TBGRAAnimatedGif.InsertFullFrame(AIndex: integer;
+  AImage: TFPCustomImage; ADelayMs: integer; AHasLocalPalette: boolean);
+var nextImage: TBGRABitmap;
+begin
+  if (AIndex < 0) or (AIndex > Count) then
+    raise ERangeError.Create('Index out of bounds');
+  if AIndex = Count then
+    AddFullFrame(AImage, ADelayMs, AHasLocalPalette)
+  else
+  begin
+    //if previous image did not clear up, ensure that
+    //next image will stay the same
+    if (AIndex > 0) and (FrameDisposeMode[AIndex-1] <> dmErase) then
+    begin
+      CurrentImage := AIndex;
+      nextImage := MemBitmap.Duplicate as TBGRABitmap;
+      FrameImagePos[AIndex] := Point(0,0);
+      FrameImage[AIndex] := nextImage;
+      FrameHasLocalPalette[AIndex] := true;
+      FreeAndNil(nextImage);
+      FrameDisposeMode[AIndex-1] := dmErase;
+    end;
+    InsertFrame(AIndex, AImage, 0,0, ADelayMs, dmErase, AHasLocalPalette);
+  end;
+end;
+procedure TBGRAAnimatedGif.ReplaceFullFrame(AIndex: integer;
+  AImage: TFPCustomImage; ADelayMs: integer; AHasLocalPalette: boolean);
+begin
+  DeleteFrame(AIndex, True);
+  if AIndex > 0 then FrameDisposeMode[AIndex-1] := dmErase;
+  InsertFrame(AIndex, AImage, 0,0, ADelayMs, dmErase, AHasLocalPalette);
+end;
+procedure TBGRAAnimatedGif.DeleteFrame(AIndex: integer;
+  AEnsureNextFrameDoesNotChange: boolean);
+var
+  nextImage: TBGRABitmap;
+  i: Integer;
+begin
+  CheckFrameIndex(AIndex);
+  //if this frame did not clear up, ensure that
+  //next image will stay the same
+  if AEnsureNextFrameDoesNotChange and
+    ((AIndex < Count-1) and (FrameDisposeMode[AIndex] <> dmErase)) then
+  begin
+    CurrentImage := AIndex+1;
+    nextImage := MemBitmap.Duplicate as TBGRABitmap;
+    FrameImagePos[AIndex+1] := Point(0,0);
+    FrameImage[AIndex+1] := nextImage;
+    FrameHasLocalPalette[AIndex+1] := true;
+    FreeAndNil(nextImage);
+  end;
+  dec(FTotalAnimationTime, FImages[AIndex].DelayMs);
+  FImages[AIndex].Image.FreeReference;
+  for i := AIndex to Count-2 do
+    FImages[i] := FImages[i+1];
+  SetLength(FImages, Count-1);
+  if (CurrentImage >= Count) then
+    CurrentImage := 0;
+end;
 procedure TBGRAAnimatedGif.LoadFromStream(Stream: TStream);
+begin
+  LoadFromStream(Stream, maxLongint);
+end;
+procedure TBGRAAnimatedGif.LoadFromStream(Stream: TStream;
+  AMaxImageCount: integer);
 var data: TGIFData;
   i: integer;
 begin
   data := GIFLoadFromStream(Stream);
+  data := GIFLoadFromStream(Stream, AMaxImageCount);
   ClearViewer;
 …
   FBackgroundColor := data.BackgroundColor;
   FAspectRatio:= data.AspectRatio;
+  LoopDone := 0;
+  LoopCount := data.LoopCount;
   SetLength(FImages, length(data.Images));
 …
     FImages[i] := data.Images[i];
     FTotalAnimationTime += FImages[i].DelayMs;
+  end;
+end;
+procedure TBGRAAnimatedGif.LoadFromResource(AFilename: string);
+var
+  stream: TStream;
+begin
+  stream := BGRAResource.GetResourceStream(AFilename);
+  try
+    LoadFromStream(stream);
+  finally
+    stream.Free;
   end;
 end;
 …
     FImages[i].Image.FreeReference;
   FImages := nil;
+  LoopDone := 0;
+  LoopCount := 0;
 end;
 …
 begin
   BackgroundMode := gbmSaveBackgroundOnce;
+  LoopCount := 0;
+  LoopDone := 0;
 end;
 …
   Mem:  TBGRABitmap;
 begin
   gif := TBGRAAnimatedGif.Create(Str);
+  gif := TBGRAAnimatedGif.Create(Str, 1);
   Mem := gif.MemBitmap;
   if Img is TBGRABitmap then

GraphicTest/Packages/bgrabitmap/bgrabitmap.inc

-              r494
+              r521
   to comment them if the functions are not available }
 {$DEFINE BGRABITMAP_USE_LCL12} { Use functions of Lazarus 1.2 }
 //{$DEFINE BGRABITMAP_USE_LCL15} { Use functions of Lazarus 1.5 }
+{$DEFINE BGRABITMAP_USE_LCL15} { Use functions of Lazarus 1.5 }
 {$MODESWITCH ADVANCEDRECORDS}
+{$MODESWITCH TypeHelpers}

GraphicTest/Packages/bgrabitmap/bgrabitmap.pas

r494	r521
133	133	begin
134	134	...
135		BGRAReplace(temp, someBmp.Filter... );
	135	BGRAReplace(someBmp, someBmp.Filter... );
136	136	end;
137	137	}

GraphicTest/Packages/bgrabitmap/bgrabitmappack.lpk

-              r494
+              r521
       <PathDelim Value="\"/>
       <SearchPaths>
         <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)\$(FPCVer)"/>
+        <UnitOutputDirectory Value="lib\$(TargetCPU)-$(TargetOS)-$(BuildMode)"/>
       </SearchPaths>
       <Parsing>
 …
       <CodeGeneration>
         <Optimizations>
           <OptimizationLevel Value="3"/>
+          <OptimizationLevel Value="0"/>
           <VariablesInRegisters Value="True"/>
         </Optimizations>
 …
     <Description Value="Drawing routines with alpha blending and antialiasing"/>
     <License Value="modified LGPL"/>
     <Version Major="9" Minor="3"/>
     <Files Count="108">
+    <Version Major="9" Minor="9" Release="3"/>
+    <Files Count="120">
       <Item1>
         <Filename Value="bgraanimatedgif.pas"/>
 …
       <Item106>
         <Filename Value="bgramultifiletype.pas"/>
         <UnitName Value="bgramultifiletype"/>
+        <UnitName Value="BGRAMultiFileType"/>
       </Item106>
       <Item107>
 …
         <UnitName Value="BGRALazResource"/>
       </Item108>
+      <Item109>
+        <Filename Value="bgraiconcursor.pas"/>
+        <UnitName Value="BGRAIconCursor"/>
+      </Item109>
+      <Item110>
+        <Filename Value="bgrablurgl.pas"/>
+        <UnitName Value="BGRABlurGL"/>
+      </Item110>
+      <Item111>
+        <Filename Value="bgrareadtiff.pas"/>
+        <UnitName Value="BGRAReadTiff"/>
+      </Item111>
+      <Item112>
+        <Filename Value="bgralazpaint.pas"/>
+        <UnitName Value="BGRALazPaint"/>
+      </Item112>
+      <Item113>
+        <Filename Value="bgramemdirectory.pas"/>
+        <UnitName Value="BGRAMemDirectory"/>
+      </Item113>
+      <Item114>
+        <Filename Value="bgraunicode.pas"/>
+        <UnitName Value="BGRAUnicode"/>
+      </Item114>
+      <Item115>
+        <Filename Value="bgratextbidi.pas"/>
+        <UnitName Value="BGRATextBidi"/>
+      </Item115>
+      <Item116>
+        <Filename Value="bgralayeroriginal.pas"/>
+        <UnitName Value="BGRALayerOriginal"/>
+      </Item116>
+      <Item117>
+        <Filename Value="bgrasvgoriginal.pas"/>
+        <UnitName Value="BGRASVGOriginal"/>
+      </Item117>
+      <Item118>
+        <Filename Value="bgragradientoriginal.pas"/>
+        <UnitName Value="BGRAGradientOriginal"/>
+      </Item118>
+      <Item119>
+        <Filename Value="bgrapixel.inc"/>
+        <Type Value="Include"/>
+      </Item119>
+      <Item120>
+        <Filename Value="bezier.inc"/>
+        <Type Value="Binary"/>
+      </Item120>
     </Files>
     <RequiredPkgs Count="2">
 …
     <PublishOptions>
       <Version Value="2"/>
-      <IgnoreBinaries Value="False"/>
     </PublishOptions>
     <CustomOptions Items="ExternHelp" Version="2">

GraphicTest/Packages/bgrabitmap/bgrabitmappack.pas

-              r494
+              r521
 unit BGRABitmapPack;
+{$warn 5023 off : no warning about unused units}
 interface
 …
   BGRAWriteBmpMioMap, BGRAOpenGLType, BGRASpriteGL, BGRAOpenGL, BGRACanvasGL,
   BGRAFontGL, BGRAOpenGL3D, BGRAPhoxo, BGRAFilterScanner, BGRAFilterType,
+  BGRAFilterBlur, BGRAMultiFileType, BGRAWinResource, BGRALazResource;
+  BGRAFilterBlur, BGRAMultiFileType, BGRAWinResource, BGRALazResource,
+  BGRAIconCursor, BGRABlurGL, BGRAReadTiff, BGRALazPaint, BGRAMemDirectory,
+  BGRAUnicode, BGRATextBidi, BGRALayerOriginal, BGRASVGOriginal,
+  BGRAGradientOriginal;
 implementation

GraphicTest/Packages/bgrabitmap/bgrabitmappack4fpgui.lpk

-              r494
+              r521
     <Description Value="Drawing routines with alpha blending and antialiasing"/>
     <License Value="modified LGPL"/>
     <Version Major="9" Minor="3"/>
     <Files Count="96">
+    <Version Major="9" Minor="9" Release="3"/>
+    <Files Count="97">
       <Item1>
         <Filename Value="bgraanimatedgif.pas"/>
 …
       </Item95>
       <Item96>
         <Filename Value="bgralazresource.pas"/>
         <UnitName Value="BGRALazResource"/>
+        <Filename Value="bgraunicode.pas"/>
+        <UnitName Value="BGRAUnicode"/>
       </Item96>
+      <Item97>
+        <Filename Value="bezier.inc"/>
+        <Type Value="Include"/>
+      </Item97>
     </Files>
     <RequiredPkgs Count="3">

GraphicTest/Packages/bgrabitmap/bgrabitmappack4fpgui.pas

r494	r521
23	23	BGRAWritePNG, BGRAGifFormat, BGRASceneTypes, BGRARenderer3D,
24	24	BGRAWriteBmpMioMap, BGRAPhoxo, BGRAFilterScanner, BGRAFilterType,
25		BGRAFilterBlur;
	25	BGRAFilterBlur, BGRAMultiFileType, BGRAWinResource, BGRAUnicode;
26	26
27	27	implementation

GraphicTest/Packages/bgrabitmap/bgrabitmappack4nogui.lpk

-              r494
+              r521
     <Description Value="Drawing routines with alpha blending and antialiasing"/>
     <License Value="modified LGPL"/>
     <Version Major="9" Minor="3"/>
     <Files Count="100">
+    <Version Major="9" Minor="9" Release="3"/>
+    <Files Count="101">
       <Item1>
         <Filename Value="bgraanimatedgif.pas"/>
 …
       </Item99>
       <Item100>
         <Filename Value="bgralazresource.pas"/>
         <UnitName Value="BGRALazResource"/>
+        <Filename Value="bgraunicode.pas"/>
+        <UnitName Value="BGRAUnicode"/>
       </Item100>
+      <Item101>
+        <Filename Value="bezier.inc"/>
+        <Type Value="Include"/>
+      </Item101>
     </Files>
     <RequiredPkgs Count="2">

GraphicTest/Packages/bgrabitmap/bgrabitmappack4nogui.pas

-              r494
+              r521
 unit BGRABitmapPack4NoGUI;
+{$warn 5023 off : no warning about unused units}
 interface
 …
   BGRANoGUIBitmap, BGRASceneTypes, BGRARenderer3D, BGRAWriteBmpMioMap,
   BGRASpriteGL, BGRAOpenGLType, BGRAOpenGL, BGRACanvasGL, BGRAPhoxo,
+  BGRAFilterScanner, BGRAFilterType;
+  BGRAFilterScanner, BGRAFilterType, BGRAFilterBlur, BGRAMultiFileType,
+  BGRAWinResource, BGRAUnicode;
 implementation

GraphicTest/Packages/bgrabitmap/bgrabitmaptypes.pas

-              r494
+              r521
 uses
   Classes, Types, BGRAGraphics,
   FPImage, FPImgCanv{$IFDEF BGRABITMAP_USE_LCL}, GraphType{$ENDIF},
+  FPImage, FPImgCanv{$IFDEF BGRABITMAP_USE_LCL}, LCLType, GraphType, LResources{$ENDIF},
   BGRAMultiFileType;
 …
   Int32or64 = {$IFDEF CPU64}Int64{$ELSE}LongInt{$ENDIF};
   UInt32or64 = {$IFDEF CPU64}UInt64{$ELSE}LongWord{$ENDIF};
+  HDC = {$IFDEF BGRABITMAP_USE_LCL}LCLType.HDC{$ELSE}PtrUInt{$ENDIF};
 {=== Miscellaneous types ===}
 …
   TTextLayout = BGRAGraphics.TTextLayout;
+  TFontBidiMode = (fbmAuto, fbmLeftToRight, fbmRightToLeft);
+  TBidiTextAlignment = (btaNatural, btaOpposite, btaLeftJustify, btaRightJustify, btaCenter);
 const
+  RadialBlurTypeToStr: array[TRadialBlurType] of string =
+  ('Normal','Disk','Corona','Precise','Fast','Box');
   tlTop = BGRAGraphics.tlTop;
   tlCenter = BGRAGraphics.tlCenter;
 …
     {** Returns the total size of the string provided using the current font.
         Orientation is not taken into account, so that the width is along the text }
+    function TextSize(sUTF8: string): TSize; virtual; abstract;
+    function TextSize(sUTF8: string): TSize; overload; virtual; abstract;
+    function TextSize(sUTF8: string; AMaxWidth: integer; ARightToLeft: boolean): TSize; overload; virtual; abstract;
+    function TextFitInfo(sUTF8: string; AMaxWidth: integer): integer; virtual; abstract;
+    function TextSizeAngle(sUTF8: string; {%H-}orientationTenthDegCCW: integer): TSize; virtual;
     {** Draws the UTF8 encoded string, with color ''c''.
 …
         If align is taRightJustify, (''x'',''y'') is the top-right corner.
         The value of ''FontOrientation'' is taken into account, so that the text may be rotated }
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment); virtual; abstract;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment); overload; virtual; abstract;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment; {%H-}ARightToLeft: boolean); overload; virtual;
     {** Same as above functions, except that the text is filled using texture.
         The value of ''FontOrientation'' is taken into account, so that the text may be rotated }
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment); virtual; abstract;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment); overload; virtual; abstract;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment; {%H-}ARightToLeft: boolean); overload; virtual;
     {** Same as above, except that the orientation is specified, overriding the value of the property ''FontOrientation'' }
     procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientationTenthDegCCW: integer; sUTF8: string; c: TBGRAPixel; align: TAlignment); virtual; abstract;
+    procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientationTenthDegCCW: integer; sUTF8: string; c: TBGRAPixel; align: TAlignment); overload; virtual; abstract;
     {** Same as above, except that the orientation is specified, overriding the value of the property ''FontOrientation'' }
     procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientationTenthDegCCW: integer; sUTF8: string; texture: IBGRAScanner; align: TAlignment); virtual; abstract;
+    procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientationTenthDegCCW: integer; sUTF8: string; texture: IBGRAScanner; align: TAlignment); overload; virtual; abstract;
     {** Draw the UTF8 encoded string at the coordinate (''x'',''y''), clipped inside the rectangle ''ARect''.
         Additional style information is provided by the style parameter.
         The color ''c'' is used to fill the text. No rotation is applied. }
     procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; c: TBGRAPixel); virtual; abstract;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; c: TBGRAPixel); overload; virtual; abstract;
     {** Same as above except a ''texture'' is used to fill the text }
     procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; texture: IBGRAScanner); virtual; abstract;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; texture: IBGRAScanner); overload; virtual; abstract;
     {** Copy the path for the UTF8 encoded string into ''ADest''.
 …
         If ''align'' is ''taRightJustify'', (''x'',''y'') is the top-right corner. }
     procedure CopyTextPathTo({%H-}ADest: IBGRAPath; {%H-}x, {%H-}y: single; {%H-}s: string; {%H-}align: TAlignment); virtual; //optional
+    function HandlesTextPath: boolean; virtual;
   end;
 …
     byte index }
 function RemoveLineEndingUTF8(var sUTF8: string; indexUTF8: integer): boolean;
 {** Default word break handler, that simply divide when there is a space }
+{** Default word break handler }
 procedure BGRADefaultWordBreakHandler(var ABefore, AAfter: string);
 …
     ifGif,
     {** BMP format, transparency, no compression. Note that transparency is
         not supported by all BMP readers so it is not recommended to avoid
+        not supported by all BMP readers so it is recommended to avoid
         storing images with transparency in this format }
     ifBmp,
+    {** iGO BMP (16-bit, rudimentary lossless compression) }
+    ifBmpMioMap,
     {** ICO format, contains different sizes of the same image }
     ifIco,
+    {** CUR format, has hotspot, contains different sizes of the same image }
+    ifCur,
     {** PCX format, opaque, rudimentary lossless compression }
     ifPcx,
 …
     {** X-Pixmap, text encoded image, limited support }
     ifXPixMap,
+    {** iGO BMP, limited support }
+    ifBmpMioMap);
+    {** Scalable Vector Graphic, vectorial, read-only as raster }
+    ifSvg);
+  {* Image information from superficial analysis }
+  TQuickImageInfo = record
+    {** Width in pixels }
+    Width,
+    {** Height in pixels }
+    Height,
+    {** Bitdepth for colors (1, 2, 4, 8 for images with palette/grayscale, 16, 24 or 48 if each channel is present) }
+    ColorDepth,
+    {** Bitdepth for alpha (0 if no alpha channel, 1 if bit mask, 8 or 16 if alpha channel) }
+    AlphaDepth: integer;
+  end;
+  {* Bitmap reader with additional features }
+  TBGRAImageReader = class(TFPCustomImageReader)
+    {** Return bitmap information (size, bit depth) }
+    function GetQuickInfo(AStream: TStream): TQuickImageInfo; virtual; abstract;
+    {** Return a draft of the bitmap, the ratio may change compared to the original width and height (useful to make thumbnails) }
+    function GetBitmapDraft(AStream: TStream; AMaxWidth, AMaxHeight: integer; out AOriginalWidth,AOriginalHeight: integer): TBGRACustomBitmap; virtual; abstract;
+  end;
   {* Options when loading an image }
 …
 {$I bgracustombitmap.inc}
+operator =(const AGuid1, AGuid2: TGuid): boolean;
+type
+  { TBGRAResourceManager }
+  TBGRAResourceManager = class
+  protected
+    function GetWinResourceType(AExtension: string): pchar;
+  public
+    function GetResourceStream(AFilename: string): TStream; virtual;
+    function IsWinResource(AFilename: string): boolean; virtual;
+  end;
+var
+  BGRAResource : TBGRAResourceManager;
 implementation
 uses Math, SysUtils, BGRAUTF8,
   FPReadTiff, FPReadXwd, FPReadXPM,
+uses Math, SysUtils, BGRAUTF8, BGRAUnicode,
+  FPReadXwd, FPReadXPM,
   FPWriteTiff, FPWriteJPEG, BGRAWritePNG, FPWriteBMP, FPWritePCX,
   FPWriteTGA, FPWriteXPM;
 …
 procedure BGRADefaultWordBreakHandler(var ABefore, AAfter: string);
+var p: integer;
+begin
+  if (AAfter <> '') and (ABefore <> '') and (AAfter[1]<> ' ') and (ABefore[length(ABefore)] <> ' ') then
+const spacingChars = [' '];
+  wordBreakChars = [' ',#9,'-','?','!'];
+var p, charLen: integer;
+  u: Cardinal;
+begin
+  if (AAfter <> '') and (ABefore <> '') and not (AAfter[1] in spacingChars) and not (ABefore[length(ABefore)] in wordBreakChars) then
   begin
     p := length(ABefore);
+    while (p > 1) and (ABefore[p-1] <> ' ') do dec(p);
+    while (p > 1) and not (ABefore[p-1] in wordBreakChars) do dec(p);
+    while (p < length(ABefore)+1) and (ABefore[p] in [#$80..#$BF]) do inc(p); //do not split UTF8 char
+    //keep non-spacing mark together
+    while p <= length(ABefore) do
+    begin
+      charLen := UTF8CharacterLength(@ABefore[p]);
+      if p+charLen > length(ABefore)+1 then charLen := length(ABefore)+1-p;
+      u := UTF8CodepointToUnicode(@ABefore[p],charLen);
+      if GetUnicodeBidiClass(u) = ubcNonSpacingMark then
+        inc(p,charLen)
+      else
+        break;
+    end;
+    if p = 1 then
+    begin
+      //keep ideographic punctuation together
+      charLen := UTF8CharacterLength(@AAfter[p]);
+      if charLen > length(AAfter) then charLen := length(AAfter);
+      u := UTF8CodepointToUnicode(@AAfter[p],charLen);
+      case u of
+      UNICODE_IDEOGRAPHIC_COMMA,
+      UNICODE_IDEOGRAPHIC_FULL_STOP,
+      UNICODE_FULLWIDTH_COMMA,
+      UNICODE_HORIZONTAL_ELLIPSIS:
+        begin
+          p := length(ABefore)+1;
+          while p > 1 do
+          begin
+            charLen := 1;
+            dec(p);
+            while (p > 0) and (ABefore[p] in [#$80..#$BF]) do
+            begin
+              dec(p); //do not split UTF8 char
+              inc(charLen);
+            end;
+            if charLen <= 4 then
+              u := UTF8CodepointToUnicode(@ABefore[p],charLen)
+            else
+              u := ord('A');
+            case GetUnicodeBidiClass(u) of
+              ubcNonSpacingMark: ;   // include NSM
+              ubcOtherNeutrals, ubcWhiteSpace, ubcCommonSeparator, ubcEuropeanNumberSeparator:
+                begin
+                  p := 1;
+                  break;
+                end
+            else
+              break;
+            end;
+          end;
+        end;
+      end;
+    end;
     if p > 1 then //can put the word after
     begin
 …
     end;
   end;
   while (ABefore <> '') and (ABefore[length(ABefore)] =' ') do delete(ABefore,length(ABefore),1);
   while (AAfter <> '') and (AAfter[1] =' ') do delete(AAfter,1,1);
+  while (ABefore <> '') and (ABefore[length(ABefore)] in spacingChars) do delete(ABefore,length(ABefore),1);
+  while (AAfter <> '') and (AAfter[1] in spacingChars) do delete(AAfter,1,1);
 end;
 …
 { TBGRACustomFontRenderer }
+function TBGRACustomFontRenderer.TextSizeAngle(sUTF8: string;
+  orientationTenthDegCCW: integer): TSize;
+begin
+  result := TextSize(sUTF8); //ignore orientation by default
+end;
+procedure TBGRACustomFontRenderer.TextOut(ADest: TBGRACustomBitmap; x,
+  y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment;
+  ARightToLeft: boolean);
+begin
+  //if RightToLeft is not handled
+  TextOut(ADest,x,y,sUTF8,c,align);
+end;
+procedure TBGRACustomFontRenderer.TextOut(ADest: TBGRACustomBitmap; x,
+  y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment;
+  ARightToLeft: boolean);
+begin
+  //if RightToLeft is not handled
+  TextOut(ADest,x,y,sUTF8,texture,align);
+end;
 procedure TBGRACustomFontRenderer.CopyTextPathTo(ADest: IBGRAPath; x, y: single; s: string; align: TAlignment);
 begin {optional implementation} end;
+function TBGRACustomFontRenderer.HandlesTextPath: boolean;
+begin
+  result := false;
+end;
 …
     end;
+    if (magic[0] = $00) and (magic[1] = $00) and (magic[2] in[$01,$02]) and (magic[3] = $00) and
+      (magic[4] + (magic[5] shl 8) > 0) then inc(scores[ifIco]);
+    if (magic[0] = $00) and (magic[1] = $00) and (magic[3] = $00) and
+      (magic[4] + (magic[5] shl 8) > 0) then
+    begin
+      if magic[2] = $01 then
+        inc(scores[ifIco])
+      else if magic[2] = $02 then
+        inc(scores[ifCur]);
+    end;
     if (copy(magicAsText,1,4) = 'PDN3') then
 …
       with CreateBGRAImageReader(ifOpenRaster) do
         try
+          AStream.Position := streamStartPos;
           if CheckContents(AStream) then inc(scores[ifOpenRaster],2);
         finally
 …
     if (copy(magicAsText,1,8) = '/* XPM *') or (copy(magicAsText,1,6) = '! XPM2') then inc(scores[ifXPixMap]);
+    if (copy(magicAsText,1,6) = '<?xml ') then inc(scores[ifSvg]);
     AStream.Position := streamStartPos;
 …
   if (ext = '.pcx') then result := ifPcx else
   if (ext = '.bmp') then result := ifBmp else
+  if (ext = '.ico') or (ext = '.cur') then result := ifIco else
+  if (ext = '.ico') then result := ifIco else
+  if (ext = '.cur') then result := ifCur else
   if (ext = '.pdn') then result := ifPaintDotNet else
   if (ext = '.lzp') then result := ifLazPaint else
 …
   if (ext = '.xwd') then result := ifXwd else
   if (ext = '.xpm') then result := ifXPixMap else
+  if (ext = '.oxo') then result := ifPhoxo;
+  if (ext = '.oxo') then result := ifPhoxo else
+  if (ext = '.svg') then result := ifSvg;
 end;
 …
     ifGif: result := 'gif';
     ifBmp: result := 'bmp';
+    ifBmpMioMap: result := 'bmp';
     ifIco: result := 'ico';
+    ifCur: result := 'ico';
     ifPcx: result := 'pcx';
     ifPaintDotNet: result := 'pdn';
     ifLazPaint: result := 'lzp';
     ifOpenRaster: result := 'ora';
+    ifPhoxo: result := 'oXo';
     ifPsd: result := 'psd';
     ifTarga: result := 'tga';
 …
     ifXwd: result := 'xwd';
     ifXPixMap: result := 'xpm';
     ifBmpMioMap: result := 'bmp';
+    ifSvg: result := 'svg';
     else result := '?';
   end;
 …
       ifOpenRaster: raise exception.Create('You need to call BGRAOpenRaster.RegisterOpenRasterFormat to read this image.');
       ifPaintDotNet: raise exception.Create('You need to call BGRAPaintNet.RegisterPaintNetFormat to read this image.');
+      ifSvg: raise exception.Create('You need to call BGRA.RegisterSvgFormat to read this image.');
     else
       raise exception.Create('The image reader is not registered for this image format.');
 …
       ifUnknown: raise exception.Create('The image format is unknown');
       ifOpenRaster: raise exception.Create('You need to call BGRAOpenRaster.RegisterOpenRasterFormat to write with this image format.');
+      ifPhoxo: raise exception.Create('You need to call BGRAPhoxo.RegisterPhoxoFormat to write with this image format.');
     else
       raise exception.Create('The image writer is not registered for this image format.');
 …
     result := DefaultBGRAImageWriter[AFormat].Create;
 end;
+operator =(const AGuid1, AGuid2: TGuid): boolean;
+begin
+  result := CompareMem(@AGuid1, @AGuid2, sizeof(TGuid));
+end;
+type
+  TResourceType = record
+    ext: string;
+    code: pchar;
+  end;
+const
+  ResourceTypes: array[1..7] of TResourceType =
+   ((ext: 'CUR'; code: RT_GROUP_CURSOR),
+    (ext: 'BMP'; code: RT_BITMAP),
+    (ext: 'ICO'; code: RT_GROUP_ICON),
+    (ext: 'DAT'; code: RT_RCDATA),
+    (ext: 'DATA'; code: RT_RCDATA),
+    (ext: 'HTM'; code: RT_HTML),
+    (ext: 'HTML'; code: RT_HTML));
+{ TBGRAResourceManager }
+function TBGRAResourceManager.GetWinResourceType(AExtension: string): pchar;
+var
+  i: Integer;
+begin
+  if (AExtension <> '') and (AExtension[1]='.') then delete(AExtension,1,1);
+  for i := low(ResourceTypes) to high(ResourceTypes) do
+    if AExtension = ResourceTypes[i].ext then
+      exit(ResourceTypes[i].code);
+  exit(RT_RCDATA);
+end;
+function TBGRAResourceManager.GetResourceStream(AFilename: string): TStream;
+var
+  name,ext: RawByteString;
+  rt: PChar;
+begin
+  ext := UpperCase(ExtractFileExt(AFilename));
+  name := ChangeFileExt(AFilename,'');
+  rt := GetWinResourceType(ext);
+  if (rt = RT_GROUP_CURSOR) or (rt = RT_GROUP_ICON) then
+    raise exception.Create('Not implemented');
+  result := TResourceStream.Create(HINSTANCE, name, rt);
+end;
+function TBGRAResourceManager.IsWinResource(AFilename: string): boolean;
+var
+  name,ext: RawByteString;
+  rt: PChar;
+begin
+  ext := UpperCase(ExtractFileExt(AFilename));
+  name := ChangeFileExt(AFilename,'');
+  rt := GetWinResourceType(ext);
+  result := FindResource(HINSTANCE, pchar(name), rt)<>0;
+end;
+{$IFDEF BGRABITMAP_USE_LCL}
+type
+  { TLCLResourceManager }
+  TLCLResourceManager = class(TBGRAResourceManager)
+  protected
+    function FindLazarusResource(AFilename: string): TLResource;
+  public
+    function GetResourceStream(AFilename: string): TStream; override;
+    function IsWinResource(AFilename: string): boolean; override;
+  end;
+function TLCLResourceManager.FindLazarusResource(AFilename: string): TLResource;
+var
+  name,ext: RawByteString;
+begin
+  ext := UpperCase(ExtractFileExt(AFilename));
+  if (ext<>'') and (ext[1]='.') then Delete(ext,1,1);
+  name := ChangeFileExt(AFilename,'');
+  if ext<>'' then
+    result := LazarusResources.Find(name,ext)
+  else
+    result := LazarusResources.Find(name);
+end;
+function TLCLResourceManager.GetResourceStream(AFilename: string): TStream;
+var
+  res: TLResource;
+begin
+  res := FindLazarusResource(AFilename);
+  if Assigned(res) then
+    result := TLazarusResourceStream.CreateFromHandle(res)
+  else
+    result := inherited GetResourceStream(AFilename);
+end;
+function TLCLResourceManager.IsWinResource(AFilename: string): boolean;
+begin
+  if FindLazarusResource(AFilename)<>nil then
+    result := false
+  else
+    Result:=inherited IsWinResource(AFilename);
+end;
+{$ENDIF}
 initialization
 …
   //writing XWD not implemented
-  DefaultBGRAImageReader[ifTiff] := TFPReaderTiff;
   DefaultBGRAImageReader[ifXwd] := TFPReaderXWD;
   //the other readers are registered by their unit
+  {$IFDEF BGRABITMAP_USE_LCL}
+  BGRAResource := TLCLResourceManager.Create;
+  {$ELSE}
+  BGRAResource := TBGRAResourceManager.Create;
+  {$ENDIF}
 finalization
 …
   {$DEFINE INCLUDE_FINAL}
   {$I bgrapixel.inc}
+  BGRAResource.Free;
 end.

GraphicTest/Packages/bgrabitmap/bgrablend.pas

-              r494
+              r521
 procedure DrawPixelInlineWithAlphaCheck(dest: PBGRAPixel; const c: TBGRAPixel);
 begin
+  if c.alpha = 0 then
+    exit;
+  if c.alpha = 255 then
+  begin
+    dest^ := c;
+    exit;
+  end;
+  DrawPixelInlineNoAlphaCheck(dest,c);
+  case c.alpha of
+: ;
+: dest^ := c;
+  else
+    DrawPixelInlineNoAlphaCheck(dest,c);
+  end;
 end;
 …
 begin
   c.alpha := ApplyOpacity(c.alpha,appliedOpacity);
+  if c.alpha = 0 then
+    exit;
+  if c.alpha = 255 then
+  begin
+    dest^ := c;
+    exit;
+  end;
+  DrawPixelInlineNoAlphaCheck(dest,c);
+  DrawPixelInlineWithAlphaCheck(dest, c);
 end;
 …
 begin
   calpha := ec.alpha shr 8;
+  if calpha = 0 then
+    exit;
+  if calpha = 255 then
+  begin
+    dest^ := GammaCompression(ec);
+    exit;
+  end;
+  DrawExpandedPixelInlineNoAlphaCheck(dest,ec,calpha);
+  case calpha of
+: ;
+: dest^ := GammaCompression(ec);
+  else
+    DrawExpandedPixelInlineNoAlphaCheck(dest,ec,calpha);
+  end;
 end;
 procedure DrawPixelInlineExpandedOrNotWithAlphaCheck(dest: PBGRAPixel; const ec: TExpandedPixel; c: TBGRAPixel);
 begin
+  if c.alpha = 0 then
+    exit;
+  if c.alpha = 255 then
+  begin
+    dest^ := c;
+    exit;
+  end;
+  DrawExpandedPixelInlineNoAlphaCheck(dest,ec,c.alpha);
+  case c.alpha of
+: ;
+: dest^ := c;
+  else
+    DrawExpandedPixelInlineNoAlphaCheck(dest,ec,c.alpha);
+  end;
 end;
 procedure DrawPixelInlineNoAlphaCheck(dest: PBGRAPixel; const c: TBGRAPixel);
 var
+  a1f, a2f, a12, a12m: cardinal;
+begin
+  {$HINTS OFF}
+  a12  := 65025 - (not dest^.alpha) * (not c.alpha);
+  {$HINTS ON}
+  a12m := a12 shr 1;
+  a1f := dest^.alpha * (not c.alpha);
+  a2f := (c.alpha shl 8) - c.alpha;
+  PDWord(dest)^ := ((GammaCompressionTab[(GammaExpansionTab[dest^.red] * a1f +
+                     GammaExpansionTab[c.red] * a2f + a12m) div a12]) shl TBGRAPixel_RedShift) or
+                   ((GammaCompressionTab[(GammaExpansionTab[dest^.green] * a1f +
+                     GammaExpansionTab[c.green] * a2f + a12m) div a12]) shl TBGRAPixel_GreenShift) or
+                   ((GammaCompressionTab[(GammaExpansionTab[dest^.blue] * a1f +
+                     GammaExpansionTab[c.blue] * a2f + a12m) div a12]) shl TBGRAPixel_BlueShift) or
+                   (((a12 + a12 shr 7) shr 8) shl TBGRAPixel_AlphaShift);
+  a1f, a2f, a12, a12m, alphaCorr: NativeUInt;
+begin
+  case dest^.alpha of
+: dest^ := c;
+:
+      begin
+        alphaCorr := c.alpha;
+        if alphaCorr >= 128 then alphaCorr += 1;
+        dest^.red := GammaCompressionTab[(GammaExpansionTab[dest^.red] * NativeUInt(256-alphaCorr) + GammaExpansionTab[c.red]*alphaCorr) shr 8];
+        dest^.green := GammaCompressionTab[(GammaExpansionTab[dest^.green] * NativeUInt(256-alphaCorr) + GammaExpansionTab[c.green]*alphaCorr) shr 8];
+        dest^.blue := GammaCompressionTab[(GammaExpansionTab[dest^.blue] * NativeUInt(256-alphaCorr) + GammaExpansionTab[c.blue]*alphaCorr) shr 8];
+      end;
+    else
+    begin
+      {$HINTS OFF}
+      a12  := 65025 - (not dest^.alpha) * (not c.alpha);
+      {$HINTS ON}
+      a12m := a12 shr 1;
+      a1f := dest^.alpha * (not c.alpha);
+      a2f := (c.alpha shl 8) - c.alpha;
+      PDWord(dest)^ := ((GammaCompressionTab[(GammaExpansionTab[dest^.red] * a1f +
+                         GammaExpansionTab[c.red] * a2f + a12m) div a12]) shl TBGRAPixel_RedShift) or
+                       ((GammaCompressionTab[(GammaExpansionTab[dest^.green] * a1f +
+                         GammaExpansionTab[c.green] * a2f + a12m) div a12]) shl TBGRAPixel_GreenShift) or
+                       ((GammaCompressionTab[(GammaExpansionTab[dest^.blue] * a1f +
+                         GammaExpansionTab[c.blue] * a2f + a12m) div a12]) shl TBGRAPixel_BlueShift) or
+                       (((a12 + a12 shr 7) shr 8) shl TBGRAPixel_AlphaShift);
+    end;
+  end;
 end;
 …
   const ec: TExpandedPixel; calpha: byte);
 var
+  a1f, a2f, a12, a12m: cardinal;
+begin
+  {$HINTS OFF}
+  a12  := 65025 - (not dest^.alpha) * (not calpha);
+  {$HINTS ON}
+  a12m := a12 shr 1;
+  a1f := dest^.alpha * (not calpha);
+  a2f := (calpha shl 8) - calpha;
+  PDWord(dest)^ := ((GammaCompressionTab[(GammaExpansionTab[dest^.red] * a1f +
+                     ec.red * a2f + a12m) div a12]) shl TBGRAPixel_RedShift) or
+                   ((GammaCompressionTab[(GammaExpansionTab[dest^.green] * a1f +
+                     ec.green * a2f + a12m) div a12]) shl TBGRAPixel_GreenShift) or
+                   ((GammaCompressionTab[(GammaExpansionTab[dest^.blue] * a1f +
+                     ec.blue * a2f + a12m) div a12]) shl TBGRAPixel_BlueShift) or
+                   (((a12 + a12 shr 7) shr 8) shl TBGRAPixel_AlphaShift);
+  a1f, a2f, a12, a12m, alphaCorr: NativeUInt;
+begin
+  case dest^.alpha of
+: begin
+         dest^.red := GammaCompressionTab[ec.red];
+         dest^.green := GammaCompressionTab[ec.green];
+         dest^.blue := GammaCompressionTab[ec.blue];
+         dest^.alpha := calpha;
+      end;
+:
+      begin
+        alphaCorr := calpha;
+        if alphaCorr >= 128 then alphaCorr += 1;
+        dest^.red := GammaCompressionTab[(GammaExpansionTab[dest^.red] * NativeUInt(256-alphaCorr) + ec.red*alphaCorr) shr 8];
+        dest^.green := GammaCompressionTab[(GammaExpansionTab[dest^.green] * NativeUInt(256-alphaCorr) + ec.green*alphaCorr) shr 8];
+        dest^.blue := GammaCompressionTab[(GammaExpansionTab[dest^.blue] * NativeUInt(256-alphaCorr) + ec.blue*alphaCorr) shr 8];
+      end;
+    else
+    begin
+      {$HINTS OFF}
+      a12  := 65025 - (not dest^.alpha) * (not calpha);
+      {$HINTS ON}
+      a12m := a12 shr 1;
+      a1f := dest^.alpha * (not calpha);
+      a2f := (calpha shl 8) - calpha;
+      PDWord(dest)^ := ((GammaCompressionTab[(GammaExpansionTab[dest^.red] * a1f +
+                         ec.red * a2f + a12m) div a12]) shl TBGRAPixel_RedShift) or
+                       ((GammaCompressionTab[(GammaExpansionTab[dest^.green] * a1f +
+                         ec.green * a2f + a12m) div a12]) shl TBGRAPixel_GreenShift) or
+                       ((GammaCompressionTab[(GammaExpansionTab[dest^.blue] * a1f +
+                         ec.blue * a2f + a12m) div a12]) shl TBGRAPixel_BlueShift) or
+                       (((a12 + a12 shr 7) shr 8) shl TBGRAPixel_AlphaShift);
+    end;
+  end;
 end;
 procedure FastBlendPixelInline(dest: PBGRAPixel; const c: TBGRAPixel);
 var
+  a1f, a2f, a12, a12m: cardinal;
+begin
+  if c.alpha = 0 then
+    exit;
+  if c.alpha = 255 then
+  begin
+    dest^ := c;
+    exit;
+  end;
+  {$HINTS OFF}
+  a12  := 65025 - (not dest^.alpha) * (not c.alpha);
+  {$HINTS ON}
+  a12m := a12 shr 1;
+  a1f := dest^.alpha * (not c.alpha);
+  a2f := (c.alpha shl 8) - c.alpha;
+  PDWord(dest)^ := (((dest^.red * a1f + c.red * a2f + a12m) div a12) shl TBGRAPixel_RedShift) or
+                   (((dest^.green * a1f + c.green * a2f + a12m) div a12) shl TBGRAPixel_GreenShift) or
+                   (((dest^.blue * a1f + c.blue * a2f + a12m) div a12) shl TBGRAPixel_BlueShift) or
+                   (((a12 + a12 shr 7) shr 8) shl TBGRAPixel_AlphaShift);
+  a1f, a2f, a12, a12m, alphaCorr: NativeUInt;
+begin
+  case c.alpha of
+: ;
+: dest^ := c;
+    else
+    begin
+      case dest^.alpha of
+: dest^ := c;
+:
+        begin
+          alphaCorr := c.alpha;
+          if alphaCorr >= 128 then alphaCorr += 1;
+          dest^.red := (dest^.red * NativeUInt(256-alphaCorr) + c.red*(alphaCorr+1)) shr 8;
+          dest^.green := (dest^.green * NativeUInt(256-alphaCorr) + c.green*(alphaCorr+1)) shr 8;
+          dest^.blue := (dest^.blue * NativeUInt(256-alphaCorr) + c.blue*(alphaCorr+1)) shr 8;
+        end;
+        else
+        begin
+          {$HINTS OFF}
+          a12  := 65025 - (not dest^.alpha) * (not c.alpha);
+          {$HINTS ON}
+          a12m := a12 shr 1;
+          a1f := dest^.alpha * (not c.alpha);
+          a2f := (c.alpha shl 8) - c.alpha;
+          PDWord(dest)^ := (((dest^.red * a1f + c.red * a2f + a12m) div a12) shl TBGRAPixel_RedShift) or
+                           (((dest^.green * a1f + c.green * a2f + a12m) div a12) shl TBGRAPixel_GreenShift) or
+                           (((dest^.blue * a1f + c.blue * a2f + a12m) div a12) shl TBGRAPixel_BlueShift) or
+                           (((a12 + a12 shr 7) shr 8) shl TBGRAPixel_AlphaShift);
+        end;
+      end;
+    end;
+  end;
 end;

GraphicTest/Packages/bgrabitmap/bgracanvas.pas

-              r494
+              r521
                          Filled: boolean = False;
                          Continuous: boolean = False);
+    procedure Draw(X,Y: Integer; SrcBitmap: TBGRACustomBitmap);
+    procedure Draw(X,Y: Integer; SrcBitmap: TBGRACustomBitmap); overload;
+    procedure Draw(X,Y: Integer; SrcBitmap: TBitmap); overload;
     procedure CopyRect(X,Y: Integer; SrcBitmap: TBGRACustomBitmap; SrcRect: TRect);
     procedure StretchDraw(DestRect: TRect; SrcBitmap: TBGRACustomBitmap; HorizFlip: Boolean = false; VertFlip: Boolean = false);
 …
 begin
   FCustomPenStyle := DuplicatePenStyle(AValue);
+  if IsSolidPenStyle(AValue) then FPenStyle := psSolid else
+  if IsClearPenStyle(AValue) then FPenStyle := psClear else
+    FPenStyle := psPattern;
+  FPenStyle:= BGRAToPenStyle(AValue);
 end;
 procedure TBGRAPen.SetPenStyle(const AValue: TPenStyle);
 begin
+  if AValue = psPattern then exit;
   Case AValue of
   psSolid: FCustomPenStyle := SolidPenStyle;
 …
 begin
   if not ComputeEllipseC(x1,y1,x2,y2,cx,cy,rx,ry) then exit;
   angle1 := round(arctan2(-(sy-cy)/ry,(sx-cx)/rx)*65536/(2*Pi));
   angle2 := round(arctan2(-(ey-cy)/ry,(ex-cx)/rx)*65536/(2*Pi));
+  angle1 := round(arctan2(-(sy-cy)/ry,(sx-cx)/rx)*65536/(2*Pi)) and 65535;
+  angle2 := round(arctan2(-(ey-cy)/ry,(ex-cx)/rx)*65536/(2*Pi)) and 65535;
   Arc65536(x1,y1,x2,y2,angle1, angle2, [aoClosePath,aoFillPath]);
 end;
 …
 begin
   if not ComputeEllipseC(x1,y1,x2,y2,cx,cy,rx,ry) then exit;
   angle1 := round(arctan2(-(sy-cy)/ry,(sx-cx)/rx)*65536/(2*Pi));
   angle2 := round(arctan2(-(ey-cy)/ry,(ex-cx)/rx)*65536/(2*Pi));
+  angle1 := round(arctan2(-(sy-cy)/ry,(sx-cx)/rx)*65536/(2*Pi)) and 65535;
+  angle2 := round(arctan2(-(ey-cy)/ry,(ex-cx)/rx)*65536/(2*Pi)) and 65535;
   Arc65536(x1,y1,x2,y2,angle1, angle2, [aoPie,aoFillPath]);
 end;
 …
     multi := TBGRAMultishapeFiller.Create;
     multi.Antialiasing := AntialiasingMode <> amOff;
+    with bounds do
+    begin
+      multi.AddPolygon([PointF(Left-0.5,Top-0.5),PointF(Right-0.5,Top-0.5),
+                        PointF(Right-0.5-width,Top-0.5+width),PointF(Left-0.5+width,Top-0.5+width),
+                        PointF(Left-0.5+width,Bottom-0.5-width),PointF(Left-0.5,Bottom-0.5)],color1);
+      multi.AddPolygon([PointF(Right-0.5,Bottom-0.5),PointF(Left-0.5,Bottom-0.5),
+                        PointF(Left-0.5+width,Bottom-0.5-width),PointF(Right-0.5-width,Bottom-0.5-width),
+                        PointF(Right-0.5-width,Top-0.5+width),PointF(Right-0.5,Top-0.5)],color2);
+    end;
+    multi.AddPolygon([PointF(bounds.Left-0.5,bounds.Top-0.5),PointF(bounds.Right-0.5,bounds.Top-0.5),
+                      PointF(bounds.Right-0.5-width,bounds.Top-0.5+width),PointF(bounds.Left-0.5+width,bounds.Top-0.5+width),
+                      PointF(bounds.Left-0.5+width,bounds.Bottom-0.5-width),PointF(bounds.Left-0.5,bounds.Bottom-0.5)],color1);
+    multi.AddPolygon([PointF(bounds.Right-0.5,bounds.Bottom-0.5),PointF(bounds.Left-0.5,bounds.Bottom-0.5),
+                      PointF(bounds.Left-0.5+width,bounds.Bottom-0.5-width),PointF(bounds.Right-0.5-width,bounds.Bottom-0.5-width),
+                      PointF(bounds.Right-0.5-width,bounds.Top-0.5+width),PointF(bounds.Right-0.5,bounds.Top-0.5)],color2);
     multi.Draw(FBitmap);
     multi.Free;
 …
 end;
+procedure TBGRACanvas.Draw(X, Y: Integer; SrcBitmap: TBitmap);
+begin
+  FBitmap.PutImage(X,Y,SrcBitmap,dmDrawWithTransparency);
+end;
 procedure TBGRACanvas.CopyRect(X, Y: Integer; SrcBitmap: TBGRACustomBitmap;
   SrcRect: TRect);

GraphicTest/Packages/bgrabitmap/bgracanvas2d.pas

-              r494
+              r521
     procedure addColorStop(APosition: single; AColor: string);
     procedure setColors(ACustomGradient: TBGRACustomGradient);
+    function GetGammaCorrection: boolean;
+    procedure SetGammaCorrection(AValue: boolean);
+    property gammaCorrection: boolean read GetGammaCorrection write SetGammaCorrection;
   end;
 …
     strokeTextureProvider: IBGRACanvasTextureProvider2D;
     fillColor: TBGRAPixel;
+    fillMode: TFillMode;
     fillTextureProvider: IBGRACanvasTextureProvider2D;
     globalAlpha: byte;
 …
     FPathPoints: array of TPointF;
     FPathPointCount: integer;
+    FTextPaths: array of record
+        Text: string;
+        FontName: string;
+        FontMatrix: TAffineMatrix;
+        FontAlign: TAlignment;
+        FontAnchor: TFontVerticalAnchor;
+        FontStyle: TFontStyles;
+      end;
     FFontRenderer: TBGRACustomFontRenderer;
     FLastCoord, FStartCoord: TPointF;
 …
     function GetTextAlignLCL: TAlignment;
     function GetTextBaseline: string;
+    function GetFillMode: TFillMode;
     function GetWidth: Integer;
     procedure SetFontName(AValue: string);
 …
     procedure FillPoly(const points: array of TPointF);
     procedure FillStrokePoly(const points: array of TPointF; fillOver: boolean);
+    procedure FillTexts(AErase: boolean);
     procedure SetLineJoinLCL(AValue: TPenJoinStyle);
     procedure SetLineWidth(const AValue: single);
 …
     procedure SetTextAlignLCL(AValue: TAlignment);
     procedure SetTextBaseine(AValue: string);
+    procedure SetFillMode(mode: TFillMode);
     procedure StrokePoly(const points: array of TPointF);
+    procedure DrawShadow(const points, points2: array of TPointF);
+    procedure DrawShadow(const points, points2: array of TPointF; AFillMode: TFillMode = fmWinding);
+    procedure DrawShadowMask(X,Y: integer; AMask: TBGRACustomBitmap; AMaskOwned: boolean);
     procedure ClearPoly(const points: array of TPointF);
     function ApplyTransform(const points: array of TPointF; matrix: TAffineMatrix): ArrayOfTPointF; overload;
 …
     function getCursor: TBGRACustomPathCursor; //IBGRAPath
   public
     antialiasing, linearBlend: boolean;
+    antialiasing, linearBlend, gradientGammaCorrection: boolean;
     constructor Create(ASurface: TBGRACustomBitmap);
     destructor Destroy; override;
 …
     procedure shadowNone;
     function getShadowColor: TBGRAPixel;
     function createLinearGradient(x0,y0,x1,y1: single): IBGRACanvasGradient2D; overload;
     function createLinearGradient(p0,p1: TPointF): IBGRACanvasGradient2D; overload;
     function createLinearGradient(x0,y0,x1,y1: single; Colors: TBGRACustomGradient): IBGRACanvasGradient2D; overload;
     function createLinearGradient(p0,p1: TPointF; Colors: TBGRACustomGradient): IBGRACanvasGradient2D; overload;
+    function createRadialGradient(x0,y0,r0,x1,y1,r1: single; flipGradient: boolean=false): IBGRACanvasGradient2D; overload;
+    function createRadialGradient(p0: TPointF; r0: single; p1: TPointF; r1: single; flipGradient: boolean=false): IBGRACanvasGradient2D; overload;
+    function createRadialGradient(x0,y0,r0,x1,y1,r1: single; Colors: TBGRACustomGradient; flipGradient: boolean=false): IBGRACanvasGradient2D; overload;
+    function createRadialGradient(p0: TPointF; r0: single; p1: TPointF; r1: single; Colors: TBGRACustomGradient; flipGradient: boolean=false): IBGRACanvasGradient2D; overload;
     function createPattern(image: TBGRACustomBitmap; repetition: string): IBGRACanvasTextureProvider2D; overload;
     function createPattern(texture: IBGRAScanner): IBGRACanvasTextureProvider2D; overload;
 …
     procedure moveTo(x,y: single); overload;
     procedure lineTo(x,y: single); overload;
     procedure moveTo(const pt: TPointF); overload;
     procedure lineTo(const pt: TPointF); overload;
+    procedure moveTo(constref pt: TPointF); overload;
+    procedure lineTo(constref pt: TPointF); overload;
     procedure polylineTo(const pts: array of TPointF);
     procedure quadraticCurveTo(cpx,cpy,x,y: single); overload;
     procedure quadraticCurveTo(const cp,pt: TPointF); overload;
+    procedure quadraticCurveTo(constref cp,pt: TPointF); overload;
     procedure bezierCurveTo(cp1x,cp1y,cp2x,cp2y,x,y: single); overload;
     procedure bezierCurveTo(const cp1,cp2,pt: TPointF); overload;
+    procedure bezierCurveTo(constref cp1,cp2,pt: TPointF); overload;
     procedure rect(x,y,w,h: single);
     procedure roundRect(x,y,w,h,radius: single); overload;
 …
     procedure arc(cx, cy, rx,ry, xAngleRadCW, startAngleRadCW, endAngleRadCW: single; anticlockwise: boolean); overload;
     procedure arc(cx, cy, rx,ry, xAngleRadCW, startAngleRadCW, endAngleRadCW: single); overload;
     procedure arc(const arcDef: TArcDef); overload;
+    procedure arc(constref arcDef: TArcDef); overload;
     procedure arcTo(x1, y1, x2, y2, radius: single); overload;
     procedure arcTo(p1,p2: TPointF; radius: single); overload;
 …
     property textAlign: string read GetTextAlign write SetTextAlign;
     property textBaseline: string read GetTextBaseline write SetTextBaseine;
+    property fillMode: TFillMode read GetFillMode write SetFillMode;
     property currentPath: ArrayOfTPointF read GetCurrentPathAsPoints;
 …
     nbColorStops: integer;
     FCustomGradient: TBGRACustomGradient;
+    FGammaCorrection: boolean;
   protected
     scanner: TBGRAGradientScanner;
 …
     function getColorArray: TGradientArrayOfColors;
     function getPositionArray: TGradientArrayOfPositions;
+    procedure GetBGRAGradient(out ABGRAGradient: TBGRACustomGradient; out AOwned: boolean);
+    function GetGammaCorrection: boolean;
+    procedure SetGammaCorrection(AValue: boolean);
   public
+    constructor Create;
     function getTexture: IBGRAScanner; override;
     destructor Destroy; override;
 …
     property texture: IBGRAScanner read GetTexture;
     property colorStopCount: integer read nbColorStops;
+    property gammaCorrection: boolean read GetGammaCorrection write SetGammaCorrection;
   end;
 …
   protected
     o1,o2: TPointF;
+    FTransform: TAffineMatrix;
     procedure CreateScanner; override;
   public
+    constructor Create(x0,y0,x1,y1: single);
+    constructor Create(p0,p1: TPointF);
+    constructor Create(x0,y0,x1,y1: single; transform: TAffineMatrix);
+    constructor Create(p0,p1: TPointF; transform: TAffineMatrix);
+  end;
+  { TBGRACanvasRadialGradient2D }
+  TBGRACanvasRadialGradient2D = class(TBGRACanvasGradient2D)
+  protected
+    c0,c1: TPointF;
+    cr0,cr1: single;
+    FFlipGradient: boolean;
+    FTransform: TAffineMatrix;
+    procedure CreateScanner; override;
+  public
+    constructor Create(x0,y0,r0,x1,y1,r1: single; transform: TAffineMatrix; flipGradient: boolean=false);
+    constructor Create(p0: TPointF; r0: single; p1: TPointF; r1: single; transform: TAffineMatrix; flipGradient: boolean=false);
   end;
 …
     GradientColors: TBGRACustomGradient;
 begin
+  if FCustomGradient = nil then
+  begin
+    GradientColors := TBGRAMultiGradient.Create(getColorArray,getPositionArray,False,False);
+    GradientOwner := true;
+  end else
+  begin
+    GradientColors := FCustomGradient;
+    GradientOwner := false;
+  end;
+  GetBGRAGradient(GradientColors,GradientOwner);
   scanner := TBGRAGradientScanner.Create(GradientColors,gtLinear,o1,o2,False,GradientOwner);
+end;
+constructor TBGRACanvasLinearGradient2D.Create(x0, y0, x1, y1: single);
+  scanner.Transform := FTransform;
+end;
+constructor TBGRACanvasLinearGradient2D.Create(x0, y0, x1, y1: single; transform: TAffineMatrix);
 begin
   o1 := PointF(x0,y0);
   o2 := PointF(x1,y1);
+end;
+constructor TBGRACanvasLinearGradient2D.Create(p0, p1: TPointF);
+  FTransform := transform;
+end;
+constructor TBGRACanvasLinearGradient2D.Create(p0, p1: TPointF; transform: TAffineMatrix);
 begin
   o1 := p0;
   o2 := p1;
+  FTransform := transform;
+end;
+{ TBGRACanvasRadialGradient2D }
+procedure TBGRACanvasRadialGradient2D.CreateScanner;
+var GradientOwner: boolean;
+    GradientColors: TBGRACustomGradient;
+begin
+  GetBGRAGradient(GradientColors,GradientOwner);
+  scanner := TBGRAGradientScanner.Create(GradientColors,c0,cr0,c1,cr1,GradientOwner);
+  scanner.FlipGradient := not FFlipGradient;
+  scanner.Transform := FTransform;
+end;
+constructor TBGRACanvasRadialGradient2D.Create(x0, y0, r0, x1, y1, r1: single;
+  transform: TAffineMatrix; flipGradient: boolean);
+begin
+  self.c0 := PointF(x0,y0);
+  self.cr0 := r0;
+  self.c1 := PointF(x1,y1);
+  self.cr1 := r1;
+  FTransform := transform;
+  FFlipGradient := flipGradient;
+end;
+constructor TBGRACanvasRadialGradient2D.Create(p0: TPointF; r0: single;
+  p1: TPointF; r1: single; transform: TAffineMatrix; flipGradient: boolean);
+begin
+  self.c0 := p0;
+  self.cr0 := r0;
+  self.c1 := p1;
+  self.cr1 := r1;
+  FTransform := transform;
+  FFlipGradient := flipGradient;
 end;
 { TBGRACanvasGradient2D }
 function TBGRACanvasGradient2D.GetTexture: IBGRAScanner;
+function TBGRACanvasGradient2D.getTexture: IBGRAScanner;
 begin
   if scanner = nil then CreateScanner;
   result := scanner;
+end;
+function TBGRACanvasGradient2D.GetGammaCorrection: boolean;
+begin
+  result := FGammaCorrection;
+end;
+procedure TBGRACanvasGradient2D.SetGammaCorrection(AValue: boolean);
+begin
+  FGammaCorrection:= AValue;
+  FreeAndNil(scanner);
+end;
+constructor TBGRACanvasGradient2D.Create;
+begin
+  inherited Create;
+  scanner := nil;
+  FGammaCorrection:= false;
 end;
 …
   for i := 0 to nbColorStops-1 do
     result[i] := colorStops[i].position;
+end;
+procedure TBGRACanvasGradient2D.GetBGRAGradient(out
+  ABGRAGradient: TBGRACustomGradient; out AOwned: boolean);
+begin
+  if FCustomGradient = nil then
+  begin
+    if (colorStopCount = 2) and (colorStops[0].position = 0) and (colorStops[1].position = 1) then
+    begin
+      if FGammaCorrection then
+        ABGRAGradient := TBGRASimpleGradientWithGammaCorrection.Create(colorStops[0].color, colorStops[1].color)
+      else
+        ABGRAGradient := TBGRASimpleGradientWithoutGammaCorrection.Create(colorStops[0].color, colorStops[1].color);
+    end
+    else
+      ABGRAGradient := TBGRAMultiGradient.Create(getColorArray,getPositionArray,FGammaCorrection,False);
+    AOwned := true;
+  end else
+  begin
+    ABGRAGradient := FCustomGradient;
+    AOwned := false;
+  end;
 end;
 …
   result.strokeTextureProvider := strokeTextureProvider;
   result.fillColor := fillColor;
+  result.fillMode := fillMode;
   result.fillTextureProvider := fillTextureProvider;
   result.globalAlpha := globalAlpha;
 …
 procedure TBGRACanvas2D.FillPoly(const points: array of TPointF);
 var
+  bfill: boolean;
   tempScan: TBGRACustomScanner;
 begin
   if (length(points) = 0) or (surface = nil) then exit;
+  If hasShadow then DrawShadow(points,[]);
+  If hasShadow then DrawShadow(points,[],fillMode);
+  bfill:= currentState.fillMode = fmWinding;
   if currentState.clipMaskReadOnly <> nil then
   begin
 …
       tempScan := TBGRASolidColorMaskScanner.Create(currentState.clipMaskReadOnly,Point(0,0),ApplyGlobalAlpha(currentState.fillColor));
     if self.antialiasing then
       BGRAPolygon.FillPolyAntialiasWithTexture(surface, points, tempScan, true, linearBlend)
+      BGRAPolygon.FillPolyAntialiasWithTexture(surface, points, tempScan, bfill, linearBlend)
     else
       BGRAPolygon.FillPolyAliasedWithTexture(surface, points, tempScan, true, GetDrawMode);
+      BGRAPolygon.FillPolyAliasedWithTexture(surface, points, tempScan, bfill, GetDrawMode);
     tempScan.free;
   end else
 …
         tempScan := TBGRAOpacityScanner.Create(currentState.fillTextureProvider.texture, currentState.globalAlpha);
         if self.antialiasing then
           BGRAPolygon.FillPolyAntialiasWithTexture(surface, points, tempScan, true, linearBlend)
+          BGRAPolygon.FillPolyAntialiasWithTexture(surface, points, tempScan, bfill, linearBlend)
         else
           BGRAPolygon.FillPolyAliasedWithTexture(surface, points, tempScan, true, GetDrawMode);
+          BGRAPolygon.FillPolyAliasedWithTexture(surface, points, tempScan, bfill, GetDrawMode);
         tempScan.Free;
       end else
       begin
         if self.antialiasing then
           BGRAPolygon.FillPolyAntialiasWithTexture(surface, points, currentState.fillTextureProvider.texture, true, linearBlend)
+          BGRAPolygon.FillPolyAntialiasWithTexture(surface, points, currentState.fillTextureProvider.texture, bfill, linearBlend)
         else
           BGRAPolygon.FillPolyAliasedWithTexture(surface, points, currentState.fillTextureProvider.texture, true, GetDrawMode);
+          BGRAPolygon.FillPolyAliasedWithTexture(surface, points, currentState.fillTextureProvider.texture, bfill, GetDrawMode);
       end
     end
 …
     begin
       if self.antialiasing then
         BGRAPolygon.FillPolyAntialias(surface, points, ApplyGlobalAlpha(currentState.fillColor), false, true, linearBlend)
+        BGRAPolygon.FillPolyAntialias(surface, points, ApplyGlobalAlpha(currentState.fillColor), false, bfill, linearBlend)
       else
         BGRAPolygon.FillPolyAliased(surface, points, ApplyGlobalAlpha(currentState.fillColor), false, true, GetDrawMode)
+        BGRAPolygon.FillPolyAliased(surface, points, ApplyGlobalAlpha(currentState.fillColor), false, bfill, GetDrawMode)
     end
   end;
 …
   contour : array of TPointF;
   texture: IBGRAScanner;
+  idxContour: Integer;
 begin
   if (length(points) = 0) or (surface = nil) then exit;
 …
   tempScan2 := nil;
   multi := TBGRAMultishapeFiller.Create;
   multi.FillMode := fmWinding;
+  multi.FillMode := self.fillMode;
   if currentState.clipMaskReadOnly <> nil then
   begin
 …
       else
         tempScan2 := TBGRASolidColorMaskScanner.Create(currentState.clipMaskReadOnly,Point(0,0),ApplyGlobalAlpha(currentState.strokeColor));
       multi.AddPolygon(contour,tempScan);
+      idxContour := multi.AddPolygon(contour,tempScan);
     end else
     begin
 …
         texture := nil;
       if texture = nil then
         multi.AddPolygon(contour,ApplyGlobalAlpha(currentState.strokeColor))
+        idxContour := multi.AddPolygon(contour,ApplyGlobalAlpha(currentState.strokeColor))
       else
         multi.AddPolygon(contour,texture);
+        idxContour := multi.AddPolygon(contour,texture);
     end;
+    multi.OverrideFillMode(idxContour, fmWinding);
     If hasShadow then DrawShadow(points,contour);
   end else
 …
   tempScan2.free;
   multi.Free;
+end;
+procedure TBGRACanvas2D.FillTexts(AErase: boolean);
+var
+  i,j: Integer;
+  hy,hx,h: single;
+  bmp,bmpTransf,shadowBmp: TBGRACustomBitmap;
+  tempScan: TBGRACustomScanner;
+  m: TAffineMatrix;
+  s: TSize;
+  surfaceBounds, shadowBounds: TRect;
+  rf: TResampleFilter;
+  pad: TSize;
+  p: PBGRAPixel;
+begin
+  for i := 0 to High(FTextPaths) do
+  with FTextPaths[i] do
+  begin
+    hx := VectLen(FontMatrix[1,1],FontMatrix[2,1]);
+    hy := VectLen(FontMatrix[1,2],FontMatrix[2,2]);
+    h := max(hx,hy);
+    if self.antialiasing then h := round(h);
+    if h<=0 then continue;
+    m := FontMatrix*AffineMatrixScale(hx/sqr(h),hy/sqr(h));
+    if pixelCenteredCoordinates then m := AffineMatrixTranslation(0.5,0.5)*m;
+    bmp := BGRABitmapFactory.Create;
+    try
+      bmp.FontName := FontName;
+      bmp.FontStyle:= FontStyle;
+      bmp.FontHeight:= round(h);
+      if self.antialiasing then
+        bmp.FontQuality := fqFineAntialiasing
+      else
+        bmp.FontQuality:= fqSystem;
+      bmp.FontVerticalAnchor:= FontAnchor;
+      m := m*AffineMatrixTranslation(0,-bmp.FontVerticalAnchorOffset);
+      bmp.FontVerticalAnchor:= fvaTop;
+      s := bmp.TextSize(Text);
+      case FontAlign of
+        taCenter: m := m*AffineMatrixTranslation(-s.cx/2,0);
+        taRightJustify: m := m*AffineMatrixTranslation(-s.cx,0);
+      end;
+      pad := Size(round(h/3), round(h/3));
+      m := m*AffineMatrixTranslation(-pad.cx,-pad.cy);
+      surfaceBounds := surface.GetImageAffineBounds(m, Types.Rect(0,0,s.cx+pad.cx*2,s.cy+pad.cy*2));
+      if hasShadow then
+      begin
+        shadowBounds := surfaceBounds;
+        shadowBounds.Inflate(ceil(shadowBlur),ceil(shadowBlur));
+        shadowBounds.Offset(round(shadowOffsetX),round(shadowOffsetY));
+        shadowBounds.Intersect(surface.ClipRect);
+        if not IsRectEmpty(shadowBounds) then
+        begin
+          shadowBounds.Offset(-round(shadowOffsetX),-round(shadowOffsetY));
+          UnionRect(surfaceBounds, surfaceBounds, shadowBounds);
+        end;
+      end;
+      if not IsRectEmpty(surfaceBounds) then
+      begin
+        bmp.SetSize(s.cx+pad.cx*2,s.cy+pad.cy*2);
+        bmp.Fill(BGRABlack);
+        bmp.TextOut(pad.cx,pad.cy,Text,BGRAWhite);
+        if self.antialiasing then bmp.ConvertToLinearRGB else
+        begin
+          p := bmp.Data;
+          for j := bmp.NbPixels-1 downto 0 do
+          begin
+            if p^.green<128 then p^ := BGRABlack else p^ := BGRAWhite;
+            inc(p);
+          end;
+        end;
+        bmpTransf := BGRABitmapFactory.Create(surfaceBounds.Width,surfaceBounds.Height,BGRABlack);
+        try
+          m := AffineMatrixTranslation(-surfaceBounds.Left,-surfaceBounds.Top)*m;
+          if self.antialiasing then rf:= rfCosine else rf := rfBox;
+          bmpTransf.PutImageAffine(m, bmp, rf, GetDrawMode);
+          FreeAndNil(bmp);
+          if AErase then
+            surface.EraseMask(surfaceBounds.Left,surfaceBounds.Top, bmpTransf) else
+          begin
+            if hasShadow then
+            begin
+              shadowBmp := BGRABitmapFactory.Create(bmpTransf.Width,bmpTransf.Height);
+              shadowBmp.FillMask(0,0, bmpTransf, getShadowColor, GetDrawMode);
+              DrawShadowMask(surfaceBounds.Left+round(shadowOffsetX),surfaceBounds.Top+round(shadowOffsetY), shadowBmp, true);
+            end;
+            if currentState.clipMaskReadOnly <> nil then
+            begin
+              if currentState.fillTextureProvider <> nil then
+                tempScan := TBGRATextureMaskScanner.Create(currentState.clipMaskReadOnly,Point(0,0),currentState.fillTextureProvider.texture,currentState.globalAlpha)
+              else
+                tempScan := TBGRASolidColorMaskScanner.Create(currentState.clipMaskReadOnly,Point(0,0),ApplyGlobalAlpha(currentState.fillColor));
+              surface.FillMask(surfaceBounds.Left,surfaceBounds.Top, bmpTransf, tempScan, GetDrawMode);
+              tempScan.free;
+            end else
+            begin
+              if currentState.fillTextureProvider <> nil then
+              begin
+                if currentState.globalAlpha <> 255 then
+                begin
+                  tempScan := TBGRAOpacityScanner.Create(currentState.fillTextureProvider.texture, currentState.globalAlpha);
+                  surface.FillMask(surfaceBounds.Left,surfaceBounds.Top, bmpTransf, tempScan, GetDrawMode);
+                  tempScan.Free;
+                end else
+                  surface.FillMask(surfaceBounds.Left,surfaceBounds.Top, bmpTransf, currentState.fillTextureProvider.texture, GetDrawMode);
+              end
+              else
+                surface.FillMask(surfaceBounds.Left,surfaceBounds.Top, bmpTransf, ApplyGlobalAlpha(currentState.fillColor), GetDrawMode);
+            end;
+          end;
+        finally
+          bmpTransf.Free;
+        end;
+      end;
+    finally
+      bmp.Free;
+    end;
+  end;
 end;
 …
 end;
 procedure TBGRACanvas2D.DrawShadow(const points, points2: array of TPointF);
 const invSqrt2 = 1/sqrt(2);
+procedure TBGRACanvas2D.DrawShadow(const points, points2: array of TPointF;
+  AFillMode: TFillMode = fmWinding);
 var ofsPts,ofsPts2: array of TPointF;
     offset: TPointF;
     i: Integer;
     tempBmp,blurred: TBGRACustomBitmap;
+    tempBmp: TBGRACustomBitmap;
     maxRect: TRect;
     foundRect: TRect;
 …
   tempBmp := surface.NewBitmap(foundRect.Right-foundRect.Left,foundRect.Bottom-foundRect.Top,BGRAPixelTransparent);
   tempBmp.FillMode := fmWinding;
+  tempBmp.FillMode := AFillMode;
   tempBmp.FillPolyAntialias(ofsPts, getShadowColor);
   tempBmp.FillPolyAntialias(ofsPts2, getShadowColor);
+  DrawShadowMask(foundRect.Left,foundRect.Top, tempBmp, true);
+end;
+procedure TBGRACanvas2D.DrawShadowMask(X, Y: integer; AMask: TBGRACustomBitmap; AMaskOwned: boolean);
+const invSqrt2 = 1/sqrt(2);
+var
+  bmp: TBGRACustomBitmap;
+begin
+  bmp := AMask;
   if shadowBlur > 0 then
   begin
 …
     begin
       if shadowBlur*invSqrt2 >= 0.5 then
+      begin
+        blurred := tempBmp.FilterBlurRadial(round(shadowBlur*invSqrt2),rbBox);
+        tempBmp.Free;
+        tempBmp := blurred;
+      end;
+        bmp := AMask.FilterBlurRadial(round(shadowBlur*invSqrt2),rbBox);
     end
     else
     begin
       if (shadowBlur < 5) and (abs(shadowBlur-round(shadowBlur)) > 1e-6) then
         blurred := tempBmp.FilterBlurRadial(round(shadowBlur*10),rbPrecise)
+        bmp := AMask.FilterBlurRadial(round(shadowBlur*10),rbPrecise)
       else
+        blurred := tempBmp.FilterBlurRadial(round(shadowBlur),rbFast);
+      tempBmp.Free;
+      tempBmp := blurred;
+        bmp := AMask.FilterBlurRadial(round(shadowBlur),rbFast);
     end;
   end;
   if currentState.clipMaskReadOnly <> nil then
+    tempBmp.ApplyMask(currentState.clipMaskReadOnly);
+  surface.PutImage(foundRect.Left,foundRect.Top,tempBmp,GetDrawMode,currentState.globalAlpha);
+  tempBmp.Free;
+  begin
+    if (bmp = AMask) and not AMaskOwned then bmp := AMask.Duplicate;
+    bmp.ApplyMask(currentState.clipMaskReadOnly);
+  end;
+  surface.PutImage(X,Y,bmp,GetDrawMode,currentState.globalAlpha);
+  if bmp <> AMask then bmp.Free;
+  if AMaskOwned then AMask.Free;
 end;
 …
   pixelCenteredCoordinates := false;
   antialiasing := true;
+  gradientGammaCorrection := false;
 end;
 …
 end;
+function TBGRACanvas2D.GetFillMode: TFillMode;
+begin
+  result := currentState.fillMode;
+end;
+procedure TBGRACanvas2D.SetFillMode(mode: TFillMode);
+begin
+  currentState.fillMode := mode;
+end;
 procedure TBGRACanvas2D.fillStyle(color: TBGRAPixel);
 begin
 …
 end;
 function TBGRACanvas2D.createLinearGradient(x0, y0, x1, y1: single
+  ): IBGRACanvasGradient2D;
+begin
   result := createLinearGradient(ApplyTransform(PointF(x0,y0)), ApplyTransform(PointF(x1,y1)));
+end;
+function TBGRACanvas2D.createLinearGradient(p0, p1: TPointF
   ): IBGRACanvasGradient2D;
+begin
   result := TBGRACanvasLinearGradient2D.Create(p0,p1);
+function TBGRACanvas2D.createLinearGradient(x0, y0, x1, y1: single): IBGRACanvasGradient2D;
+begin
+  result := createLinearGradient(PointF(x0,y0), PointF(x1,y1));
+end;
+function TBGRACanvas2D.createLinearGradient(p0, p1: TPointF): IBGRACanvasGradient2D;
+begin
+  result := TBGRACanvasLinearGradient2D.Create(p0,p1,
+            AffineMatrixTranslation(FCanvasOffset.x,FCanvasOffset.y)*currentState.matrix);
+  result.gammaCorrection := gradientGammaCorrection;
 end;
 …
 begin
   result := createLinearGradient(p0,p1);
+  result.setColors(Colors);
+end;
+function TBGRACanvas2D.createRadialGradient(x0, y0, r0, x1, y1, r1: single;
+  flipGradient: boolean): IBGRACanvasGradient2D;
+begin
+  result := createRadialGradient(PointF(x0,y0), r0, PointF(x1,y1), r1, flipGradient);
+end;
+function TBGRACanvas2D.createRadialGradient(p0: TPointF; r0: single;
+  p1: TPointF; r1: single; flipGradient: boolean): IBGRACanvasGradient2D;
+begin
+  result := TBGRACanvasRadialGradient2D.Create(p0,r0,p1,r1,
+            AffineMatrixTranslation(FCanvasOffset.x,FCanvasOffset.y)*currentState.matrix,
+            flipGradient);
+  result.gammaCorrection := gradientGammaCorrection;
+end;
+function TBGRACanvas2D.createRadialGradient(x0, y0, r0, x1, y1, r1: single;
+  Colors: TBGRACustomGradient; flipGradient: boolean): IBGRACanvasGradient2D;
+begin
+  result := createRadialGradient(x0,y0,r0,x1,y1,r1,flipGradient);
+  result.setColors(Colors);
+end;
+function TBGRACanvas2D.createRadialGradient(p0: TPointF; r0: single;
+  p1: TPointF; r1: single; Colors: TBGRACustomGradient; flipGradient: boolean): IBGRACanvasGradient2D;
+begin
+  result := createRadialGradient(p0,r0,p1,r1,flipGradient);
   result.setColors(Colors);
 end;
 …
   FLastCoord := EmptyPointF;
   FStartCoord := EmptyPointF;
+  FTextPaths := nil;
 end;
 …
 end;
 procedure TBGRACanvas2D.moveTo(const pt: TPointF);
+procedure TBGRACanvas2D.moveTo(constref pt: TPointF);
 begin
   if (FPathPointCount <> 0) and not isEmptyPointF(FPathPoints[FPathPointCount-1]) then
 …
 end;
 procedure TBGRACanvas2D.lineTo(const pt: TPointF);
+procedure TBGRACanvas2D.lineTo(constref pt: TPointF);
 begin
   AddPoint(ApplyTransform(pt));
 …
 end;
 procedure TBGRACanvas2D.quadraticCurveTo(const cp, pt: TPointF);
+procedure TBGRACanvas2D.quadraticCurveTo(constref cp, pt: TPointF);
 begin
   quadraticCurveTo(cp.x,cp.y,pt.x,pt.y);
 …
 end;
 procedure TBGRACanvas2D.bezierCurveTo(const cp1, cp2, pt: TPointF);
+procedure TBGRACanvas2D.bezierCurveTo(constref cp1, cp2, pt: TPointF);
 begin
   bezierCurveTo(cp1.x,cp1.y,cp2.x,cp2.y,pt.x,pt.y);
 …
 end;
 procedure TBGRACanvas2D.arc(const arcDef: TArcDef);
+procedure TBGRACanvas2D.arc(constref arcDef: TArcDef);
 var previousMatrix: TAffineMatrix;
 begin
 …
 var renderer : TBGRACustomFontRenderer;
   previousMatrix: TAffineMatrix;
+  fva: TFontVerticalAnchor;
 begin
   renderer := fontRenderer;
+  if renderer = nil then exit;
   if renderer.FontEmHeight <= 0 then exit;
+  previousMatrix := currentState.matrix;
+  scale(currentState.fontEmHeight/renderer.FontEmHeight);
+  if (currentState.textBaseline <> 'top') and
+    (currentState.textBaseline <> 'hanging') then
+  with renderer.GetFontPixelMetric do
+  begin
+    if currentState.textBaseline = 'bottom' then
+       translate(0,-Lineheight)
+    else if currentState.textBaseline = 'middle' then
+       translate(0,-Lineheight/2)
+    else if currentState.textBaseline = 'alphabetic' then
+       translate(0,-baseline);
+  end;
+  if renderer <> nil then
+    renderer.CopyTextPathTo(self, x,y, AText, taLeftJustify);
+  currentState.matrix := previousMatrix;
+  case currentState.textBaseline of
+    'bottom': fva := fvaBottom;
+    'middle': fva := fvaCenter;
+    'alphabetic': fva := fvaBaseline;
+    else {'top','hanging'}
+      fva := fvaTop;
+  end;
+  if renderer.HandlesTextPath then
+  begin
+    previousMatrix := currentState.matrix;
+    translate(x,y);
+    scale(currentState.fontEmHeight/renderer.FontEmHeight);
+    if fva <> fvaTop then
+    with renderer.GetFontPixelMetric do
+    case fva of
+      fvaBottom: translate(0,-Lineheight);
+      fvaCenter: translate(0,-Lineheight/2);
+      fvaBaseline: translate(0,-baseline);
+    end;
+    renderer.CopyTextPathTo(self, 0,0, AText, textAlignLCL);
+    currentState.matrix := previousMatrix;
+  end else
+  begin
+    setlength(FTextPaths, length(FTextPaths)+1);
+    FTextPaths[high(FTextPaths)].Text := AText;
+    FTextPaths[high(FTextPaths)].FontName := fontName;
+    FTextPaths[high(FTextPaths)].FontMatrix := currentState.matrix*AffineMatrixTranslation(x,y)*AffineMatrixScale(fontEmHeight,fontEmHeight);
+    FTextPaths[high(FTextPaths)].FontStyle := fontStyle;
+    FTextPaths[high(FTextPaths)].FontAlign := textAlignLCL;
+    FTextPaths[high(FTextPaths)].FontAnchor := fva;
+  end;
   FLastCoord := EmptyPointF;
   FStartCoord := EmptyPointF;
 …
 procedure TBGRACanvas2D.fill;
 begin
+  if FPathPointCount = 0 then exit;
+  FillPoly(slice(FPathPoints,FPathPointCount));
+  if FPathPointCount > 0 then
+    FillPoly(slice(FPathPoints,FPathPointCount));
+  FillTexts(false);
 end;
 procedure TBGRACanvas2D.stroke;
 begin
   if FPathPointCount = 0 then exit;
   StrokePoly(slice(FPathPoints,FPathPointCount));
+  if FPathPointCount > 0 then
+    StrokePoly(slice(FPathPoints,FPathPointCount));
 end;
 procedure TBGRACanvas2D.fillOverStroke;
 begin
+  if FPathPointCount = 0 then exit;
+  FillStrokePoly(slice(FPathPoints,FPathPointCount),true);
+  if FPathPointCount > 0 then
+    FillStrokePoly(slice(FPathPoints,FPathPointCount),true);
+  FillTexts(false);
 end;
 procedure TBGRACanvas2D.strokeOverFill;
 begin
+  if FPathPointCount = 0 then exit;
+  FillStrokePoly(slice(FPathPoints,FPathPointCount),false);
+  FillTexts(false);
+  if FPathPointCount > 0 then
+    FillStrokePoly(slice(FPathPoints,FPathPointCount),false);
 end;
 procedure TBGRACanvas2D.clearPath;
 begin
+  if FPathPointCount = 0 then exit;
+  ClearPoly(slice(FPathPoints,FPathPointCount));
+  if FPathPointCount > 0 then
+    ClearPoly(slice(FPathPoints,FPathPointCount));
+  FillTexts(true);
 end;
 …
   begin
     setlength(FPathPoints,FPathPointCount);
     result := IsPointInPolygon(FPathPoints,pt+FCanvasOffset,True);
+    result := IsPointInPolygon(FPathPoints,pt+FCanvasOffset, fillMode = fmWinding);
   end;
 end;

GraphicTest/Packages/bgrabitmap/bgracanvasgl.pas

-              r494
+              r521
     function GetUniformVariable(AProgram: DWord; AName: string): DWord; virtual; abstract;
     function GetAttribVariable(AProgram: DWord; AName: string): DWord; virtual; abstract;
     procedure SetUniformSingle(AVariable: DWord; const AValue; ACount: integer); virtual; abstract;
     procedure SetUniformInteger(AVariable: DWord; const AValue; ACount: integer); virtual; abstract;
+    procedure SetUniformSingle(AVariable: DWord; const AValue; AElementCount, AComponentCount: integer); virtual; abstract;
+    procedure SetUniformInteger(AVariable: DWord; const AValue; AElementCount, AComponentCount: integer); virtual; abstract;
     procedure BindAttribute(AAttribute: TAttributeVariable); virtual; abstract;
     procedure UnbindAttribute(AAttribute: TAttributeVariable); virtual; abstract;
 …
   TBGLCustomCanvas = class
   private
+    FActiveFrameBuffer: TBGLCustomFrameBuffer;
     FHeight: integer;
     FWidth: integer;
 …
     FClipRect: TRect;
   protected
     procedure SwapRect(var r: TRect);
     procedure SwapRect(var x1,y1,x2,y2: single);
+    procedure SwapRect(var r: TRect); overload;
+    procedure SwapRect(var x1,y1,x2,y2: single); overload;
     procedure InternalArc(cx,cy,rx,ry: single; const StartPoint,EndPoint: TPointF; ABorderColor,AOuterFillColor,ACenterFillColor: TBGRAPixel; AOptions: TArcOptions; ADrawChord: boolean = false); overload;
     procedure InternalArc(cx,cy,rx,ry: single; StartAngleRad,EndAngleRad: Single; ABorderColor,AOuterFillColor,ACenterFillColor: TBGRAPixel; AOptions: TArcOptions; ADrawChord: boolean = false); overload;
     procedure InternalArcInRect(r: TRect; StartAngleRad,EndAngleRad: Single; ABorderColor,AOuterFillColor,ACenterFillColor: TBGRAPixel; AOptions: TArcOptions; ADrawChord: boolean = false); overload;
     function ComputeEllipseC(r: TRect; AHasBorder: boolean; out cx,cy,rx,ry: single): boolean;
+    function GetHeight: integer; virtual;
+    function GetWidth: integer; virtual;
     procedure SetWidth(AValue: integer); virtual;
     procedure SetHeight(AValue: integer); virtual;
 …
     function GetFaceCulling: TFaceCulling; virtual; abstract;
     procedure SetFaceCulling(AValue: TFaceCulling); virtual; abstract;
+    procedure SetActiveFrameBuffer(AValue: TBGLCustomFrameBuffer); virtual;
     function GetLighting: TBGLCustomLighting; virtual;
 …
     procedure InternalStartPolygon(const pt: TPointF); virtual; abstract;
     procedure InternalStartTriangleFan(const pt: TPointF); virtual; abstract;
     procedure InternalContinueShape(const pt: TPointF); virtual; abstract;
     procedure InternalContinueShape(const {%H-}pt: TPoint3D); virtual; overload;
     procedure InternalContinueShape(const {%H-}pt: TPoint3D_128); virtual; overload;
     procedure InternalContinueShape(const {%H-}pt, {%H-}normal: TPoint3D_128); virtual; overload;
+    procedure InternalContinueShape(const pt: TPointF); overload; virtual; abstract;
+    procedure InternalContinueShape(const {%H-}pt: TPoint3D); overload; virtual;
+    procedure InternalContinueShape(const {%H-}pt: TPoint3D_128); overload; virtual;
+    procedure InternalContinueShape(const {%H-}pt, {%H-}normal: TPoint3D_128); overload; virtual;
     procedure InternalEndShape; virtual; abstract;
 …
     procedure Fill(AColor: TBGRAPixel); virtual; abstract;
     procedure PutPixels(const APoints: array of TPointF; AColor: TBGRAPixel); virtual; overload;
     procedure PutPixels(const APoints: array of TPointF; const AColors: array of TBGRAPixel); virtual; overload;
     procedure Line(x1,y1,x2,y2: single; AColor: TBGRAPixel; ADrawLastPoint: boolean = true);
     procedure Line(p1,p2: TPointF; AColor: TBGRAPixel; ADrawLastPoint: boolean = true);
+    procedure PutPixels(const APoints: array of TPointF; AColor: TBGRAPixel); overload; virtual;
+    procedure PutPixels(const APoints: array of TPointF; const AColors: array of TBGRAPixel); overload; virtual;
+    procedure Line(x1,y1,x2,y2: single; AColor: TBGRAPixel; ADrawLastPoint: boolean = true); overload;
+    procedure Line(p1,p2: TPointF; AColor: TBGRAPixel; ADrawLastPoint: boolean = true); overload;
     procedure Polylines(const APoints: array of TPointF; AColor: TBGRAPixel; ADrawLastPoints: boolean = true); virtual;
 …
     procedure FillPolyConvex(const APoints: array of TPointF; AColor: TBGRAPixel; APixelCenteredCoordinates: boolean = true);
     procedure FillTriangleLinearColor(pt1,pt2,pt3: TPointF; c1,c2,c3: TBGRAPixel; APixelCenteredCoordinates: boolean = true);
     procedure FillTriangles(const APoints: array of TPointF; AColor: TBGRAPixel; APixelCenteredCoordinates: boolean = true); virtual;
     procedure FillTrianglesLinearColor(const APoints: array of TPointF; const AColors: array of TBGRAPixel; APixelCenteredCoordinates: boolean = true); virtual; overload;
     procedure FillTrianglesLinearColor(const APoints: array of TPoint3D; const AColors: array of TBGRAPixel); virtual; overload;
     procedure FillTrianglesLinearColor(const APoints: array of TPoint3D_128; const AColors: array of TBGRAPixel); virtual; overload;
     procedure FillTrianglesLinearColor(const APoints, ANormals: array of TPoint3D_128; const AColors: array of TBGRAPixel); virtual; overload;
     procedure FillTrianglesFan(const APoints: array of TPointF; ACenterColor, ABorderColor: TBGRAPixel; APixelCenteredCoordinates: boolean = true); virtual;
     procedure FillTriangleLinearColor(pt1,pt2,pt3: TPointF; c1,c2,c3: TColorF; APixelCenteredCoordinates: boolean = true);
     procedure FillTriangles(const APoints: array of TPointF; AColor: TColorF; APixelCenteredCoordinates: boolean = true); virtual;
     procedure FillTrianglesLinearColor(const APoints: array of TPointF; const AColors: array of TColorF; APixelCenteredCoordinates: boolean = true); virtual; overload;
     procedure FillTrianglesLinearColor(const APoints: array of TPoint3D; const AColors: array of TColorF); virtual; overload;
     procedure FillTrianglesLinearColor(const APoints: array of TPoint3D_128; const AColors: array of TColorF); virtual; overload;
     procedure FillTrianglesLinearColor(const APoints, ANormals: array of TPoint3D_128; const AColors: array of TColorF); virtual; overload;
     procedure FillTrianglesFan(const APoints: array of TPointF; ACenterColor, ABorderColor: TColorF; APixelCenteredCoordinates: boolean = true); virtual;
     procedure FillQuadLinearColor(pt1,pt2,pt3,pt4: TPointF; c1,c2,c3,c4: TBGRAPixel; APixelCenteredCoordinates: boolean = true);
     procedure FillQuads(const APoints: array of TPointF; AColor: TBGRAPixel; APixelCenteredCoordinates: boolean = true); virtual;
     procedure FillQuadsLinearColor(const APoints: array of TPointF; const AColors: array of TBGRAPixel; APixelCenteredCoordinates: boolean = true); virtual; overload;
     procedure FillQuadsLinearColor(const APoints: array of TPoint3D; const AColors: array of TBGRAPixel); virtual; overload;
     procedure FillQuadsLinearColor(const APoints: array of TPoint3D_128; const AColors: array of TBGRAPixel); virtual; overload;
     procedure FillQuadsLinearColor(const APoints, ANormals: array of TPoint3D_128; const AColors: array of TBGRAPixel); virtual; overload;
     procedure FillQuadLinearColor(pt1,pt2,pt3,pt4: TPointF; c1,c2,c3,c4: TColorF; APixelCenteredCoordinates: boolean = true);
     procedure FillQuads(const APoints: array of TPointF; AColor: TColorF; APixelCenteredCoordinates: boolean = true); virtual;
     procedure FillQuadsLinearColor(const APoints: array of TPointF; const AColors: array of TColorF; APixelCenteredCoordinates: boolean = true); virtual; overload;
     procedure FillQuadsLinearColor(const APoints: array of TPoint3D; const AColors: array of TColorF); virtual; overload;
     procedure FillQuadsLinearColor(const APoints: array of TPoint3D_128; const AColors: array of TColorF); virtual; overload;
     procedure FillQuadsLinearColor(const APoints, ANormals: array of TPoint3D_128; const AColors: array of TColorF); virtual; overload;
+    procedure FillTriangleLinearColor(pt1,pt2,pt3: TPointF; c1,c2,c3: TBGRAPixel; APixelCenteredCoordinates: boolean = true); overload;
+    procedure FillTriangles(const APoints: array of TPointF; AColor: TBGRAPixel; APixelCenteredCoordinates: boolean = true); overload; virtual;
+    procedure FillTrianglesLinearColor(const APoints: array of TPointF; const AColors: array of TBGRAPixel; APixelCenteredCoordinates: boolean = true); overload; virtual;
+    procedure FillTrianglesLinearColor(const APoints: array of TPoint3D; const AColors: array of TBGRAPixel); overload; virtual;
+    procedure FillTrianglesLinearColor(const APoints: array of TPoint3D_128; const AColors: array of TBGRAPixel); overload; virtual;
+    procedure FillTrianglesLinearColor(const APoints, ANormals: array of TPoint3D_128; const AColors: array of TBGRAPixel); overload; virtual;
+    procedure FillTrianglesFan(const APoints: array of TPointF; ACenterColor, ABorderColor: TBGRAPixel; APixelCenteredCoordinates: boolean = true); overload; virtual;
+    procedure FillTriangleLinearColor(pt1,pt2,pt3: TPointF; c1,c2,c3: TColorF; APixelCenteredCoordinates: boolean = true); overload;
+    procedure FillTriangles(const APoints: array of TPointF; AColor: TColorF; APixelCenteredCoordinates: boolean = true); overload; virtual;
+    procedure FillTrianglesLinearColor(const APoints: array of TPointF; const AColors: array of TColorF; APixelCenteredCoordinates: boolean = true); overload; virtual;
+    procedure FillTrianglesLinearColor(const APoints: array of TPoint3D; const AColors: array of TColorF); overload; virtual;
+    procedure FillTrianglesLinearColor(const APoints: array of TPoint3D_128; const AColors: array of TColorF); overload; virtual;
+    procedure FillTrianglesLinearColor(const APoints, ANormals: array of TPoint3D_128; const AColors: array of TColorF); overload; virtual;
+    procedure FillTrianglesFan(const APoints: array of TPointF; ACenterColor, ABorderColor: TColorF; APixelCenteredCoordinates: boolean = true); overload; virtual;
+    procedure FillQuadLinearColor(pt1,pt2,pt3,pt4: TPointF; c1,c2,c3,c4: TBGRAPixel; APixelCenteredCoordinates: boolean = true); overload;
+    procedure FillQuads(const APoints: array of TPointF; AColor: TBGRAPixel; APixelCenteredCoordinates: boolean = true); overload; virtual;
+    procedure FillQuadsLinearColor(const APoints: array of TPointF; const AColors: array of TBGRAPixel; APixelCenteredCoordinates: boolean = true); overload; virtual;
+    procedure FillQuadsLinearColor(const APoints: array of TPoint3D; const AColors: array of TBGRAPixel); overload; virtual;
+    procedure FillQuadsLinearColor(const APoints: array of TPoint3D_128; const AColors: array of TBGRAPixel); overload; virtual;
+    procedure FillQuadsLinearColor(const APoints, ANormals: array of TPoint3D_128; const AColors: array of TBGRAPixel); overload; virtual;
+    procedure FillQuadLinearColor(pt1,pt2,pt3,pt4: TPointF; c1,c2,c3,c4: TColorF; APixelCenteredCoordinates: boolean = true); overload;
+    procedure FillQuads(const APoints: array of TPointF; AColor: TColorF; APixelCenteredCoordinates: boolean = true); overload; virtual;
+    procedure FillQuadsLinearColor(const APoints: array of TPointF; const AColors: array of TColorF; APixelCenteredCoordinates: boolean = true); overload; virtual;
+    procedure FillQuadsLinearColor(const APoints: array of TPoint3D; const AColors: array of TColorF); overload; virtual;
+    procedure FillQuadsLinearColor(const APoints: array of TPoint3D_128; const AColors: array of TColorF); overload; virtual;
+    procedure FillQuadsLinearColor(const APoints, ANormals: array of TPoint3D_128; const AColors: array of TColorF); overload; virtual;
     procedure DrawPath(APath: TBGLPath; c: TBGRAPixel);
     procedure FillPathConvex(APath: TBGLPath; c: TBGRAPixel; APixelCenteredCoordinates: boolean = true);
     procedure FillRectLinearColor(r: TRect; ATopLeftColor, ATopRightColor, ABottomRightColor, ABottomLeftColor: TBGRAPixel); virtual; overload;
+    procedure FillRectLinearColor(r: TRect; ATopLeftColor, ATopRightColor, ABottomRightColor, ABottomLeftColor: TBGRAPixel); overload; virtual;
     procedure FillRectLinearColor(x1,y1,x2,y2: single;
          ATopLeftColor, ATopRightColor, ABottomRightColor, ABottomLeftColor: TBGRAPixel;
          APixelCenteredCoordinates: boolean = true); virtual; overload;
+         APixelCenteredCoordinates: boolean = true); overload; virtual;
     procedure Ellipse(cx,cy,rx,ry: single; AColor: TBGRAPixel); overload;
 …
     procedure FillRect(r: TRect; AColor: TBGRAPixel); overload;
     procedure FillRect(r: TRectF; AColor: TBGRAPixel; APixelCenteredCoordinates: boolean = false); overload;
     procedure FillRect(r: TRect; AScanner: IBGRAScanner); virtual; overload;
+    procedure FillRect(r: TRect; AScanner: IBGRAScanner); overload; virtual;
     procedure RoundRect(x1,y1,x2,y2,rx,ry: single; ABorderColor: TBGRAPixel; options: TRoundRectangleOptions = []); overload;
     procedure RoundRect(x1,y1,x2,y2,rx,ry: single; ABorderColor,AFillColor: TBGRAPixel; options: TRoundRectangleOptions = []); overload;
 …
     procedure ResetTransform; virtual;
     procedure UseOrthoProjection; virtual; overload;
     procedure UseOrthoProjection(AMinX,AMinY,AMaxX,AMaxY: single); virtual; overload;
+    procedure UseOrthoProjection; overload; virtual;
+    procedure UseOrthoProjection(AMinX,AMinY,AMaxX,AMaxY: single); overload; virtual;
     procedure StartZBuffer; virtual;
     procedure EndZBuffer; virtual;
     procedure WaitForGPU({%H-}AOption: TWaitForGPUOption); virtual;
+    function GetImage({%H-}x,{%H-}y,{%H-}w,{%H-}h: integer): TBGRACustomBitmap; virtual;
+    function CreateFrameBuffer({%H-}AWidth,{%H-}AHeight: integer): TBGLCustomFrameBuffer; virtual;
     procedure NoClip;
+    property Width: integer read FWidth write SetWidth;
+    property Height: integer read FHeight write SetHeight;
+    property ActiveFrameBuffer: TBGLCustomFrameBuffer read FActiveFrameBuffer write SetActiveFrameBuffer;
+    property Width: integer read GetWidth write SetWidth;
+    property Height: integer read GetHeight write SetHeight;
     property ClipRect: TRect read GetClipRect write SetClipRect;
     property Matrix: TAffineMatrix read GetMatrix write SetMatrix;
 …
 var index: integer;
 begin
+  if ShaderList = nil then ShaderList := TStringList.Create;
   index := ShaderList.IndexOf(AName);
   if index = -1 then
 …
 var index: integer;
 begin
+  if ShaderList = nil then ShaderList := TStringList.Create;
   index := ShaderList.IndexOf(AName);
   if AValue = nil then
 …
   end;
   result := true;
+end;
+function TBGLCustomCanvas.GetHeight: integer;
+begin
+  if FActiveFrameBuffer = nil then
+    result := FHeight
+  else
+    result := FActiveFrameBuffer.Height;
+end;
+function TBGLCustomCanvas.GetWidth: integer;
+begin
+  if FActiveFrameBuffer = nil then
+    result := FWidth
+  else
+    result := FActiveFrameBuffer.Width;
 end;
 …
 end;
+procedure TBGLCustomCanvas.SetActiveFrameBuffer(AValue: TBGLCustomFrameBuffer);
+begin
+  if FActiveFrameBuffer=AValue then Exit;
+  if FActiveFrameBuffer <> nil then
+    FActiveFrameBuffer.SetCanvas(nil);
+  FActiveFrameBuffer:=AValue;
+  if FActiveFrameBuffer <> nil then
+    FActiveFrameBuffer.SetCanvas(self);
+end;
 procedure TBGLCustomCanvas.SwapRect(var r: TRect);
 var
 …
   ATexture: IBGLTexture; AAlpha: byte);
 begin
+  {$PUSH}{$OPTIMIZATION OFF}
   ATexture.DrawAffine(Origin, HAxis, VAxis, AAlpha);
+  {$POP}
 end;
 …
   ATexture: IBGLTexture; AColor: TBGRAPixel);
 begin
+  {$PUSH}{$OPTIMIZATION OFF}
   ATexture.DrawAffine(Origin, HAxis, VAxis, AColor);
+  {$POP}
 end;
 …
 end;
+function TBGLCustomCanvas.GetImage(x, y, w, h: integer): TBGRACustomBitmap;
+begin
+  result := nil;
+end;
+function TBGLCustomCanvas.CreateFrameBuffer(AWidth, AHeight: integer): TBGLCustomFrameBuffer;
+begin
+  result := nil;
+  raise exception.Create('Not implemented');
+end;
 end.

GraphicTest/Packages/bgrabitmap/bgracolorquantization.pas

-              r494
+              r521
     FSeparateAlphaChannel: boolean;
     procedure Init(ABox: TBGRAColorBox);
     procedure NormalizeArrayOfColors(AColors: ArrayOfTBGRAPixel; ARedBounds, AGreenBounds, ABlueBounds, AAlphaBounds: TDimensionMinMax; AUniform: boolean);
     procedure NormalizeArrayOfColors(AColors: ArrayOfTBGRAPixel; AColorBounds, AAlphaBounds: TDimensionMinMax);
+    procedure NormalizeArrayOfColors(AColors: ArrayOfTBGRAPixel; ARedBounds, AGreenBounds, ABlueBounds, AAlphaBounds: TDimensionMinMax; AUniform: boolean); overload;
+    procedure NormalizeArrayOfColors(AColors: ArrayOfTBGRAPixel; AColorBounds, AAlphaBounds: TDimensionMinMax); overload;
   protected
     function GetPalette: TBGRACustomApproxPalette; override;
 …
     destructor Destroy; override;
     procedure ApplyDitheringInplace(AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap; ABounds: TRect); override;
     function GetDitheredBitmap(AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap; ABounds: TRect): TBGRACustomBitmap; override;
+    function GetDitheredBitmap(AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap; ABounds: TRect): TBGRACustomBitmap; overload; override;
     function GetDitheredBitmapIndexedData(ABitDepth: integer; AByteOrder: TRawImageByteOrder; AAlgorithm: TDitheringAlgorithm;
       ABitmap: TBGRACustomBitmap; out AScanlineSize: PtrInt): Pointer; override;
+      ABitmap: TBGRACustomBitmap; out AScanlineSize: PtrInt): Pointer; overload; override;
     procedure SaveBitmapToStream(AAlgorithm: TDitheringAlgorithm;
       ABitmap: TBGRACustomBitmap; AStream: TStream; AFormat: TBGRAImageFormat); override;
 …
 implementation
 uses BGRADithering, FPimage, FPWriteBMP, BGRAWritePNG;
+uses BGRADithering, FPimage, FPWriteBMP, BGRAWritePNG, math;
 const MedianMinPercentage = 0.2;
 …
       begin
         FLeafColorComputed := true;
         FCenterColor.alpha:= FLeaf.FBounds[cdAlpha].GetCenter shr AlphaShift;
         FCenterColor.red:= GammaCompressionTab[FLeaf.FBounds[cdRed].GetCenter shr RedShift];
         FCenterColor.green:= GammaCompressionTab[FLeaf.FBounds[cdGreen].GetCenter shr GreenShift];
         FCenterColor.blue:= GammaCompressionTab[FLeaf.FBounds[cdBlue].GetCenter];
+        FCenterColor.alpha:= min(FLeaf.FBounds[cdAlpha].GetCenter shr AlphaShift, 255);
+        FCenterColor.red:= GammaCompressionTab[min(FLeaf.FBounds[cdRed].GetCenter shr RedShift, 65535)];
+        FCenterColor.green:= GammaCompressionTab[min(FLeaf.FBounds[cdGreen].GetCenter shr GreenShift, 65535)];
+        FCenterColor.blue:= GammaCompressionTab[min(FLeaf.FBounds[cdBlue].GetCenter, 65535)];
         FAverageColor := FLeaf.AverageColorOrMainColor;
         extremumColor := FAverageColor;

GraphicTest/Packages/bgrabitmap/bgracompressablebitmap.pas

-              r494
+              r521
    public
      CompressionLevel: Tcompressionlevel;
      constructor Create;
      constructor Create(Source: TBGRABitmap);
+     constructor Create; overload;
+     constructor Create(Source: TBGRABitmap); overload;
      function GetBitmap: TBGRABitmap;
      //call Compress as many times as necessary
      //when it returns false, it means that
 …
 implementation
+uses BGRAUTF8;
 // size of each chunk treated by Compress function
 const maxPartSize = 524288;
 …
     comp := Tcompressionstream.Create(CompressionLevel,FCompressedDataArray[high(FCompressedDataArray)],true);
     comp.write(partSize,sizeof(partSize));
+    LEWriteLongint(comp, partSize);
     comp.CopyFrom(FUncompressedData,partSize);
     comp.Free;
 …
 end;
-{$hints off}
-function WinReadLongint(Stream: TStream): longint;
-begin
-  stream.Read(Result, sizeof(Result));
-  Result := LEtoN(Result);
-end;
-{$hints on}
-procedure WinWriteLongint(Stream: TStream; AValue: LongInt);
-begin
-  AValue := NtoLE(AValue);
-  stream.Write(AValue, sizeof(AValue));
-end;
 procedure TBGRACompressableBitmap.WriteToStream(AStream: TStream);
 var i:integer;
 …
   repeat
   until not Compress;
   WinWriteLongint(AStream,FWidth);
   WinWriteLongint(AStream,FHeight);
   WinWriteLongint(AStream,length(FCaption));
+  LEWriteLongint(AStream,FWidth);
+  LEWriteLongint(AStream,FHeight);
+  LEWriteLongint(AStream,length(FCaption));
   AStream.Write(FCaption[1],length(FCaption));
   if (FWidth=0) or (FHeight = 0) then exit;
   WinWriteLongint(AStream,FBounds.Left);
   WinWriteLongint(AStream,FBounds.Top);
   WinWriteLongint(AStream,FBounds.Right);
   WinWriteLongint(AStream,FBounds.Bottom);
   WinWriteLongint(AStream,ord(FLineOrder));
   WinWriteLongint(AStream,length(FCompressedDataArray));
+  LEWriteLongint(AStream,FBounds.Left);
+  LEWriteLongint(AStream,FBounds.Top);
+  LEWriteLongint(AStream,FBounds.Right);
+  LEWriteLongint(AStream,FBounds.Bottom);
+  LEWriteLongint(AStream,ord(FLineOrder));
+  LEWriteLongint(AStream,length(FCompressedDataArray));
   for i := 0 to high(FCompressedDataArray) do
   begin
     WinWriteLongint(AStream,FCompressedDataArray[i].Size);
+    LEWriteLongint(AStream,FCompressedDataArray[i].Size);
     FCompressedDataArray[i].Position := 0;
     AStream.CopyFrom(FCompressedDataArray[i],FCompressedDataArray[i].Size);
 …
 begin
   FreeData;
   FWidth := WinReadLongint(AStream);
   FHeight := WinReadLongint(AStream);
   setlength(FCaption,WinReadLongint(AStream));
+  FWidth := LEReadLongint(AStream);
+  FHeight := LEReadLongint(AStream);
+  setlength(FCaption,LEReadLongint(AStream));
   AStream.Read(FCaption[1],length(FCaption));
   if (FWidth=0) or (FHeight = 0) then
 …
   end;
   FBounds.Left := WinReadLongint(AStream);
   FBounds.Top := WinReadLongint(AStream);
   FBounds.Right := WinReadLongint(AStream);
   FBounds.Bottom := WinReadLongint(AStream);
   FLineOrder := TRawImageLineOrder(WinReadLongint(AStream));
   setlength(FCompressedDataArray,WinReadLongint(AStream));
+  FBounds.Left := LEReadLongint(AStream);
+  FBounds.Top := LEReadLongint(AStream);
+  FBounds.Right := LEReadLongint(AStream);
+  FBounds.Bottom := LEReadLongint(AStream);
+  FLineOrder := TRawImageLineOrder(LEReadLongint(AStream));
+  setlength(FCompressedDataArray,LEReadLongint(AStream));
   for i := 0 to high(FCompressedDataArray) do
   begin
     size := WinReadLongint(AStream);
+    size := LEReadLongint(AStream);
     FCompressedDataArray[i] := TMemoryStream.Create;
     FCompressedDataArray[i].CopyFrom(AStream,size);
 …
     FCompressedDataArray[i].Position := 0;
     decomp := Tdecompressionstream.Create(FCompressedDataArray[i],true);
+    {$hints off}
+    decomp.read(partSize,sizeof(partSize));
+    {$hints on}
+    partSize := LEReadLongint(decomp);
     FUncompressedData.CopyFrom(decomp,partSize);
     decomp.Free;

GraphicTest/Packages/bgrabitmap/bgracustombitmap.inc

-              r494
+              r521
     {** Returns the corresponding OpenGL texture. The value is ''nil'' if no texture is associated. **}
     function GetTextureGL: IUnknown;
     function GetImageBoundsWithin(const ARect: TRect; Channel: TChannel = cAlpha; ANothingValue: Byte = 0): TRect;
     function GetImageBoundsWithin(const ARect: TRect; Channels: TChannels; ANothingValue: Byte = 0): TRect;
+    function GetImageBoundsWithin(const ARect: TRect; Channel: TChannel = cAlpha; ANothingValue: Byte = 0): TRect; overload;
+    function GetImageBoundsWithin(const ARect: TRect; Channels: TChannels; ANothingValue: Byte = 0): TRect; overload;
     function ProvidesScanline(ARect: TRect): boolean;
     function GetScanlineAt(X,Y: integer): PBGRAPixel;
 …
     function IsScanPutPixelsDefined: boolean; virtual;
     function GetTextureGL: IUnknown; virtual;
     function GetImageBoundsWithin(const ARect: TRect; Channel: TChannel = cAlpha; ANothingValue: Byte = 0): TRect; virtual;
     function GetImageBoundsWithin(const ARect: TRect; Channels: TChannels; ANothingValue: Byte = 0): TRect; virtual;
+    function GetImageBoundsWithin(const ARect: TRect; Channel: TChannel = cAlpha; ANothingValue: Byte = 0): TRect; overload; virtual;
+    function GetImageBoundsWithin(const ARect: TRect; Channels: TChannels; ANothingValue: Byte = 0): TRect; overload; virtual;
     function ProvidesScanline({%H-}ARect: TRect): boolean; virtual;
     function GetScanlineAt({%H-}X,{%H-}Y: integer): PBGRAPixel; virtual;
 …
     procedure SetFontAntialias(const AValue: Boolean);
   protected
+     { accessors to properies }
+    FXorMask: TBGRACustomBitmap;
+    { accessors to properies }
      function GetArrowEndRepeat: integer; virtual; abstract;
      function GetArrowStartRepeat: integer; virtual; abstract;
 …
      function GetNbPixels: integer; virtual; abstract;
      function CheckEmpty: boolean; virtual; abstract;
+     function CheckIsZero: boolean; virtual; abstract;
      function GetHasTransparentPixels: boolean; virtual; abstract;
+     function GetHasSemiTransparentPixels: boolean; virtual; abstract;
      function GetAverageColor: TColor; virtual; abstract;
      function GetAveragePixel: TBGRAPixel; virtual; abstract;
 …
      function GetFontFullHeight: integer; virtual; abstract;
      procedure SetFontFullHeight(AHeight: integer); virtual; abstract;
+     function GetFontVerticalAnchorOffset: single; virtual; abstract;
      function GetPenJoinStyle: TPenJoinStyle; virtual; abstract;
      procedure SetPenJoinStyle(const AValue: TPenJoinStyle); virtual; abstract;
 …
      function GetTextureGL: IUnknown; virtual;
+     function GetFontRightToLeftFor(AText: string): boolean;
   public
 …
      ScanOffset: TPoint;
+     {** Cursor position for mouse pointer }
+     HotSpot: TPoint;
+     { ** Free reference to xor mask }
+     procedure DiscardXorMask; virtual; abstract;
+     { ** Allocate xor mask }
+     procedure NeedXorMask; virtual; abstract;
+     {** Xor mask to be applied when image is drawn }
+     property XorMask: TBGRACustomBitmap read FXorMask;
      {** Width of the image in pixels }
      property Width: integer Read GetWidth;
 …
      {** Returns True if the bitmap only contains transparent pixels or has a size of zero }
      property Empty: boolean Read CheckEmpty;
+     property IsZero: boolean Read CheckIsZero;
      {** Returns True if there are transparent or semitransparent pixels,
          and so if the image would be stored with an alpha channel }
      property HasTransparentPixels: boolean Read GetHasTransparentPixels;
+     property HasSemiTransparentPixels: boolean Read GetHasSemiTransparentPixels;
      {** Average color of the image }
 …
      FontVerticalAnchor: TFontVerticalAnchor;
+     {** Specifies the base direction of the text (cf Unicode). By default, it is
+         automatically determined by the first strongly oriented character.
+         You can specify another base direction here however it is not taken
+         into account by the LCL on Linux. }
+     FontBidiMode: TFontBidiMode;
      {** Specifies the height of the font in pixels without taking into account
          additional line spacing. A negative value means that it is the
 …
      {** Simplified property to specify the quality (see ''FontQuality'') }
      property FontAntialias: Boolean read GetFontAntialias write SetFontAntialias;
+     property FontVerticalAnchorOffset: single read GetFontVerticalAnchorOffset;
      {** Returns measurement for the current font in pixels }
      property FontPixelMetric: TFontPixelMetric read GetFontPixelMetric;
 …
   public
      constructor Create; virtual; abstract; overload;
      constructor Create(AFPImage: TFPCustomImage); virtual; abstract; overload;
      constructor Create(ABitmap: TBitmap; AUseTransparent: boolean = true); virtual; abstract; overload;
      constructor Create(AWidth, AHeight: integer; Color: TColor); virtual; abstract; overload;
      constructor Create(AWidth, AHeight: integer; Color: TBGRAPixel); virtual; abstract; overload;
      constructor Create(AFilename: string); virtual; abstract; overload;
      constructor Create(AFilename: string; AIsUtf8Filename: boolean); virtual; abstract; overload;
      constructor Create(AFilename: string; AIsUtf8Filename: boolean; AOptions: TBGRALoadingOptions); virtual; abstract; overload;
      constructor Create(AStream: TStream); virtual; abstract; overload;
      function NewBitmap(AWidth, AHeight: integer): TBGRACustomBitmap; virtual; abstract; overload;
      function NewBitmap(AWidth, AHeight: integer; Color: TBGRAPixel): TBGRACustomBitmap; virtual; abstract; overload;
      function NewBitmap(Filename: string): TBGRACustomBitmap; virtual; abstract; overload;
      function NewBitmap(Filename: string; AIsUtf8: boolean): TBGRACustomBitmap; virtual; abstract; overload;
      function NewBitmap(Filename: string; AIsUtf8: boolean; AOptions: TBGRALoadingOptions): TBGRACustomBitmap; virtual; abstract; overload;
      function NewBitmap(AFPImage: TFPCustomImage): TBGRACustomBitmap; virtual; abstract; overload;
+     constructor Create; overload; virtual; abstract;
+     constructor Create(AFPImage: TFPCustomImage); overload; virtual; abstract;
+     constructor Create(ABitmap: TBitmap; AUseTransparent: boolean = true); overload; virtual; abstract;
+     constructor Create(AWidth, AHeight: integer; Color: TColor); overload; virtual; abstract;
+     constructor Create(AWidth, AHeight: integer; Color: TBGRAPixel); overload; virtual; abstract;
+     constructor Create(AFilename: string); overload; virtual; abstract;
+     constructor Create(AFilename: string; AIsUtf8Filename: boolean); overload; virtual; abstract;
+     constructor Create(AFilename: string; AIsUtf8Filename: boolean; AOptions: TBGRALoadingOptions); overload; virtual; abstract;
+     constructor Create(AStream: TStream); overload; virtual; abstract;
+     function NewBitmap(AWidth, AHeight: integer): TBGRACustomBitmap; overload; virtual; abstract;
+     function NewBitmap(AWidth, AHeight: integer; Color: TBGRAPixel): TBGRACustomBitmap; overload; virtual; abstract;
+     function NewBitmap(Filename: string): TBGRACustomBitmap; overload; virtual; abstract;
+     function NewBitmap(Filename: string; AIsUtf8: boolean): TBGRACustomBitmap; overload; virtual; abstract;
+     function NewBitmap(Filename: string; AIsUtf8: boolean; AOptions: TBGRALoadingOptions): TBGRACustomBitmap; overload; virtual; abstract;
+     function NewBitmap(AFPImage: TFPCustomImage): TBGRACustomBitmap; overload; virtual; abstract;
      //there are UTF8 functions that are different from standard function as those
 …
   {==== Load and save files ====}
      {** Load image from a file. ''filename'' is an ANSI string }
      procedure LoadFromFile(const filename: string); virtual;
      procedure LoadFromFile(const filename: string; AOptions: TBGRALoadingOptions); virtual;
+     procedure LoadFromFile(const filename: string); overload; virtual;
+     procedure LoadFromFile(const filename: string; AOptions: TBGRALoadingOptions); overload; virtual;
      {** Load image from a file with the specified image reader. ''filename'' is an ANSI string }
      procedure LoadFromFile(const filename:String; Handler:TFPCustomImageReader); virtual;
      procedure LoadFromFile(const filename:String; Handler:TFPCustomImageReader; AOptions: TBGRALoadingOptions); virtual;
+     procedure LoadFromFile(const filename:String; Handler:TFPCustomImageReader); overload; virtual;
+     procedure LoadFromFile(const filename:String; Handler:TFPCustomImageReader; AOptions: TBGRALoadingOptions); overload; virtual;
      {** Load image from a file. ''filename'' is an UTF8 string }
      procedure LoadFromFileUTF8(const filenameUTF8: string; AOptions: TBGRALoadingOptions = []); virtual;
+     procedure LoadFromFileUTF8(const filenameUTF8: string; AOptions: TBGRALoadingOptions = []); overload; virtual;
      {** Load image from a file with the specified image reader. ''filename'' is an UTF8 string }
      procedure LoadFromFileUTF8(const filenameUTF8: string; AHandler: TFPCustomImageReader; AOptions: TBGRALoadingOptions = []); virtual;
+     procedure LoadFromFileUTF8(const filenameUTF8: string; AHandler: TFPCustomImageReader; AOptions: TBGRALoadingOptions = []); overload; virtual;
      {** Load image from a stream. Format is detected automatically }
      procedure LoadFromStream(Str: TStream); virtual; overload;
      procedure LoadFromStream(Str: TStream; AOptions: TBGRALoadingOptions); virtual; overload;
+     procedure LoadFromStream(Str: TStream);overload; virtual;
+     procedure LoadFromStream(Str: TStream; AOptions: TBGRALoadingOptions);overload; virtual;
      {** Load image from a stream. The specified image reader is used }
+     procedure LoadFromStream(Str: TStream; Handler: TFPCustomImageReader); virtual; overload;
+     procedure LoadFromStream(Str: TStream; Handler: TFPCustomImageReader; AOptions: TBGRALoadingOptions); virtual; overload;
+     procedure LoadFromStream(Str: TStream; Handler: TFPCustomImageReader);overload; virtual;
+     procedure LoadFromStream(Str: TStream; Handler: TFPCustomImageReader; AOptions: TBGRALoadingOptions);overload; virtual;
+     {** Load image from an embedded Lazarus resource. Format is detected automatically }
+     procedure LoadFromResource(AFilename: string); overload; virtual;
+     procedure LoadFromResource(AFilename: string; AOptions: TBGRALoadingOptions); overload; virtual; abstract;
+     {** Load image from an embedded Lazarus resource. The specified image reader is used }
+     procedure LoadFromResource(AFilename: string; Handler: TFPCustomImageReader); overload; virtual;
+     procedure LoadFromResource(AFilename: string; Handler: TFPCustomImageReader; AOptions: TBGRALoadingOptions); overload; virtual;
      {** Save image to a file. The format is guessed from the file extension. ''filename'' is an ANSI string }
      procedure SaveToFile(const filename: string); virtual; overload;
+     procedure SaveToFile(const filename: string);overload; virtual;
      {** Save image to a file with the specified image writer. ''filename'' is an ANSI string }
      procedure SaveToFile(const filename: string; Handler:TFPCustomImageWriter); virtual; overload;
+     procedure SaveToFile(const filename: string; Handler:TFPCustomImageWriter);overload; virtual;
      {** Save image to a file. The format is guessed from the file extension. ''filename'' is an ANSI string }
      procedure SaveToFileUTF8(const filenameUTF8: string); virtual; overload;
+     procedure SaveToFileUTF8(const filenameUTF8: string);overload; virtual;
      {** Save image to a file with the specified image writer. ''filename'' is an UTF8 string }
      procedure SaveToFileUTF8(const filenameUTF8: string; Handler:TFPCustomImageWriter); virtual; overload;
+     procedure SaveToFileUTF8(const filenameUTF8: string; Handler:TFPCustomImageWriter);overload; virtual;
      {** Save image to a stream with the specified image writer }{inherited
 …
      {** Gets the content of the specified device context }
      procedure LoadFromDevice(DC: System.THandle); virtual; abstract; overload;
+     procedure LoadFromDevice(DC: HDC); overload; virtual; abstract;
      {** Gets the content from the specified rectangular area of a device context }
      procedure LoadFromDevice(DC: System.THandle; ARect: TRect); virtual; abstract; overload;
+     procedure LoadFromDevice(DC: HDC; ARect: TRect); overload; virtual; abstract;
      {** Fills the content with a screenshot of the primary monitor }
      procedure TakeScreenshotOfPrimaryMonitor; virtual; abstract;
 …
      {Pixel functions}
      procedure SetPixel(x, y: int32or64; c: TColor); virtual; abstract; overload;
      procedure XorPixel(x, y: int32or64; c: TBGRAPixel); virtual; abstract; overload;
      procedure SetPixel(x, y: int32or64; c: TBGRAPixel); virtual; abstract; overload;
      procedure DrawPixel(x, y: int32or64; c: TBGRAPixel); virtual; abstract; overload;
+     procedure SetPixel(x, y: int32or64; c: TColor); overload; virtual; abstract;
+     procedure XorPixel(x, y: int32or64; c: TBGRAPixel); overload; virtual; abstract;
+     procedure SetPixel(x, y: int32or64; c: TBGRAPixel); overload; virtual; abstract;
+     procedure DrawPixel(x, y: int32or64; c: TBGRAPixel); overload; virtual; abstract;
      procedure DrawPixel(x, y: int32or64; c: TBGRAPixel; ADrawMode: TDrawMode); overload;
      procedure DrawPixel(x, y: int32or64; ec: TExpandedPixel); virtual; abstract; overload;
+     procedure DrawPixel(x, y: int32or64; ec: TExpandedPixel); overload; virtual; abstract;
      procedure FastBlendPixel(x, y: int32or64; c: TBGRAPixel); virtual; abstract;
      procedure ErasePixel(x, y: int32or64; alpha: byte); virtual; abstract;
      procedure AlphaPixel(x, y: int32or64; alpha: byte); virtual; abstract;
      function GetPixel(x, y: int32or64): TBGRAPixel; virtual; abstract; overload;
+     function GetPixel(x, y: int32or64): TBGRAPixel; overload; virtual; abstract;
      function GetPixel256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter = rfLinear; smoothBorder: boolean = true): TBGRAPixel; virtual; abstract;
      function GetPixel(x, y: single; AResampleFilter: TResampleFilter = rfLinear; smoothBorder: boolean = true): TBGRAPixel; virtual; abstract; overload;
      function GetPixelCycle(x, y: int32or64): TBGRAPixel; virtual; overload;
      function GetPixelCycle(x, y: single; AResampleFilter: TResampleFilter = rfLinear): TBGRAPixel; virtual; abstract; overload;
      function GetPixelCycle(x, y: single; AResampleFilter: TResampleFilter; repeatX: boolean; repeatY: boolean): TBGRAPixel; virtual; abstract; overload;
      function GetPixelCycle256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter = rfLinear): TBGRAPixel; virtual; abstract; overload;
      function GetPixelCycle256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter; repeatX: boolean; repeatY: boolean): TBGRAPixel; virtual; abstract; overload;
+     function GetPixel(x, y: single; AResampleFilter: TResampleFilter = rfLinear; smoothBorder: boolean = true): TBGRAPixel; overload; virtual; abstract;
+     function GetPixelCycle(x, y: int32or64): TBGRAPixel;overload; virtual;
+     function GetPixelCycle(x, y: single; AResampleFilter: TResampleFilter = rfLinear): TBGRAPixel; overload; virtual; abstract;
+     function GetPixelCycle(x, y: single; AResampleFilter: TResampleFilter; repeatX: boolean; repeatY: boolean): TBGRAPixel; overload; virtual; abstract;
+     function GetPixelCycle256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter = rfLinear): TBGRAPixel; overload; virtual; abstract;
+     function GetPixelCycle256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter; repeatX: boolean; repeatY: boolean): TBGRAPixel; overload; virtual; abstract;
      {Line primitives}
      procedure SetHorizLine(x, y, x2: int32or64; c: TBGRAPixel); virtual; abstract;
      procedure XorHorizLine(x, y, x2: int32or64; c: TBGRAPixel); virtual; abstract;
      procedure DrawHorizLine(x, y, x2: int32or64; c: TBGRAPixel); virtual; abstract; overload;
      procedure DrawHorizLine(x, y, x2: int32or64; ec: TExpandedPixel); virtual; abstract; overload;
+     procedure DrawHorizLine(x, y, x2: int32or64; c: TBGRAPixel); overload; virtual; abstract;
+     procedure DrawHorizLine(x, y, x2: int32or64; ec: TExpandedPixel); overload; virtual; abstract;
      procedure DrawHorizLine(x, y, x2: int32or64; texture: IBGRAScanner); overload;
      procedure FastBlendHorizLine(x, y, x2: int32or64; c: TBGRAPixel); virtual; abstract;
      procedure HorizLine(x,y,x2: Int32or64; c: TBGRAPixel; ADrawMode: TDrawMode); overload;
      procedure HorizLine(x,y,x2: Int32or64; texture: IBGRAScanner; ADrawMode: TDrawMode); virtual; abstract; overload;
+     procedure HorizLine(x,y,x2: Int32or64; texture: IBGRAScanner; ADrawMode: TDrawMode); overload; virtual; abstract;
      procedure DrawHorizLineDiff(x, y, x2: int32or64; c, compare: TBGRAPixel; maxDiff: byte); virtual; abstract;
      procedure AlphaHorizLine(x, y, x2: int32or64; alpha: byte); virtual; abstract;
 …
      {Shapes}
      procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single; AFillColor: TBGRAPixel); virtual; abstract;
      procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single; AFillColor: TBGRAPixel); virtual; abstract;
      procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single; AFillTexture: IBGRAScanner); virtual; abstract;
      procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single; AFillTexture: IBGRAScanner); virtual; abstract;
      procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single); virtual; abstract;
      procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single); virtual; abstract;
      procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single; AFillColor: TBGRAPixel); virtual; abstract;
      procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single; AFillColor: TBGRAPixel); virtual; abstract;
      procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single; AFillTexture: IBGRAScanner); virtual; abstract;
      procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single; AFillTexture: IBGRAScanner); virtual; abstract;
      procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single); virtual; abstract;
      procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single); virtual; abstract;
+     procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single; AFillColor: TBGRAPixel); overload; virtual; abstract;
+     procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single; AFillColor: TBGRAPixel); overload; virtual; abstract;
+     procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single; AFillTexture: IBGRAScanner); overload; virtual; abstract;
+     procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single; AFillTexture: IBGRAScanner); overload; virtual; abstract;
+     procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single); overload; virtual; abstract;
+     procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single); overload; virtual; abstract;
+     procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single; AFillColor: TBGRAPixel); overload; virtual; abstract;
+     procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single; AFillColor: TBGRAPixel); overload; virtual; abstract;
+     procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single; AFillTexture: IBGRAScanner); overload; virtual; abstract;
+     procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single; AFillTexture: IBGRAScanner); overload; virtual; abstract;
+     procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single); overload; virtual; abstract;
+     procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single); overload; virtual; abstract;
      procedure ArrowStartAsNone; virtual; abstract;
 …
      procedure DrawLine(x1, y1, x2, y2: integer; c: TBGRAPixel; DrawLastPixel: boolean; ADrawMode: TDrawMode= dmDrawWithTransparency); virtual; abstract;
      procedure DrawLineAntialias(x1, y1, x2, y2: integer; c: TBGRAPixel; DrawLastPixel: boolean); virtual; abstract; overload;
      procedure DrawLineAntialias(x1, y1, x2, y2: integer; c1, c2: TBGRAPixel; dashLen: integer; DrawLastPixel: boolean); virtual; abstract; overload;
      procedure DrawLineAntialias(x1, y1, x2, y2: integer; c1, c2: TBGRAPixel; dashLen: integer; DrawLastPixel: boolean; var DashPos: integer); virtual; abstract; overload;
      procedure DrawLineAntialias(x1, y1, x2, y2: single; c: TBGRAPixel; w: single); virtual; abstract; overload;
      procedure DrawLineAntialias(x1, y1, x2, y2: single; texture: IBGRAScanner; w: single); virtual; abstract; overload;
      procedure DrawLineAntialias(x1, y1, x2, y2: single; c: TBGRAPixel; w: single; ClosedCap: boolean); virtual; abstract; overload;
      procedure DrawLineAntialias(x1, y1, x2, y2: single; texture: IBGRAScanner; w: single; ClosedCap: boolean); virtual; abstract; overload;
+     procedure DrawLineAntialias(x1, y1, x2, y2: integer; c: TBGRAPixel; DrawLastPixel: boolean); overload; virtual; abstract;
+     procedure DrawLineAntialias(x1, y1, x2, y2: integer; c1, c2: TBGRAPixel; dashLen: integer; DrawLastPixel: boolean); overload; virtual; abstract;
+     procedure DrawLineAntialias(x1, y1, x2, y2: integer; c1, c2: TBGRAPixel; dashLen: integer; DrawLastPixel: boolean; var DashPos: integer); overload; virtual; abstract;
+     procedure DrawLineAntialias(x1, y1, x2, y2: single; c: TBGRAPixel; w: single); overload; virtual; abstract;
+     procedure DrawLineAntialias(x1, y1, x2, y2: single; texture: IBGRAScanner; w: single); overload; virtual; abstract;
+     procedure DrawLineAntialias(x1, y1, x2, y2: single; c: TBGRAPixel; w: single; ClosedCap: boolean); overload; virtual; abstract;
+     procedure DrawLineAntialias(x1, y1, x2, y2: single; texture: IBGRAScanner; w: single; ClosedCap: boolean); overload; virtual; abstract;
      procedure DrawPolyLine(const points: array of TPoint; c: TBGRAPixel; DrawLastPixel: boolean; ADrawMode: TDrawMode=dmDrawWithTransparency);
      procedure DrawPolyLineAntialias(const points: array of TPoint; c: TBGRAPixel; DrawLastPixel: boolean); virtual; overload;
      procedure DrawPolyLineAntialias(const points: array of TPoint; c1, c2: TBGRAPixel; dashLen: integer; DrawLastPixel: boolean); virtual; overload;
      procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single); virtual; abstract; overload;
      procedure DrawPolyLineAntialias(const points: array of TPointF; texture: IBGRAScanner; w: single); virtual; abstract; overload;
      procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; ClosedCap: boolean); virtual; abstract; overload;
      procedure DrawPolyLineAntialias(const points: array of TPointF; texture: IBGRAScanner; w: single; ClosedCap: boolean); virtual; abstract; overload;
      procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; fillcolor: TBGRAPixel); virtual; abstract; overload;
      procedure DrawPolyLineAntialiasAutocycle(const points: array of TPointF; c: TBGRAPixel; w: single); virtual; abstract; overload;
      procedure DrawPolyLineAntialiasAutocycle(const points: array of TPointF; texture: IBGRAScanner; w: single); virtual; abstract; overload;
+     procedure DrawPolyLineAntialias(const points: array of TPoint; c: TBGRAPixel; DrawLastPixel: boolean);overload; virtual;
+     procedure DrawPolyLineAntialias(const points: array of TPoint; c1, c2: TBGRAPixel; dashLen: integer; DrawLastPixel: boolean);overload; virtual;
+     procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single); overload; virtual; abstract;
+     procedure DrawPolyLineAntialias(const points: array of TPointF; texture: IBGRAScanner; w: single); overload; virtual; abstract;
+     procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; ClosedCap: boolean); overload; virtual; abstract;
+     procedure DrawPolyLineAntialias(const points: array of TPointF; texture: IBGRAScanner; w: single; ClosedCap: boolean); overload; virtual; abstract;
+     procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; fillcolor: TBGRAPixel); overload; virtual; abstract;
+     procedure DrawPolyLineAntialiasAutocycle(const points: array of TPointF; c: TBGRAPixel; w: single); overload; virtual; abstract;
+     procedure DrawPolyLineAntialiasAutocycle(const points: array of TPointF; texture: IBGRAScanner; w: single); overload; virtual; abstract;
      procedure DrawPolygon(const points: array of TPoint; c: TBGRAPixel; ADrawMode: TDrawMode=dmDrawWithTransparency);
      procedure DrawPolygonAntialias(const points: array of TPoint; c: TBGRAPixel); overload;
+     procedure DrawPolygonAntialias(const points: array of TPointF; c: TBGRAPixel; w: single); virtual; abstract; overload;
+     procedure DrawPolygonAntialias(const points: array of TPointF; texture: IBGRAScanner; w: single); virtual; abstract; overload;
+     procedure DrawPolygonAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; fillcolor: TBGRAPixel); virtual; abstract; overload;
+     procedure DrawPolygonAntialias(const points: array of TPoint; c1, c2: TBGRAPixel; dashLen: integer); overload;
+     procedure DrawPolygonAntialias(const points: array of TPointF; c: TBGRAPixel; w: single); overload; virtual; abstract;
+     procedure DrawPolygonAntialias(const points: array of TPointF; texture: IBGRAScanner; w: single); overload; virtual; abstract;
+     procedure DrawPolygonAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; fillcolor: TBGRAPixel); overload; virtual; abstract;
      procedure EraseLine(x1, y1, x2, y2: integer; alpha: byte; DrawLastPixel: boolean); virtual; abstract;
      procedure EraseLineAntialias(x1, y1, x2, y2: integer; alpha: byte; DrawLastPixel: boolean); virtual; abstract; overload;
      procedure EraseLineAntialias(x1, y1, x2, y2: single; alpha: byte; w: single); virtual; abstract; overload;
      procedure EraseLineAntialias(x1, y1, x2, y2: single; alpha: byte; w: single; Closed: boolean); virtual; abstract; overload;
+     procedure EraseLineAntialias(x1, y1, x2, y2: integer; alpha: byte; DrawLastPixel: boolean); overload; virtual; abstract;
+     procedure EraseLineAntialias(x1, y1, x2, y2: single; alpha: byte; w: single); overload; virtual; abstract;
+     procedure EraseLineAntialias(x1, y1, x2, y2: single; alpha: byte; w: single; Closed: boolean); overload; virtual; abstract;
      procedure ErasePolyLine(const points: array of TPoint; alpha: byte; DrawLastPixel: boolean);
      procedure ErasePolyLineAntialias(const points: array of TPoint; alpha: byte; DrawLastPixel: boolean); overload;
      procedure ErasePolyLineAntialias(const points: array of TPointF; alpha: byte; w: single); virtual; abstract; overload;
+     procedure ErasePolyLineAntialias(const points: array of TPointF; alpha: byte; w: single); overload; virtual; abstract;
      procedure ErasePolygonOutline(const points: array of TPoint; alpha: byte);
      procedure ErasePolygonOutlineAntialias(const points: array of TPoint; alpha: byte);
      procedure FillPath(APath: IBGRAPath; c: TBGRAPixel); virtual; abstract;
      procedure FillPath(APath: IBGRAPath; texture: IBGRAScanner); virtual; abstract;
      procedure ErasePath(APath: IBGRAPath; alpha: byte); virtual; abstract;
      procedure FillPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AFillColor: TBGRAPixel); virtual; abstract;
      procedure FillPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AFillTexture: IBGRAScanner); virtual; abstract;
      procedure ErasePath(APath: IBGRAPath; AMatrix: TAffineMatrix; alpha: byte); virtual; abstract;
      procedure FillTriangleLinearColor(pt1,pt2,pt3: TPointF; c1,c2,c3: TBGRAPixel); virtual; abstract; overload;
      procedure FillTriangleLinearColorAntialias(pt1,pt2,pt3: TPointF; c1,c2,c3: TBGRAPixel); virtual; abstract; overload;
      procedure FillTriangleLinearMapping(pt1,pt2,pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF; TextureInterpolation: Boolean= True); virtual; abstract; overload;
      procedure FillTriangleLinearMappingLightness(pt1,pt2,pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF; light1,light2,light3: word; TextureInterpolation: Boolean= True); virtual; abstract; overload;
      procedure FillTriangleLinearMappingAntialias(pt1,pt2,pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF); virtual; abstract; overload;
      procedure FillQuadLinearColor(pt1,pt2,pt3,pt4: TPointF; c1,c2,c3,c4: TBGRAPixel); virtual; abstract; overload;
      procedure FillQuadLinearColorAntialias(pt1,pt2,pt3,pt4: TPointF; c1,c2,c3,c4: TBGRAPixel); virtual; abstract; overload;
      procedure FillQuadLinearMapping(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; TextureInterpolation: Boolean= True; ACulling: TFaceCulling = fcNone);  virtual; abstract; overload;
      procedure FillQuadLinearMappingLightness(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; light1,light2,light3,light4: word; TextureInterpolation: Boolean= True); virtual; abstract; overload;
      procedure FillQuadLinearMappingAntialias(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ACulling: TFaceCulling = fcNone); virtual; abstract; overload;
      procedure FillQuadPerspectiveMapping(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ADrawMode: TDrawMode = dmDrawWithTransparency); virtual; abstract; overload;
      procedure FillQuadPerspectiveMapping(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ACleanBorders: TRect; ADrawMode: TDrawMode = dmDrawWithTransparency); virtual; abstract; overload;
      procedure FillQuadPerspectiveMappingAntialias(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF); virtual; abstract; overload;
      procedure FillQuadPerspectiveMappingAntialias(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ACleanBorders: TRect); virtual; abstract; overload;
+     procedure FillPath(APath: IBGRAPath; c: TBGRAPixel); overload; virtual; abstract;
+     procedure FillPath(APath: IBGRAPath; texture: IBGRAScanner); overload; virtual; abstract;
+     procedure ErasePath(APath: IBGRAPath; alpha: byte); overload; virtual; abstract;
+     procedure FillPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AFillColor: TBGRAPixel); overload; virtual; abstract;
+     procedure FillPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AFillTexture: IBGRAScanner); overload; virtual; abstract;
+     procedure ErasePath(APath: IBGRAPath; AMatrix: TAffineMatrix; alpha: byte); overload; virtual; abstract;
+     procedure FillTriangleLinearColor(pt1,pt2,pt3: TPointF; c1,c2,c3: TBGRAPixel); overload; virtual; abstract;
+     procedure FillTriangleLinearColorAntialias(pt1,pt2,pt3: TPointF; c1,c2,c3: TBGRAPixel); overload; virtual; abstract;
+     procedure FillTriangleLinearMapping(pt1,pt2,pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF; TextureInterpolation: Boolean= True); overload; virtual; abstract;
+     procedure FillTriangleLinearMappingLightness(pt1,pt2,pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF; light1,light2,light3: word; TextureInterpolation: Boolean= True); overload; virtual; abstract;
+     procedure FillTriangleLinearMappingAntialias(pt1,pt2,pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF); overload; virtual; abstract;
+     procedure FillQuadLinearColor(pt1,pt2,pt3,pt4: TPointF; c1,c2,c3,c4: TBGRAPixel); overload; virtual; abstract;
+     procedure FillQuadLinearColorAntialias(pt1,pt2,pt3,pt4: TPointF; c1,c2,c3,c4: TBGRAPixel); overload; virtual; abstract;
+     procedure FillQuadLinearMapping(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; TextureInterpolation: Boolean= True; ACulling: TFaceCulling = fcNone); overload; virtual; abstract;
+     procedure FillQuadLinearMappingLightness(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; light1,light2,light3,light4: word; TextureInterpolation: Boolean= True); overload; virtual; abstract;
+     procedure FillQuadLinearMappingAntialias(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ACulling: TFaceCulling = fcNone); overload; virtual; abstract;
+     procedure FillQuadPerspectiveMapping(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual; abstract;
+     procedure FillQuadPerspectiveMapping(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ACleanBorders: TRect; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual; abstract;
+     procedure FillQuadPerspectiveMappingAntialias(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF); overload; virtual; abstract;
+     procedure FillQuadPerspectiveMappingAntialias(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ACleanBorders: TRect); overload; virtual; abstract;
      procedure FillQuadAffineMapping(Orig,HAxis,VAxis: TPointF; AImage: TBGRACustomBitmap; APixelCenteredCoordinates: boolean = true; ADrawMode: TDrawMode = dmDrawWithTransparency; AOpacity: byte = 255); virtual; abstract;
      procedure FillQuadAffineMappingAntialias(Orig,HAxis,VAxis: TPointF; AImage: TBGRACustomBitmap; APixelCenteredCoordinates: boolean = true; AOpacity: byte = 255); virtual; abstract;
      procedure FillPolyLinearColor(const points: array of TPointF; AColors: array of TBGRAPixel);  virtual; abstract; overload;
      procedure FillPolyLinearMapping(const points: array of TPointF; texture: IBGRAScanner; texCoords: array of TPointF; TextureInterpolation: Boolean); virtual; abstract; overload;
      procedure FillPolyLinearMappingLightness(const points: array of TPointF; texture: IBGRAScanner; texCoords: array of TPointF; lightnesses: array of word; TextureInterpolation: Boolean); virtual; abstract; overload;
      procedure FillPolyPerspectiveMapping(const points: array of TPointF; const pointsZ: array of single; texture: IBGRAScanner; texCoords: array of TPointF; TextureInterpolation: Boolean; zbuffer: psingle = nil); virtual; abstract; overload;
      procedure FillPolyPerspectiveMappingLightness(const points: array of TPointF; const pointsZ: array of single; texture: IBGRAScanner; texCoords: array of TPointF; lightnesses: array of word; TextureInterpolation: Boolean; zbuffer: psingle = nil); virtual; abstract; overload;
      procedure FillPoly(const points: array of TPointF; c: TBGRAPixel; drawmode: TDrawMode); virtual; abstract;
      procedure FillPoly(const points: array of TPointF; texture: IBGRAScanner; drawmode: TDrawMode); virtual; abstract;
      procedure FillPolyAntialias(const points: array of TPointF; c: TBGRAPixel); virtual; abstract;
      procedure FillPolyAntialias(const points: array of TPointF; texture: IBGRAScanner); virtual; abstract;
      procedure ErasePoly(const points: array of TPointF; alpha: byte); virtual; abstract;
      procedure ErasePolyAntialias(const points: array of TPointF; alpha: byte); virtual; abstract;
      procedure FillShape(shape: TBGRACustomFillInfo; c: TBGRAPixel; drawmode: TDrawMode); virtual; abstract;
      procedure FillShape(shape: TBGRACustomFillInfo; texture: IBGRAScanner; drawmode: TDrawMode); virtual; abstract;
      procedure FillShapeAntialias(shape: TBGRACustomFillInfo; c: TBGRAPixel); virtual; abstract;
      procedure FillShapeAntialias(shape: TBGRACustomFillInfo; texture: IBGRAScanner); virtual; abstract;
      procedure EraseShape(shape: TBGRACustomFillInfo; alpha: byte); virtual; abstract;
+     procedure FillPolyLinearColor(const points: array of TPointF; AColors: array of TBGRAPixel);  overload; virtual; abstract;
+     procedure FillPolyLinearMapping(const points: array of TPointF; texture: IBGRAScanner; texCoords: array of TPointF; TextureInterpolation: Boolean); overload; virtual; abstract;
+     procedure FillPolyLinearMappingLightness(const points: array of TPointF; texture: IBGRAScanner; texCoords: array of TPointF; lightnesses: array of word; TextureInterpolation: Boolean); overload; virtual; abstract;
+     procedure FillPolyPerspectiveMapping(const points: array of TPointF; const pointsZ: array of single; texture: IBGRAScanner; texCoords: array of TPointF; TextureInterpolation: Boolean; zbuffer: psingle = nil); overload; virtual; abstract;
+     procedure FillPolyPerspectiveMappingLightness(const points: array of TPointF; const pointsZ: array of single; texture: IBGRAScanner; texCoords: array of TPointF; lightnesses: array of word; TextureInterpolation: Boolean; zbuffer: psingle = nil); overload; virtual; abstract;
+     procedure FillPoly(const points: array of TPointF; c: TBGRAPixel; drawmode: TDrawMode; APixelCenteredCoordinates: boolean = true); overload; virtual; abstract;
+     procedure FillPoly(const points: array of TPointF; texture: IBGRAScanner; drawmode: TDrawMode; APixelCenteredCoordinates: boolean = true); overload; virtual; abstract;
+     procedure FillPolyAntialias(const points: array of TPointF; c: TBGRAPixel; APixelCenteredCoordinates: boolean = true); overload; virtual; abstract;
+     procedure FillPolyAntialias(const points: array of TPointF; texture: IBGRAScanner; APixelCenteredCoordinates: boolean = true); overload; virtual; abstract;
+     procedure ErasePoly(const points: array of TPointF; alpha: byte; APixelCenteredCoordinates: boolean = true); virtual; abstract;
+     procedure ErasePolyAntialias(const points: array of TPointF; alpha: byte; APixelCenteredCoordinates: boolean = true); virtual; abstract;
+     procedure FillShape(shape: TBGRACustomFillInfo; c: TBGRAPixel; drawmode: TDrawMode); overload; virtual; abstract;
+     procedure FillShape(shape: TBGRACustomFillInfo; texture: IBGRAScanner; drawmode: TDrawMode); overload; virtual; abstract;
+     procedure FillShapeAntialias(shape: TBGRACustomFillInfo; c: TBGRAPixel); overload; virtual; abstract;
+     procedure FillShapeAntialias(shape: TBGRACustomFillInfo; texture: IBGRAScanner); overload; virtual; abstract;
+     procedure EraseShape(shape: TBGRACustomFillInfo; alpha: byte); overload; virtual; abstract;
      procedure EraseShapeAntialias(shape: TBGRACustomFillInfo; alpha: byte); virtual; abstract;
+     procedure EllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel; w: single); virtual; abstract;
+     procedure EllipseAntialias(x, y, rx, ry: single; texture: IBGRAScanner; w: single); virtual; abstract;
+     procedure EllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel; w: single; back: TBGRAPixel); virtual; abstract;
+     procedure FillEllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel); virtual; abstract;
+     procedure FillEllipseAntialias(x, y, rx, ry: single; texture: IBGRAScanner); virtual; abstract;
+     procedure FillEllipseLinearColorAntialias(x, y, rx, ry: single; outercolor, innercolor: TBGRAPixel); virtual; abstract;
+     procedure EraseEllipseAntialias(x, y, rx, ry: single; alpha: byte); virtual; abstract;
+     procedure Ellipse(x, y, rx, ry: single; c: TBGRAPixel; w: single; ADrawMode: TDrawMode); overload; virtual; abstract;
+     procedure Ellipse(AOrigin, AXAxis, AYAxis: TPointF; c: TBGRAPixel; w: single; ADrawMode: TDrawMode); overload; virtual; abstract;
+     procedure EllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel; w: single); overload; virtual; abstract;
+     procedure EllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; c: TBGRAPixel; w: single); overload; virtual; abstract;
+     procedure EllipseAntialias(x, y, rx, ry: single; texture: IBGRAScanner; w: single); overload; virtual; abstract;
+     procedure EllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; texture: IBGRAScanner; w: single); overload; virtual; abstract;
+     procedure EllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel; w: single; back: TBGRAPixel); overload; virtual; abstract;
+     procedure EllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; c: TBGRAPixel; w: single; back: TBGRAPixel); overload; virtual; abstract;
+     procedure FillEllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel); overload; virtual; abstract;
+     procedure FillEllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; c: TBGRAPixel); overload; virtual; abstract;
+     procedure FillEllipseAntialias(x, y, rx, ry: single; texture: IBGRAScanner); overload; virtual; abstract;
+     procedure FillEllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; texture: IBGRAScanner); overload; virtual; abstract;
+     procedure FillEllipseLinearColorAntialias(x, y, rx, ry: single; outercolor, innercolor: TBGRAPixel); overload; virtual; abstract;
+     procedure FillEllipseLinearColorAntialias(AOrigin, AXAxis, AYAxis: TPointF; outercolor, innercolor: TBGRAPixel); overload; virtual; abstract;
+     procedure EraseEllipseAntialias(x, y, rx, ry: single; alpha: byte); overload; virtual; abstract;
+     procedure EraseEllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; alpha: byte); overload; virtual; abstract;
      procedure Arc(cx,cy,rx,ry: single; const StartPoint,EndPoint: TPointF; AColor: TBGRAPixel; w: single; ADrawChord: boolean; AFillColor: TBGRAPixel); overload;
 …
      procedure FillPieInRect(const ARect: TRect; StartAngleRad,EndAngleRad: Single; texture: IBGRAScanner); overload;
      procedure Rectangle(x, y, x2, y2: integer; c: TBGRAPixel; mode: TDrawMode); virtual; abstract; overload;
      procedure Rectangle(x, y, x2, y2: integer; BorderColor, FillColor: TBGRAPixel; mode: TDrawMode); virtual; abstract; overload;
      procedure Rectangle(x, y, x2, y2: integer; c: TColor); virtual; overload;
      procedure Rectangle(r: TRect; c: TBGRAPixel; mode: TDrawMode); virtual; overload;
      procedure Rectangle(r: TRect; BorderColor, FillColor: TBGRAPixel; mode: TDrawMode); virtual;overload;
      procedure Rectangle(r: TRect; c: TColor); virtual; overload;
      procedure RectangleAntialias(x, y, x2, y2: single; c: TBGRAPixel; w: single); virtual; overload;
      procedure RectangleAntialias(x, y, x2, y2: single; c: TBGRAPixel; w: single; back: TBGRAPixel); virtual; abstract; overload;
      procedure RectangleAntialias(x, y, x2, y2: single; texture: IBGRAScanner; w: single); virtual; abstract; overload;
+     procedure Rectangle(x, y, x2, y2: integer; c: TBGRAPixel; mode: TDrawMode); overload; virtual; abstract;
+     procedure Rectangle(x, y, x2, y2: integer; BorderColor, FillColor: TBGRAPixel; mode: TDrawMode); overload; virtual; abstract;
+     procedure Rectangle(x, y, x2, y2: integer; c: TColor); overload; virtual;
+     procedure Rectangle(r: TRect; c: TBGRAPixel; mode: TDrawMode); overload; virtual;
+     procedure Rectangle(r: TRect; BorderColor, FillColor: TBGRAPixel; mode: TDrawMode); overload; virtual;
+     procedure Rectangle(r: TRect; c: TColor); overload; virtual;
+     procedure RectangleAntialias(x, y, x2, y2: single; c: TBGRAPixel; w: single); overload; virtual;
+     procedure RectangleAntialias(x, y, x2, y2: single; c: TBGRAPixel; w: single; back: TBGRAPixel); overload; virtual; abstract;
+     procedure RectangleAntialias(x, y, x2, y2: single; texture: IBGRAScanner; w: single); overload; virtual; abstract;
      procedure RectangleWithin(x1,y1,x2,y2: single; ABorderColor: TBGRAPixel; w: single; AFillColor: TBGRAPixel; APixelCenteredCoordinates: boolean = true); overload;
      procedure RectangleWithin(r: TRect; ABorderColor: TBGRAPixel; w: single; AFillColor: TBGRAPixel); overload;
+     procedure RoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; BorderColor, FillColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); virtual; abstract; overload;
+     procedure RoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; BorderColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); virtual; abstract; overload;
+     procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; c: TBGRAPixel; w: single; options: TRoundRectangleOptions = []); virtual; abstract;
+     procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; pencolor: TBGRAPixel; w: single; fillcolor: TBGRAPixel; options: TRoundRectangleOptions = []); virtual; abstract;
+     procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; penTexture: IBGRAScanner; w: single; fillTexture: IBGRAScanner; options: TRoundRectangleOptions = []); virtual; abstract;
+     procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; texture: IBGRAScanner; w: single; options: TRoundRectangleOptions = []); virtual; abstract;
+     procedure FillRoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; FillColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); virtual;
+     procedure FillRoundRectAntialias(x,y,x2,y2,rx,ry: single; c: TBGRAPixel; options: TRoundRectangleOptions = []; pixelCenteredCoordinates: boolean = true); virtual; abstract;
+     procedure FillRoundRectAntialias(x,y,x2,y2,rx,ry: single; texture: IBGRAScanner; options: TRoundRectangleOptions = []; pixelCenteredCoordinates: boolean = true); virtual; abstract;
+     procedure RoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; BorderColor, FillColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual; abstract;
+     procedure RoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; BorderColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual; abstract;
+     procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; c: TBGRAPixel; w: single; options: TRoundRectangleOptions = []); overload; virtual; abstract;
+     procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; pencolor: TBGRAPixel; w: single; fillcolor: TBGRAPixel; options: TRoundRectangleOptions = []); overload; virtual; abstract;
+     procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; penTexture: IBGRAScanner; w: single; fillTexture: IBGRAScanner; options: TRoundRectangleOptions = []); overload; virtual; abstract;
+     procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; texture: IBGRAScanner; w: single; options: TRoundRectangleOptions = []); overload; virtual; abstract;
+     procedure FillRoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; FillColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;
+     procedure FillRoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; FillTexture: IBGRAScanner; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual; abstract;
+     procedure FillRoundRectAntialias(x,y,x2,y2,rx,ry: single; c: TBGRAPixel; options: TRoundRectangleOptions = []; pixelCenteredCoordinates: boolean = true); overload; virtual; abstract;
+     procedure FillRoundRectAntialias(x,y,x2,y2,rx,ry: single; texture: IBGRAScanner; options: TRoundRectangleOptions = []; pixelCenteredCoordinates: boolean = true); overload; virtual; abstract;
      procedure EraseRoundRectAntialias(x,y,x2,y2,rx,ry: single; alpha: byte; options: TRoundRectangleOptions = []; pixelCenteredCoordinates: boolean = true); virtual; abstract;
+     procedure EllipseInRect(r: TRect; BorderColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); virtual; overload;
+     procedure EllipseInRect(r: TRect; BorderColor,FillColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); virtual; overload;
+     procedure FillEllipseInRect(r: TRect; FillColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); virtual;
+     procedure FillRect(r: TRect; c: TColor); virtual; overload;
+     procedure FillRect(r: TRect; c: TBGRAPixel; mode: TDrawMode); virtual; overload;
+     procedure FillRect(r: TRect; texture: IBGRAScanner; mode: TDrawMode); virtual; overload;
+     procedure FillRect(r: TRect; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint); virtual; overload;
+     procedure FillRect(r: TRect; texture: IBGRAScanner; mode: TDrawMode; ditheringAlgorithm: TDitheringAlgorithm); virtual; overload;
+     procedure FillRect(r: TRect; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint; ditheringAlgorithm: TDitheringAlgorithm); virtual; overload;
+     procedure FillRect(x, y, x2, y2: integer; c: TColor); virtual; overload;
+     procedure FillRect(x, y, x2, y2: integer; c: TBGRAPixel; mode: TDrawMode); virtual; abstract; overload;
+     procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode); virtual; overload;
+     procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint); virtual; abstract; overload;
+     procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode; ditheringAlgorithm: TDitheringAlgorithm); virtual; overload;
+     procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint; ditheringAlgorithm: TDitheringAlgorithm); virtual; abstract; overload;
+     procedure FillRectAntialias(x, y, x2, y2: single; c: TBGRAPixel; pixelCenteredCoordinates: boolean = true); virtual; abstract;
+     procedure FillRectAntialias(x, y, x2, y2: single; texture: IBGRAScanner; pixelCenteredCoordinates: boolean = true); virtual; abstract;
+     procedure EllipseInRect(r: TRect; BorderColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;
+     procedure EllipseInRect(r: TRect; BorderColor,FillColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;
+     procedure FillEllipseInRect(r: TRect; FillColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;
+     procedure FillEllipseInRect(r: TRect; FillTexture: IBGRAScanner; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;
+     procedure FillRect(r: TRect; c: TColor); overload; virtual;
+     procedure FillRect(r: TRect; c: TBGRAPixel; mode: TDrawMode); overload; virtual;
+     procedure FillRect(r: TRect; texture: IBGRAScanner; mode: TDrawMode); overload; virtual;
+     procedure FillRect(r: TRect; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint); overload; virtual;
+     procedure FillRect(r: TRect; texture: IBGRAScanner; mode: TDrawMode; ditheringAlgorithm: TDitheringAlgorithm); overload; virtual;
+     procedure FillRect(r: TRect; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint; ditheringAlgorithm: TDitheringAlgorithm); overload; virtual;
+     procedure FillRect(x, y, x2, y2: integer; c: TColor); overload; virtual;
+     procedure FillRect(x, y, x2, y2: integer; c: TBGRAPixel; mode: TDrawMode); overload; virtual; abstract;
+     procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode); overload; virtual;
+     procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint); overload; virtual; abstract;
+     procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode; ditheringAlgorithm: TDitheringAlgorithm); overload; virtual;
+     procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint; ditheringAlgorithm: TDitheringAlgorithm); overload; virtual; abstract;
+     procedure FillRectAntialias(x, y, x2, y2: single; c: TBGRAPixel; pixelCenteredCoordinates: boolean = true); overload; virtual; abstract;
+     procedure FillRectAntialias(x, y, x2, y2: single; texture: IBGRAScanner; pixelCenteredCoordinates: boolean = true); overload; virtual; abstract;
+     procedure FillRectAntialias(ARect: TRectF; c: TBGRAPixel; pixelCenteredCoordinates: boolean = true); overload;
+     procedure FillRectAntialias(ARect: TRectF; texture: IBGRAScanner; pixelCenteredCoordinates: boolean = true); overload;
      procedure EraseRectAntialias(x, y, x2, y2: single; alpha: byte; pixelCenteredCoordinates: boolean = true); virtual; abstract;
      procedure AlphaFillRect(x, y, x2, y2: integer; alpha: byte); virtual; abstract;
+     procedure TextOut(x, y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment); virtual; abstract; overload;
+     procedure TextOut(x, y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment); virtual; abstract; overload;
+     procedure TextOutCurved(ACursor: TBGRACustomPathCursor; sUTF8: string; AColor: TBGRAPixel; AAlign: TAlignment; ALetterSpacing: single); virtual; abstract; overload;
+     procedure TextOutCurved(ACursor: TBGRACustomPathCursor; sUTF8: string; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single); virtual; abstract; overload;
+     procedure TextOutCurved(APath: IBGRAPath; sUTF8: string; AColor: TBGRAPixel; AAlign: TAlignment; ALetterSpacing: single); virtual; overload;
+     procedure TextOutCurved(APath: IBGRAPath; sUTF8: string; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single); virtual; overload;
+     procedure TextOutAngle(x, y: single; orientationTenthDegCCW: integer; sUTF8: string; c: TBGRAPixel; align: TAlignment); virtual; abstract;
+     procedure TextOutAngle(x, y: single; orientationTenthDegCCW: integer; sUTF8: string; texture: IBGRAScanner; align: TAlignment); virtual; abstract;
+     procedure TextRect(ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; c: TBGRAPixel); virtual; abstract; overload;
+     procedure TextRect(ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; texture: IBGRAScanner); virtual; abstract; overload;
+     function TextSize(sUTF8: string): TSize; virtual; abstract;
+     procedure TextOut(x, y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment; ARightToLeft: boolean); overload; virtual; abstract;
+     procedure TextOut(x, y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment; ARightToLeft: boolean); overload; virtual; abstract;
+     procedure TextOutCurved(ACursor: TBGRACustomPathCursor; sUTF8: string; AColor: TBGRAPixel; AAlign: TAlignment; ALetterSpacing: single); overload; virtual; abstract;
+     procedure TextOutCurved(ACursor: TBGRACustomPathCursor; sUTF8: string; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single); overload; virtual; abstract;
+     procedure TextOutCurved(APath: IBGRAPath; sUTF8: string; AColor: TBGRAPixel; AAlign: TAlignment; ALetterSpacing: single); overload; virtual;
+     procedure TextOutCurved(APath: IBGRAPath; sUTF8: string; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single); overload; virtual;
+     procedure TextOutAngle(x, y: single; orientationTenthDegCCW: integer; sUTF8: string; c: TBGRAPixel; align: TAlignment); overload; virtual; abstract;
+     procedure TextOutAngle(x, y: single; orientationTenthDegCCW: integer; sUTF8: string; texture: IBGRAScanner; align: TAlignment); overload; virtual; abstract;
+     procedure TextRect(ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; c: TBGRAPixel); overload; virtual; abstract;
+     procedure TextRect(ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; texture: IBGRAScanner); overload; virtual; abstract;
+     procedure TextMultiline(x,y: single; sUTF8: string; c: TBGRAPixel; AAlign: TBidiTextAlignment = btaLeftJustify; AVertAlign: TTextLayout = tlTop; AParagraphSpacing: single = 0); overload;
+     procedure TextMultiline(x,y: single; sUTF8: string; ATexture: IBGRAScanner; AAlign: TBidiTextAlignment = btaLeftJustify; AVertAlign: TTextLayout = tlTop; AParagraphSpacing: single = 0); overload;
+     procedure TextMultiline(ALeft,ATop,AWidth: single; sUTF8: string; c: TBGRAPixel; AAlign: TBidiTextAlignment = btaNatural; AVertAlign: TTextLayout = tlTop; AParagraphSpacing: single = 0); overload; virtual; abstract;
+     procedure TextMultiline(ALeft,ATop,AWidth: single; sUTF8: string; ATexture: IBGRAScanner; AAlign: TBidiTextAlignment = btaNatural; AVertAlign: TTextLayout = tlTop; AParagraphSpacing: single = 0); overload; virtual; abstract;
+     function TextSize(sUTF8: string): TSize; overload; virtual; abstract;
+     function TextAffineBox(sUTF8: string): TAffineBox; virtual; abstract;
+     function TextSize(sUTF8: string; AMaxWidth: integer): TSize; overload; virtual; abstract;
+     function TextSize(sUTF8: string; AMaxWidth: integer; ARightToLeft: boolean): TSize; overload; virtual; abstract;
+     function TextFitInfo(sUTF8: string; AMaxWidth: integer): integer; virtual; abstract;
      { Draw the UTF8 encoded string, (x,y) being the top-left corner. The color c or texture is used to fill the text.
        The value of FontOrientation is taken into account, so that the text may be rotated. }
+     procedure TextOut(x, y: single; sUTF8: string; c: TBGRAPixel); virtual; overload;
+     procedure TextOut(x, y: single; sUTF8: string; c: TColor); virtual; overload;
+     procedure TextOut(x, y: single; sUTF8: string; texture: IBGRAScanner); virtual; overload;
+     procedure TextOut(x, y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment); overload; virtual;
+     procedure TextOut(x, y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment); overload; virtual;
+     procedure TextOut(x, y: single; sUTF8: string; c: TBGRAPixel); overload; virtual;
+     procedure TextOut(x, y: single; sUTF8: string; c: TBGRAPixel; ARightToLeft: boolean); overload; virtual;
+     procedure TextOut(x, y: single; sUTF8: string; c: TColor); overload; virtual;
+     procedure TextOut(x, y: single; sUTF8: string; c: TColor; ARightToLeft: boolean); overload; virtual;
+     procedure TextOut(x, y: single; sUTF8: string; texture: IBGRAScanner); overload; virtual;
+     procedure TextOut(x, y: single; sUTF8: string; texture: IBGRAScanner; ARightToLeft: boolean); overload; virtual;
      { Draw the UTF8 encoded string in the rectangle ARect. Text is wrapped if necessary.
        The position depends on the specified horizontal alignment halign and vertical alignement valign.
        The color c or texture is used to fill the text. No rotation is applied. }
      procedure TextRect(ARect: TRect; sUTF8: string; halign: TAlignment; valign: TTextLayout; c: TBGRAPixel); virtual; overload;
      procedure TextRect(ARect: TRect; sUTF8: string; halign: TAlignment; valign: TTextLayout; texture: IBGRAScanner); virtual; overload;
+     procedure TextRect(ARect: TRect; sUTF8: string; halign: TAlignment; valign: TTextLayout; c: TBGRAPixel); overload; virtual;
+     procedure TextRect(ARect: TRect; sUTF8: string; halign: TAlignment; valign: TTextLayout; texture: IBGRAScanner); overload; virtual;
      {Spline}
      function ComputeClosedSpline(const APoints: array of TPointF; AStyle: TSplineStyle): ArrayOfTPointF; virtual; abstract;
      function ComputeOpenedSpline(const APoints: array of TPointF; AStyle: TSplineStyle): ArrayOfTPointF; virtual; abstract;
      function ComputeBezierCurve(const curve: TCubicBezierCurve): ArrayOfTPointF; virtual; abstract;
      function ComputeBezierCurve(const curve: TQuadraticBezierCurve): ArrayOfTPointF; virtual; abstract;
      function ComputeBezierSpline(const spline: array of TCubicBezierCurve): ArrayOfTPointF; virtual; abstract;
      function ComputeBezierSpline(const spline: array of TQuadraticBezierCurve): ArrayOfTPointF; virtual; abstract;
      function ComputeWidePolyline(const points: array of TPointF; w: single): ArrayOfTPointF; virtual; abstract;
      function ComputeWidePolyline(const points: array of TPointF; w: single; ClosedCap: boolean): ArrayOfTPointF; virtual; abstract;
+     function ComputeBezierCurve(const curve: TCubicBezierCurve): ArrayOfTPointF; overload; virtual; abstract;
+     function ComputeBezierCurve(const curve: TQuadraticBezierCurve): ArrayOfTPointF; overload; virtual; abstract;
+     function ComputeBezierSpline(const spline: array of TCubicBezierCurve): ArrayOfTPointF; overload; virtual; abstract;
+     function ComputeBezierSpline(const spline: array of TQuadraticBezierCurve): ArrayOfTPointF; overload; virtual; abstract;
+     function ComputeWidePolyline(const points: array of TPointF; w: single): ArrayOfTPointF; overload; virtual; abstract;
+     function ComputeWidePolyline(const points: array of TPointF; w: single; ClosedCap: boolean): ArrayOfTPointF; overload; virtual; abstract;
      function ComputeWidePolygon(const points: array of TPointF; w: single): ArrayOfTPointF; virtual; abstract;
+     function ComputeEllipse(x,y,rx,ry: single): ArrayOfTPointF; deprecated;
+     function ComputeEllipse(x,y,rx,ry,w: single): ArrayOfTPointF; deprecated;
+     function ComputeEllipseContour(x,y,rx,ry: single; quality: single = 1): ArrayOfTPointF; virtual; abstract;
+     function ComputeEllipseBorder(x,y,rx,ry,w: single; quality: single = 1): ArrayOfTPointF; virtual; abstract;
+     function ComputeEllipse(x,y,rx,ry: single): ArrayOfTPointF; overload; deprecated;
+     function ComputeEllipse(x,y,rx,ry,w: single): ArrayOfTPointF; overload; deprecated;
+     function ComputeEllipseContour(x,y,rx,ry: single; quality: single = 1): ArrayOfTPointF; overload; virtual; abstract;
+     function ComputeEllipseContour(AOrigin, AXAxis, AYAxis: TPointF; quality: single = 1): ArrayOfTPointF; overload; virtual; abstract;
+     function ComputeEllipseBorder(x,y,rx,ry,w: single; quality: single = 1): ArrayOfTPointF; overload; virtual; abstract;
+     function ComputeEllipseBorder(AOrigin, AXAxis, AYAxis: TPointF; w: single; quality: single = 1): ArrayOfTPointF; overload; virtual; abstract;
      function ComputeArc65536(x,y,rx,ry: single; start65536,end65536: word; quality: single = 1): ArrayOfTPointF; virtual; abstract;
      function ComputeArcRad(x,y,rx,ry: single; startRad,endRad: single; quality: single = 1): ArrayOfTPointF; virtual; abstract;
      function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; quality: single = 1): ArrayOfTPointF; virtual; abstract;
      function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; options: TRoundRectangleOptions; quality: single = 1): ArrayOfTPointF; virtual; abstract;
+     function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; quality: single = 1): ArrayOfTPointF; overload; virtual; abstract;
+     function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; options: TRoundRectangleOptions; quality: single = 1): ArrayOfTPointF; overload; virtual; abstract;
      function ComputePie65536(x,y,rx,ry: single; start65536,end65536: word; quality: single = 1): ArrayOfTPointF; virtual; abstract;
      function ComputePieRad(x,y,rx,ry: single; startRad,endRad: single; quality: single = 1): ArrayOfTPointF; virtual; abstract;
 …
      procedure FillTransparent; virtual;
      procedure NoClip; virtual; abstract;
      procedure ApplyGlobalOpacity(alpha: byte); virtual; abstract; overload;
      procedure ApplyGlobalOpacity(ARect: TRect; alpha: byte); virtual; abstract; overload;
      procedure Fill(c: TColor); virtual; overload;
      procedure Fill(c: TBGRAPixel); virtual; overload;
      procedure Fill(texture: IBGRAScanner; mode: TDrawMode); virtual; abstract; overload;
      procedure Fill(texture: IBGRAScanner); virtual; abstract; overload;
      procedure Fill(c: TBGRAPixel; start, Count: integer); virtual; abstract; overload;
+     procedure ApplyGlobalOpacity(alpha: byte); overload; virtual; abstract;
+     procedure ApplyGlobalOpacity(ARect: TRect; alpha: byte); overload; virtual; abstract;
+     procedure Fill(c: TColor); overload; virtual;
+     procedure Fill(c: TBGRAPixel); overload; virtual;
+     procedure Fill(texture: IBGRAScanner; mode: TDrawMode); overload; virtual; abstract;
+     procedure Fill(texture: IBGRAScanner); overload; virtual; abstract;
+     procedure Fill(c: TBGRAPixel; start, Count: integer); overload; virtual; abstract;
      procedure DrawPixels(c: TBGRAPixel; start, Count: integer); virtual; abstract;
+     procedure AlphaFill(alpha: byte); virtual; overload;
+     procedure AlphaFill(alpha: byte; start, Count: integer); virtual; abstract; overload;
+     procedure FillMask(x,y: integer; AMask: TBGRACustomBitmap; color: TBGRAPixel); virtual; overload;
+     procedure FillMask(x,y: integer; AMask: TBGRACustomBitmap; texture: IBGRAScanner); virtual; overload;
+     procedure FillMask(x,y: integer; AMask: TBGRACustomBitmap; color: TBGRAPixel; ADrawMode: TDrawMode); virtual; abstract; overload;
+     procedure FillMask(x,y: integer; AMask: TBGRACustomBitmap; texture: IBGRAScanner; ADrawMode: TDrawMode; AOpacity: byte = 255); virtual; abstract; overload;
+     procedure FillClearTypeMask(x,y: integer; xThird: integer; AMask: TBGRACustomBitmap; color: TBGRAPixel; ARGBOrder: boolean = true); virtual; abstract; overload;
+     procedure FillClearTypeMask(x,y: integer; xThird: integer; AMask: TBGRACustomBitmap; texture: IBGRAScanner; ARGBOrder: boolean = true); virtual; abstract; overload;
+     procedure ReplaceColor(before, after: TColor); virtual; abstract; overload;
+     procedure ReplaceColor(before, after: TBGRAPixel); virtual; abstract; overload;
+     procedure ReplaceColor(ARect: TRect; before, after: TColor); virtual; abstract; overload;
+     procedure ReplaceColor(ARect: TRect; before, after: TBGRAPixel); virtual; abstract; overload;
+     procedure ReplaceTransparent(after: TBGRAPixel); virtual; abstract; overload;
+     procedure ReplaceTransparent(ABounds: TRect; after: TBGRAPixel); virtual; abstract; overload;
+     procedure AlphaFill(alpha: byte); overload; virtual;
+     procedure AlphaFill(alpha: byte; start, Count: integer); overload; virtual; abstract;
+     procedure FillMask(x,y: integer; AMask: TBGRACustomBitmap; color: TBGRAPixel); overload; virtual;
+     procedure FillMask(x,y: integer; AMask: TBGRACustomBitmap; texture: IBGRAScanner); overload; virtual;
+     procedure FillMask(x,y: integer; AMask: TBGRACustomBitmap; color: TBGRAPixel; ADrawMode: TDrawMode); overload; virtual; abstract;
+     procedure FillMask(x,y: integer; AMask: TBGRACustomBitmap; texture: IBGRAScanner; ADrawMode: TDrawMode; AOpacity: byte = 255); overload; virtual; abstract;
+     procedure EraseMask(x,y: integer; AMask: TBGRACustomBitmap; alpha: byte=255); virtual; abstract;
+     procedure FillClearTypeMask(x,y: integer; xThird: integer; AMask: TBGRACustomBitmap; color: TBGRAPixel; ARGBOrder: boolean = true); overload; virtual; abstract;
+     procedure FillClearTypeMask(x,y: integer; xThird: integer; AMask: TBGRACustomBitmap; texture: IBGRAScanner; ARGBOrder: boolean = true); overload; virtual; abstract;
+     procedure ReplaceColor(before, after: TColor); overload; virtual; abstract;
+     procedure ReplaceColor(before, after: TBGRAPixel); overload; virtual; abstract;
+     procedure ReplaceColor(ARect: TRect; before, after: TColor); overload; virtual; abstract;
+     procedure ReplaceColor(ARect: TRect; before, after: TBGRAPixel); overload; virtual; abstract;
+     procedure ReplaceTransparent(after: TBGRAPixel); overload; virtual; abstract;
+     procedure ReplaceTransparent(ABounds: TRect; after: TBGRAPixel); overload; virtual; abstract;
      procedure FloodFill(X, Y: integer; Color: TBGRAPixel;
        mode: TFloodfillMode; Tolerance: byte = 0); virtual;
 …
        gtype: TGradientType; o1, o2: TPointF; mode: TDrawMode;
        gammaColorCorrection: boolean = True; Sinus: Boolean=False;
        ditherAlgo: TDitheringAlgorithm = daNearestNeighbor); virtual; abstract; overload;
+       ditherAlgo: TDitheringAlgorithm = daNearestNeighbor); overload; virtual; abstract;
      procedure GradientFill(x, y, x2, y2: integer; gradient: TBGRACustomGradient;
        gtype: TGradientType; o1, o2: TPointF; mode: TDrawMode;
        Sinus: Boolean=False;
        ditherAlgo: TDitheringAlgorithm = daNearestNeighbor); virtual; abstract; overload;
+       ditherAlgo: TDitheringAlgorithm = daNearestNeighbor); overload; virtual; abstract;
      function CreateBrushTexture(ABrushStyle: TBrushStyle; APatternColor, ABackgroundColor: TBGRAPixel;
                 AWidth: integer = 8; AHeight: integer = 8; APenWidth: single = 1): TBGRACustomBitmap; virtual; abstract;
 …
      procedure DataDrawTransparent(ACanvas: TCanvas; Rect: TRect;
        AData: Pointer; ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer); virtual; abstract;
      procedure DataDrawOpaque(ACanvas: TCanvas; Rect: TRect; AData: Pointer;
+     procedure DataDrawOpaque(ACanvas: TCanvas; ARect: TRect; AData: Pointer;
        ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer); virtual; abstract;
      procedure GetImageFromCanvas(CanvasSource: TCanvas; x, y: integer); virtual; abstract;
      procedure Draw(ACanvas: TCanvas; x, y: integer; Opaque: boolean = True); virtual; abstract;
      procedure Draw(ACanvas: TCanvas; Rect: TRect; Opaque: boolean = True); virtual; abstract;
+     procedure Draw(ACanvas: TCanvas; x, y: integer; Opaque: boolean = True); overload; virtual; abstract;
+     procedure Draw(ACanvas: TCanvas; Rect: TRect; Opaque: boolean = True); overload; virtual; abstract;
      procedure DrawPart(ARect: TRect; ACanvas: TCanvas; x, y: integer; Opaque: boolean); virtual;
      function GetPart(ARect: TRect): TBGRACustomBitmap; virtual; abstract;
 …
      {BGRA bitmap functions}
+     procedure CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadePosition: byte; mode: TDrawMode = dmDrawWithTransparency); virtual; abstract;
+     procedure CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadeMask: IBGRAScanner; mode: TDrawMode = dmDrawWithTransparency); virtual; abstract;
+     procedure PutImage(x, y: integer; Source: TBGRACustomBitmap; mode: TDrawMode; AOpacity: byte = 255); virtual; abstract;
+     procedure CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadePosition: byte; mode: TDrawMode = dmDrawWithTransparency); overload; virtual; abstract;
+     procedure CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadeMask: IBGRAScanner; mode: TDrawMode = dmDrawWithTransparency); overload; virtual; abstract;
+     procedure PutImage(x, y: integer; Source: TBGRACustomBitmap; mode: TDrawMode; AOpacity: byte = 255); overload; virtual; abstract;
+     procedure PutImage(x, y: integer; Source: TBitmap; mode: TDrawMode; AOpacity: byte = 255); overload;
      procedure StretchPutImage(ARect: TRect; Source: TBGRACustomBitmap; mode: TDrawMode; AOpacity: byte = 255); virtual; abstract;
+     procedure StretchPutImageProportionally(ARect: TRect; AHorizAlign: TAlignment; AVertAlign: TTextLayout; Source: TBGRACustomBitmap; mode: TDrawMode; AOpacity: byte = 255);
      procedure PutImageSubpixel(x, y: single; Source: TBGRACustomBitmap; AOpacity: byte = 255);
      procedure PutImagePart(x,y: integer; Source: TBGRACustomBitmap; SourceRect: TRect; mode: TDrawMode; AOpacity: byte = 255);
 …
      procedure PutImageAffine(AMatrix: TAffineMatrix; Source: TBGRACustomBitmap; AOpacity: Byte=255; ACorrectBlur: Boolean = false); overload;
      procedure PutImageAffine(AMatrix: TAffineMatrix; Source: TBGRACustomBitmap; AResampleFilter: TResampleFilter; AOpacity: Byte=255); overload;
+     procedure PutImageAffine(AMatrix: TAffineMatrix; Source: TBGRACustomBitmap; AOutputBounds: TRect; AResampleFilter: TResampleFilter; AMode: TDrawMode; AOpacity: Byte=255); virtual; abstract; overload;
+     procedure PutImageAffine(AMatrix: TAffineMatrix; Source: TBGRACustomBitmap; AResampleFilter: TResampleFilter; AMode: TDrawMode; AOpacity: Byte=255); overload;
+     procedure PutImageAffine(AMatrix: TAffineMatrix; Source: TBGRACustomBitmap; AOutputBounds: TRect; AResampleFilter: TResampleFilter; AMode: TDrawMode; AOpacity: Byte=255); overload; virtual; abstract;
      procedure PutImageAffine(AMatrix: TAffineMatrix; Source: TBGRACustomBitmap; AOutputBounds: TRect; AOpacity: Byte=255; ACorrectBlur: Boolean = false); overload;
      function GetImageAffineBounds(Origin,HAxis,VAxis: TPointF; Source: TBGRACustomBitmap): TRect; overload;
      function GetImageAffineBounds(Origin,HAxis,VAxis: TPointF; ASourceWidth, ASourceHeight: integer; const ASourceBounds: TRect; AClipOutput: boolean = true): TRect; overload;
      function GetImageAffineBounds(AMatrix: TAffineMatrix; Source: TBGRACustomBitmap): TRect; overload;
      function GetImageAffineBounds(AMatrix: TAffineMatrix; ASourceBounds: TRect; AClipOutput: boolean = true): TRect; virtual; abstract; overload;
      function IsAffineRoughlyTranslation(AMatrix: TAffineMatrix; ASourceBounds: TRect): boolean; virtual; abstract;
+     function GetImageAffineBounds(AMatrix: TAffineMatrix; ASourceBounds: TRect; AClipOutput: boolean = true): TRect; overload; virtual; abstract;
+     class function IsAffineRoughlyTranslation(AMatrix: TAffineMatrix; ASourceBounds: TRect): boolean; virtual; abstract;
      procedure PutImageAngle(x,y: single; Source: TBGRACustomBitmap; angle: single; AOutputBounds: TRect; imageCenterX: single = 0; imageCenterY: single = 0; AOpacity: Byte=255; ARestoreOffsetAfterRotation: boolean = false; ACorrectBlur: Boolean = false); overload;
      procedure PutImageAngle(x,y: single; Source: TBGRACustomBitmap; angle: single; imageCenterX: single = 0; imageCenterY: single = 0; AOpacity: Byte=255; ARestoreOffsetAfterRotation: boolean = false; ACorrectBlur: Boolean = false); overload;
 …
      procedure BlendImageOver(x, y: integer; Source: TBGRACustomBitmap; operation: TBlendOperation; AOpacity: byte = 255;
          ALinearBlend: boolean = false); virtual; abstract;
      function Duplicate(DuplicateProperties: Boolean = False): TBGRACustomBitmap; virtual; abstract;
      function Equals(comp: TBGRACustomBitmap): boolean; virtual; abstract;
      function Equals(comp: TBGRAPixel): boolean; virtual; abstract;
+     function Duplicate(DuplicateProperties: Boolean = False; DuplicateXorMask: Boolean = False): TBGRACustomBitmap; virtual; abstract;
+     function Equals(comp: TBGRACustomBitmap): boolean; overload; virtual; abstract;
+     function Equals(comp: TBGRAPixel): boolean; overload; virtual; abstract;
      function Resample(newWidth, newHeight: integer;
        mode: TResampleMode = rmFineResample): TBGRACustomBitmap; virtual; abstract;
      procedure VerticalFlip; virtual; overload;
      procedure VerticalFlip(ARect: TRect); virtual; abstract; overload;
      procedure HorizontalFlip; virtual; overload;
      procedure HorizontalFlip(ARect: TRect); virtual; abstract; overload;
+     procedure VerticalFlip; overload; virtual;
+     procedure VerticalFlip(ARect: TRect); overload; virtual; abstract;
+     procedure HorizontalFlip; overload; virtual;
+     procedure HorizontalFlip(ARect: TRect); overload; virtual; abstract;
      function RotateCW: TBGRACustomBitmap; virtual; abstract;
      function RotateCCW: TBGRACustomBitmap; virtual; abstract;
 …
      procedure LinearNegative; virtual; abstract;
      procedure LinearNegativeRect(ABounds: TRect); virtual; abstract;
      procedure InplaceGrayscale(AGammaCorrection: boolean = true); virtual; abstract;
      procedure InplaceGrayscale(ABounds: TRect; AGammaCorrection: boolean = true); virtual; abstract;
      procedure InplaceNormalize(AEachChannel: boolean = True); virtual; abstract;
      procedure InplaceNormalize(ABounds: TRect; AEachChannel: boolean = True); virtual; abstract;
+     procedure InplaceGrayscale(AGammaCorrection: boolean = true); overload; virtual; abstract;
+     procedure InplaceGrayscale(ABounds: TRect; AGammaCorrection: boolean = true); overload; virtual; abstract;
+     procedure InplaceNormalize(AEachChannel: boolean = True); overload; virtual; abstract;
+     procedure InplaceNormalize(ABounds: TRect; AEachChannel: boolean = True); overload; virtual; abstract;
      procedure ConvertToLinearRGB; virtual; abstract;
      procedure ConvertFromLinearRGB; virtual; abstract;
+     procedure SwapRedBlue; virtual; abstract; overload;
+     procedure SwapRedBlue(ARect: TRect); virtual; abstract; overload;
+     procedure DrawCheckers(ARect: TRect; AColorEven,AColorOdd: TBGRAPixel); virtual; abstract;
+     procedure SwapRedBlue; overload; virtual; abstract;
+     procedure SwapRedBlue(ARect: TRect); overload; virtual; abstract;
      procedure GrayscaleToAlpha; virtual; abstract;
      procedure AlphaToGrayscale; virtual; abstract;
      procedure ApplyMask(mask: TBGRACustomBitmap); overload;
      procedure ApplyMask(mask: TBGRACustomBitmap; ARect: TRect); overload;
+     procedure ApplyMask(mask: TBGRACustomBitmap; ARect: TRect; AMaskRectTopLeft: TPoint); virtual; abstract; overload;
+     function GetImageBounds(Channel: TChannel = cAlpha; ANothingValue: Byte = 0): TRect; virtual;
+     function GetImageBounds(Channels: TChannels; ANothingValue: Byte = 0): TRect; virtual;
+     function GetImageBoundsWithin(const ARect: TRect; Channel: TChannel = cAlpha; ANothingValue: Byte = 0): TRect; virtual;
+     function GetImageBoundsWithin(const ARect: TRect; Channels: TChannels; ANothingValue: Byte = 0): TRect; virtual;
+     procedure ApplyMask(mask: TBGRACustomBitmap; ARect: TRect; AMaskRectTopLeft: TPoint); overload; virtual; abstract;
+     function GetMaskFromAlpha: TBGRACustomBitmap; virtual; abstract;
+     function GetImageBounds(Channel: TChannel = cAlpha; ANothingValue: Byte = 0): TRect; overload; virtual;
+     function GetImageBounds(Channels: TChannels; ANothingValue: Byte = 0): TRect; overload; virtual;
+     function GetImageBoundsWithin(const ARect: TRect; Channel: TChannel = cAlpha; ANothingValue: Byte = 0): TRect; overload; virtual;
+     function GetImageBoundsWithin(const ARect: TRect; Channels: TChannels; ANothingValue: Byte = 0): TRect; overload; virtual;
      function GetDifferenceBounds(ABitmap: TBGRACustomBitmap): TRect; virtual; abstract;
      function MakeBitmapCopy(BackgroundColor: TColor): TBitmap; virtual; abstract;
 …
      function FilterMedian(Option: TMedianOption): TBGRACustomBitmap; virtual; abstract;
      function FilterSmooth: TBGRACustomBitmap; virtual; abstract;
      function FilterSharpen(Amount: single = 1): TBGRACustomBitmap; virtual; abstract;
      function FilterSharpen(ABounds: TRect; Amount: single = 1): TBGRACustomBitmap; virtual; abstract;
+     function FilterSharpen(Amount: single = 1): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterSharpen(ABounds: TRect; Amount: single = 1): TBGRACustomBitmap; overload; virtual; abstract;
      function FilterContour: TBGRACustomBitmap; virtual; abstract;
      function FilterPixelate(pixelSize: integer; useResample: boolean; filter: TResampleFilter = rfLinear): TBGRACustomBitmap; virtual; abstract;
      function FilterBlurRadial(radius: single; blurType: TRadialBlurType): TBGRACustomBitmap; virtual; abstract; overload;
      function FilterBlurRadial(ABounds: TRect; radius: single; blurType: TRadialBlurType): TBGRACustomBitmap; virtual; abstract; overload;
      function FilterBlurRadial(radiusX, radiusY: single; blurType: TRadialBlurType): TBGRACustomBitmap; virtual; abstract; overload;
      function FilterBlurRadial(ABounds: TRect; radiusX, radiusY: single; blurType: TRadialBlurType): TBGRACustomBitmap; virtual; abstract; overload;
      function FilterBlurMotion(distance: single; angle: single; oriented: boolean): TBGRACustomBitmap; virtual; abstract;
      function FilterBlurMotion(ABounds: TRect; distance: single; angle: single;
        oriented: boolean): TBGRACustomBitmap; virtual; abstract; function FilterCustomBlur(mask: TBGRACustomBitmap): TBGRACustomBitmap; virtual; abstract;
      function FilterCustomBlur(ABounds: TRect; mask: TBGRACustomBitmap): TBGRACustomBitmap; virtual; abstract;
      function FilterEmboss(angle: single; AStrength: integer= 64; AOptions: TEmbossOptions = []): TBGRACustomBitmap; virtual; abstract;
      function FilterEmboss(angle: single; ABounds: TRect; AStrength: integer= 64; AOptions: TEmbossOptions = []): TBGRACustomBitmap; virtual; abstract;
      function FilterEmbossHighlight(FillSelection: boolean): TBGRACustomBitmap; virtual; abstract;
      function FilterEmbossHighlight(FillSelection: boolean; BorderColor: TBGRAPixel): TBGRACustomBitmap; virtual; abstract;
      function FilterEmbossHighlight(FillSelection: boolean; BorderColor: TBGRAPixel; var Offset: TPoint): TBGRACustomBitmap; virtual; abstract;
      function FilterGrayscale: TBGRACustomBitmap; virtual; abstract;
      function FilterGrayscale(ABounds: TRect): TBGRACustomBitmap; virtual; abstract;
      function FilterNormalize(eachChannel: boolean = True): TBGRACustomBitmap; virtual; abstract;
      function FilterNormalize(ABounds: TRect; eachChannel: boolean = True): TBGRACustomBitmap; virtual; abstract;
+     function FilterBlurRadial(radius: single; blurType: TRadialBlurType): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterBlurRadial(ABounds: TRect; radius: single; blurType: TRadialBlurType): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterBlurRadial(radiusX, radiusY: single; blurType: TRadialBlurType): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterBlurRadial(ABounds: TRect; radiusX, radiusY: single; blurType: TRadialBlurType): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterBlurMotion(distance: single; angle: single; oriented: boolean): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterBlurMotion(ABounds: TRect; distance: single; angle: single; oriented: boolean): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterCustomBlur(mask: TBGRACustomBitmap): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterCustomBlur(ABounds: TRect; mask: TBGRACustomBitmap): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterEmboss(angle: single; AStrength: integer= 64; AOptions: TEmbossOptions = []): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterEmboss(angle: single; ABounds: TRect; AStrength: integer= 64; AOptions: TEmbossOptions = []): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterEmbossHighlight(FillSelection: boolean): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterEmbossHighlight(FillSelection: boolean; BorderColor: TBGRAPixel): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterEmbossHighlight(FillSelection: boolean; BorderColor: TBGRAPixel; var Offset: TPoint): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterGrayscale: TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterGrayscale(ABounds: TRect): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterNormalize(eachChannel: boolean = True): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterNormalize(ABounds: TRect; eachChannel: boolean = True): TBGRACustomBitmap; overload; virtual; abstract;
      function FilterRotate(origin: TPointF; angle: single; correctBlur: boolean = false): TBGRACustomBitmap; virtual; abstract;
      function FilterAffine(AMatrix: TAffineMatrix; correctBlur: boolean = false): TBGRACustomBitmap; virtual; abstract;
      function FilterSphere: TBGRACustomBitmap; virtual; abstract;
      function FilterTwirl(ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3): TBGRACustomBitmap; virtual; abstract;
      function FilterTwirl(ABounds: TRect; ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3): TBGRACustomBitmap; virtual; abstract;
+     function FilterTwirl(ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3): TBGRACustomBitmap; overload; virtual; abstract;
+     function FilterTwirl(ABounds: TRect; ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3): TBGRACustomBitmap; overload; virtual; abstract;
      function FilterCylinder: TBGRACustomBitmap; virtual; abstract;
      function FilterPlane: TBGRACustomBitmap; virtual; abstract;
 …
 end;
+function TBGRACustomBitmap.GetFontRightToLeftFor(AText: string): boolean;
+begin
+  case FontBidiMode of
+    fbmAuto: result := IsRightToLeftUTF8(AText);
+    fbmRightToLeft: result := true;
+  else
+    {fbmLeftToRight}
+    result := false;
+  end;
+end;
 procedure TBGRACustomBitmap.InternalArc(cx, cy, rx, ry: single;
   const StartPoint, EndPoint: TPointF; ABorderColor: TBGRAPixel; w: single; AFillColor: TBGRAPixel; AOptions: TArcOptions;
 …
 end;
+procedure TBGRACustomBitmap.LoadFromResource(AFilename: string);
+begin
+  LoadFromResource(AFilename, [loKeepTransparentRGB]);
+end;
+procedure TBGRACustomBitmap.LoadFromResource(AFilename: string;
+  Handler: TFPCustomImageReader);
+begin
+  LoadFromResource(AFilename, Handler, [loKeepTransparentRGB]);
+end;
+procedure TBGRACustomBitmap.LoadFromResource(AFilename: string;
+  Handler: TFPCustomImageReader; AOptions: TBGRALoadingOptions);
+var
+  stream: TStream;
+begin
+  stream := BGRAResource.GetResourceStream(AFilename);
+  try
+    LoadFromStream(stream,Handler,AOptions);
+  finally
+    stream.Free;
+  end;
+end;
 { Look for a pixel considering the bitmap is repeated in both directions }
 function TBGRACustomBitmap.GetPixelCycle(x, y: int32or64): TBGRAPixel;
 …
 procedure TBGRACustomBitmap.DrawPolyLine(const points: array of TPoint;
   c: TBGRAPixel; DrawLastPixel: boolean; ADrawMode: TDrawMode);
+var i: integer;
+begin
+   if length(points) = 1 then
+   begin
+     if DrawLastPixel then DrawPixel(points[0].x,points[0].y,c,ADrawMode);
+   end
+   else
+     for i := 0 to high(points)-1 do
+       DrawLine(points[i].x,points[i].Y,points[i+1].x,points[i+1].y,c,DrawLastPixel and (i=high(points)-1),ADrawMode);
+var i,start: integer;
+begin
+  start := 0;
+  for i := 0 to high(points) do
+  if IsEmptyPoint(points[i]) then start := i+1 else
+  begin
+    if (i = high(points)) or IsEmptyPoint(points[i+1]) then
+    begin
+      if (i = start) and DrawLastPixel then DrawPixel(points[i].x,points[i].y,c,ADrawMode);
+    end else
+      DrawLine(points[i].x,points[i].Y,points[i+1].x,points[i+1].y, c,
+        DrawLastPixel and ((i=high(points)-1) or IsEmptyPoint(points[i+2])), ADrawMode);
+  end;
 end;
 …
 procedure TBGRACustomBitmap.DrawPolyLineAntialias(const points: array of TPoint;
   c: TBGRAPixel; DrawLastPixel: boolean);
+var i: integer;
+begin
+   if length(points) = 1 then
+   begin
+     if DrawLastPixel then DrawLineAntialias(points[0].x,points[0].y,points[0].x,points[0].y,c,true);
+   end
+   else
+     for i := 0 to high(points)-1 do
+       DrawLineAntialias(points[i].x,points[i].Y,points[i+1].x,points[i+1].y,c,DrawLastPixel and (i=high(points)-1));
+var i,start: integer;
+begin
+  start := 0;
+  for i := 0 to high(points) do
+  if IsEmptyPoint(points[i]) then start := i+1 else
+  begin
+    if (i = high(points)) or IsEmptyPoint(points[i+1]) then
+    begin
+      if (i = start) and DrawLastPixel then DrawLineAntialias(points[i].x,points[i].y,points[i].x,points[i].y,c,true);
+    end else
+      DrawLineAntialias(points[i].x,points[i].Y,points[i+1].x,points[i+1].y, c,
+        DrawLastPixel and ((i=high(points)-1) or IsEmptyPoint(points[i+2])));
+  end;
 end;
 procedure TBGRACustomBitmap.DrawPolyLineAntialias(const points: array of TPoint; c1,
   c2: TBGRAPixel; dashLen: integer; DrawLastPixel: boolean);
+var i: integer;
+  DashPos: integer;
+begin
+   DashPos := 0;
+   if length(points) = 1 then
+   begin
+     if DrawLastPixel then DrawPixel(points[0].x,points[0].y,c1);
+   end
+   else
+     for i := 0 to high(points)-1 do
+       DrawLineAntialias(points[i].x,points[i].Y,points[i+1].x,points[i+1].y,c1,c2,dashLen,DrawLastPixel and (i=high(points)-1),DashPos);
+var i,start,dashPos: integer;
+begin
+  start := 0;
+  dashPos := 0;
+  for i := 0 to high(points) do
+  if IsEmptyPoint(points[i]) then
+  begin
+    start := i+1;
+    dashPos := 0;
+  end else
+  begin
+    if (i = high(points)) or IsEmptyPoint(points[i+1]) then
+    begin
+      if (i = start) and DrawLastPixel then DrawPixel(points[i].x,points[i].y, c1);
+    end else
+      DrawLineAntialias(points[i].x,points[i].Y,points[i+1].x,points[i+1].y, c1,c2, dashLen,
+        DrawLastPixel and ((i=high(points)-1) or IsEmptyPoint(points[i+2])), dashPos);
+  end;
 end;
 procedure TBGRACustomBitmap.DrawPolygon(const points: array of TPoint;
   c: TBGRAPixel; ADrawMode: TDrawMode);
+var i: integer;
+begin
+   if length(points) = 1 then
+   begin
+     DrawPixel(points[0].x,points[0].y,c,ADrawMode);
+   end
+   else
+   begin
+     for i := 0 to high(points)-1 do
+       DrawLine(points[i].x,points[i].Y,points[i+1].x,points[i+1].y,c,false,ADrawMode);
+     DrawLine(points[high(points)].x,points[high(points)].Y,points[0].x,points[0].y,c,false,ADrawMode);
+   end;
+var i,start: integer;
+begin
+  start := 0;
+  for i := 0 to high(points) do
+  if IsEmptyPoint(points[i]) then start := i+1 else
+  begin
+    if (i = high(points)) or IsEmptyPoint(points[i+1]) then
+    begin
+      if i = start then DrawPixel(points[i].x,points[i].y,c,ADrawMode)
+      else if (i > start) then
+        DrawLine(points[i].x,points[i].Y,points[start].x,points[start].y, c, false, ADrawMode);
+    end else
+      DrawLine(points[i].x,points[i].Y,points[i+1].x,points[i+1].y, c, false, ADrawMode);
+  end;
 end;
 procedure TBGRACustomBitmap.DrawPolygonAntialias(const points: array of TPoint;
   c: TBGRAPixel);
+var i: integer;
+begin
+   if length(points) = 1 then
+   begin
+     DrawLineAntialias(points[0].x,points[0].y,points[0].x,points[0].y,c,true);
+   end
+   else
+   begin
+     for i := 0 to high(points)-1 do
+       DrawLineAntialias(points[i].x,points[i].Y,points[i+1].x,points[i+1].y,c,false);
+     DrawLineAntialias(points[high(points)].x,points[high(points)].Y,points[0].x,points[0].y,c,false);
+   end;
+var i,start: integer;
+begin
+  start := 0;
+  for i := 0 to high(points) do
+  if IsEmptyPoint(points[i]) then start := i+1 else
+  begin
+    if (i = high(points)) or IsEmptyPoint(points[i+1]) then
+    begin
+      if i = start then DrawLineAntialias(points[i].x,points[i].y,points[i].x,points[i].y, c, true)
+      else if (i > start) then
+        DrawLineAntialias(points[i].x,points[i].Y,points[start].x,points[start].y, c, false);
+    end else
+      DrawLineAntialias(points[i].x,points[i].Y,points[i+1].x,points[i+1].y, c, false);
+  end;
+end;
+procedure TBGRACustomBitmap.DrawPolygonAntialias(const points: array of TPoint;
+  c1, c2: TBGRAPixel; dashLen: integer);
+var i,start,dashPos: integer;
+begin
+  start := 0;
+  dashPos:= 0;
+  for i := 0 to high(points) do
+  if IsEmptyPoint(points[i]) then
+  begin
+    start := i+1;
+    dashPos:= 0;
+  end else
+  begin
+    if (i = high(points)) or IsEmptyPoint(points[i+1]) then
+    begin
+      if i = start then DrawLineAntialias(points[i].x,points[i].y,points[i].x,points[i].y, c1, true)
+      else if (i > start) then
+        DrawLineAntialias(points[i].x,points[i].Y,points[start].x,points[start].y, c1,c2,dashLen, false, dashPos);
+    end else
+      DrawLineAntialias(points[i].x,points[i].Y,points[i+1].x,points[i+1].y, c1,c2,dashLen, false, dashPos);
+  end;
 end;
 procedure TBGRACustomBitmap.ErasePolyLine(const points: array of TPoint; alpha: byte;
   DrawLastPixel: boolean);
+var i: integer;
+begin
+   if length(points) = 1 then
+   begin
+     if DrawLastPixel then ErasePixel(points[0].x,points[0].y,alpha);
+   end
+   else
+     for i := 0 to high(points)-1 do
+       EraseLine(points[i].x,points[i].Y,points[i+1].x,points[i+1].y,alpha,DrawLastPixel and (i=high(points)-1));
+var i,start: integer;
+begin
+  start := 0;
+  for i := 0 to high(points) do
+  if IsEmptyPoint(points[i]) then start := i+1 else
+  begin
+    if (i = high(points)) or IsEmptyPoint(points[i+1]) then
+    begin
+      if (i = start) and DrawLastPixel then ErasePixel(points[i].x,points[i].y,alpha);
+    end else
+      EraseLine(points[i].x,points[i].Y,points[i+1].x,points[i+1].y, alpha,
+        DrawLastPixel and ((i=high(points)-1) or IsEmptyPoint(points[i+2])));
+  end;
 end;
 procedure TBGRACustomBitmap.ErasePolyLineAntialias(
   const points: array of TPoint; alpha: byte; DrawLastPixel: boolean);
+var i: integer;
+begin
+   if length(points) = 1 then
+   begin
+     if DrawLastPixel then ErasePixel(points[0].x,points[0].y,alpha);
+   end
+   else
+     for i := 0 to high(points)-1 do
+       EraseLineAntialias(points[i].x,points[i].Y,points[i+1].x,points[i+1].y,alpha,DrawLastPixel and (i=high(points)-1));
+var i,start: integer;
+begin
+  start := 0;
+  for i := 0 to high(points) do
+  if IsEmptyPoint(points[i]) then start := i+1 else
+  begin
+    if (i = high(points)) or IsEmptyPoint(points[i+1]) then
+    begin
+      if (i = start) and DrawLastPixel then ErasePixel(points[i].x,points[i].y, alpha);
+    end else
+      EraseLineAntialias(points[i].x,points[i].Y,points[i+1].x,points[i+1].y, alpha,
+        DrawLastPixel and ((i=high(points)-1) or IsEmptyPoint(points[i+2])));
+  end;
 end;
 procedure TBGRACustomBitmap.ErasePolygonOutline(const points: array of TPoint;
   alpha: byte);
+var i: integer;
+begin
+   if length(points) = 1 then
+   begin
+     ErasePixel(points[0].x,points[0].y,alpha);
+   end
+   else
+   begin
+     for i := 0 to high(points)-1 do
+       EraseLine(points[i].x,points[i].Y,points[i+1].x,points[i+1].y,alpha,false);
+     EraseLine(points[high(points)].x,points[high(points)].Y,points[0].x,points[0].y,alpha,false);
+   end;
+var i,start: integer;
+begin
+  start := 0;
+  for i := 0 to high(points) do
+  if IsEmptyPoint(points[i]) then start := i+1 else
+  begin
+    if (i = high(points)) or IsEmptyPoint(points[i+1]) then
+    begin
+      if i = start then ErasePixel(points[i].x,points[i].y, alpha)
+      else if (i > start) then
+        EraseLine(points[i].x,points[i].Y,points[start].x,points[start].y, alpha, false);
+    end else
+      EraseLine(points[i].x,points[i].Y,points[i+1].x,points[i+1].y, alpha, false);
+  end;
 end;
 procedure TBGRACustomBitmap.ErasePolygonOutlineAntialias(
   const points: array of TPoint; alpha: byte);
+var i: integer;
+begin
+   if length(points) = 1 then
+   begin
+     ErasePixel(points[0].x,points[0].y,alpha);
+   end
+   else
+   begin
+     for i := 0 to high(points)-1 do
+       EraseLineAntialias(points[i].x,points[i].Y,points[i+1].x,points[i+1].y,alpha,false);
+     EraseLineAntialias(points[high(points)].x,points[high(points)].Y,points[0].x,points[0].y,alpha,false);
+   end;
+var i,start: integer;
+begin
+  start := 0;
+  for i := 0 to high(points) do
+  if IsEmptyPoint(points[i]) then start := i+1 else
+  begin
+    if (i = high(points)) or IsEmptyPoint(points[i+1]) then
+    begin
+      if i = start then ErasePixel(points[i].x,points[i].y, alpha)
+      else if (i > start) then
+        EraseLineAntialias(points[i].x,points[i].Y,points[start].x,points[start].y, alpha, false);
+    end else
+      EraseLineAntialias(points[i].x,points[i].Y,points[i+1].x,points[i+1].y, alpha, false);
+  end;
 end;
 …
 end;
+procedure TBGRACustomBitmap.FillEllipseInRect(r: TRect;
+  FillTexture: IBGRAScanner; ADrawMode: TDrawMode);
+begin
+  FillRoundRect(r.left,r.top,r.right,r.bottom,abs(r.right-r.left),abs(r.bottom-r.top),FillTexture,ADrawMode);
+end;
 procedure TBGRACustomBitmap.FillRect(r: TRect; c: TColor);
 begin
 …
 begin
   FillRect(x,y,x2,y2,texture,mode,Point(0,0),ditheringAlgorithm);
+end;
+procedure TBGRACustomBitmap.FillRectAntialias(ARect: TRectF; c: TBGRAPixel;
+  pixelCenteredCoordinates: boolean);
+begin
+  FillRectAntialias(ARect.Left,ARect.Top,ARect.Right,ARect.Bottom, c, pixelCenteredCoordinates);
+end;
+procedure TBGRACustomBitmap.FillRectAntialias(ARect: TRectF;
+  texture: IBGRAScanner; pixelCenteredCoordinates: boolean);
+begin
+  FillRectAntialias(ARect.Left,ARect.Top,ARect.Right,ARect.Bottom, texture, pixelCenteredCoordinates);
 end;
 …
 end;
+procedure TBGRACustomBitmap.TextMultiline(x, y: single; sUTF8: string;
+  c: TBGRAPixel; AAlign: TBidiTextAlignment; AVertAlign: TTextLayout; AParagraphSpacing: single);
+begin
+  TextMultiline(x, y, EmptySingle, sUTF8, c, AAlign, AVertAlign, AParagraphSpacing);
+end;
+procedure TBGRACustomBitmap.TextMultiline(x, y: single; sUTF8: string;
+  ATexture: IBGRAScanner; AAlign: TBidiTextAlignment; AVertAlign: TTextLayout; AParagraphSpacing: single);
+begin
+  TextMultiline(x, y, EmptySingle, sUTF8, ATexture, AAlign, AVertAlign, AParagraphSpacing);
+end;
+procedure TBGRACustomBitmap.TextOut(x, y: single; sUTF8: string; c: TBGRAPixel;
+  align: TAlignment);
+begin
+  TextOut(x,y,sUTF8,c,align, GetFontRightToLeftFor(sUTF8));
+end;
+procedure TBGRACustomBitmap.TextOut(x, y: single; sUTF8: string;
+  texture: IBGRAScanner; align: TAlignment);
+begin
+  TextOut(x,y,sUTF8,texture,align, GetFontRightToLeftFor(sUTF8));
+end;
 { Draw the UTF8 encoded string, (x,y) being the top-left corner. The color c is used to fill the text.
   The value of FontOrientation is taken into account, so that the text may be rotated. }
 …
 end;
+procedure TBGRACustomBitmap.TextOut(x, y: single; sUTF8: string; c: TBGRAPixel;
+  ARightToLeft: boolean);
+begin
+  TextOut(x, y, sUTF8, c, taLeftJustify, ARightToLeft);
+end;
 { Draw the UTF8 encoded string, (x,y) being the top-left corner. The color c is used to fill the text.
   The value of FontOrientation is taken into account, so that the text may be rotated. }
 …
 begin
   TextOut(x, y, sUTF8, ColorToBGRA(c));
+end;
+procedure TBGRACustomBitmap.TextOut(x, y: single; sUTF8: string; c: TColor;
+  ARightToLeft: boolean);
+begin
+  TextOut(x, y, sUTF8, ColorToBGRA(c), ARightToLeft);
 end;
 …
 begin
   TextOut(x, y, sUTF8, texture, taLeftJustify);
+end;
+procedure TBGRACustomBitmap.TextOut(x, y: single; sUTF8: string;
+  texture: IBGRAScanner; ARightToLeft: boolean);
+begin
+  TextOut(x, y, sUTF8, texture, taLeftJustify, ARightToLeft);
 end;
 …
   style.ShowPrefix := false;
   style.Clipping := false;
+  style.RightToLeft := GetFontRightToLeftFor(sUTF8);
+  if FontBidiMode = fbmAuto then sUTF8 := AddParagraphBidiUTF8(sUTF8, style.RightToLeft);
   TextRect(ARect,ARect.Left,ARect.Top,sUTF8,style,c);
 end;
 …
   style.ShowPrefix := false;
   style.Clipping := false;
+  style.RightToLeft := GetFontRightToLeftFor(sUTF8);
+  if FontBidiMode = fbmAuto then sUTF8 := AddParagraphBidiUTF8(sUTF8, style.RightToLeft);
   TextRect(ARect,ARect.Left,ARect.Top,sUTF8,style,texture);
 end;
 …
   partial: TBGRACustomBitmap;
 begin
+  partial := GetPart(ARect);
+  if partial <> nil then
+  begin
+    partial.Draw(ACanvas, x, y, Opaque);
+    partial.Free;
+  end;
+  if (ARect.Left = 0) and (ARect.Top = 0) and (ARect.Right = Width) and (ARect.Bottom = Height) then
+    Draw(ACanvas, x,y, Opaque)
+  else
+  begin
+    partial := GetPart(ARect);
+    if partial <> nil then
+    begin
+      partial.Draw(ACanvas, x, y, Opaque);
+      partial.Free;
+    end;
+  end;
+end;
+procedure TBGRACustomBitmap.PutImage(x, y: integer; Source: TBitmap;
+  mode: TDrawMode; AOpacity: byte);
+var bgra: TBGRACustomBitmap;
+begin
+  bgra := BGRABitmapFactory.create(Source);
+  PutImage(x,y, bgra, mode, AOpacity);
+  bgra.free;
+end;
+procedure TBGRACustomBitmap.StretchPutImageProportionally(ARect: TRect;
+  AHorizAlign: TAlignment; AVertAlign: TTextLayout; Source: TBGRACustomBitmap;
+  mode: TDrawMode; AOpacity: byte);
+var
+  ratio: single;
+  imgRect: TRect;
+begin
+  if (Source.Width = 0) or (Source.Height = 0) then exit;
+  if (ARect.Width <= 0) or (ARect.Height <= 0) then exit;
+  ratio := min(ARect.Width/Source.Width, ARect.Height/Source.Height);
+  imgRect := RectWithSize(ARect.Left,ARect.Top, round(Source.Width*ratio), round(Source.Height*ratio));
+  case AHorizAlign of
+    taCenter: OffsetRect(imgRect, (ARect.Width-imgRect.Width) div 2, 0);
+    taRightJustify: OffsetRect(imgRect, ARect.Width-imgRect.Width, 0);
+  end;
+  case AVertAlign of
+    tlCenter: OffsetRect(imgRect, 0,(ARect.Height-imgRect.Height) div 2);
+    tlBottom: OffsetRect(imgRect, 0,ARect.Height-imgRect.Height);
+  end;
+  StretchPutImage(imgRect, Source, mode, AOpacity);
 end;
 …
   Source: TBGRACustomBitmap; AOutputBounds: TRect;
   AResampleFilter: TResampleFilter; AMode: TDrawMode; AOpacity: Byte);
 var m: TAffineMatrix;
+var m: TAffineMatrix; w,h: integer;
 begin
   if (Source = nil) or (Source.Width = 0) or (Source.Height = 0) or (AOpacity = 0) then exit;
+  m[1,1] := (HAxis.x-Origin.x)/(Source.Width-1); m[1,2] := (VAxis.x-Origin.x)/(Source.Height-1); m[1,3] := Origin.x;
+  m[2,1] := (HAxis.y-Origin.y)/(Source.Width-1); m[2,2] := (VAxis.y-Origin.y)/(Source.Height-1); m[2,3] := Origin.y;
+  if Source.Width < 2 then w := 2 else w := Source.Width; //avoid actual size of zero
+  if Source.Height < 2 then h := 2 else h := Source.Height;
+  m[1,1] := (HAxis.x-Origin.x)/(w-1); m[1,2] := (VAxis.x-Origin.x)/(h-1); m[1,3] := Origin.x;
+  m[2,1] := (HAxis.y-Origin.y)/(w-1); m[2,2] := (VAxis.y-Origin.y)/(h-1); m[2,3] := Origin.y;
   PutImageAffine(m,Source,AOutputBounds,AResampleFilter,AMode,AOpacity);
 end;
 …
   Source: TBGRACustomBitmap; AResampleFilter: TResampleFilter; AOpacity: Byte);
 begin
+  PutImageAffine(AMatrix, Source, AResampleFilter, dmDrawWithTransparency, AOpacity);
+end;
+procedure TBGRACustomBitmap.PutImageAffine(AMatrix: TAffineMatrix;
+  Source: TBGRACustomBitmap; AResampleFilter: TResampleFilter;
+  AMode: TDrawMode; AOpacity: Byte);
+begin
   if (Source = nil) or (Source.Width = 0) or (Source.Height = 0) or (AOpacity = 0) then exit;
+  PutImageAffine(AMatrix, Source, GetImageAffineBounds(AMatrix,Source),AResampleFilter,dmDrawWithTransparency,AOpacity);
+  PutImageAffine(AMatrix, Source, GetImageAffineBounds(AMatrix,Source),
+                 AResampleFilter,AMode,AOpacity);
 end;
 …
   else
   begin
+    if ASourceWidth < 2 then ASourceWidth := 2;   //avoid division by zero by supposing a pixel size of 2
+    if ASourceHeight < 2 then ASourceHeight := 2; //i.e. an actual size of 1 (cf pixel centered coordinates)
     m[1,1] := (HAxis.x-Origin.x)/(ASourceWidth-1); m[1,2] := (VAxis.x-Origin.x)/(ASourceHeight-1); m[1,3] := Origin.x;
     m[2,1] := (HAxis.y-Origin.y)/(ASourceWidth-1); m[2,2] := (VAxis.y-Origin.y)/(ASourceHeight-1); m[2,3] := Origin.y;
 …
   sina := -sin(-angle*Pi/180);
   Origin := Coord(0,0);
+  HAxis := Coord(w,0);
+  VAxis := Coord(0,h);
+  if w < 2 then w := 2; //when pixel size is 1, actual size is zero, so avoid that
+  if h < 2 then h := 2;
+  HAxis := Coord(w-1,0);
+  VAxis := Coord(0,h-1);
 end;

GraphicTest/Packages/bgrabitmap/bgracustomtextfx.pas

-              r494
+              r521
     FOffset: TPoint;
     function DrawMaskMulticolored(ADest: TBGRACustomBitmap; AMask: TBGRACustomBitmap; X,Y: Integer; const AColors: array of TBGRAPixel): TRect;
     function DrawMask(ADest: TBGRACustomBitmap; AMask: TBGRACustomBitmap; X,Y: Integer; AColor: TBGRAPixel): TRect;
     function DrawMask(ADest: TBGRACustomBitmap; AMask: TBGRACustomBitmap; X,Y: Integer; ATexture: IBGRAScanner): TRect;
+    function DrawMask(ADest: TBGRACustomBitmap; AMask: TBGRACustomBitmap; X,Y: Integer; AColor: TBGRAPixel): TRect; overload;
+    function DrawMask(ADest: TBGRACustomBitmap; AMask: TBGRACustomBitmap; X,Y: Integer; ATexture: IBGRAScanner): TRect; overload;
     function InternalDrawShaded(ADest: TBGRACustomBitmap; X,Y: integer; Shader: TCustomPhongShading; Altitude: integer; AColor: TBGRAPixel; ATexture: IBGRAScanner; ARounded: Boolean): TRect;
   public
 …
     procedure ApplyVerticalCylinder;
     procedure ApplyHorizontalCylinder;
     function Draw(ADest: TBGRACustomBitmap; X,Y: integer; AColor: TBGRAPixel): TRect;
     function Draw(ADest: TBGRACustomBitmap; X,Y: integer; ATexture: IBGRAScanner): TRect;
     function Draw(ADest: TBGRACustomBitmap; X, Y: integer; AColor: TBGRAPixel; AAlign: TAlignment): TRect;
     function Draw(ADest: TBGRACustomBitmap; X, Y: integer; ATexture: IBGRAScanner; AAlign: TAlignment): TRect;
     function DrawShaded(ADest: TBGRACustomBitmap; X,Y: integer; Shader: TCustomPhongShading; Altitude: integer; AColor: TBGRAPixel; ARounded: Boolean = true): TRect;
     function DrawShaded(ADest: TBGRACustomBitmap; X,Y: integer; Shader: TCustomPhongShading; Altitude: integer; ATexture: IBGRAScanner; ARounded: Boolean = true): TRect;
     function DrawShaded(ADest: TBGRACustomBitmap; X, Y: integer; Shader: TCustomPhongShading; Altitude: integer; AColor: TBGRAPixel; AAlign: TAlignment; ARounded: Boolean = true): TRect;
     function DrawShaded(ADest: TBGRACustomBitmap; X, Y: integer; Shader: TCustomPhongShading; Altitude: integer; ATexture: IBGRAScanner; AAlign: TAlignment; ARounded: Boolean = true): TRect;
     function DrawMulticolored(ADest: TBGRACustomBitmap; X,Y: integer; const AColors: array of TBGRAPixel): TRect;
     function DrawMulticolored(ADest: TBGRACustomBitmap; X,Y: integer; const AColors: array of TBGRAPixel; AAlign: TAlignment): TRect;
     function DrawOutline(ADest: TBGRACustomBitmap; X,Y: integer; AColor: TBGRAPixel): TRect;
     function DrawOutline(ADest: TBGRACustomBitmap; X,Y: integer; ATexture: IBGRAScanner): TRect;
     function DrawOutline(ADest: TBGRACustomBitmap; X,Y: integer; AColor: TBGRAPixel; AAlign: TAlignment): TRect;
     function DrawOutline(ADest: TBGRACustomBitmap; X,Y: integer; ATexture: IBGRAScanner; AAlign: TAlignment): TRect;
     function DrawShadow(ADest: TBGRACustomBitmap; X,Y,Radius: integer; AColor: TBGRAPixel): TRect;
     function DrawShadow(ADest: TBGRACustomBitmap; X,Y,Radius: integer; AColor: TBGRAPixel; AAlign: TAlignment): TRect;
+    function Draw(ADest: TBGRACustomBitmap; X,Y: integer; AColor: TBGRAPixel): TRect; overload;
+    function Draw(ADest: TBGRACustomBitmap; X,Y: integer; ATexture: IBGRAScanner): TRect; overload;
+    function Draw(ADest: TBGRACustomBitmap; X, Y: integer; AColor: TBGRAPixel; AAlign: TAlignment): TRect; overload;
+    function Draw(ADest: TBGRACustomBitmap; X, Y: integer; ATexture: IBGRAScanner; AAlign: TAlignment): TRect; overload;
+    function DrawShaded(ADest: TBGRACustomBitmap; X,Y: integer; Shader: TCustomPhongShading; Altitude: integer; AColor: TBGRAPixel; ARounded: Boolean = true): TRect; overload;
+    function DrawShaded(ADest: TBGRACustomBitmap; X,Y: integer; Shader: TCustomPhongShading; Altitude: integer; ATexture: IBGRAScanner; ARounded: Boolean = true): TRect; overload;
+    function DrawShaded(ADest: TBGRACustomBitmap; X, Y: integer; Shader: TCustomPhongShading; Altitude: integer; AColor: TBGRAPixel; AAlign: TAlignment; ARounded: Boolean = true): TRect; overload;
+    function DrawShaded(ADest: TBGRACustomBitmap; X, Y: integer; Shader: TCustomPhongShading; Altitude: integer; ATexture: IBGRAScanner; AAlign: TAlignment; ARounded: Boolean = true): TRect; overload;
+    function DrawMulticolored(ADest: TBGRACustomBitmap; X,Y: integer; const AColors: array of TBGRAPixel): TRect; overload;
+    function DrawMulticolored(ADest: TBGRACustomBitmap; X,Y: integer; const AColors: array of TBGRAPixel; AAlign: TAlignment): TRect; overload;
+    function DrawOutline(ADest: TBGRACustomBitmap; X,Y: integer; AColor: TBGRAPixel): TRect; overload;
+    function DrawOutline(ADest: TBGRACustomBitmap; X,Y: integer; ATexture: IBGRAScanner): TRect; overload;
+    function DrawOutline(ADest: TBGRACustomBitmap; X,Y: integer; AColor: TBGRAPixel; AAlign: TAlignment): TRect; overload;
+    function DrawOutline(ADest: TBGRACustomBitmap; X,Y: integer; ATexture: IBGRAScanner; AAlign: TAlignment): TRect; overload;
+    function DrawShadow(ADest: TBGRACustomBitmap; X,Y,Radius: integer; AColor: TBGRAPixel): TRect; overload;
+    function DrawShadow(ADest: TBGRACustomBitmap; X,Y,Radius: integer; AColor: TBGRAPixel; AAlign: TAlignment): TRect; overload;
     destructor Destroy; override;
     property TextMask: TBGRACustomBitmap read FTextMask;
 …
   else
     FTextMask := AMask;
+  FShadowQuality:= rbFast;
 end;

GraphicTest/Packages/bgrabitmap/bgradefaultbitmap.pas

-              r494
+              r521
 uses
   SysUtils, Classes, Types, FPImage, BGRAGraphics, BGRABitmapTypes, FPImgCanv,
   BGRACanvas, BGRACanvas2D, BGRAArrow, BGRAPen, BGRATransform;
+  BGRACanvas, BGRACanvas2D, BGRAArrow, BGRAPen, BGRATransform, BGRATextBidi;
 type
 …
       gtype: TGradientType; o1, o2: TPointF; mode: TDrawMode;
       gammaColorCorrection: boolean = True; Sinus: Boolean=False;
       ditherAlgo: TDitheringAlgorithm = daFloydSteinberg);
+      ditherAlgo: TDitheringAlgorithm = daFloydSteinberg); overload;
     procedure GradientFillDithered(x, y, x2, y2: integer; gradient: TBGRACustomGradient;
       gtype: TGradientType; o1, o2: TPointF; mode: TDrawMode;
       Sinus: Boolean=False;
       ditherAlgo: TDitheringAlgorithm = daFloydSteinberg);
+      ditherAlgo: TDitheringAlgorithm = daFloydSteinberg); overload;
   protected
     FRefCount: integer; //reference counter (not related to interface reference counter)
 …
     function SimpleStretch(NewWidth, NewHeight: integer): TBGRACustomBitmap;
     function CheckEmpty: boolean; override;
+    function CheckIsZero: boolean; override;
     function GetHasTransparentPixels: boolean; override;
+    function GetHasSemiTransparentPixels: boolean; override;
     function GetAverageColor: TColor; override;
     function GetAveragePixel: TBGRAPixel; override;
 …
     procedure SetFontRenderer(AValue: TBGRACustomFontRenderer); override;
     function CreateDefaultFontRenderer: TBGRACustomFontRenderer; virtual; abstract;
     function GetFontAnchorVerticalOffset: single;
     function GetFontAnchorRotatedOffset: TPointF;
     function GetFontAnchorRotatedOffset(ACustomOrientation: integer): TPointF;
+    function GetFontVerticalAnchorOffset: single; override;
+    function GetFontAnchorRotatedOffset: TPointF; overload;
+    function GetFontAnchorRotatedOffset(ACustomOrientation: integer): TPointF; overload;
     function GetClipRect: TRect; override;
 …
     function GetArrow: TBGRAArrow;
     procedure InternalTextOutCurved(ACursor: TBGRACustomPathCursor; sUTF8: string; AColor: TBGRAPixel; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single);
+    procedure InternalCrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadePos: byte; AFadeMask: IBGRAScanner; mode: TDrawMode = dmDrawWithTransparency);
     function CheckClippedRectBounds(var x,y,x2,y2: integer): boolean;
 …
     function GetUnique: TBGRACustomBitmap;
+    { ** Allocate xor mask }
+    procedure NeedXorMask; override;
+    { ** Free reference to xor mask }
+    procedure DiscardXorMask; override;
     {==== Constructors ====}
     {------------------------- Constructors from TFPCustomImage----------------}
     {** Creates a new bitmap, initialize properties and bitmap data }
     constructor Create(AWidth, AHeight: integer); override;
+    constructor Create(AWidth, AHeight: integer); overload; override;
     {** Can only be called with an existing instance of ''TBGRABitmap''.
         Sets the dimensions of an existing ''TBGRABitmap'' instance. }
 …
     {** Creates an image of width and height equal to zero. In this case,
         ''Data'' = '''nil''' }
     constructor Create; override;
+    constructor Create; overload; override;
     {** Creates an image by copying the content of a ''TFPCustomImage'' }
     constructor Create(AFPImage: TFPCustomImage); override;
+    constructor Create(AFPImage: TFPCustomImage); overload; override;
     {** Creates an image by copying the content of a ''TBitmap'' }
     constructor Create(ABitmap: TBitmap; AUseTransparent: boolean = true); override;
+    constructor Create(ABitmap: TBitmap; AUseTransparent: boolean = true); overload; override;
     {** Creates an image of dimensions ''AWidth'' and ''AHeight'' and fills it with the opaque color ''Color'' }
     constructor Create(AWidth, AHeight: integer; Color: TColor); override;
+    constructor Create(AWidth, AHeight: integer; Color: TColor); overload; override;
     {** Creates an image of dimensions ''AWidth'' and ''AHeight'' and fills it with ''Color'' }
     constructor Create(AWidth, AHeight: integer; Color: TBGRAPixel); override;
+    constructor Create(AWidth, AHeight: integer; Color: TBGRAPixel); overload; override;
     {** Creates an image by loading its content from the file ''AFilename''.
         The encoding of the string is the default one for the operating system.
         It is recommended to use the next constructor and UTF8 encoding }
     constructor Create(AFilename: string); override;
+    constructor Create(AFilename: string); overload; override;
     {** Creates an image by loading its content from the file ''AFilename''.
         The boolean ''AIsUtf8Filename'' specifies if UTF8 encoding is assumed
         for the filename }
     constructor Create(AFilename: string; AIsUtf8: boolean); override;
     constructor Create(AFilename: string; AIsUtf8: boolean; AOptions: TBGRALoadingOptions); override;
+    constructor Create(AFilename: string; AIsUtf8: boolean); overload; override;
+    constructor Create(AFilename: string; AIsUtf8: boolean; AOptions: TBGRALoadingOptions); overload; override;
     {** Creates an image by loading its content from the stream ''AStream'' }
     constructor Create(AStream: TStream); override;
+    constructor Create(AStream: TStream); overload; override;
     {** Free the object and all its resources }
     destructor Destroy; override;
 …
         Creates a new instance with dimensions ''AWidth'' and ''AHeight'',
         containing transparent pixels. }
     function NewBitmap(AWidth, AHeight: integer): TBGRACustomBitmap; override;
+    function NewBitmap(AWidth, AHeight: integer): TBGRACustomBitmap; overload; override;
     {** Can only be called from an existing instance of ''TBGRABitmap''.
         Creates a new instance with dimensions ''AWidth'' and ''AHeight'',
         and fills it with Color }
     function NewBitmap(AWidth, AHeight: integer; Color: TBGRAPixel): TBGRACustomBitmap; override;
+    function NewBitmap(AWidth, AHeight: integer; Color: TBGRAPixel): TBGRACustomBitmap; overload; override;
     {** Can only be called from an existing instance of ''TBGRABitmap''.
 …
         from the file ''Filename''. The encoding of the string
         is the default one for the operating system }
     function NewBitmap(Filename: string): TBGRACustomBitmap; override;
+    function NewBitmap(Filename: string): TBGRACustomBitmap; overload; override;
     {** Can only be called from an existing instance of ''TBGRABitmap''.
         Creates a new instance with by loading its content
         from the file ''Filename'' }
     function NewBitmap(Filename: string; AIsUtf8: boolean): TBGRACustomBitmap; override;
     function NewBitmap(Filename: string; AIsUtf8: boolean; AOptions: TBGRALoadingOptions): TBGRACustomBitmap; override;
+    function NewBitmap(Filename: string; AIsUtf8: boolean): TBGRACustomBitmap; overload; override;
+    function NewBitmap(Filename: string; AIsUtf8: boolean; AOptions: TBGRALoadingOptions): TBGRACustomBitmap; overload; override;
     {** Can only be called from an existing instance of ''TBGRABitmap''.
         Creates an image by copying the content of a ''TFPCustomImage'' }
     function NewBitmap(AFPImage: TFPCustomImage): TBGRACustomBitmap; override;
+    function NewBitmap(AFPImage: TFPCustomImage): TBGRACustomBitmap; overload; override;
     {** Load image from a stream. The specified image reader is used }
+    procedure LoadFromStream(Str: TStream; Handler: TFPCustomImageReader; AOptions: TBGRALoadingOptions); override;
+    procedure LoadFromStream(Str: TStream; Handler: TFPCustomImageReader; AOptions: TBGRALoadingOptions); overload; override;
+    {** Load image from an embedded Lazarus resource. Format is detected automatically }
+    procedure LoadFromResource(AFilename: string; AOptions: TBGRALoadingOptions); overload; override;
     {** Assign the content of the specified ''Source''. It can be a ''TBGRACustomBitmap'' or
         a ''TFPCustomImage'' }
     procedure Assign(Source: TPersistent); override;
+    procedure Assign(Source: TPersistent); overload; override;
     procedure Assign(Source: TBitmap; AUseTransparent: boolean); overload;
     {** Stores the image in the stream without compression nor header }
 …
     {** Sets the pixel by replacing the content at (''x'',''y'') with the specified color.
         Alpha value is set to 255 (opaque) }
     procedure SetPixel(x, y: int32or64; c: TColor); override;
+    procedure SetPixel(x, y: int32or64; c: TColor); overload; override;
     {** Sets the pixel at (''x'',''y'') with the specified content }
     procedure SetPixel(x, y: int32or64; c: TBGRAPixel); override;
+    procedure SetPixel(x, y: int32or64; c: TBGRAPixel); overload; override;
     {** Applies a logical '''xor''' to the content of the pixel with the specified value.
         This includes the alpha channel, so if you want to preserve the opacity, provide
 …
       * ''AResampleFilter'' specifies how pixels must be interpolated. Accepted
         values are ''rfBox'', ''rfLinear'', ''rfHalfCosine'' and ''rfCosine'' }
     function GetPixelCycle(x, y: single; AResampleFilter: TResampleFilter = rfLinear): TBGRAPixel; override;
+    function GetPixelCycle(x, y: single; AResampleFilter: TResampleFilter = rfLinear): TBGRAPixel; overload; override;
     {** Similar to previous ''GetPixel'' function, but the fractional part of
         the coordinate is supplied with a number from 0 to 255. The actual
         coordinate is (''x'' + ''fracX256''/256, ''y'' + ''fracY256''/256) }
     function GetPixelCycle256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter = rfLinear): TBGRAPixel; override;
+    function GetPixelCycle256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter = rfLinear): TBGRAPixel; overload; override;
     {** Computes the value of the pixel at a floating point coordiante
         by interpolating the values of the pixels around it. ''repeatX'' and
 …
       * ''AResampleFilter'' specifies how pixels must be interpolated. Accepted
         values are ''rfBox'', ''rfLinear'', ''rfHalfCosine'' and ''rfCosine'' }
     function GetPixelCycle(x, y: single; AResampleFilter: TResampleFilter; repeatX: boolean; repeatY: boolean): TBGRAPixel; override;
+    function GetPixelCycle(x, y: single; AResampleFilter: TResampleFilter; repeatX: boolean; repeatY: boolean): TBGRAPixel; overload; override;
     {** Similar to previous ''GetPixel'' function, but the fractional part of
         the coordinate is supplied with a number from 0 to 255. The actual
         coordinate is (''x'' + ''fracX256''/256, ''y'' + ''fracY256''/256) }
     function GetPixelCycle256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter; repeatX: boolean; repeatY: boolean): TBGRAPixel; override;
+    function GetPixelCycle256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter; repeatX: boolean; repeatY: boolean): TBGRAPixel; overload; override;
     {==== Drawing lines and polylines (integer coordinates) ====}
 …
     {** Draws an antialiased line from (x1,y1) to (x2,y2) using an improved version of Bresenham's algorithm
         ''c'' specifies the color. ''DrawLastPixel'' specifies if (x2,y2) must be drawn }
     procedure DrawLineAntialias(x1, y1, x2, y2: integer; c: TBGRAPixel; DrawLastPixel: boolean); override;
+    procedure DrawLineAntialias(x1, y1, x2, y2: integer; c: TBGRAPixel; DrawLastPixel: boolean); overload; override;
     {** Draws an antialiased line with two colors ''c1'' and ''c2'' as dashes of lenght ''dashLen'' }
     procedure DrawLineAntialias(x1, y1, x2, y2: integer; c1, c2: TBGRAPixel; dashLen: integer; DrawLastPixel: boolean); override;
+    procedure DrawLineAntialias(x1, y1, x2, y2: integer; c1, c2: TBGRAPixel; dashLen: integer; DrawLastPixel: boolean); overload; override;
     {** Draws an antialiased line with two colors ''c1'' and ''c2'' as dashes of lenght ''dashLen''.
         ''DashPos'' can be used to specify the start dash position and to retrieve the dash position at the end
 …
     {** Draws a line from (x1,y1) to (x2,y2) using current pen style/cap/join }
     procedure DrawLineAntialias(x1, y1, x2, y2: single; c: TBGRAPixel; w: single); override;
+    procedure DrawLineAntialias(x1, y1, x2, y2: single; c: TBGRAPixel; w: single); overload; override;
     {** Draws a line from (x1,y1) to (x2,y2) using current pen style/cap/join.
         ''texture'' specifies the source color to use when filling the line }
     procedure DrawLineAntialias(x1, y1, x2, y2: single; texture: IBGRAScanner; w: single); override;
+    procedure DrawLineAntialias(x1, y1, x2, y2: single; texture: IBGRAScanner; w: single); overload; override;
     {** Draws a line from (x1,y1) to (x2,y2) using current pen style/cap/join.
         ''Closed'' specifies if the end of the line is closed. If it is not closed,
         a space is left so that the next line can fit }
     procedure DrawLineAntialias(x1, y1, x2, y2: single; c: TBGRAPixel; w: single; ClosedCap: boolean); override;
+    procedure DrawLineAntialias(x1, y1, x2, y2: single; c: TBGRAPixel; w: single; ClosedCap: boolean); overload; override;
     {** Same as above with ''texture'' specifying the source color to use when filling the line }
     procedure DrawLineAntialias(x1, y1, x2, y2: single; texture: IBGRAScanner; w: single; ClosedCap: boolean); override;
+    procedure DrawLineAntialias(x1, y1, x2, y2: single; texture: IBGRAScanner; w: single; ClosedCap: boolean); overload; override;
     {** Draws a polyline using current pen style/cap/join }
     procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single); override;
+    procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single); overload; override;
     {** Draws a polyline using current pen style/cap/join.
         ''texture'' specifies the source color to use when filling the line }
     procedure DrawPolyLineAntialias(const points: array of TPointF; texture: IBGRAScanner; w: single); override;
+    procedure DrawPolyLineAntialias(const points: array of TPointF; texture: IBGRAScanner; w: single); overload; override;
     {** Draws a polyline using current pen style/cap/join.
         ''Closed'' specifies if the end of the line is closed. If it is not closed,
         a space is left so that the next line can fit }
     procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; ClosedCap: boolean); override;
     procedure DrawPolyLineAntialias(const points: array of TPointF; texture: IBGRAScanner; w: single; ClosedCap: boolean); override;
+    procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; ClosedCap: boolean); overload; override;
+    procedure DrawPolyLineAntialias(const points: array of TPointF; texture: IBGRAScanner; w: single; ClosedCap: boolean); overload; override;
     {** Draws a polyline using current pen style/cap/join.
         ''fillcolor'' specifies a color to fill the polygon formed by the points }
     procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; fillcolor: TBGRAPixel); override;
+    procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; fillcolor: TBGRAPixel); overload; override;
     {** Draws a polyline using current pen style/cap/join.
         The last point considered as a join with the first point if it has
 …
         The polygon is always closed. You don't need to set the last point
         to be the same as the first point }
     procedure DrawPolygonAntialias(const points: array of TPointF; c: TBGRAPixel; w: single); override;
+    procedure DrawPolygonAntialias(const points: array of TPointF; c: TBGRAPixel; w: single); overload; override;
     {** Draws a polygon using current pen style/cap/join.
         The polygon is always closed. You don't need to set the last point
         to be the same as the first point }
     procedure DrawPolygonAntialias(const points: array of TPointF; texture: IBGRAScanner; w: single); override;
+    procedure DrawPolygonAntialias(const points: array of TPointF; texture: IBGRAScanner; w: single); overload; override;
     {** Draws a filled polygon using current pen style/cap/join.
         The polygon is always closed. You don't need to set the last point
         to be the same as the first point. }
     procedure DrawPolygonAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; fillcolor: TBGRAPixel); override;
+    procedure DrawPolygonAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; fillcolor: TBGRAPixel); overload; override;
     {** Erases a line from (x1,y1) to (x2,y2) using current pen style/cap/join }
 …
     {** Draw a size border of a rectangle,
         using the specified ''mode'' }
     procedure Rectangle(x, y, x2, y2: integer; c: TBGRAPixel; mode: TDrawMode); override;
+    procedure Rectangle(x, y, x2, y2: integer; c: TBGRAPixel; mode: TDrawMode); overload; override;
     {** Draw a filled rectangle with a border of color ''BorderColor'',
         using the specified ''mode'' }
     procedure Rectangle(x, y, x2, y2: integer; BorderColor, FillColor: TBGRAPixel; mode: TDrawMode); override;
+    procedure Rectangle(x, y, x2, y2: integer; BorderColor, FillColor: TBGRAPixel; mode: TDrawMode); overload; override;
     {** Fills completely a rectangle, without any border, with the specified ''mode'' }
     procedure FillRect(x, y, x2, y2: integer; c: TBGRAPixel; mode: TDrawMode); override; overload;
+    procedure FillRect(x, y, x2, y2: integer; c: TBGRAPixel; mode: TDrawMode); overload; override;
     {** Fills completely a rectangle, without any border, with the specified ''texture'' and
         with the specified ''mode'' }
     procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint); override; overload;
     procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint; ditheringAlgorithm: TDitheringAlgorithm); override; overload;
+    procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint); overload; override;
+    procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint; ditheringAlgorithm: TDitheringAlgorithm); overload; override;
     {** Sets the alpha value within the specified rectangle }
     procedure AlphaFillRect(x, y, x2, y2: integer; alpha: byte); override;
 …
     {** Draws a round rectangle, with corners having an elliptical diameter of ''DX'' and ''DY'' }
     procedure RoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; BorderColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); override;
+    procedure FillRoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; FillTexture: IBGRAScanner; ADrawMode: TDrawMode = dmDrawWithTransparency); override; overload;
     {==== Rectangles and ellipses (floating point coordinates) ====}
 …
     {** Fills a rectangle with antialiasing. For example (-0.5,-0.5,0.5,0.5)
         fills one pixel }
     procedure FillRectAntialias(x, y, x2, y2: single; c: TBGRAPixel; pixelCenteredCoordinates: boolean = true); override;
+    procedure FillRectAntialias(x, y, x2, y2: single; c: TBGRAPixel; pixelCenteredCoordinates: boolean = true); overload; override;
     {** Fills a rectangle with a texture }
     procedure FillRectAntialias(x, y, x2, y2: single; texture: IBGRAScanner; pixelCenteredCoordinates: boolean = true); override;
+    procedure FillRectAntialias(x, y, x2, y2: single; texture: IBGRAScanner; pixelCenteredCoordinates: boolean = true); overload; override;
     {** Erases the content of a rectangle with antialiasing }
     procedure EraseRectAntialias(x, y, x2, y2: single; alpha: byte; pixelCenteredCoordinates: boolean = true); override;
 …
         elliptical radius of ''rx'' and ''ry''. ''options'' specifies how to
         draw the corners. See [[BGRABitmap Geometry types|geometry types]] }
     procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; c: TBGRAPixel; w: single; options: TRoundRectangleOptions = []); override;
+    procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; c: TBGRAPixel; w: single; options: TRoundRectangleOptions = []); overload; override;
     {** Draws a rounded rectangle border with the specified texture.
         The corners have an elliptical radius of ''rx'' and ''ry''.
         ''options'' specifies how to draw the corners.
         See [[BGRABitmap Geometry types|geometry types]] }
     procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; texture: IBGRAScanner; w: single; options: TRoundRectangleOptions = []); override;
+    procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; texture: IBGRAScanner; w: single; options: TRoundRectangleOptions = []); overload; override;
     {** Draws and fills a round rectangle }
     procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; pencolor: TBGRAPixel; w: single; fillcolor: TBGRAPixel; options: TRoundRectangleOptions = []); override;
+    procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; pencolor: TBGRAPixel; w: single; fillcolor: TBGRAPixel; options: TRoundRectangleOptions = []); overload; override;
     {** Draws and fills a round rectangle with textures }
     procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; penTexture: IBGRAScanner; w: single; fillTexture: IBGRAScanner; options: TRoundRectangleOptions = []); override;
+    procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; penTexture: IBGRAScanner; w: single; fillTexture: IBGRAScanner; options: TRoundRectangleOptions = []); overload; override;
     {** Fills a rounded rectangle with antialiasing. The corners have an
         elliptical radius of ''rx'' and ''ry''. ''options'' specifies how to
         draw the corners. See [[BGRABitmap Geometry types|geometry types]] }
     procedure FillRoundRectAntialias(x,y,x2,y2,rx,ry: single; c: TBGRAPixel; options: TRoundRectangleOptions = []; pixelCenteredCoordinates: boolean = true); override;
+    procedure FillRoundRectAntialias(x,y,x2,y2,rx,ry: single; c: TBGRAPixel; options: TRoundRectangleOptions = []; pixelCenteredCoordinates: boolean = true); overload; override;
     {** Fills a rounded rectangle with a texture }
     procedure FillRoundRectAntialias(x,y,x2,y2,rx,ry: single; texture: IBGRAScanner; options: TRoundRectangleOptions = []; pixelCenteredCoordinates: boolean = true); override;
+    procedure FillRoundRectAntialias(x,y,x2,y2,rx,ry: single; texture: IBGRAScanner; options: TRoundRectangleOptions = []; pixelCenteredCoordinates: boolean = true); overload; override;
     {** Erases the content of a rounded rectangle with a texture }
+    procedure EraseRoundRectAntialias(x,y,x2,y2,rx,ry: single; alpha: byte; options: TRoundRectangleOptions = []; pixelCenteredCoordinates: boolean = true); override;
+    procedure EraseRoundRectAntialias(x,y,x2,y2,rx,ry: single; alpha: byte; options: TRoundRectangleOptions = []; pixelCenteredCoordinates: boolean = true); overload; override;
+    {** Draws an ellipse without antialising. ''rx'' is the horizontal radius and
+        ''ry'' the vertical radius }
+    procedure Ellipse(x, y, rx, ry: single; c: TBGRAPixel; w: single; ADrawMode: TDrawMode); overload; override;
+    procedure Ellipse(AOrigin, AXAxis, AYAxis: TPointF; c: TBGRAPixel; w: single; ADrawMode: TDrawMode); overload; override;
     {** Draws an ellipse with antialising. ''rx'' is the horizontal radius and
         ''ry'' the vertical radius }
+    procedure EllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel; w: single); override;
+    procedure EllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel; w: single); overload; override;
+    procedure EllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; c: TBGRAPixel; w: single); overload; override;
     {** Draws an ellipse border with a ''texture'' }
+    procedure EllipseAntialias(x, y, rx, ry: single; texture: IBGRAScanner; w: single); override;
+    procedure EllipseAntialias(x, y, rx, ry: single; texture: IBGRAScanner; w: single); overload; override;
+    procedure EllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; texture: IBGRAScanner; w: single); overload; override;
     {** Draws and fills an ellipse }
+    procedure EllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel; w: single; back: TBGRAPixel); override;
+    procedure EllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel; w: single; back: TBGRAPixel); overload; override;
+    procedure EllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; c: TBGRAPixel; w: single; back: TBGRAPixel); overload; override;
     {** Fills an ellipse }
+    procedure FillEllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel); override;
+    procedure FillEllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel); overload; override;
+    procedure FillEllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; c: TBGRAPixel); overload; override;
     {** Fills an ellipse with a ''texture'' }
+    procedure FillEllipseAntialias(x, y, rx, ry: single; texture: IBGRAScanner); override;
+    procedure FillEllipseAntialias(x, y, rx, ry: single; texture: IBGRAScanner); overload; override;
+    procedure FillEllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; texture: IBGRAScanner); overload; override;
     {** Fills an ellipse with a gradient of color. ''outercolor'' specifies
         the end color of the gradient on the border of the ellipse and
         ''innercolor'' the end color of the gradient at the center of the
         ellipse }
+    procedure FillEllipseLinearColorAntialias(x, y, rx, ry: single; outercolor, innercolor: TBGRAPixel); override;
+    procedure FillEllipseLinearColorAntialias(x, y, rx, ry: single; outercolor, innercolor: TBGRAPixel); overload; override;
+    procedure FillEllipseLinearColorAntialias(AOrigin, AXAxis, AYAxis: TPointF; outercolor, innercolor: TBGRAPixel); overload; override;
     {** Erases the content of an ellipse }
+    procedure EraseEllipseAntialias(x, y, rx, ry: single; alpha: byte); override;
+    procedure EraseEllipseAntialias(x, y, rx, ry: single; alpha: byte); overload; override;
+    procedure EraseEllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; alpha: byte); overload; override;
     {==== Polygons and path ====}
     procedure FillPoly(const points: array of TPointF; c: TBGRAPixel; drawmode: TDrawMode); override;
     procedure FillPoly(const points: array of TPointF; texture: IBGRAScanner; drawmode: TDrawMode); override;
     procedure FillPolyAntialias(const points: array of TPointF; c: TBGRAPixel); override;
     procedure FillPolyAntialias(const points: array of TPointF; texture: IBGRAScanner); override;
     procedure ErasePoly(const points: array of TPointF; alpha: byte); override;
     procedure ErasePolyAntialias(const points: array of TPointF; alpha: byte); override;
+    procedure FillPoly(const points: array of TPointF; c: TBGRAPixel; drawmode: TDrawMode; APixelCenteredCoordinates: boolean = true); overload; override;
+    procedure FillPoly(const points: array of TPointF; texture: IBGRAScanner; drawmode: TDrawMode; APixelCenteredCoordinates: boolean = true); overload; override;
+    procedure FillPolyAntialias(const points: array of TPointF; c: TBGRAPixel; APixelCenteredCoordinates: boolean = true); overload; override;
+    procedure FillPolyAntialias(const points: array of TPointF; texture: IBGRAScanner; APixelCenteredCoordinates: boolean = true); overload; override;
+    procedure ErasePoly(const points: array of TPointF; alpha: byte; APixelCenteredCoordinates: boolean = true); override;
+    procedure ErasePolyAntialias(const points: array of TPointF; alpha: byte; APixelCenteredCoordinates: boolean = true); override;
     procedure FillTriangleLinearColor(pt1,pt2,pt3: TPointF; c1,c2,c3: TBGRAPixel); override;
 …
     procedure FillPolyPerspectiveMappingLightness(const points: array of TPointF; const pointsZ: array of single; texture: IBGRAScanner; texCoords: array of TPointF; lightnesses: array of word; TextureInterpolation: Boolean; zbuffer: psingle = nil); override;
     procedure FillShape(shape: TBGRACustomFillInfo; c: TBGRAPixel; drawmode: TDrawMode); override;
     procedure FillShape(shape: TBGRACustomFillInfo; texture: IBGRAScanner; drawmode: TDrawMode); override;
     procedure FillShapeAntialias(shape: TBGRACustomFillInfo; c: TBGRAPixel); override;
     procedure FillShapeAntialias(shape: TBGRACustomFillInfo; texture: IBGRAScanner); override;
+    procedure FillShape(shape: TBGRACustomFillInfo; c: TBGRAPixel; drawmode: TDrawMode); overload; override;
+    procedure FillShape(shape: TBGRACustomFillInfo; texture: IBGRAScanner; drawmode: TDrawMode); overload; override;
+    procedure FillShapeAntialias(shape: TBGRACustomFillInfo; c: TBGRAPixel); overload; override;
+    procedure FillShapeAntialias(shape: TBGRACustomFillInfo; texture: IBGRAScanner); overload; override;
     procedure EraseShape(shape: TBGRACustomFillInfo; alpha: byte); override;
     procedure EraseShapeAntialias(shape: TBGRACustomFillInfo; alpha: byte); override;
     procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single; AFillColor: TBGRAPixel); override;
     procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single; AFillColor: TBGRAPixel); override;
     procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single; AFillTexture: IBGRAScanner); override;
     procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single; AFillTexture: IBGRAScanner); override;
     procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single); override;
     procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single); override;
     procedure FillPath(APath: IBGRAPath; AFillColor: TBGRAPixel); override;
     procedure FillPath(APath: IBGRAPath; AFillTexture: IBGRAScanner); override;
     procedure ErasePath(APath: IBGRAPath; alpha: byte); override;
     procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single; AFillColor: TBGRAPixel); override;
     procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single; AFillColor: TBGRAPixel); override;
     procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single; AFillTexture: IBGRAScanner); override;
     procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single; AFillTexture: IBGRAScanner); override;
     procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single); override;
     procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single); override;
     procedure FillPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AFillColor: TBGRAPixel); override;
     procedure FillPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AFillTexture: IBGRAScanner); override;
     procedure ErasePath(APath: IBGRAPath; AMatrix: TAffineMatrix; alpha: byte); override;
+    procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single; AFillColor: TBGRAPixel); overload; override;
+    procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single; AFillColor: TBGRAPixel); overload; override;
+    procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single; AFillTexture: IBGRAScanner); overload; override;
+    procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single; AFillTexture: IBGRAScanner); overload; override;
+    procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single); overload; override;
+    procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single); overload; override;
+    procedure FillPath(APath: IBGRAPath; AFillColor: TBGRAPixel); overload; override;
+    procedure FillPath(APath: IBGRAPath; AFillTexture: IBGRAScanner); overload; override;
+    procedure ErasePath(APath: IBGRAPath; alpha: byte); overload; override;
+    procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single; AFillColor: TBGRAPixel); overload; override;
+    procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single; AFillColor: TBGRAPixel); overload; override;
+    procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single; AFillTexture: IBGRAScanner); overload; override;
+    procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single; AFillTexture: IBGRAScanner); overload; override;
+    procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single); overload; override;
+    procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single); overload; override;
+    procedure FillPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AFillColor: TBGRAPixel); overload; override;
+    procedure FillPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AFillTexture: IBGRAScanner); overload; override;
+    procedure ErasePath(APath: IBGRAPath; AMatrix: TAffineMatrix; alpha: byte); overload; override;
     procedure ArrowStartAsNone; override;
 …
       If align is taRightJustify, (x,y) is the top-right corner.
       The value of FontOrientation is taken into account, so that the text may be rotated. }
     procedure TextOut(x, y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment); override; overload;
+    procedure TextOut(x, y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment; ARightToLeft: boolean); overload; override;
     { Same as above functions, except that the text is filled using texture.
       The value of FontOrientation is taken into account, so that the text may be rotated. }
     procedure TextOut(x, y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment); override; overload;
+    procedure TextOut(x, y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment; ARightToLeft: boolean); overload; override;
     { Same as above, except that the orientation is specified, overriding the value of the property FontOrientation. }
+    procedure TextOutAngle(x, y: single; orientationTenthDegCCW: integer; sUTF8: string; c: TBGRAPixel; align: TAlignment); override; overload;
+    procedure TextOutAngle(x, y: single; orientationTenthDegCCW: integer; sUTF8: string; texture: IBGRAScanner; align: TAlignment); override; overload;
+    procedure TextOutCurved(ACursor: TBGRACustomPathCursor; sUTF8: string; AColor: TBGRAPixel; AAlign: TAlignment; ALetterSpacing: single); override; overload;
+    procedure TextOutCurved(ACursor: TBGRACustomPathCursor; sUTF8: string; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single); override; overload;
+    procedure TextOutAngle(x, y: single; orientationTenthDegCCW: integer; sUTF8: string; c: TBGRAPixel; align: TAlignment); overload; override;
+    procedure TextOutAngle(x, y: single; orientationTenthDegCCW: integer; sUTF8: string; texture: IBGRAScanner; align: TAlignment); overload; override;
+    procedure TextOutCurved(ACursor: TBGRACustomPathCursor; sUTF8: string; AColor: TBGRAPixel; AAlign: TAlignment; ALetterSpacing: single); overload; override;
+    procedure TextOutCurved(ACursor: TBGRACustomPathCursor; sUTF8: string; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single); overload; override;
+    procedure TextMultiline(ALeft,ATop,AWidth: single; sUTF8: string; c: TBGRAPixel; AAlign: TBidiTextAlignment = btaNatural; AVertAlign: TTextLayout = tlTop; AParagraphSpacing: single = 0); overload; override;
+    procedure TextMultiline(ALeft,ATop,AWidth: single; sUTF8: string; ATexture: IBGRAScanner; AAlign: TBidiTextAlignment = btaNatural; AVertAlign: TTextLayout = tlTop; AParagraphSpacing: single = 0); overload; override;
     { Draw the UTF8 encoded string at the coordinate (x,y), clipped inside the rectangle ARect.
       Additional style information is provided by the style parameter.
       The color c or texture is used to fill the text. No rotation is applied. }
     procedure TextRect(ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; c: TBGRAPixel); override; overload;
     procedure TextRect(ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; texture: IBGRAScanner); override; overload;
+    procedure TextRect(ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; c: TBGRAPixel); overload; override;
+    procedure TextRect(ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; texture: IBGRAScanner); overload; override;
     { Returns the total size of the string provided using the current font.
       Orientation is not taken into account, so that the width is along the text.  }
+      Orientation is not taken into account, so that the width is along the text. End of lines are stripped from the string. }
     function TextSize(sUTF8: string): TSize; override;
+    { Returns the affine box of the string provided using the current font.
+      Orientation is taken into account. End of lines are stripped from the string. }
+    function TextAffineBox(sUTF8: string): TAffineBox; override;
+    { Returns the total size of a paragraph i.e. with word break }
+    function TextSize(sUTF8: string; AMaxWidth: integer): TSize; override;
+    function TextSize(sUTF8: string; AMaxWidth: integer; ARightToLeft: boolean): TSize; override;
+    function TextFitInfo(sUTF8: string; AMaxWidth: integer): integer; override;
     {Spline}
 …
     function ComputeOpenedSpline(const APoints: array of TPointF; AStyle: TSplineStyle): ArrayOfTPointF; override;
+    function ComputeBezierCurve(const ACurve: TCubicBezierCurve): ArrayOfTPointF; override;
+    function ComputeBezierCurve(const ACurve: TQuadraticBezierCurve): ArrayOfTPointF; override;
+    function ComputeBezierSpline(const ASpline: array of TCubicBezierCurve): ArrayOfTPointF; override;
+    function ComputeBezierSpline(const ASpline: array of TQuadraticBezierCurve): ArrayOfTPointF; override;
+    function ComputeWidePolyline(const points: array of TPointF; w: single): ArrayOfTPointF; override;
+    function ComputeWidePolyline(const points: array of TPointF; w: single; ClosedCap: boolean): ArrayOfTPointF; override;
+    function ComputeWidePolygon(const points: array of TPointF; w: single): ArrayOfTPointF; override;
+    function ComputeEllipseContour(x,y,rx,ry: single; quality: single = 1): ArrayOfTPointF; override;
+    function ComputeEllipseBorder(x,y,rx,ry,w: single; quality: single = 1): ArrayOfTPointF; override;
+    function ComputeBezierCurve(const ACurve: TCubicBezierCurve): ArrayOfTPointF; overload; override;
+    function ComputeBezierCurve(const ACurve: TQuadraticBezierCurve): ArrayOfTPointF; overload; override;
+    function ComputeBezierSpline(const ASpline: array of TCubicBezierCurve): ArrayOfTPointF; overload; override;
+    function ComputeBezierSpline(const ASpline: array of TQuadraticBezierCurve): ArrayOfTPointF; overload; override;
+    function ComputeWidePolyline(const points: array of TPointF; w: single): ArrayOfTPointF; overload; override;
+    function ComputeWidePolyline(const points: array of TPointF; w: single; ClosedCap: boolean): ArrayOfTPointF; overload; override;
+    function ComputeWidePolygon(const points: array of TPointF; w: single): ArrayOfTPointF; overload; override;
+    function ComputeEllipseContour(x,y,rx,ry: single; quality: single = 1): ArrayOfTPointF;  overload; override;
+    function ComputeEllipseContour(AOrigin, AXAxis, AYAxis: TPointF; quality: single = 1): ArrayOfTPointF;  overload; override;
+    function ComputeEllipseBorder(x,y,rx,ry,w: single; quality: single = 1): ArrayOfTPointF; overload; override;
+    function ComputeEllipseBorder(AOrigin, AXAxis, AYAxis: TPointF; w: single; quality: single = 1): ArrayOfTPointF; override; overload;
     function ComputeArc65536(x,y,rx,ry: single; start65536,end65536: word; quality: single = 1): ArrayOfTPointF; override;
     function ComputeArcRad(x,y,rx,ry: single; startRad,endRad: single; quality: single = 1): ArrayOfTPointF; override;
     function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; quality: single = 1): ArrayOfTPointF; override;
     function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; options: TRoundRectangleOptions; quality: single = 1): ArrayOfTPointF; override;
+    function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; quality: single = 1): ArrayOfTPointF; overload; override;
+    function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; options: TRoundRectangleOptions; quality: single = 1): ArrayOfTPointF; overload; override;
     function ComputePie65536(x,y,rx,ry: single; start65536,end65536: word; quality: single = 1): ArrayOfTPointF; override;
     function ComputePieRad(x,y,rx,ry: single; startRad,endRad: single; quality: single = 1): ArrayOfTPointF; override;
 …
     {Filling}
     procedure NoClip; override;
     procedure Fill(texture: IBGRAScanner; mode: TDrawMode); override;
     procedure Fill(texture: IBGRAScanner); override;
     procedure Fill(c: TBGRAPixel; start, Count: integer); override;
+    procedure Fill(texture: IBGRAScanner; mode: TDrawMode); overload; override;
+    procedure Fill(texture: IBGRAScanner); overload; override;
+    procedure Fill(c: TBGRAPixel; start, Count: integer); overload; override;
     procedure DrawPixels(c: TBGRAPixel; start, Count: integer); override;
     procedure AlphaFill(alpha: byte; start, Count: integer); override;
     procedure FillMask(x,y: integer; AMask: TBGRACustomBitmap; color: TBGRAPixel; ADrawMode: TDrawMode); override;
     procedure FillMask(x,y: integer; AMask: TBGRACustomBitmap; texture: IBGRAScanner; ADrawMode: TDrawMode; AOpacity: byte = 255); override;
+    procedure EraseMask(x,y: integer; AMask: TBGRACustomBitmap; alpha: byte=255); override;
     procedure FillClearTypeMask(x,y: integer; xThird: integer; AMask: TBGRACustomBitmap; color: TBGRAPixel; ARGBOrder: boolean = true); override;
     procedure FillClearTypeMask(x,y: integer; xThird: integer; AMask: TBGRACustomBitmap; texture: IBGRAScanner; ARGBOrder: boolean = true); override;
 …
     {Canvas drawing functions}
     procedure Draw(ACanvas: TCanvas; x, y: integer; Opaque: boolean = True); override;
     procedure Draw(ACanvas: TCanvas; Rect: TRect; Opaque: boolean = True); override;
+    procedure Draw(ACanvas: TCanvas; x, y: integer; Opaque: boolean = True); overload; override;
+    procedure Draw(ACanvas: TCanvas; Rect: TRect; Opaque: boolean = True); overload; override;
     procedure InvalidateBitmap; override;         //call if you modify with Scanline
     procedure LoadFromBitmapIfNeeded; override;   //call to ensure that bitmap data is up to date
     {BGRA bitmap functions}
     procedure CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadePosition: byte; mode: TDrawMode = dmDrawWithTransparency); override;
     procedure CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadeMask: IBGRAScanner; mode: TDrawMode = dmDrawWithTransparency); override;
     procedure PutImage(x, y: integer; Source: TBGRACustomBitmap; mode: TDrawMode; AOpacity: byte = 255); override;
     procedure PutImageAffine(AMatrix: TAffineMatrix; Source: TBGRACustomBitmap; AOutputBounds: TRect; AResampleFilter: TResampleFilter; AMode: TDrawMode; AOpacity: Byte=255); override; overload;
     function GetImageAffineBounds(AMatrix: TAffineMatrix; ASourceBounds: TRect; AClipOutput: boolean = true): TRect; override; overload;
     function IsAffineRoughlyTranslation(AMatrix: TAffineMatrix; ASourceBounds: TRect): boolean; override;
+    procedure CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadePosition: byte; mode: TDrawMode = dmDrawWithTransparency); overload; override;
+    procedure CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadeMask: IBGRAScanner; mode: TDrawMode = dmDrawWithTransparency); overload; override;
+    procedure PutImage(x, y: integer; Source: TBGRACustomBitmap; mode: TDrawMode; AOpacity: byte = 255); overload; override;
+    procedure PutImageAffine(AMatrix: TAffineMatrix; Source: TBGRACustomBitmap; AOutputBounds: TRect; AResampleFilter: TResampleFilter; AMode: TDrawMode; AOpacity: Byte=255); overload; override;
+    function GetImageAffineBounds(AMatrix: TAffineMatrix; ASourceBounds: TRect; AClipOutput: boolean = true): TRect; overload; override;
+    class function IsAffineRoughlyTranslation(AMatrix: TAffineMatrix; ASourceBounds: TRect): boolean; override;
     procedure StretchPutImage(ARect: TRect; Source: TBGRACustomBitmap; mode: TDrawMode; AOpacity: byte = 255); override;
 …
     function GetPart(ARect: TRect): TBGRACustomBitmap; override;
     function GetPtrBitmap(Top,Bottom: Integer): TBGRACustomBitmap; override;
     function Duplicate(DuplicateProperties: Boolean = False) : TBGRACustomBitmap; override;
+    function Duplicate(DuplicateProperties: Boolean = False; DuplicateXorMask: Boolean = False) : TBGRACustomBitmap; override;
     procedure CopyPropertiesTo(ABitmap: TBGRADefaultBitmap);
     function Equals(comp: TBGRACustomBitmap): boolean; override;
     function Equals(comp: TBGRAPixel): boolean; override;
+    function Equals(comp: TBGRACustomBitmap): boolean; overload; override;
+    function Equals(comp: TBGRAPixel): boolean; overload; override;
     function GetDifferenceBounds(ABitmap: TBGRACustomBitmap): TRect; override;
     function MakeBitmapCopy(BackgroundColor: TColor): TBitmap; override;
 …
     function Resample(newWidth, newHeight: integer;
       mode: TResampleMode = rmFineResample): TBGRACustomBitmap; override;
     procedure VerticalFlip(ARect: TRect); override; overload;
     procedure HorizontalFlip(ARect: TRect); override; overload;
+    procedure VerticalFlip(ARect: TRect); overload; override;
+    procedure HorizontalFlip(ARect: TRect); overload; override;
     function RotateCW: TBGRACustomBitmap; override;
     function RotateCCW: TBGRACustomBitmap; override;
 …
     procedure LinearNegative; override;
     procedure LinearNegativeRect(ABounds: TRect); override;
     procedure InplaceGrayscale(AGammaCorrection: boolean = true); override;
     procedure InplaceGrayscale(ABounds: TRect; AGammaCorrection: boolean = true); override;
     procedure InplaceNormalize(AEachChannel: boolean = True); override;
     procedure InplaceNormalize(ABounds: TRect; AEachChannel: boolean = True); override;
+    procedure InplaceGrayscale(AGammaCorrection: boolean = true); overload; override;
+    procedure InplaceGrayscale(ABounds: TRect; AGammaCorrection: boolean = true); overload; override;
+    procedure InplaceNormalize(AEachChannel: boolean = True); overload; override;
+    procedure InplaceNormalize(ABounds: TRect; AEachChannel: boolean = True); overload; override;
     procedure SwapRedBlue; override;
     procedure SwapRedBlue(ARect: TRect); override;
     procedure GrayscaleToAlpha; override;
     procedure AlphaToGrayscale; override;
+    procedure ApplyMask(mask: TBGRACustomBitmap; ARect: TRect; AMaskRectTopLeft: TPoint); override; overload;
+    procedure ApplyMask(mask: TBGRACustomBitmap; ARect: TRect; AMaskRectTopLeft: TPoint); overload; override;
+    function GetMaskFromAlpha: TBGRACustomBitmap; override;
     procedure ApplyGlobalOpacity(alpha: byte); override;
     procedure ApplyGlobalOpacity(ABounds: TRect; alpha: byte); override;
     procedure ConvertToLinearRGB; override;
     procedure ConvertFromLinearRGB; override;
     procedure DrawCheckers(ARect: TRect; AColorEven,AColorOdd: TBGRAPixel);
+    procedure DrawCheckers(ARect: TRect; AColorEven,AColorOdd: TBGRAPixel); override;
     {Filters}
 …
     function FilterMedian(Option: TMedianOption): TBGRACustomBitmap; override;
     function FilterSmooth: TBGRACustomBitmap; override;
     function FilterSharpen(Amount: single = 1): TBGRACustomBitmap; override;
     function FilterSharpen(ABounds: TRect; Amount: single = 1): TBGRACustomBitmap; override;
+    function FilterSharpen(Amount: single = 1): TBGRACustomBitmap; overload; override;
+    function FilterSharpen(ABounds: TRect; Amount: single = 1): TBGRACustomBitmap; overload; override;
     function FilterContour: TBGRACustomBitmap; override;
     function FilterPixelate(pixelSize: integer; useResample: boolean; filter: TResampleFilter = rfLinear): TBGRACustomBitmap; override;
     function FilterBlurRadial(radius: single; blurType: TRadialBlurType): TBGRACustomBitmap; override;
     function FilterBlurRadial(ABounds: TRect; radius: single; blurType: TRadialBlurType): TBGRACustomBitmap; override;
     function FilterBlurRadial(radiusX, radiusY: single; blurType: TRadialBlurType): TBGRACustomBitmap; override;
     function FilterBlurRadial(ABounds: TRect; radiusX, radiusY: single; blurType: TRadialBlurType): TBGRACustomBitmap; override;
     function FilterBlurMotion(distance: single; angle: single; oriented: boolean): TBGRACustomBitmap; override;
     function FilterBlurMotion(ABounds: TRect; distance: single; angle: single; oriented: boolean): TBGRACustomBitmap; override;
     function FilterCustomBlur(mask: TBGRACustomBitmap): TBGRACustomBitmap; override;
     function FilterCustomBlur(ABounds: TRect; mask: TBGRACustomBitmap): TBGRACustomBitmap; override;
     function FilterEmboss(angle: single; AStrength: integer= 64; AOptions: TEmbossOptions = []): TBGRACustomBitmap; override;
     function FilterEmboss(angle: single; ABounds: TRect; AStrength: integer= 64; AOptions: TEmbossOptions = []): TBGRACustomBitmap; override;
     function FilterEmbossHighlight(FillSelection: boolean): TBGRACustomBitmap; override;
     function FilterEmbossHighlight(FillSelection: boolean; BorderColor: TBGRAPixel): TBGRACustomBitmap; override;
     function FilterEmbossHighlight(FillSelection: boolean; BorderColor: TBGRAPixel; var Offset: TPoint): TBGRACustomBitmap; override;
     function FilterGrayscale: TBGRACustomBitmap; override;
     function FilterGrayscale(ABounds: TRect): TBGRACustomBitmap; override;
     function FilterNormalize(eachChannel: boolean = True): TBGRACustomBitmap; override;
     function FilterNormalize(ABounds: TRect; eachChannel: boolean = True): TBGRACustomBitmap; override;
+    function FilterBlurRadial(radius: single; blurType: TRadialBlurType): TBGRACustomBitmap; overload; override;
+    function FilterBlurRadial(ABounds: TRect; radius: single; blurType: TRadialBlurType): TBGRACustomBitmap; overload; override;
+    function FilterBlurRadial(radiusX, radiusY: single; blurType: TRadialBlurType): TBGRACustomBitmap; overload; override;
+    function FilterBlurRadial(ABounds: TRect; radiusX, radiusY: single; blurType: TRadialBlurType): TBGRACustomBitmap; overload; override;
+    function FilterBlurMotion(distance: single; angle: single; oriented: boolean): TBGRACustomBitmap; overload; override;
+    function FilterBlurMotion(ABounds: TRect; distance: single; angle: single; oriented: boolean): TBGRACustomBitmap; overload; override;
+    function FilterCustomBlur(mask: TBGRACustomBitmap): TBGRACustomBitmap; overload; override;
+    function FilterCustomBlur(ABounds: TRect; mask: TBGRACustomBitmap): TBGRACustomBitmap; overload; override;
+    function FilterEmboss(angle: single; AStrength: integer= 64; AOptions: TEmbossOptions = []): TBGRACustomBitmap; overload; override;
+    function FilterEmboss(angle: single; ABounds: TRect; AStrength: integer= 64; AOptions: TEmbossOptions = []): TBGRACustomBitmap; overload; override;
+    function FilterEmbossHighlight(FillSelection: boolean): TBGRACustomBitmap; overload; override;
+    function FilterEmbossHighlight(FillSelection: boolean; BorderColor: TBGRAPixel): TBGRACustomBitmap; overload; override;
+    function FilterEmbossHighlight(FillSelection: boolean; BorderColor: TBGRAPixel; var Offset: TPoint): TBGRACustomBitmap; overload; override;
+    function FilterGrayscale: TBGRACustomBitmap; overload; override;
+    function FilterGrayscale(ABounds: TRect): TBGRACustomBitmap; overload; override;
+    function FilterNormalize(eachChannel: boolean = True): TBGRACustomBitmap; overload; override;
+    function FilterNormalize(ABounds: TRect; eachChannel: boolean = True): TBGRACustomBitmap; overload; override;
     function FilterRotate(origin: TPointF; angle: single; correctBlur: boolean = false): TBGRACustomBitmap; override;
     function FilterAffine(AMatrix: TAffineMatrix; correctBlur: boolean = false): TBGRACustomBitmap; override;
     function FilterSphere: TBGRACustomBitmap; override;
     function FilterTwirl(ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3): TBGRACustomBitmap; override;
     function FilterTwirl(ABounds: TRect; ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3): TBGRACustomBitmap; override;
+    function FilterTwirl(ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3): TBGRACustomBitmap; overload; override;
+    function FilterTwirl(ABounds: TRect; ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3): TBGRACustomBitmap; overload; override;
     function FilterCylinder: TBGRACustomBitmap; override;
     function FilterPlane: TBGRACustomBitmap; override;
 …
   public
     constructor Create(AWidth, AHeight: integer; AData: Pointer); overload;
     function Duplicate(DuplicateProperties: Boolean = False): TBGRACustomBitmap; override;
+    function Duplicate(DuplicateProperties: Boolean = False; DuplicateXorMask: Boolean = False): TBGRACustomBitmap; override;
     procedure SetDataPtr(AData: Pointer);
     property LineOrder: TRawImageLineOrder Read GetLineOrder Write SetLineOrder;
 …
     procedure TakeScreenshot({%H-}ARect: TRect); override;
     procedure TakeScreenshotOfPrimaryMonitor; override;
     procedure LoadFromDevice({%H-}DC: System.THandle); override;
     procedure LoadFromDevice({%H-}DC: System.THandle; {%H-}ARect: TRect); override;
+    procedure LoadFromDevice({%H-}DC: HDC); override;
+    procedure LoadFromDevice({%H-}DC: HDC; {%H-}ARect: TRect); override;
   end;
 …
 begin
   if FUser <> nil then
+  begin
     FUser.FBitmapModified := True;
+    FUser.FAlphaCorrectionNeeded := true;
+  end;
   inherited Changed(Sender);
 end;
 …
 end;
+function TBGRADefaultBitmap.CheckIsZero: boolean;
+var
+  i: integer;
+  p: PBGRAPixel;
+begin
+  p := Data;
+  for i := (NbPixels shr 1) - 1 downto 0 do
+  begin
+    if PInt64(p)^ <> 0 then
+    begin
+      Result := False;
+      exit;
+    end;
+    Inc(p,2);
+  end;
+  if Odd(NbPixels) and (PDWord(p)^ <> 0) then
+  begin
+    Result := false;
+    exit;
+  end;
+  Result := True;
+end;
 function TBGRADefaultBitmap.GetCanvasAlphaCorrection: boolean;
 begin
 …
 procedure TBGRADefaultBitmap.SetArrowEndSize(AValue: TPointF);
 begin
+  {$PUSH}{$OPTIMIZATION OFF}
   GetArrow.EndSize := AValue;
+  {$POP}
 end;
 procedure TBGRADefaultBitmap.SetArrowStartSize(AValue: TPointF);
 begin
+  {$PUSH}{$OPTIMIZATION OFF}
   GetArrow.StartSize := AValue;
+  {$POP}
 end;
 …
 end;
 function TBGRADefaultBitmap.GetFontAnchorVerticalOffset: single;
+function TBGRADefaultBitmap.GetFontVerticalAnchorOffset: single;
 begin
   case FontVerticalAnchor of
 …
   ACustomOrientation: integer): TPointF;
 begin
   result := PointF(0, GetFontAnchorVerticalOffset);
+  result := PointF(0, GetFontVerticalAnchorOffset);
   if ACustomOrientation <> 0 then
     result := AffineMatrixRotationDeg(-ACustomOrientation*0.1)*result;
 …
 function TBGRADefaultBitmap.NewReference: TBGRACustomBitmap;
 begin
   Inc(FRefCount);
+  if self <> nil then Inc(FRefCount);
   Result := self;
 end;
 …
 end;
+procedure TBGRADefaultBitmap.NeedXorMask;
+begin
+  if FXorMask = nil then
+    FXorMask := BGRABitmapFactory.Create(Width,Height);
+end;
+procedure TBGRADefaultBitmap.DiscardXorMask;
+begin
+  if Assigned(FXorMask) then
+  begin
+    if FXorMask is TBGRADefaultBitmap then
+    begin
+      TBGRADefaultBitmap(FXorMask).FreeReference;
+      FXorMask := nil;
+    end else
+      FreeAndNil(FXorMask);
+  end;
+end;
 { Creates a new bitmap with dimensions AWidth and AHeight and filled with
   transparent pixels. Internally, it uses the same type so that if you
 …
   OldJpegPerf: TJPEGReadPerformance;
 begin
+  DiscardXorMask;
   if (loBmpAutoOpaque in AOptions) and (Handler is TBGRAReaderBMP) then
   begin
 …
   end else
     inherited LoadFromStream(Str, Handler, AOptions);
+end;
+procedure TBGRADefaultBitmap.LoadFromResource(AFilename: string;
+  AOptions: TBGRALoadingOptions);
+var
+  stream: TStream;
+  format: TBGRAImageFormat;
+  reader: TFPCustomImageReader;
+  magic: array[1..2] of char;
+  startPos: Int64;
+  ext: String;
+begin
+  stream := BGRAResource.GetResourceStream(AFilename);
+  try
+    ext := Uppercase(ExtractFileExt(AFilename));
+    if (ext = '.BMP') and BGRAResource.IsWinResource(AFilename) then
+    begin
+      reader := TBGRAReaderBMP.Create;
+      TBGRAReaderBMP(reader).Subformat := bsfHeaderless;
+    end else
+    begin
+      format := DetectFileFormat(stream, ext);
+      reader := CreateBGRAImageReader(format);
+    end;
+    try
+      LoadFromStream(stream, reader, AOptions);
+    finally
+      reader.Free;
+    end;
+  finally
+    stream.Free;
+  end;
 end;
 …
   ReallocData;
   NoClip;
+  DiscardXorMask;
 end;
 …
 destructor TBGRADefaultBitmap.Destroy;
 begin
+  DiscardXorMask;
   FPenStroker.Free;
   FFontRenderer.Free;
 …
     SetSize(TBGRACustomBitmap(Source).Width, TBGRACustomBitmap(Source).Height);
     PutImage(0, 0, TBGRACustomBitmap(Source), dmSet);
+    if Source is TBGRADefaultBitmap then
+    begin
+      HotSpot := TBGRADefaultBitmap(Source).HotSpot;
+      if XorMask <> TBGRADefaultBitmap(Source).XorMask then
+      begin
+        DiscardXorMask;
+        if TBGRADefaultBitmap(Source).XorMask is TBGRADefaultBitmap then
+          FXorMask := TBGRADefaultBitmap(TBGRADefaultBitmap(Source).XorMask).NewReference as TBGRADefaultBitmap
+        else
+          FXorMask := TBGRADefaultBitmap(Source).XorMask.Duplicate;
+      end;
+    end;
   end else
   if Source is TFPCustomImage then
 …
 function TBGRADefaultBitmap.GetCanvas: TCanvas;
 begin
+  Result := Bitmap.Canvas;
+  if FDataModified or (FBitmap = nil) then
+  begin
+    RebuildBitmap;
+    FDataModified := False;
+  end;
+  Result := FBitmap.Canvas;
 end;
 …
 procedure TBGRADefaultBitmap.CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadePosition: byte; mode: TDrawMode = dmDrawWithTransparency);
-var constScanner: TBGRAConstantScanner;
 begin
   if AFadePosition = 0 then
 …
   if AFadePosition = 255 then
     FillRect(ARect, Source2, mode) else
+  begin
+    constScanner := TBGRAConstantScanner.Create(BGRA(AFadePosition,AFadePosition,AFadePosition,255));
+    CrossFade(ARect, Source1,Source2, constScanner, mode);
+    constScanner.Free;
+  end;
+    InternalCrossFade(ARect, Source1,Source2, AFadePosition,nil, mode);
 end;
 procedure TBGRADefaultBitmap.CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadeMask: IBGRAScanner; mode: TDrawMode = dmDrawWithTransparency);
+var xb,yb: NativeInt;
+  pdest: PBGRAPixel;
+  c: TBGRAPixel;
+  fadePos: byte;
+begin
+  if not IntersectRect(ARect,ARect,ClipRect) then exit;
+  for yb := ARect.top to ARect.Bottom-1 do
+  begin
+    pdest := GetScanlineFast(yb)+ARect.Left;
+    Source1.ScanMoveTo(ARect.left, yb);
+    Source2.ScanMoveTo(ARect.left, yb);
+    AFadeMask.ScanMoveTo(ARect.left, yb);
+    for xb := ARect.left to ARect.Right-1 do
+    begin
+      fadePos := AFadeMask.ScanNextPixel.green;
+      c := MergeBGRAWithGammaCorrection(Source1.ScanNextPixel,not fadePos,Source2.ScanNextPixel,fadePos);
+      case mode of
+      dmSet: pdest^ := c;
+      dmDrawWithTransparency: DrawPixelInlineWithAlphaCheck(pdest, c);
+      dmLinearBlend: FastBlendPixelInline(pdest,c);
+      dmSetExceptTransparent: if c.alpha = 255 then pdest^ := c;
+      end;
+      inc(pdest);
+    end;
+  end;
+  InvalidateBitmap;
+begin
+  InternalCrossFade(ARect, Source1,Source2, 0,AFadeMask, mode);
 end;
 …
 end;
+procedure TBGRADefaultBitmap.InternalCrossFade(ARect: TRect; Source1,
+  Source2: IBGRAScanner; AFadePos: byte; AFadeMask: IBGRAScanner; mode: TDrawMode);
+var xb,yb: NativeInt;
+  pdest: PBGRAPixel;
+  c: TBGRAPixel;
+  buf1,buf2: ArrayOfTBGRAPixel;
+begin
+  if not IntersectRect(ARect,ARect,ClipRect) then exit;
+  setlength(buf1, ARect.Width);
+  setlength(buf2, ARect.Width);
+  for yb := ARect.top to ARect.Bottom-1 do
+  begin
+    pdest := GetScanlineFast(yb)+ARect.Left;
+    Source1.ScanMoveTo(ARect.left, yb);
+    Source1.ScanPutPixels(@buf1[0], length(buf1), dmSet);
+    Source2.ScanMoveTo(ARect.left, yb);
+    Source2.ScanPutPixels(@buf2[0], length(buf2), dmSet);
+    if AFadeMask<>nil then AFadeMask.ScanMoveTo(ARect.left, yb);
+    for xb := 0 to ARect.Right-ARect.left-1 do
+    begin
+      if AFadeMask<>nil then AFadePos := AFadeMask.ScanNextPixel.green;
+      c := MergeBGRAWithGammaCorrection(buf1[xb],not AFadePos,buf2[xb],AFadePos);
+      case mode of
+      dmSet: pdest^ := c;
+      dmDrawWithTransparency: DrawPixelInlineWithAlphaCheck(pdest, c);
+      dmLinearBlend: FastBlendPixelInline(pdest,c);
+      dmSetExceptTransparent: if c.alpha = 255 then pdest^ := c;
+      end;
+      inc(pdest);
+    end;
+  end;
+  InvalidateBitmap;
+end;
 procedure TBGRADefaultBitmap.InternalArc(cx, cy, rx, ry: single; StartAngleRad,
   EndAngleRad: Single; ABorderColor: TBGRAPixel; w: single; AFillColor: TBGRAPixel; AOptions: TArcOptions;
 …
 end;
 function TBGRADefaultBitmap.IsAffineRoughlyTranslation(AMatrix: TAffineMatrix; ASourceBounds: TRect): boolean;
+class function TBGRADefaultBitmap.IsAffineRoughlyTranslation(AMatrix: TAffineMatrix; ASourceBounds: TRect): boolean;
 const oneOver512 = 1/512;
 var Orig,HAxis,VAxis: TPointF;
 …
   tempPath := TBGRAPath.Create(APath);
   multi := TBGRAMultishapeFiller.Create;
+  multi.FillMode := FillMode;
   multi.PolygonOrder := poLastOnTop;
   multi.AddPathFill(tempPath,AMatrix,AFillColor);
 …
   tempPath := TBGRAPath.Create(APath);
   multi := TBGRAMultishapeFiller.Create;
+  multi.FillMode := FillMode;
   multi.PolygonOrder := poLastOnTop;
   multi.AddPathFill(tempPath,AMatrix,AFillColor);
 …
   tempPath := TBGRAPath.Create(APath);
   multi := TBGRAMultishapeFiller.Create;
+  multi.FillMode := FillMode;
   multi.PolygonOrder := poLastOnTop;
   multi.AddPathFill(tempPath,AMatrix,AFillTexture);
 …
   tempPath := TBGRAPath.Create(APath);
   multi := TBGRAMultishapeFiller.Create;
+  multi.FillMode := FillMode;
   multi.PolygonOrder := poLastOnTop;
   multi.AddPathFill(tempPath,AMatrix,AFillTexture);
 …
 procedure TBGRADefaultBitmap.FillPoly(const points: array of TPointF;
   c: TBGRAPixel; drawmode: TDrawMode);
 begin
   BGRAPolygon.FillPolyAliased(self, points, c, FEraseMode, FillMode = fmWinding, drawmode);
+  c: TBGRAPixel; drawmode: TDrawMode; APixelCenteredCoordinates: boolean);
+begin
+  BGRAPolygon.FillPolyAliased(self, points, c, FEraseMode, FillMode = fmWinding, drawmode, APixelCenteredCoordinates);
 end;
 procedure TBGRADefaultBitmap.FillPoly(const points: array of TPointF;
   texture: IBGRAScanner; drawmode: TDrawMode);
 begin
   BGRAPolygon.FillPolyAliasedWithTexture(self, points, texture, FillMode = fmWinding, drawmode);
+  texture: IBGRAScanner; drawmode: TDrawMode; APixelCenteredCoordinates: boolean);
+begin
+  BGRAPolygon.FillPolyAliasedWithTexture(self, points, texture, FillMode = fmWinding, drawmode, APixelCenteredCoordinates);
 end;
 …
 end;
 procedure TBGRADefaultBitmap.FillPolyAntialias(const points: array of TPointF; c: TBGRAPixel);
 begin
   BGRAPolygon.FillPolyAntialias(self, points, c, FEraseMode, FillMode = fmWinding, LinearAntialiasing);
+procedure TBGRADefaultBitmap.FillPolyAntialias(const points: array of TPointF; c: TBGRAPixel; APixelCenteredCoordinates: boolean);
+begin
+  BGRAPolygon.FillPolyAntialias(self, points, c, FEraseMode, FillMode = fmWinding, LinearAntialiasing, APixelCenteredCoordinates);
 end;
 procedure TBGRADefaultBitmap.FillPolyAntialias(const points: array of TPointF;
   texture: IBGRAScanner);
 begin
   BGRAPolygon.FillPolyAntialiasWithTexture(self, points, texture, FillMode = fmWinding, LinearAntialiasing);
+  texture: IBGRAScanner; APixelCenteredCoordinates: boolean);
+begin
+  BGRAPolygon.FillPolyAntialiasWithTexture(self, points, texture, FillMode = fmWinding, LinearAntialiasing, APixelCenteredCoordinates);
 end;
 procedure TBGRADefaultBitmap.ErasePoly(const points: array of TPointF;
   alpha: byte);
 begin
   BGRAPolygon.FillPolyAliased(self, points, BGRA(0, 0, 0, alpha), True, FillMode = fmWinding, dmDrawWithTransparency);
 end;
 procedure TBGRADefaultBitmap.ErasePolyAntialias(const points: array of TPointF; alpha: byte);
+  alpha: byte; APixelCenteredCoordinates: boolean);
+begin
+  BGRAPolygon.FillPolyAliased(self, points, BGRA(0, 0, 0, alpha), True, FillMode = fmWinding, dmDrawWithTransparency, APixelCenteredCoordinates);
+end;
+procedure TBGRADefaultBitmap.ErasePolyAntialias(const points: array of TPointF; alpha: byte; APixelCenteredCoordinates: boolean);
 begin
   FEraseMode := True;
   FillPolyAntialias(points, BGRA(0, 0, 0, alpha));
+  FillPolyAntialias(points, BGRA(0, 0, 0, alpha), APixelCenteredCoordinates);
   FEraseMode := False;
 end;
 …
   c: TBGRAPixel; w: single);
 begin
   if (PenStyle = psClear) or (c.alpha = 0) then exit;
+  if (PenStyle = psClear) or (c.alpha = 0) or (w = 0) then exit;
   if (PenStyle = psSolid) then
     BGRAPolygon.BorderEllipseAntialias(self, x, y, rx, ry, w, c, FEraseMode, LinearAntialiasing)
 …
 end;
+procedure TBGRADefaultBitmap.EllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF;
+  c: TBGRAPixel; w: single);
+begin
+  if (PenStyle = psClear) or (c.alpha = 0) or (w = 0) then exit;
+  DrawPolygonAntialias(ComputeEllipseContour(AOrigin, AXAxis, AYAxis),c,w);
+end;
 procedure TBGRADefaultBitmap.EllipseAntialias(x, y, rx, ry: single;
   texture: IBGRAScanner; w: single);
 begin
   if (PenStyle = psClear) then exit;
+  if (PenStyle = psClear) or (w = 0) then exit;
   if (PenStyle = psSolid) then
     BGRAPolygon.BorderEllipseAntialiasWithTexture(self, x, y, rx, ry, w, texture, LinearAntialiasing)
 …
 end;
+procedure TBGRADefaultBitmap.EllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF;
+  texture: IBGRAScanner; w: single);
+begin
+  if (PenStyle = psClear) or (w = 0) then exit;
+  DrawPolygonAntialias(ComputeEllipseContour(AOrigin, AXAxis, AYAxis),texture,w);
+end;
 procedure TBGRADefaultBitmap.EllipseAntialias(x, y, rx, ry: single;
   c: TBGRAPixel; w: single; back: TBGRAPixel);
 …
     hw: single;
 begin
+  if w=0 then exit;
+  if (w=0) or (PenStyle = psClear) or (c.alpha = 0) then
+  begin
+    FillEllipseAntialias(x, y, rx, ry, back);
+    exit;
+  end;
   rx := abs(rx);
   ry := abs(ry);
 …
   { use multishape filler for fine junction between polygons }
   multi := TBGRAMultishapeFiller.Create;
+  if not (PenStyle = psClear) and (c.alpha <> 0) then
+  begin
+    if (PenStyle = psSolid) then
+    begin
+      multi.AddEllipse(x,y,rx-hw,ry-hw,back);
+      multi.AddEllipseBorder(x,y,rx,ry,w,c)
+    end
+    else
+    begin
+      multi.AddEllipse(x,y,rx,ry,back);
+      multi.AddPolygon(ComputeWidePolygon(ComputeEllipseContour(x,y,rx,ry),w),c);
+      multi.PolygonOrder := poLastOnTop;
+    end;
+  end;
+  if (PenStyle = psSolid) then
+  begin
+    if back.alpha <> 0 then multi.AddEllipse(x,y,rx-hw,ry-hw,back);
+    multi.AddEllipseBorder(x,y,rx,ry,w,c)
+  end
+  else
+  begin
+    if back.alpha <> 0 then multi.AddEllipse(x,y,rx,ry,back);
+    multi.AddPolygon(ComputeWidePolygon(ComputeEllipseContour(x,y,rx,ry),w),c);
+  end;
+  multi.PolygonOrder := poLastOnTop;
   multi.Draw(self);
   multi.Free;
 end;
+procedure TBGRADefaultBitmap.EllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF;
+  c: TBGRAPixel; w: single; back: TBGRAPixel);
+var multi: TBGRAMultishapeFiller;
+    pts: ArrayOfTPointF;
+begin
+  if (w=0) or (PenStyle = psClear) or (c.alpha = 0) then
+  begin
+    FillEllipseAntialias(AOrigin, AXAxis, AYAxis, back);
+    exit;
+  end;
+  { use multishape filler for fine junction between polygons }
+  multi := TBGRAMultishapeFiller.Create;
+  pts := ComputeEllipseContour(AOrigin, AXAxis, AYAxis);
+  if back.alpha <> 0 then multi.AddPolygon(pts, back);
+  pts := ComputeWidePolygon(pts,w);
+  multi.AddPolygon(pts,c);
+  multi.PolygonOrder := poLastOnTop;
+  multi.Draw(self);
+  multi.Free;
+end;
 procedure TBGRADefaultBitmap.FillEllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel);
 begin
   BGRAPolygon.FillEllipseAntialias(self, x, y, rx, ry, c, FEraseMode, LinearAntialiasing);
+end;
+procedure TBGRADefaultBitmap.FillEllipseAntialias(AOrigin, AXAxis,
+  AYAxis: TPointF; c: TBGRAPixel);
+var
+  pts: array of TPointF;
+begin
+  if c.alpha = 0 then exit;
+  pts := ComputeEllipseContour(AOrigin,AXAxis,AYAxis);
+  FillPolyAntialias(pts, c);
 end;
 …
 begin
   BGRAPolygon.FillEllipseAntialiasWithTexture(self, x, y, rx, ry, texture, LinearAntialiasing);
+end;
+procedure TBGRADefaultBitmap.FillEllipseAntialias(AOrigin, AXAxis,
+  AYAxis: TPointF; texture: IBGRAScanner);
+var
+  pts: array of TPointF;
+begin
+  pts := ComputeEllipseContour(AOrigin,AXAxis,AYAxis);
+  FillPolyAntialias(pts, texture);
 end;
 …
 end;
+procedure TBGRADefaultBitmap.FillEllipseLinearColorAntialias(AOrigin, AXAxis,
+  AYAxis: TPointF; outercolor, innercolor: TBGRAPixel);
+var
+  grad: TBGRAGradientScanner;
+  affine: TBGRAAffineScannerTransform;
+begin
+  grad := TBGRAGradientScanner.Create(innercolor,outercolor,gtRadial,PointF(0,0),PointF(1,0),True);
+  affine := TBGRAAffineScannerTransform.Create(grad);
+  affine.Fit(AOrigin,AXAxis,AYAxis);
+  FillEllipseAntialias(AOrigin,AXAxis,AYAxis,affine);
+  affine.Free;
+  grad.Free;
+end;
 procedure TBGRADefaultBitmap.EraseEllipseAntialias(x, y, rx, ry: single; alpha: byte);
 begin
   FEraseMode := True;
   FillEllipseAntialias(x, y, rx, ry, BGRA(0, 0, 0, alpha));
+  FEraseMode := False;
+end;
+procedure TBGRADefaultBitmap.EraseEllipseAntialias(AOrigin, AXAxis,
+  AYAxis: TPointF; alpha: byte);
+begin
+  FEraseMode := True;
+  FillEllipseAntialias(AOrigin, AXAxis, AYAxis, BGRA(0, 0, 0, alpha));
   FEraseMode := False;
 end;
 …
   c: TBGRAPixel; options: TRoundRectangleOptions; pixelCenteredCoordinates: boolean);
 begin
+  if not pixelCenteredCoordinates then
+  begin
+    x -= 0.5;
+    y -= 0.5;
+    x2 -= 0.5;
+    y2 -= 0.5;
+  end;
+  BGRAPolygon.FillRoundRectangleAntialias(self,x,y,x2,y2,rx,ry,options,c,False, LinearAntialiasing);
+  BGRAPolygon.FillRoundRectangleAntialias(self,x,y,x2,y2,rx,ry,options,c,False, LinearAntialiasing, pixelCenteredCoordinates);
 end;
 …
   ry: single; texture: IBGRAScanner; options: TRoundRectangleOptions; pixelCenteredCoordinates: boolean);
 begin
+  if not pixelCenteredCoordinates then
+  begin
+    x -= 0.5;
+    y -= 0.5;
+    x2 -= 0.5;
+    y2 -= 0.5;
+  end;
+  BGRAPolygon.FillRoundRectangleAntialiasWithTexture(self,x,y,x2,y2,rx,ry,options,texture, LinearAntialiasing);
+  BGRAPolygon.FillRoundRectangleAntialiasWithTexture(self,x,y,x2,y2,rx,ry,options,texture, LinearAntialiasing, pixelCenteredCoordinates);
 end;
 …
   ry: single; alpha: byte; options: TRoundRectangleOptions; pixelCenteredCoordinates: boolean);
 begin
+  if not pixelCenteredCoordinates then
+  begin
+    x -= 0.5;
+    y -= 0.5;
+    x2 -= 0.5;
+    y2 -= 0.5;
+  end;
+  BGRAPolygon.FillRoundRectangleAntialias(self,x,y,x2,y2,rx,ry,options,BGRA(0,0,0,alpha),True, LinearAntialiasing);
+  BGRAPolygon.FillRoundRectangleAntialias(self,x,y,x2,y2,rx,ry,options,BGRA(0,0,0,alpha),True, LinearAntialiasing, pixelCenteredCoordinates);
+end;
+procedure TBGRADefaultBitmap.Ellipse(x, y, rx, ry: single; c: TBGRAPixel;
+  w: single; ADrawMode: TDrawMode);
+begin
+  if (PenStyle = psClear) or (c.alpha = 0) or (w = 0) then exit;
+  if (PenStyle = psSolid) then
+    BGRAPolygon.BorderEllipse(self, x, y, rx, ry, w, c, FEraseMode, ADrawMode)
+  else
+    FillPoly(ComputeWidePolygon(ComputeEllipseContour(x,y,rx,ry),w),c, ADrawMode);
+end;
+procedure TBGRADefaultBitmap.Ellipse(AOrigin, AXAxis, AYAxis: TPointF;
+  c: TBGRAPixel; w: single; ADrawMode: TDrawMode);
+begin
+  if (PenStyle = psClear) or (c.alpha = 0) or (w = 0) then exit;
+  FillPoly(ComputeWidePolygon(ComputeEllipseContour(AOrigin, AXAxis, AYAxis),w),c,ADrawMode);
 end;
 …
 end;
+procedure TBGRADefaultBitmap.FillRoundRect(X1, Y1, X2, Y2: integer; DX,
+  DY: integer; FillTexture: IBGRAScanner; ADrawMode: TDrawMode);
+begin
+  BGRAFillRoundRectAliased(self,X1,Y1,X2,Y2,DX,DY,BGRAPixelTransparent,FillTexture,ADrawMode);
+end;
 {------------------------- Text functions ---------------------------------------}
 …
 end;
+procedure TBGRADefaultBitmap.TextMultiline(ALeft, ATop, AWidth: single; sUTF8: string;
+  c: TBGRAPixel; AAlign: TBidiTextAlignment; AVertAlign: TTextLayout; AParagraphSpacing: single);
+var
+  layout: TBidiTextLayout;
+  i: Integer;
+begin
+  if FontBidiMode = fbmAuto then
+    layout := TBidiTextLayout.Create(FontRenderer, sUTF8)
+  else
+    layout := TBidiTextLayout.Create(FontRenderer, sUTF8, GetFontRightToLeftFor(sUTF8));
+  for i := 0 to layout.ParagraphCount-1 do
+    layout.ParagraphAlignment[i] := AAlign;
+  layout.ParagraphSpacingBelow:= AParagraphSpacing;
+  layout.AvailableWidth := AWidth;
+  case AVertAlign of
+    tlBottom: layout.TopLeft := PointF(ALeft,ATop-layout.TotalTextHeight);
+    tlCenter: layout.TopLeft := PointF(ALeft,ATop-layout.TotalTextHeight/2);
+    else layout.TopLeft := PointF(ALeft,ATop);
+  end;
+  layout.DrawText(self, c);
+  layout.Free;
+end;
+procedure TBGRADefaultBitmap.TextMultiline(ALeft, ATop, AWidth: single;
+  sUTF8: string; ATexture: IBGRAScanner; AAlign: TBidiTextAlignment;
+  AVertAlign: TTextLayout; AParagraphSpacing: single);
+var
+  layout: TBidiTextLayout;
+  i: Integer;
+begin
+  if FontBidiMode = fbmAuto then
+    layout := TBidiTextLayout.Create(FontRenderer, sUTF8)
+  else
+    layout := TBidiTextLayout.Create(FontRenderer, sUTF8, GetFontRightToLeftFor(sUTF8));
+  for i := 0 to layout.ParagraphCount-1 do
+    layout.ParagraphAlignment[i] := AAlign;
+  layout.ParagraphSpacingBelow:= AParagraphSpacing;
+  layout.AvailableWidth := AWidth;
+  case AVertAlign of
+    tlBottom: layout.TopLeft := PointF(ALeft,ATop-layout.TotalTextHeight);
+    tlCenter: layout.TopLeft := PointF(ALeft,ATop-layout.TotalTextHeight/2);
+    else layout.TopLeft := PointF(ALeft,ATop);
+  end;
+  layout.DrawText(self, ATexture);
+  layout.Free;
+end;
 procedure TBGRADefaultBitmap.TextOut(x, y: single; sUTF8: string;
   texture: IBGRAScanner; align: TAlignment);
 begin
   FontRenderer.TextOut(self,x,y,CleanTextOutString(sUTF8),texture,align);
+  texture: IBGRAScanner; align: TAlignment; ARightToLeft: boolean);
+begin
+  FontRenderer.TextOut(self,x,y,CleanTextOutString(sUTF8),texture,align, ARightToLeft);
 end;
 procedure TBGRADefaultBitmap.TextOut(x, y: single; sUTF8: string;
   c: TBGRAPixel; align: TAlignment);
+  c: TBGRAPixel; align: TAlignment; ARightToLeft: boolean);
 begin
   with (PointF(x,y)-GetFontAnchorRotatedOffset) do
     FontRenderer.TextOut(self,x,y,CleanTextOutString(sUTF8),c,align);
+    FontRenderer.TextOut(self,x,y,CleanTextOutString(sUTF8),c,align, ARightToLeft);
 end;
 …
 function TBGRADefaultBitmap.TextSize(sUTF8: string): TSize;
 begin
+  result := FontRenderer.TextSize(sUTF8);
+  result := FontRenderer.TextSize(CleanTextOutString(sUTF8));
+end;
+function TBGRADefaultBitmap.TextAffineBox(sUTF8: string): TAffineBox;
+var size: TSize;
+  m: TAffineMatrix;
+  dy: single;
+begin
+  dy := GetFontVerticalAnchorOffset;
+  size := FontRenderer.TextSizeAngle(sUTF8, FontOrientation);
+  m := AffineMatrixRotationDeg(-FontOrientation*0.1);
+  result := TAffineBox.AffineBox(PointF(0,-dy), m*PointF(size.cx,-dy), m*PointF(0,size.cy-dy));
+end;
+function TBGRADefaultBitmap.TextSize(sUTF8: string; AMaxWidth: integer): TSize;
+begin
+  result := FontRenderer.TextSize(sUTF8, AMaxWidth, GetFontRightToLeftFor(sUTF8));
+end;
+function TBGRADefaultBitmap.TextSize(sUTF8: string; AMaxWidth: integer;
+  ARightToLeft: boolean): TSize;
+begin
+  result := FontRenderer.TextSize(sUTF8, AMaxWidth, ARightToLeft);
+end;
+function TBGRADefaultBitmap.TextFitInfo(sUTF8: string; AMaxWidth: integer
+  ): integer;
+begin
+  result := FontRenderer.TextFitInfo(sUTF8, AMaxWidth);
 end;
 …
 end;
+function TBGRADefaultBitmap.ComputeEllipseContour(AOrigin, AXAxis,
+  AYAxis: TPointF; quality: single): ArrayOfTPointF;
+begin
+  result := BGRAPath.ComputeEllipse(AOrigin,AXAxis,AYAxis, quality);
+end;
 function TBGRADefaultBitmap.ComputeEllipseBorder(x, y, rx, ry, w: single; quality: single): ArrayOfTPointF;
 begin
   result := ComputeWidePolygon(ComputeEllipseContour(x,y,rx,ry, quality),w);
+end;
+function TBGRADefaultBitmap.ComputeEllipseBorder(AOrigin, AXAxis,
+  AYAxis: TPointF; w: single; quality: single): ArrayOfTPointF;
+begin
+  result := ComputeWidePolygon(ComputeEllipseContour(AOrigin,AXAxis,AYAxis, quality),w);
 end;
 …
   self.FillRect(X,Y,X+AMask.Width,Y+AMask.Height,scan,ADrawMode);
   scan.Free;
+end;
+procedure TBGRADefaultBitmap.EraseMask(x, y: integer; AMask: TBGRACustomBitmap;
+  alpha: byte);
+var
+  x0,y0,x2, y2, yb,xb, tx, delta: integer;
+  p, psrc: PBGRAPixel;
+begin
+  if (AMask = nil) or (alpha = 0) then exit;
+  x0 := x;
+  y0 := y;
+  x2 := x+AMask.Width;
+  y2 := y+AMask.Height;
+  if not CheckClippedRectBounds(x,y,x2,y2) then exit;
+  tx := x2 - x;
+  Dec(x2);
+  Dec(y2);
+  p := Scanline[y] + x;
+  if FLineOrder = riloBottomToTop then
+    delta := -Width
+  else
+    delta := Width;
+  for yb := y to y2 do
+  begin
+    psrc := AMask.ScanLine[yb-y0]+(x-x0);
+    if alpha = 255 then
+    begin
+      for xb := tx-1 downto 0 do
+      begin
+        ErasePixelInline(p, psrc^.green);
+        inc(p);
+        inc(psrc);
+      end;
+    end else
+    begin
+      for xb := tx-1 downto 0 do
+      begin
+        ErasePixelInline(p, ApplyOpacity(psrc^.green,alpha));
+        inc(p);
+        inc(psrc);
+      end;
+    end;
+    dec(p, tx);
+    Inc(p, delta);
+  end;
+  InvalidateBitmap;
 end;
 …
       exit;
     StartMask := $FFFFFFFF shl (X1 and 31);
+    if X2 and 31 = 31 then
+      EndMask := $FFFFFFFF
+    case X2 and 31 of
+: EndMask := $FFFFFFFF;
+: EndMask := $7FFFFFFF;
     else
       EndMask := 1 shl ((X2 and 31) + 1) - 1;
+    end;
     StartPos := X1 shr 5 + AY * VisitedLineSize;
     EndPos := X2 shr 5 + AY * VisitedLineSize;
 …
       end;
       InvalidateBitmap;
+      if (Source is TBGRADefaultBitmap) and Assigned(TBGRADefaultBitmap(Source).XorMask) then
+        PutImage(x,y,TBGRADefaultBitmap(Source).XorMask,dmXor,AOpacity);
     end;
     dmDrawWithTransparency:
 …
       end;
       InvalidateBitmap;
+      if (Source is TBGRADefaultBitmap) and Assigned(TBGRADefaultBitmap(Source).XorMask) then
+        PutImage(x,y,TBGRADefaultBitmap(Source).XorMask,dmXor,AOpacity);
     end;
     dmFastBlend:
 …
       end;
       InvalidateBitmap;
+      if (Source is TBGRADefaultBitmap) and Assigned(TBGRADefaultBitmap(Source).XorMask) then
+        PutImage(x,y,TBGRADefaultBitmap(Source).XorMask,dmXor,AOpacity);
     end;
     dmXor:
 …
 procedure TBGRADefaultBitmap.StretchPutImage(ARect: TRect;
   Source: TBGRACustomBitmap; mode: TDrawMode; AOpacity: byte);
+var noTransition: boolean;
 begin
   If (Source = nil) or (AOpacity = 0) then exit;
 …
      PutImage(ARect.Left,ARect.Top,Source,mode,AOpacity)
   else
+     BGRAResample.StretchPutImage(Source, ARect.Right-ARect.Left, ARect.Bottom-ARect.Top, self, ARect.left,ARect.Top, mode, AOpacity);
+  begin
+     noTransition:= (mode = dmXor) or ((mode in [dmDrawWithTransparency,dmFastBlend,dmSetExceptTransparent]) and
+                                       (Source is TBGRADefaultBitmap) and
+                                       Assigned(TBGRADefaultBitmap(Source).XorMask));
+     BGRAResample.StretchPutImage(Source, ARect.Right-ARect.Left, ARect.Bottom-ARect.Top, self, ARect.left,ARect.Top, mode, AOpacity, noTransition);
+    if (mode in [dmDrawWithTransparency,dmFastBlend,dmSetExceptTransparent]) and Assigned(TBGRADefaultBitmap(Source).XorMask) then
+      BGRAResample.StretchPutImage(TBGRADefaultBitmap(Source).XorMask, ARect.Right-ARect.Left, ARect.Bottom-ARect.Top, self, ARect.left,ARect.Top, dmXor, AOpacity, noTransition);
+  end;
 end;
 { Duplicate bitmap content. Optionally, bitmap properties can be also duplicated }
 function TBGRADefaultBitmap.Duplicate(DuplicateProperties: Boolean = False): TBGRACustomBitmap;
+function TBGRADefaultBitmap.Duplicate(DuplicateProperties: Boolean = False; DuplicateXorMask: Boolean = False): TBGRACustomBitmap;
 var Temp: TBGRADefaultBitmap;
 begin
 …
   if DuplicateProperties then
     CopyPropertiesTo(Temp);
+  if DuplicateXorMask and Assigned(XorMask) then
+    Temp.FXorMask := FXorMask.Duplicate(True) as TBGRADefaultBitmap;
   Result := Temp;
 end;
 …
   ABitmap.FontAntialias := FontAntialias;
   ABitmap.FontOrientation := FontOrientation;
+  ABitmap.FontBidiMode:= FontBidiMode;
   ABitmap.LineCap := LineCap;
   ABitmap.JoinStyle := JoinStyle;
   ABitmap.FillMode := FillMode;
   ABitmap.ClipRect := ClipRect;
+  ABitmap.HotSpot := HotSpot;
 end;
 …
 end;
+function TBGRADefaultBitmap.GetHasSemiTransparentPixels: boolean;
+var
+  n: integer;
+  p: PBGRAPixel;
+begin
+  p := Data;
+  for n := NbPixels - 1 downto 0 do
+  begin
+    if (p^.alpha > 0) and (p^.alpha < 255) then
+    begin
+      result := true;
+      exit;
+    end;
+    inc(p);
+  end;
+  result := false;
+end;
 function TBGRADefaultBitmap.GetAverageColor: TColor;
 var
 …
   freemem(line);
   InvalidateBitmap;
+  if Assigned(XorMask) then XorMask.VerticalFlip(ARect);
 end;
 …
   end;
   InvalidateBitmap;
+  if Assigned(XorMask) then XorMask.HorizontalFlip(ARect);
 end;
 …
     end;
   end;
+  if Assigned(XorMask) then TBGRADefaultBitmap(result).FXorMask := self.XorMask.RotateCW;
 end;
 …
     end;
   end;
+  if Assigned(XorMask) then TBGRADefaultBitmap(result).FXorMask := self.XorMask.RotateCCW;
 end;
 …
   end;
   InvalidateBitmap;
+end;
+function TBGRADefaultBitmap.GetMaskFromAlpha: TBGRACustomBitmap;
+var y,x: integer;
+  psrc, pdest: PBGRAPixel;
+begin
+  result := BGRABitmapFactory.Create(Width,Height);
+  for y := 0 to self.Height-1 do
+  begin
+    psrc := self.ScanLine[y];
+    pdest := result.ScanLine[y];
+    for x := 0 to self.Width-1 do
+    begin
+      pdest^ := BGRA(psrc^.alpha,psrc^.alpha,psrc^.alpha);
+      inc(psrc);
+      inc(pdest);
+    end;
+  end;
 end;
 …
 end;
 function TBGRAPtrBitmap.Duplicate(DuplicateProperties: Boolean = False): TBGRACustomBitmap;
+function TBGRAPtrBitmap.Duplicate(DuplicateProperties: Boolean = False; DuplicateXorMask: Boolean = False): TBGRACustomBitmap;
 begin
   Result := NewBitmap(Width, Height);
   if DuplicateProperties then CopyPropertiesTo(TBGRADefaultBitmap(Result));
+  if DuplicateXorMask and Assigned(XorMask) then
+    TBGRADefaultBitmap(Result).FXorMask := FXorMask.Duplicate(True);
 end;
 …
 end;
 procedure TBGRAPtrBitmap.LoadFromDevice(DC: System.THandle);
 begin
   CannotResize;
 end;
 procedure TBGRAPtrBitmap.LoadFromDevice(DC: System.THandle; ARect: TRect);
 begin
   CannotResize;
+procedure TBGRAPtrBitmap.LoadFromDevice(DC: HDC);
+begin
+  NotImplemented;
+end;
+procedure TBGRAPtrBitmap.LoadFromDevice(DC: HDC; ARect: TRect);
+begin
+  NotImplemented;
 end;

GraphicTest/Packages/bgrabitmap/bgradithering.pas

-              r494
+              r521
     procedure SetTransparentColorIndex(AValue: integer);
   public
     constructor Create(APalette: TBGRACustomApproxPalette; AIgnoreAlpha: boolean; ABitsPerPixelForIndices: integer); //use platform byte order
     constructor Create(APalette: TBGRACustomApproxPalette; AIgnoreAlpha: boolean; ABitsPerPixelForIndices: integer; AByteOrder: TRawImageByteOrder); //maybe necessary if larger than 8 bits per pixel
+    constructor Create(APalette: TBGRACustomApproxPalette; AIgnoreAlpha: boolean; ABitsPerPixelForIndices: integer); overload; //use platform byte order
+    constructor Create(APalette: TBGRACustomApproxPalette; AIgnoreAlpha: boolean; ABitsPerPixelForIndices: integer; AByteOrder: TRawImageByteOrder); overload; //maybe necessary if larger than 8 bits per pixel
     function DitherImage(AAlgorithm: TDitheringAlgorithm; AImage: TBGRACustomBitmap): Pointer; overload; //use minimum scanline size

GraphicTest/Packages/bgrabitmap/bgradnetdeserial.pas

-              r494
+              r521
     FContainer: TDotNetDeserialization;
     function GetTypeAsString: string; virtual; abstract;
     function GetFieldAsString(Index: longword): string; virtual; abstract;
     function GetFieldAsString(Name: string): string;
+    function GetFieldAsString(Index: longword): string; overload; virtual; abstract;
+    function GetFieldAsString(Name: string): string; overload;
     function GetFieldCount: longword; virtual; abstract;
     function GetFieldName(Index: longword): string; virtual; abstract;
 …
     function FindObject(typeName: string): TCustomSerializedObject;
     function GetSimpleField(obj: TCustomSerializedObject; Name: string): string;
     function GetObjectField(obj: TCustomSerializedObject; Name: string): TCustomSerializedObject;
     function GetObjectField(obj: TCustomSerializedObject; index: integer): TCustomSerializedObject;
     function GetObject(id: string): TCustomSerializedObject;
     function GetObject(id: longword): TCustomSerializedObject;
+    function GetObjectField(obj: TCustomSerializedObject; Name: string): TCustomSerializedObject; overload;
+    function GetObjectField(obj: TCustomSerializedObject; index: integer): TCustomSerializedObject; overload;
+    function GetObject(id: string): TCustomSerializedObject; overload;
+    function GetObject(id: longword): TCustomSerializedObject; overload;
     function IsBoxedValue(obj: TCustomSerializedObject; index: integer): boolean;
     function GetBoxedValue(obj: TCustomSerializedObject; index: integer): string;

GraphicTest/Packages/bgrabitmap/bgrafillinfo.pas

-              r494
+              r521
   public
     WindingFactor: integer;
     constructor Create(x1, y1, x2, y2, rx, ry: single; options: TRoundRectangleOptions);
+    constructor Create(x1, y1, x2, y2, rx, ry: single; options: TRoundRectangleOptions; APixelCenteredCoordinates: boolean = true);
     function SegmentsCurved: boolean; override;
     function GetBounds: TRect; override;
 …
       var inter: ArrayOfTIntersectionInfo; var nbInter: integer); override;
   public
     constructor Create(x1, y1, x2, y2, rx, ry, w: single; options: TRoundRectangleOptions);
+    constructor Create(x1, y1, x2, y2, rx, ry, w: single; options: TRoundRectangleOptions; APixelCenteredCoordinates: boolean = true);
     function GetBounds: TRect; override;
     function SegmentsCurved: boolean; override;
 …
     function NbMaxIntersection: integer; override;
     procedure SetIntersectionValues(AInter: TIntersectionInfo; AInterX: Single; AWinding, ANumSegment: integer; {%H-}dy: single; {%H-}AData: pointer); virtual;
+    procedure InitPoints(const points: array of TPointF);
   public
     constructor Create(const points: array of TPointF);
+    constructor Create(const points: array of TPointF; APixelCenteredCoordinates: boolean = true);
     function CreateSegmentData(numPt,nextPt: integer; x,y: single): pointer; virtual;
     procedure FreeSegmentData(data: pointer); virtual;
 …
       var inter: ArrayOfTIntersectionInfo; var nbInter: integer); override;
   public
     constructor Create(const points: array of TPointF);
+    constructor Create(const points: array of TPointF; APixelCenteredCoordinates: boolean = true);
     destructor Destroy; override;
     function GetSliceIndex: integer; override;
 …
       var inter: ArrayOfTIntersectionInfo; var nbInter: integer); override;
   public
     constructor Create(const points: array of TPointF);
+    constructor Create(const points: array of TPointF; APixelCenteredCoordinates: boolean = true);
     function CreateIntersectionArray: ArrayOfTIntersectionInfo; override;
     function GetSliceIndex: integer; override;
 …
 procedure TFillShapeInfo.SortIntersection(var inter: ArrayOfTIntersectionInfo; nbInter: integer);
 var
   i,j: Integer;
+  i,j,k: Integer;
   tempInter: TIntersectionInfo;
 begin
 …
   begin
     j := i;
+    while (j > 0) and (inter[j - 1].interX > inter[j].interX) do
+    begin
+      tempInter    := inter[j - 1];
+      inter[j - 1] := inter[j];
+      inter[j]     := tempInter;
+      Dec(j);
+    while (j > 0) and (inter[i].interX < inter[j-1].interX) do dec(j);
+    if j <> i then
+    begin
+      tempInter := inter[i];
+      for k := i-1 downto j do
+        inter[k+1] := inter[k];
+      inter[j]  := tempInter;
     end;
   end;
 …
     if (windingSum = 0) xor (prevSum = 0) then
     begin
+      tempInfo := inter[nbAlternate];
+      inter[nbAlternate] := inter[i];
+      inter[i] := tempInfo;
+      if nbAlternate<>i then
+      begin
+        tempInfo := inter[nbAlternate];
+        inter[nbAlternate] := inter[i];
+        inter[i] := tempInfo;
+      end;
       inc(nbAlternate);
     end;
 …
 { TCustomFillPolyInfo }
 constructor TCustomFillPolyInfo.Create(const points: array of TPointF);
+constructor TCustomFillPolyInfo.Create(const points: array of TPointF; APixelCenteredCoordinates: boolean);
 var
+  i, j: integer;
+  First, cur, nbP: integer;
+begin
+  setlength(FPoints, length(points));
+  nbP := 0;
+  first := -1;
+  for i := 0 to high(points) do
+  if isEmptyPointF(points[i]) then
+  begin
+    if first<>-1 then
+    begin
+      if nbP = first+1 then //is there only one point?
+      begin
+        dec(nbP);
+        first := -1; //remove subpolygon
+      end else
+      if (FPoints[nbP-1] = FPoints[first]) then
+        dec(nbP); //remove just last looping point
+    end;
+    if first<>-1 then
+    begin
+      FPoints[nbP] := points[i];
+      inc(nbP);
+      first := -1;
+    end;
+  end else
+  if (first=-1) or (points[i]<>points[i-1]) then
+  begin
+    if first = -1 then first := nbP;
+    FPoints[nbP] := points[i];
+    inc(nbP);
+  end;
+  setlength(FPoints, nbP);
+  cur, first, i, j: integer;
+begin
+  InitPoints(points);
   //look for empty points, correct coordinate and successors
 …
   cur   := -1;
   First := -1;
+  first := -1;
   for i := 0 to high(FPoints) do
     if not isEmptyPointF(FPoints[i]) then
     begin
       FEmptyPt[i]  := False;
+      FPoints[i].x += 0.5;
+      FPoints[i].y += 0.5;
+      if APixelCenteredCoordinates then
+      begin
+        FPoints[i].x += 0.5;
+        FPoints[i].y += 0.5;
+      end;
       if cur <> -1 then
         FNext[cur] := i;
       if First = -1 then
         First := i;
+      if first = -1 then
+        first := i;
       cur     := i;
     end
     else
     begin
       if (First <> -1) and (cur <> First) then
         FNext[cur] := First;
+      if (first <> -1) and (cur <> first) then
+        FNext[cur] := first;
       FEmptyPt[i] := True;
       FNext[i] := -1;
       cur   := -1;
       First := -1;
     end;
   if (First <> -1) and (cur <> First) then
     FNext[cur] := First;
+      first := -1;
+    end;
+  if (first <> -1) and (cur <> first) then
+    FNext[cur] := first;
   setlength(FPrev, length(FPoints));
 …
 end;
+procedure TCustomFillPolyInfo.InitPoints(const points: array of TPointF);
+const
+  minDist = 0.00390625; //1 over 256
+var
+  i, first, nbP: integer;
+  function PointAlmostEqual(const p1,p2: TPointF): boolean;
+  begin
+    result := (abs(p1.x-p2.x) < minDist) and (abs(p1.y-p2.y) < minDist);
+  end;
+  procedure EndOfSubPolygon;
+  begin
+    //if there is a subpolygon
+    if first<>-1 then
+    begin
+      //last point is the same as first point?
+      if (nbP >= first+2) and PointAlmostEqual(FPoints[nbP-1],FPoints[first]) then
+        dec(nbP); //remove superfluous looping point
+      if (nbP <= first+2) then //are there only one or two points?
+      begin
+        //remove subpolygon because we need at least a triangle
+        nbP := first;
+        first := -1;
+      end;
+    end;
+  end;
+begin
+  setlength(FPoints, length(points));
+  nbP := 0;
+  first := -1;
+  for i := 0 to high(points) do
+  if isEmptyPointF(points[i]) then
+  begin
+    EndOfSubPolygon;
+    if first<>-1 then
+    begin
+      FPoints[nbP] := EmptyPointF;
+      inc(nbP);
+      first := -1;
+    end;
+  end else
+  if (first=-1) or not PointAlmostEqual(FPoints[nbP-1],points[i]) then
+  begin
+    if first = -1 then first := nbP;
+    FPoints[nbP] := points[i];
+    inc(nbP);
+  end;
+  EndOfSubPolygon;
+  //if last point was a subpolygon delimiter (EmptyPointF) then removes it
+  if (nbP > 0) and isEmptyPointF(FPoints[nbP-1]) then dec(nbP);
+  setlength(FPoints, nbP);
+end;
 { TFillPolyInfo }
 …
 end;
 constructor TFillPolyInfo.Create(const points: array of TPointF);
+constructor TFillPolyInfo.Create(const points: array of TPointF; APixelCenteredCoordinates: boolean);
   function AddSeg(numSlice: integer): integer;
   begin
 …
 begin
   inherited Create(points);
+  inherited Create(points, APixelCenteredCoordinates);
   //slice
 …
 end;
 constructor TOnePassFillPolyInfo.Create(const points: array of TPointF);
+constructor TOnePassFillPolyInfo.Create(const points: array of TPointF; APixelCenteredCoordinates: boolean);
 var i,j: integer;
   p: POnePassRecord;
   temp: single;
 begin
   inherited create(points);
+  inherited create(points, APixelCenteredCoordinates);
   FShouldInitializeDrawing := true;
 …
 { TFillRoundRectangleInfo }
 constructor TFillRoundRectangleInfo.Create(x1, y1, x2, y2, rx, ry: single; options: TRoundRectangleOptions);
+constructor TFillRoundRectangleInfo.Create(x1, y1, x2, y2, rx, ry: single; options: TRoundRectangleOptions; APixelCenteredCoordinates: boolean);
 var
   temp: Single;
 …
     x2 := temp;
   end;
+  FX1  := x1 + 0.5;
+  FY1  := y1 + 0.5;
+  FX2  := x2 + 0.5;
+  FY2  := y2 + 0.5;
+  if APixelCenteredCoordinates then
+  begin
+    FX1  := x1 + 0.5;
+    FY1  := y1 + 0.5;
+    FX2  := x2 + 0.5;
+    FY2  := y2 + 0.5;
+  end else
+  begin
+    FX1 := x1;
+    FY1 := y1;
+    FX2 := x2;
+    FY2 := y2;
+  end;
   FRX := abs(rx);
   FRY := abs(ry);
 …
 { TFillBorderRoundRectInfo }
 constructor TFillBorderRoundRectInfo.Create(x1, y1, x2, y2, rx, ry, w: single; options: TRoundRectangleOptions);
+constructor TFillBorderRoundRectInfo.Create(x1, y1, x2, y2, rx, ry, w: single; options: TRoundRectangleOptions; APixelCenteredCoordinates: boolean);
 var rdiff: single;
   temp: Single;
 …
   if 2*ry > y2-y1 then ry := (y2-y1)/2;
   rdiff := w*(sqrt(2)-1);
   FOuterBorder := TFillRoundRectangleInfo.Create(x1-w/2,y1-w/2,x2+w/2,y2+w/2, rx+rdiff, ry+rdiff, options);
+  FOuterBorder := TFillRoundRectangleInfo.Create(x1-w/2,y1-w/2,x2+w/2,y2+w/2, rx+rdiff, ry+rdiff, options, APixelCenteredCoordinates);
   if (abs(x2-x1) > w) and (abs(y2-y1) > w) then
   begin
     if (rx-rdiff <= 0) or (ry-rdiff <= 0) then
       FInnerBorder := TFillRoundRectangleInfo.Create(x1+w/2, y1+w/2, x2-w/2, y2-w/2, 0,0, options)
+      FInnerBorder := TFillRoundRectangleInfo.Create(x1+w/2, y1+w/2, x2-w/2, y2-w/2, 0,0, options, APixelCenteredCoordinates)
     else
       FInnerBorder := TFillRoundRectangleInfo.Create(x1+w/2, y1+w/2, x2-w/2, y2-w/2, rx-rdiff, ry-rdiff, options);
+      FInnerBorder := TFillRoundRectangleInfo.Create(x1+w/2, y1+w/2, x2-w/2, y2-w/2, rx-rdiff, ry-rdiff, options, APixelCenteredCoordinates);
     FInnerBorder.WindingFactor := -1;
   end

GraphicTest/Packages/bgrabitmap/bgrafilterblur.pas

-              r494
+              r521
   public
     constructor Create(bmp: TBGRACustomBitmap; ABounds: TRect; radius: single;
                        blurType: TRadialBlurType);
+                       blurType: TRadialBlurType); overload;
     constructor Create(bmp: TBGRACustomBitmap; ABounds: TRect; radiusX,radiusY: single;
                        blurType: TRadialBlurType);
+                       blurType: TRadialBlurType); overload;
   protected
     procedure DoExecute; override;
 …
 procedure FilterBlur(bmp: TBGRACustomBitmap; ABounds: TRect;
    blurMask: TBGRACustomBitmap; ADestination: TBGRACustomBitmap; ACheckShouldStop: TCheckShouldStopFunc); forward;
+   blurMask: TBGRACustomBitmap; ADestination: TBGRACustomBitmap; ACheckShouldStop: TCheckShouldStopFunc); forward; overload;
 procedure FilterBlurMotion(bmp: TBGRACustomBitmap; ABounds: TRect; distance: single;
   angle: single; oriented: boolean; ADestination: TBGRACustomBitmap; ACheckShouldStop: TCheckShouldStopFunc); forward;
+  angle: single; oriented: boolean; ADestination: TBGRACustomBitmap; ACheckShouldStop: TCheckShouldStopFunc); forward; overload;
 procedure FilterBlurRadial(bmp: TBGRACustomBitmap; ABounds: TRect; radiusX,radiusY: single;
   blurType: TRadialBlurType; ADestination: TBGRACustomBitmap; ACheckShouldStop: TCheckShouldStopFunc); forward;
+  blurType: TRadialBlurType; ADestination: TBGRACustomBitmap; ACheckShouldStop: TCheckShouldStopFunc); forward; overload;
 type
 …
     FRadiusX,FRadiusY: single;
   public
     constructor Create(bmp: TBGRACustomBitmap; ABounds: TRect; radius: single);
     constructor Create(bmp: TBGRACustomBitmap; ABounds: TRect; radiusX,radiusY: single);
+    constructor Create(bmp: TBGRACustomBitmap; ABounds: TRect; radius: single); overload;
+    constructor Create(bmp: TBGRACustomBitmap; ABounds: TRect; radiusX,radiusY: single); overload;
   protected
     {$IFNDEF CPU64}
 …
 procedure FilterBlurRadial(bmp: TBGRACustomBitmap; ABounds: TRect; radius: single;
   blurType: TRadialBlurType; ADestination: TBGRACustomBitmap; ACheckShouldStop: TCheckShouldStopFunc);
+  blurType: TRadialBlurType; ADestination: TBGRACustomBitmap; ACheckShouldStop: TCheckShouldStopFunc); overload;
 begin
   if radius = 0 then
 …
 end;
+function FilterBlurRadial(bmp: TBGRACustomBitmap; radius: single;
+  blurType: TRadialBlurType): TBGRACustomBitmap;
+function FilterBlurRadial(bmp: TBGRACustomBitmap; radius: single; blurType: TRadialBlurType): TBGRACustomBitmap;  overload;
 begin
   if blurType = rbBox then
 …
 function FilterBlurRadial(bmp: TBGRACustomBitmap; radiusX: single;
   radiusY: single; blurType: TRadialBlurType): TBGRACustomBitmap;
+  radiusY: single; blurType: TRadialBlurType): TBGRACustomBitmap; overload;
 begin
   if blurType = rbBox then
 …
 function CreateRadialBlurTask(ABmp: TBGRACustomBitmap; ABounds: TRect; ARadius: single;
   ABlurType: TRadialBlurType): TFilterTask;
+  ABlurType: TRadialBlurType): TFilterTask; overload;
 begin
   if ABlurType = rbBox then
 …
 function CreateRadialBlurTask(ABmp: TBGRACustomBitmap; ABounds: TRect;
   ARadiusX, ARadiusY: single; ABlurType: TRadialBlurType): TFilterTask;
+  ARadiusX, ARadiusY: single; ABlurType: TRadialBlurType): TFilterTask; overload;
 begin
   if ABlurType = rbBox then
 …
 function FilterBlurMotion(bmp: TBGRACustomBitmap; distance: single;
   angle: single; oriented: boolean): TBGRACustomBitmap;
+  angle: single; oriented: boolean): TBGRACustomBitmap;  overload;
 begin
   result := bmp.NewBitmap(bmp.Width,bmp.Height);
 …
 end;
 function FilterBlur(bmp: TBGRACustomBitmap; blurMask: TBGRACustomBitmap): TBGRACustomBitmap;
+function FilterBlur(bmp: TBGRACustomBitmap; blurMask: TBGRACustomBitmap): TBGRACustomBitmap; overload;
 begin
   result := bmp.NewBitmap(bmp.Width,bmp.Height);

GraphicTest/Packages/bgrabitmap/bgrafilters.pas

-              r494
+              r521
 { Grayscale converts colored pixel into grayscale with same luminosity }
 function FilterGrayscale(bmp: TBGRACustomBitmap): TBGRACustomBitmap;
 function FilterGrayscale(bmp: TBGRACustomBitmap; ABounds: TRect): TBGRACustomBitmap;
+function FilterGrayscale(bmp: TBGRACustomBitmap): TBGRACustomBitmap; overload;
+function FilterGrayscale(bmp: TBGRACustomBitmap; ABounds: TRect): TBGRACustomBitmap; overload;
 function CreateGrayscaleTask(bmp: TBGRACustomBitmap; ABounds: TRect): TFilterTask;
 …
   and light colors lightest possible }
 function FilterNormalize(bmp: TBGRACustomBitmap;
   eachChannel: boolean = True): TBGRACustomBitmap;
+  eachChannel: boolean = True): TBGRACustomBitmap; overload;
 function FilterNormalize(bmp: TBGRACustomBitmap; ABounds: TRect;
   eachChannel: boolean = True): TBGRACustomBitmap;
+  eachChannel: boolean = True): TBGRACustomBitmap; overload;
 ////////////////////// 3X3 FILTERS ////////////////////////////////////////////
 { Sharpen filter add more contrast between pixels }
 function FilterSharpen(bmp: TBGRACustomBitmap; AAmount: integer = 256): TBGRACustomBitmap;
 function FilterSharpen(bmp: TBGRACustomBitmap; ABounds: TRect; AAmount: integer = 256): TBGRACustomBitmap;
+function FilterSharpen(bmp: TBGRACustomBitmap; AAmount: integer = 256): TBGRACustomBitmap; overload;
+function FilterSharpen(bmp: TBGRACustomBitmap; ABounds: TRect; AAmount: integer = 256): TBGRACustomBitmap; overload;
 { Compute a contour, as if the image was drawn with a 2 pixels-wide black pencil }
 …
 { Emboss filter compute a color difference in the angle direction }
 function FilterEmboss(bmp: TBGRACustomBitmap; angle: single; AStrength: integer= 64; AOptions: TEmbossOptions = []): TBGRACustomBitmap;
 function FilterEmboss(bmp: TBGRACustomBitmap; angle: single; ABounds: TRect; AStrength: integer= 64; AOptions: TEmbossOptions = []): TBGRACustomBitmap;
+function FilterEmboss(bmp: TBGRACustomBitmap; angle: single; AStrength: integer= 64; AOptions: TEmbossOptions = []): TBGRACustomBitmap; overload;
+function FilterEmboss(bmp: TBGRACustomBitmap; angle: single; ABounds: TRect; AStrength: integer= 64; AOptions: TEmbossOptions = []): TBGRACustomBitmap; overload;
 { Emboss highlight computes a sort of emboss with 45 degrees angle and
 …
 { Twirl distortion, i.e. a progressive rotation }
 function FilterTwirl(bmp: TBGRACustomBitmap; ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3): TBGRACustomBitmap;
 function FilterTwirl(bmp: TBGRACustomBitmap; ABounds: TRect; ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3): TBGRACustomBitmap;
+function FilterTwirl(bmp: TBGRACustomBitmap; ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3): TBGRACustomBitmap; overload;
+function FilterTwirl(bmp: TBGRACustomBitmap; ABounds: TRect; ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3): TBGRACustomBitmap; overload;
 { Distort the image as if it were on a vertical cylinder }
 …
   with rbFast blur, the optimization entails an hyperbolic shape. }
 type TRadialBlurTask = BGRAFilterBlur.TRadialBlurTask;
 function FilterBlurRadial(bmp: TBGRACustomBitmap; radius: single; blurType: TRadialBlurType): TBGRACustomBitmap;
 function FilterBlurRadial(bmp: TBGRACustomBitmap; radiusX: single; radiusY: single; blurType: TRadialBlurType): TBGRACustomBitmap;
 function CreateRadialBlurTask(ABmp: TBGRACustomBitmap; ABounds: TRect; ARadius: single; ABlurType: TRadialBlurType): TRadialBlurTask;
 function CreateRadialBlurTask(ABmp: TBGRACustomBitmap; ABounds: TRect; ARadiusX,ARadiusY: single; ABlurType: TRadialBlurType): TRadialBlurTask;
+function FilterBlurRadial(bmp: TBGRACustomBitmap; radius: single; blurType: TRadialBlurType): TBGRACustomBitmap; overload;
+function FilterBlurRadial(bmp: TBGRACustomBitmap; radiusX: single; radiusY: single; blurType: TRadialBlurType): TBGRACustomBitmap; overload;
+function CreateRadialBlurTask(ABmp: TBGRACustomBitmap; ABounds: TRect; ARadius: single; ABlurType: TRadialBlurType): TRadialBlurTask; overload;
+function CreateRadialBlurTask(ABmp: TBGRACustomBitmap; ABounds: TRect; ARadiusX,ARadiusY: single; ABlurType: TRadialBlurType): TRadialBlurTask; overload;
 { The precise blur allow to specify the blur radius with subpixel accuracy }

GraphicTest/Packages/bgrabitmap/bgrafilterscanner.pas

-              r494
+              r521
       ADest: PBGRAPixel; ACount: integer); override;
   public
     constructor Create(ASource: IBGRAScanner; ABounds: TRect);
     constructor Create(ASource: TBGRACustomBitmap);
+    constructor Create(ASource: IBGRAScanner; ABounds: TRect); overload;
+    constructor Create(ASource: TBGRACustomBitmap); overload;
     property SourceBorderColor: TBGRAPixel read FSourceBorderColor write FSourceBorderColor;
     property DestinationBorderColor: TBGRAPixel read FDestinationBorderColor write FDestinationBorderColor;
 …
   public
     constructor Create(ASource: IBGRAScanner; ABounds: TRect;
                        AGammaCorrection: boolean = False);
+                       AGammaCorrection: boolean = False); overload;
     constructor Create(ASource: TBGRACustomBitmap;
                        AGammaCorrection: boolean = False);
+                       AGammaCorrection: boolean = False); overload;
     property Opacity: Byte read FOpacity write FOpacity;
   end;
 …
   public
     constructor Create(ASource: IBGRAScanner; ABounds: TRect;
                        AAmount: integer = 256);
+                       AAmount: integer = 256); overload;
     constructor Create(ASource: TBGRACustomBitmap;
                        AAmount: integer = 256);
+                       AAmount: integer = 256); overload;
   end;
 …
     procedure SetSourceChannel(AValue: TChannel);
   public
     constructor Create(ASource: IBGRAScanner; ABounds: TRect; ABoundsVisible: Boolean);
     constructor Create(ASource: TBGRACustomBitmap; ABoundsVisible: Boolean);
+    constructor Create(ASource: IBGRAScanner; ABounds: TRect; ABoundsVisible: Boolean); overload;
+    constructor Create(ASource: TBGRACustomBitmap; ABoundsVisible: Boolean); overload;
     property FillSelection: boolean read FFillSelection write FFillSelection;
     property SourceChannel: TChannel read FSourceChannel write SetSourceChannel;
 …
   highlight: TBGRAPixel;
 begin
+  sum := (PByte(PTop)+FChannelOffset)^ + (PByte(PTop+1)+FChannelOffset)^+
+         (PByte(PMiddle)+FChannelOffset)^ - (PByte(PMiddle+2)+FChannelOffset)^ -
+         (PByte(PBottom+1)+FChannelOffset)^ - (PByte(PBottom+2)+FChannelOffset)^;
+  sum := NativeInt((PByte(PTop)+FChannelOffset)^) +
+         NativeInt((PByte(PTop+1)+FChannelOffset)^) +
+         NativeInt((PByte(PMiddle)+FChannelOffset)^) -
+         NativeInt((PByte(PMiddle+2)+FChannelOffset)^) -
+         NativeInt((PByte(PBottom+1)+FChannelOffset)^) -
+         NativeInt((PByte(PBottom+2)+FChannelOffset)^);
   sum := 128 - sum div 3;
   if sum > 255 then
 …
       begin
         if ADest^.alpha <> 0 then
           DWord(ADest^) := DWord(ADest^) xor (not ($ff shl TBGRAPixel_AlphaShift));
+          DWord(ADest^) := DWord(ADest^) xor ($ffffffff and not ($ff shl TBGRAPixel_AlphaShift));
         Inc(ADest);
         dec(ACount);
 …
           ADest^ := BGRAPixelTransparent
         else
           DWord(ADest^) := DWord(ASource^) xor (not ($ff shl TBGRAPixel_AlphaShift));
+          DWord(ADest^) := DWord(ASource^) xor ($ffffffff and not ($ff shl TBGRAPixel_AlphaShift));
         inc(ASource);
         Inc(ADest);

GraphicTest/Packages/bgrabitmap/bgrafontgl.pas

-              r494
+              r521
     function CreateGlyph(AIdentifier: string): TRenderedGlyph; virtual;
     procedure CopyFontToRenderer; virtual;
     procedure DoTextOut(X, Y: Single; const Text : UTF8String; AColor: TBGRAPixel; AHorizontalAlign: TAlignment; AVerticalAlign: TTextLayout); virtual;
     procedure DoTextOut(X, Y: Single; const Text : UTF8String; AColor: TBGRAPixel); override;
+    procedure DoTextOut(X, Y: Single; const Text : UTF8String; AColor: TBGRAPixel; AHorizontalAlign: TAlignment; AVerticalAlign: TTextLayout); overload; virtual;
+    procedure DoTextOut(X, Y: Single; const Text : UTF8String; AColor: TBGRAPixel); overload; override;
     procedure DoTextRect(X, Y, Width, Height: Single; const Text : UTF8String; AColor: TBGRAPixel); override;
     function GetClipped: boolean; override;

GraphicTest/Packages/bgrabitmap/bgrafpguibitmap.pas

-              r494
+              r521
     procedure TakeScreenshot({%H-}ARect: TRect); override; //not available
     procedure TakeScreenshotOfPrimaryMonitor; override; //not available
     procedure LoadFromDevice({%H-}DC: System.THandle); override; //not available
     procedure LoadFromDevice({%H-}DC: System.THandle; {%H-}ARect: TRect); override; //not available
+    procedure LoadFromDevice({%H-}DC: HDC); override; //not available
+    procedure LoadFromDevice({%H-}DC: HDC; {%H-}ARect: TRect); override; //not available
     property BitmapTransparent: boolean read GetBitmapTransparent write SetBitmapTransparent;
     property Canvas: TBGRACanvas read GetPseudoCanvas;
 …
 end;
 procedure TBGRAfpGUIBitmap.LoadFromDevice(DC: System.THandle);
 begin
   NotAvailable;
 end;
 procedure TBGRAfpGUIBitmap.LoadFromDevice(DC: System.THandle; ARect: TRect);
+procedure TBGRAfpGUIBitmap.LoadFromDevice(DC: HDC);
+begin
+  NotAvailable;
+end;
+procedure TBGRAfpGUIBitmap.LoadFromDevice(DC: HDC; ARect: TRect);
 begin
   NotAvailable;

GraphicTest/Packages/bgrabitmap/bgrafreetype.pas

-              r494
+              r521
     procedure UpdateFont;
     procedure Init;
+    procedure TextOutAnglePatch(ADest: TBGRACustomBitmap; x, y: single; orientation: integer; s: string;
+              c: TBGRAPixel; tex: IBGRAScanner; align: TAlignment);
   public
     FontHinted: boolean;
 …
     OutlineTexture: IBGRAScanner;
     constructor Create;
     constructor Create(AShader: TCustomPhongShading; AShaderOwner: boolean);
+    constructor Create; overload;
+    constructor Create(AShader: TCustomPhongShading; AShaderOwner: boolean); overload;
     function GetFontPixelMetric: TFontPixelMetric; override;
+    procedure TextOutAngle({%H-}ADest: TBGRACustomBitmap; {%H-}x, {%H-}y: single; {%H-}orientation: integer; {%H-}s: string; {%H-}c: TBGRAPixel; {%H-}align: TAlignment); override;
+    procedure TextOutAngle({%H-}ADest: TBGRACustomBitmap; {%H-}x, {%H-}y: single; {%H-}orientation: integer; {%H-}s: string; {%H-}texture: IBGRAScanner; {%H-}align: TAlignment); override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; s: string; texture: IBGRAScanner; align: TAlignment); override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; s: string; c: TBGRAPixel; align: TAlignment); override;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; s: string; style: TTextStyle; c: TBGRAPixel); override;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; s: string; style: TTextStyle; texture: IBGRAScanner); override;
+    function TextSize(s: string): TSize; override;
+    procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientation: integer; s: string; c: TBGRAPixel; align: TAlignment); overload; override;
+    procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientation: integer; s: string; texture: IBGRAScanner; align: TAlignment); overload; override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; s: string; texture: IBGRAScanner; align: TAlignment); overload; override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; s: string; c: TBGRAPixel; align: TAlignment); overload; override;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; s: string; style: TTextStyle; c: TBGRAPixel); overload; override;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; s: string; style: TTextStyle; texture: IBGRAScanner); overload; override;
+    function TextSize(s: string): TSize; overload; override;
+    function TextSize(sUTF8: string; AMaxWidth: integer; {%H-}ARightToLeft: boolean): TSize; overload; override;
+    function TextFitInfo(sUTF8: string; AMaxWidth: integer): integer; override;
     destructor Destroy; override;
     property Collection: TCustomFreeTypeFontCollection read GetCollection;
 …
     constructor Create(ADestination: TBGRACustomBitmap);
     procedure DrawText(AText: string; AFont: TFreeTypeRenderableFont; x,y: single; AColor: TFPColor); override; overload;
+    procedure DrawText(AText: string; AFont: TFreeTypeRenderableFont; x,y: single; AColor: TFPColor); overload; override;
     procedure DrawText(AText: string; AFont: TFreeTypeRenderableFont; x,y: single; AColor: TBGRAPixel); overload;
     procedure DrawText(AText: string; AFont: TFreeTypeRenderableFont; x,y: single; AColor: TBGRAPixel; AAlign: TFreeTypeAlignments); overload;
 …
     {$ENDIF}
     {$IFDEF BGRABITMAP_USE_LCL15}
     procedure DrawGlyph(AGlyph: integer; AFont: TFreeTypeRenderableFont; x,y: single; AColor: TFPColor); override; overload;
+    procedure DrawGlyph(AGlyph: integer; AFont: TFreeTypeRenderableFont; x,y: single; AColor: TFPColor); overload; override;
     procedure DrawGlyph(AGlyph: integer; AFont: TFreeTypeRenderableFont; x,y: single; AColor: TBGRAPixel); overload;
     procedure DrawGlyph(AGlyph: integer; AFont: TFreeTypeRenderableFont; x,y: single; AColor: TBGRAPixel; AAlign: TFreeTypeAlignments); overload;
 …
 implementation
 uses BGRABlend, Math;
+uses BGRABlend, Math, BGRATransform;
 { TBGRAFreeTypeFontRenderer }
 …
 end;
+procedure TBGRAFreeTypeFontRenderer.TextOutAnglePatch(ADest: TBGRACustomBitmap;
+  x, y: single; orientation: integer; s: string; c: TBGRAPixel;
+  tex: IBGRAScanner; align: TAlignment);
+const orientationToDeg = -0.1;
+var
+  temp: TBGRACustomBitmap;
+  coord: TPointF;
+  angleDeg: single;
+  OldOrientation: integer;
+  filter: TResampleFilter;
+  OldFontQuality: TBGRAFontQuality;
+begin
+  OldOrientation := FontOrientation;
+  FontOrientation:= 0;
+  OldFontQuality := FontQuality;
+  if FontQuality in[fqFineClearTypeRGB,fqFineClearTypeBGR] then FontQuality:= fqFineAntialiasing
+  else if FontQuality = fqSystemClearType then FontQuality:= fqSystem;
+  temp := BGRABitmapFactory.Create;
+  with TextSize(s) do
+    temp.SetSize(cx,cy);
+  temp.FillTransparent;
+  if tex<>nil then
+    TextOut(temp,0,0, s, tex, taLeftJustify)
+  else
+    TextOut(temp,0,0, s, c, taLeftJustify);
+  orientation:= orientation mod 3600;
+  if orientation < 0 then orientation += 3600;
+  angleDeg := orientation * orientationToDeg;
+  coord := PointF(x,y);
+  case align of
+  taRightJustify: coord -= AffineMatrixRotationDeg(angleDeg)*PointF(temp.Width,0);
+  taCenter: coord -= AffineMatrixRotationDeg(angleDeg)*PointF(temp.Width,0)*0.5;
+  end;
+  case orientation of
+,900,1800,2700: filter := rfBox;
+  else filter := rfCosine;
+  end;
+  ADest.PutImageAngle(coord.x,coord.y, temp, angleDeg, filter);
+  temp.Free;
+  FontOrientation:= OldOrientation;
+  FontQuality:= OldFontQuality;
+end;
 constructor TBGRAFreeTypeFontRenderer.Create;
 begin
 …
   y: single; orientation: integer; s: string; c: TBGRAPixel; align: TAlignment);
 begin
+  TextOutAnglePatch(ADest, x,y, orientation, s, c, nil, align);
+{procedure TForm1.TextOutAnglePatch(ADest: TBGRABitmap;
+  x, y: single; orientationTenthDegCCW: integer;
+  s: string; c: TBGRAPixel; AAlign: TAlignment; AResampleFilter: TResampleFilter);
+const orientationToDeg = -0.1;
+var
+  temp: TBGRABitmap;
+  coord: TPointF;
+  angleDeg: single;
+begin
+  temp := TBGRABitmap.Create;
+  ADest.CopyPropertiesTo(temp);
+  temp.FontOrientation := 0;
+  with temp.TextSize(s) do
+    temp.SetSize(cx,cy);
+  temp.FillTransparent;
++
+  temp.TextOut(0,0, s, c);
+  angleDeg := orientationTenthDegCCW * orientationToDeg;
+  coord := PointF(x,y);
+  case AAlign of
+  taRightJustify: coord -= AffineMatrixRotationDeg(angleDeg)*PointF(temp.Width,0);
+  taCenter: coord -= AffineMatrixRotationDeg(angleDeg)*PointF(temp.Width,0)*0.5;
+  end;
+  ADest.PutImageAngle(coord.x,coord.y, temp, angleDeg, rfBox);
+  temp.Free;
+end;           }
 end;
 …
   align: TAlignment);
 begin
+  TextOutAnglePatch(ADest, x,y, orientation, s, BGRAPixelTransparent, texture, align);
 end;
 …
   result.cx := round(FFont.TextWidth(s));
   result.cy := round(FFont.LineFullHeight);
+end;
+function TBGRAFreeTypeFontRenderer.TextSize(sUTF8: string; AMaxWidth: integer;
+  ARightToLeft: boolean): TSize;
+var
+  remains: string;
+  w,h,totalH: single;
+begin
+  UpdateFont;
+  result.cx := 0;
+  totalH := 0;
+  h := FFont.LineFullHeight;
+  repeat
+    FFont.SplitText(sUTF8, AMaxWidth, remains);
+    w := FFont.TextWidth(sUTF8);
+    if round(w)>result.cx then result.cx := round(w);
+    totalH += h;
+    sUTF8 := remains;
+  until remains = '';
+  result.cy := ceil(totalH);
+end;
+function TBGRAFreeTypeFontRenderer.TextFitInfo(sUTF8: string; AMaxWidth: integer): integer;
+var
+  remains: string;
+begin
+  UpdateFont;
+  FFont.SplitText(sUTF8, AMaxWidth, remains);
+  result := length(sUTF8);
 end;

GraphicTest/Packages/bgrabitmap/bgragifformat.pas

-              r494
+              r521
     AspectRatio: single;
     BackgroundColor: TColor;
+    LoopCount: Word;
     Images: array of TGifSubImage;
   end;
 …
   GIFExtensionIntroducer = $21;
   GIFBlockTerminator     = $00;
+  GIFFileTerminator      = $3B;
   GIFGraphicControlExtension_TransparentFlag = $01;  //transparent color index is provided
 …
   GIFCodeTableSize = 4096;
+  NetscapeApplicationIdentifier = 'NETSCAPE2.0';
+  NetscapeSubBlockIdLoopCount = 1;
+  NetscapeSubBlockIdBuffering = 2;
 function CeilLn2(AValue: Integer): integer;
 function BGRAToPackedRgbTriple(color: TBGRAPixel): TPackedRGBTriple;
 function PackedRgbTribleToBGRA(rgb: TPackedRGBTriple): TBGRAPixel;
 function GIFLoadFromStream(stream: TStream): TGIFData;
+function GIFLoadFromStream(stream: TStream; MaxImageCount: integer = maxLongint): TGIFData;
 procedure GIFSaveToStream(AData: TGifData; Stream: TStream; AQuantizerFactory: TBGRAColorQuantizerAny;
           ADitheringAlgorithm: TDitheringAlgorithm);
 …
 //Adapted from the work of Udo Schmal, http://www.gocher.me/FPWriteGIF
 procedure GIFEncodeLZW(AStream: TStream; AImageData: PByte;
           AImageWidth, AImageHeight: integer; ABitDepth: integer);
+          AImageWidth, AImageHeight: integer; ABitDepth: byte);
 implementation
 …
       if (bytinbuf = 0) then
       begin
+        AStream.Read(bytinbuf, 1);
+        if AStream.Read(bytinbuf, 1) <> 1 then
+          raise exception.Create('Unexpected end of stream');
         if (bytinbuf = 0) then
+        begin
           endofsrc := True;
+          result := endcode;
+          exit;
+        end;
         AStream.Read(bytbuf, bytinbuf);
         bytbufidx := 0;
 …
     bitbuf := bitbuf shr codelen;
     Dec(bitsinbuf, codelen);
+    //write(inttostr(result)+'@'+inttostr(codelen)+' ');
   end;
 …
       if interlaced then
       begin
+        while (ycnt >= yd) and (pass < 5) do
+        begin
+        while ycnt >= yd do
+        begin
+          if pass >= 5 then exit;
           Inc(pass);
           ycnt  := GIFInterlacedStart[pass];
           ystep := GIFInterlacedStep[pass];
         end;
       end;
+      end else exit;
     end;
 …
   InitStringTable;
   curcode := getnextcode;
+  //Write('Reading ');
   while (curcode <> endcode) and (pass < 5) and not endofsrc do
   begin
 …
       begin
         if (curcode > stridx) then
+        begin
+          //write('!Invalid! ');
           break;
+        end;
         AddStr2Tab(Code2Str(oldcode), firstchar(Code2Str(oldcode)));
         WriteStr(Code2Str(stridx - 1));
 …
   end;
   DoneStringTable;
+  //Writeln;
   if not endofsrc then
   begin
     bytinbuf:= 0;
     AStream.Read(bytinbuf, 1);
+    AStream.ReadBuffer(bytinbuf, 1);
     if bytinbuf <> 0 then
       raise exception.Create('Invalid GIF format: expecting block terminator');
 …
 //Adapted from the work of Udo Schmal, http://www.gocher.me/FPWriteGIF
 procedure GIFEncodeLZW(AStream: TStream; AImageData: PByte;
+          AImageWidth, AImageHeight: integer; ABitDepth: integer);
+          AImageWidth, AImageHeight: integer; ABitDepth: byte);
+var  //input position
+  PInput, PInputEnd: PByte;
+  // get the next pixel from the bitmap
+  function ReadValue: byte;
+  begin
+    result := PInput^;
+    Inc(PInput);
+  end;
+var // GIF buffer can be up to 255 bytes long
+  OutputBufferSize: NativeInt;
+  OutputBuffer: packed array[0..255] of byte;
+  procedure FlushByteOutput;
+  begin
+    if OutputBufferSize > 0 then
+    begin
+      OutputBuffer[0] := OutputBufferSize;
+      AStream.WriteBuffer(OutputBuffer, OutputBufferSize+1);
+      OutputBufferSize := 0;
+    end;
+  end;
+  procedure OutputByte(AValue: byte);
+  begin
+    if OutputBufferSize = 255 then FlushByteOutput;
+    inc(OutputBufferSize);
+    OutputBuffer[OutputBufferSize] := AValue;
+  end;
+type TCode = Word;
 var
+   LZWSize: byte;
+   OutputBufferSize: NativeInt;
+   OutputBuffer: packed array[0..255] of byte;
+   rPrefix: array[0..GIFCodeTableSize-1] of integer; // string prefixes
+   rSuffix: array[0..GIFCodeTableSize-1] of integer; // string suffixes
+   rCodeStack: array[0..GIFCodeTableSize-1] of byte; // encoded pixels
+   rSP: integer; // pointer into CodeStack
+   rClearCode: integer; // reset decode params
+   rEndCode: integer; // last code in input stream
+   rCurSize: integer; // current code size
+   rBitString: integer; // steady stream of bits to be decoded
+   rBits: integer; // number of valid bits in BitString
+   rMaxVal: boolean; // max code value found?
+   rCurX: integer; // position of next pixel
+   rCurY: integer; // position of next pixel
+   rCurScan: PByte;
+   rFirstSlot: integer; // for encoding an image
+   rNextSlot: integer; // for encoding
+   rRowsLeft: integer; // rows left to do
+   rLast: integer; // last byte read in
+   rUnget: boolean; // read a new byte, or use zLast?
+   procedure FlushOutput;
+  BitBuffer       : DWord; // steady stream of bit output
+  BitBufferLen    : Byte;  // number of bits in buffer
+  CurCodeSize     : byte;  // current code size
+  // save the code in the output data stream
+  procedure WriteCode(Code: TCode);
+  begin
+    //Write(IntToStr(Code)+'@'+IntToStr(CurCodeSize)+' ');
+    // append code to bit buffer
+    BitBuffer := BitBuffer or (Code shl BitBufferLen);
+    BitBufferLen := BitBufferLen + CurCodeSize;
+    // output whole bytes
+    while BitBufferLen >= 8 do
+    begin
+      OutputByte(BitBuffer and $ff);
+      BitBuffer := BitBuffer shr 8;
+      BitBufferLen -= 8;
+    end;
+  end;
+  procedure CloseBitOutput;
+  begin
+    // write out the rest of the bit string
+    // and add padding bits if necessary
+    while BitBufferLen > 0 do
+    begin
+      OutputByte(BitBuffer and $ff);
+      BitBuffer := BitBuffer shr 8;
+      if BitBufferLen >= 8 then
+        BitBufferLen -= 8
+      else
+        BitBufferLen := 0;
+    end;
+  end;
+type
+  PCodeTableEntry = ^TCodeTableEntry;
+  TCodeTableEntry = packed record
+               Prefix: TCode;
+               LongerFirst, LongerLast: TCode;
+               Suffix, Padding: Byte;
+               NextWithPrefix: TCode;
+             end;
+var
+  ClearCode     : TCode;   // reset decode params
+  EndStreamCode : TCode;   // last code in input stream
+  FirstCodeSlot : TCode;   // first slot when table is empty
+  NextCodeSlot  : TCode;   // next slot to be used
+  PEntry: PCodeTableEntry;
+  CodeTable: array of TCodeTableEntry;
+  CurrentCode   : TCode; // code representing current string
+  procedure DoClearCode;
+  var
+    i: Word;
+  begin
+    for i := 0 to (1 shl ABitDepth)-1 do
+    with CodeTable[i] do
+    begin
+      LongerFirst:= 0;
+      LongerLast:= 0;
+    end;
+    WriteCode(ClearCode);
+    CurCodeSize := ABitDepth + 1;
+    NextCodeSlot := FirstCodeSlot;
+  end;
+var
+  CurValue: Byte;
+  i: TCode;
+  found: boolean; // decoded string in prefix table?
+begin
+   if ABitDepth > 8 then
+     raise exception.Create('Maximum bit depth is 8');
+   //output
+   AStream.WriteByte(ABitDepth);
+   ClearCode := 1 shl ABitDepth;
+   EndStreamCode := ClearCode + 1;
+   FirstCodeSlot := ClearCode + 2;
+   CurCodeSize := ABitDepth + 1;
+   OutputBufferSize := 0;
+   BitBuffer := 0;
+   BitBufferLen := 0;
+   //input
+   PInput := AImageData;
+   PInputEnd := AImageData + PtrInt(AImageWidth)*AImageHeight;
+   setlength(CodeTable, GIFCodeTableSize);
+   DoClearCode;
+   //write('Writing ');
+   while PInput < PInputEnd do
    begin
+     if OutputBufferSize > 0 then
+     CurrentCode := ReadValue;
+     if CurrentCode >= ClearCode then
+       raise exception.Create('Internal error');
+     //try to match the longest string
+     while PInput < PInputEnd do
      begin
+       OutputBuffer[0] := OutputBufferSize;
+       AStream.WriteBuffer(OutputBuffer, OutputBufferSize+1);
+       OutputBufferSize := 0;
+     end;
+   end;
+   procedure OutputByte(AValue: byte);
+   begin
+     if OutputBufferSize = 255 then FlushOutput;
+     inc(OutputBufferSize);
+     OutputBuffer[OutputBufferSize] := AValue;
+   end;
+   procedure LZWReset;
+   var i: integer;
+   begin
+     for i := 0 to (GIFCodeTableSize - 1) do
+     begin
+       rPrefix[i] := 0;
+       rSuffix[i] := 0;
+     end;
+     rCurSize := LZWSize + 1;
+     rClearCode := (1 shl LZWSize);
+     rEndCode := rClearCode + 1;
+     rFirstSlot := (1 shl (rCurSize - 1)) + 2;
+     rNextSlot := rFirstSlot;
+     rMaxVal := false;
+   end;
+   // save a code value on the code stack
+   procedure LZWSaveCode(Code: integer);
+   begin
+     rCodeStack[rSP] := Code;
+     inc(rSP);
+   end;
+   // save the code in the output data stream
+   procedure LZWPutCode(code: integer);
+   var
+     n: integer;
+     b: byte;
+   begin
+     // write out finished bytes
+     // a literal "8" for 8 bits per byte
+     while (rBits >= 8) do
+     begin
+       b := (rBitString and $ff);
+       rBitString := (rBitString shr 8);
+       rBits := rBits - 8;
+       OutputByte(b);
+     end;
+     // make sure no junk bits left above the first byte
+     rBitString := (rBitString and $ff);
+     // and save out-going code
+     n := (code shl rBits);
+     rBitString := (rBitString or n);
+     rBits := rBits + rCurSize;
+   end;
+   // get the next pixel from the bitmap, and return it as an index into the colormap
+   function LZWReadBitmap: integer;
+   begin
+     if rUnget then
+     begin
+       result := rLast;
+       rUnget := false;
+     end
+     else
+     begin
+       if rCurScan = nil then
+         rCurScan := AImageData + rCurY*AImageWidth;
+       result := (rCurScan+rCurX)^;
+       inc(rCurX); // inc X position
+       if (rCurX >= AImageWidth) then // bumping Y ?
+       CurValue := ReadValue;
+       found := false;
+       i := CodeTable[CurrentCode].LongerFirst;
+       while i <> 0 do
        begin
+         rCurX := 0;
+         inc(rCurY);
+         rCurScan := nil;
+         dec(rRowsLeft);
+         PEntry := @CodeTable[i];
+         if PEntry^.Suffix = CurValue then
+         begin
+           found := true;
+           CurrentCode := i;
+           break;
+         end;
+         i := PEntry^.NextWithPrefix;
+       end;
+       if not found then
+       begin
+         PEntry := @CodeTable[CurrentCode];
+         if PEntry^.LongerFirst = 0 then
+         begin
+           //store the first and last code being longer
+           PEntry^.LongerFirst := NextCodeSlot;
+           PEntry^.LongerLast := NextCodeSlot;
+         end else
+         begin
+           //link next entry having the same prefix
+           CodeTable[PEntry^.LongerLast].NextWithPrefix:= NextCodeSlot;
+           PEntry^.LongerLast := NextCodeSlot;
+         end;
+         // add new encode table entry
+         PEntry := @CodeTable[NextCodeSlot];
+         PEntry^.Prefix := CurrentCode;
+         PEntry^.Suffix := CurValue;
+         PEntry^.LongerFirst := 0;
+         PEntry^.LongerLast := 0;
+         PEntry^.NextWithPrefix := 0;
+         inc(NextCodeSlot);
+         Dec(PInput);
+         break;
        end;
      end;
+     rLast := result;
+     // write the code of the longest entry found
+     WriteCode(CurrentCode);
+     if NextCodeSlot >= GIFCodeTableSize then
+       DoClearCode
+     else if NextCodeSlot > 1 shl CurCodeSize then
+       inc(CurCodeSize);
    end;
+var
+   i,n,
+   cc: integer; // current code to translate
+   oc: integer; // last code encoded
+   found: boolean; // decoded string in prefix table?
+   pixel: byte; // lowest code to search for
+   ldx: integer; // last index found
+   fdx: integer; // current index found
+   b: byte;
+begin
+   LZWSize := ABitDepth;
+   AStream.WriteBuffer(LZWSize, 1);
+   OutputBufferSize := 0;
+   // init data block
+   fillchar(rCodeStack, sizeof(rCodeStack), 0);
+   rBitString := 0;
+   rBits := 0;
+   rCurX := 0;
+   rCurY := 0;
+   rCurScan := nil;
+   rLast := 0;
+   rUnget:= false;
+   LZWReset;
+   // all within the data record
+   // always save the clear code first ...
+   LZWPutCode(rClearCode);
+   // and first pixel
+   oc := LZWReadBitmap;
+   LZWPutCode(oc);
+   // nothing found yet (but then, we haven't searched)
+   ldx := 0;
+   fdx := 0;
+   // and the rest of the pixels
+   rRowsLeft := AImageHeight;
+   while (rRowsLeft > 0) do
+   begin
+     rSP := 0; // empty the stack of old data
+     n := LZWReadBitmap; // next pixel from the bitmap
+     LZWSaveCode(n);
+     cc := rCodeStack[0]; // beginning of the string
+     // add new encode table entry
+     rPrefix[rNextSlot] := oc;
+     rSuffix[rNextSlot] := cc;
+     inc(rNextSlot);
+     if (rNextSlot >= GIFCodeTableSize) then
+       rMaxVal := true
+     else if (rNextSlot > (1 shl rCurSize)) then
+       inc(rCurSize);
+     // find the running string of matching codes
+     ldx := cc;
+     found := true;
+     while (found and (rRowsLeft > 0)) do
+     begin
+       n := LZWReadBitmap;
+       LZWSaveCode(n);
+       cc := rCodeStack[0];
+       if (ldx < rFirstSlot) then
+         i := rFirstSlot
+       else
+         i := ldx + 1;
+       pixel := rCodeStack[rSP - 1];
+       found := false;
+       while ((not found) and (i < rNextSlot)) do
+       begin
+         found := ((rPrefix[i] = ldx) and (rSuffix[i] = pixel));
+         inc(i);
+       end;
+       if (found) then
+       begin
+         ldx := i - 1;
+         fdx := i - 1;
+       end;
+     end;
+     // if not found, save this index, and get the same code again
+     if (not found) then
+     begin
+       rUnget := true;
+       rLast := rCodeStack[rSP-1];
+       dec(rSP);
+       cc := ldx;
+     end
+     else
+       cc := fdx;
+     // whatever we got, write it out as current table entry
+     LZWPutCode(cc);
+     if (rMaxVal and (rRowsLeft > 0)) then
+     begin
+       LZWPutCode(rClearCode);
+       LZWReset;
+       cc := LZWReadBitmap;
+       LZWPutCode(cc);
+     end;
+     oc := cc;
+   end;
+   LZWPutCode(rEndCode);
+   // write out the rest of the bit string
+   while (rBits > 0) do
+   begin
+     b := (rBitString and $ff);
+     rBitString := (rBitString shr 8);
+     rBits := rBits - 8;
+     OutputByte(b);
+   end;
+   FlushOutput;
+   b := 0;
+   AStream.Write(b, 1);
+   WriteCode(EndStreamCode);
+   CloseBitOutput;
+   FlushByteOutput;
+   AStream.WriteByte(0); //GIF block terminator
+   //Writeln;
 end;
 function GIFLoadFromStream(stream: TStream): TGIFData;
+function GIFLoadFromStream(stream: TStream; MaxImageCount: integer = maxLongint): TGIFData;
   procedure DumpData;
 …
       stream.position := stream.position + Count;
     until (Count = 0) or (stream.position >= stream.size);
+  end;
+  function ReadString: string;
+  var Count: byte;
+  begin
+    Count := 0;
+    stream.Read(Count, 1);
+    setlength(result, Count);
+    if Count > 0 then
+      stream.ReadBuffer(result[1], length(result));
   end;
 …
     GIFExtensionBlock: TGIFExtensionBlock;
     GIFGraphicControlExtension: TGIFGraphicControlExtension;
+    mincount, Count:   byte;
+    mincount, Count, SubBlockId:   byte;
+    app: String;
   begin
     stream.ReadBuffer({%H-}GIFExtensionBlock, sizeof(GIFExtensionBlock));
     case GIFExtensionBlock.FunctionCode of
       $F9:
+      $F9: //graphic control extension
       begin
         Count := 0;
 …
         DumpData;
       end;
+      $ff: //application extension
+      begin
+        app := ReadString;
+        if app <> '' then
+        begin
+          if app = NetscapeApplicationIdentifier then
+          begin
+            repeat
+              Count := 0;
+              stream.Read(Count,1);
+              if Count = 0 then break;
+              stream.ReadBuffer({%H-}SubBlockId,1);
+              Dec(Count);
+              if (SubBlockId = NetscapeSubBlockIdLoopCount) and (Count >= 2) then
+              begin
+                stream.ReadBuffer(result.LoopCount, 2);
+                dec(Count,2);
+                result.LoopCount := LEtoN(result.LoopCount);
+                if result.LoopCount > 0 then inc(result.LoopCount);
+              end;
+              stream.Position:= stream.Position+Count;
+            until false;
+          end else
+            DumpData;
+        end;
+      end
       else
       begin
 …
   result.Images := nil;
   result.AspectRatio := 1;
+  result.LoopCount := 1;
   if stream = nil then exit;
 …
       case GIFBlockID of
         ';': ;
+        ',': LoadImage;
+        ',': begin
+               if NbImages >= MaxImageCount then break;
+               LoadImage;
+             end;
         '!': ReadExtension;
         else
 …
           for x := 0 to Image.Width -1 do
           begin
+            pdest^ := APalette.IndexOfColor(psource^);
+            if psource^.alpha < 128 then
+              pdest^ := APalette.IndexOfColor(BGRAPixelTransparent)
+            else
+              pdest^ := APalette.IndexOfColor(BGRA(psource^.red,psource^.green,psource^.blue,255));
             inc(psource);
             inc(pdest);
 …
     for i := 0 to ImageCount-1 do
       WriteImage(i);
+  end;
+  procedure WriteLoopExtension;
+  var
+    app: shortstring;
+    w: Word;
+  begin
+    if AData.LoopCount = 1 then exit;
+    Stream.WriteByte(GIFExtensionIntroducer);
+    Stream.WriteByte($ff);
+    app := NetscapeApplicationIdentifier;
+    Stream.WriteBuffer(app[0], length(app)+1);
+    Stream.WriteByte(3);
+    Stream.WriteByte(NetscapeSubBlockIdLoopCount);
+    if AData.LoopCount = 0 then
+      w := 0
+    else
+      w := AData.LoopCount-1;
+    w := NtoLE(w);
+    Stream.WriteWord(w);
+    Stream.WriteByte(0);
   end;
 …
     WriteGlobalPalette;
+    WriteLoopExtension;
     WriteImages;
     Stream.WriteByte($3B); //end of file
+    Stream.WriteByte(GIFFileTerminator); //end of file
   finally

GraphicTest/Packages/bgrabitmap/bgragradients.pas

-              r494
+              r521
 function nGradientInfo(StartColor, StopColor: TBGRAPixel; Direction: TGradientDirection; EndPercent: Single): TnGradientInfo;
 function nGradientAlphaFill(ARect: TRect; ADir: TGradientDirection; const AGradient: array of TnGradientInfo): TBGRABitmap;
 function nGradientAlphaFill(AWidth, AHeight: Integer; ADir: TGradientDirection; const AGradient: array of TnGradientInfo): TBGRABitmap;
 procedure nGradientAlphaFill(ACanvas: TCanvas; ARect: TRect; ADir: TGradientDirection; const AGradient: array of TnGradientInfo);
 procedure nGradientAlphaFill(ABitmap: TBGRABitmap; ARect: TRect; ADir: TGradientDirection; const AGradient: array of TnGradientInfo);
+function nGradientAlphaFill(ARect: TRect; ADir: TGradientDirection; const AGradient: array of TnGradientInfo): TBGRABitmap; overload;
+function nGradientAlphaFill(AWidth, AHeight: Integer; ADir: TGradientDirection; const AGradient: array of TnGradientInfo): TBGRABitmap; overload;
+procedure nGradientAlphaFill(ACanvas: TCanvas; ARect: TRect; ADir: TGradientDirection; const AGradient: array of TnGradientInfo); overload;
+procedure nGradientAlphaFill(ABitmap: TBGRABitmap; ARect: TRect; ADir: TGradientDirection; const AGradient: array of TnGradientInfo); overload;
 function DoubleGradientAlphaFill(ARect: TRect; AStart1,AStop1,AStart2,AStop2: TBGRAPixel;
                                  ADirection1,ADirection2,ADir: TGradientDirection; AValue: Single): TBGRABitmap;
+                                 ADirection1,ADirection2,ADir: TGradientDirection; AValue: Single): TBGRABitmap; overload;
 function DoubleGradientAlphaFill(AWidth,AHeight: Integer; AStart1,AStop1,AStart2,AStop2: TBGRAPixel;
                                  ADirection1,ADirection2,ADir: TGradientDirection; AValue: Single): TBGRABitmap;
+                                 ADirection1,ADirection2,ADir: TGradientDirection; AValue: Single): TBGRABitmap; overload;
 procedure DoubleGradientAlphaFill(ACanvas: TCanvas; ARect: TRect; AStart1,AStop1,AStart2,AStop2: TBGRAPixel;
                                  ADirection1,ADirection2,ADir: TGradientDirection; AValue: Single);
+                                 ADirection1,ADirection2,ADir: TGradientDirection; AValue: Single); overload;
 procedure DoubleGradientAlphaFill(ABitmap: TBGRABitmap; ARect: TRect; AStart1,AStop1,AStart2,AStop2: TBGRAPixel;
                                  ADirection1,ADirection2,ADir: TGradientDirection; AValue: Single);
+                                 ADirection1,ADirection2,ADir: TGradientDirection; AValue: Single); overload;
 {----------------------------------------------------------------------}
 …
 { Create a precise height map for a rectangle height map with a border (not grayscale anymore but more precise) }
 function CreateRectanglePreciseMap(width,height,border: integer; options: TRectangleMapOptions = []): TBGRABitmap;
+function CreateRectanglePreciseMap(width, height, borderWidth, borderHeight: integer; options: TRectangleMapOptions): TBGRABitmap;
 { Create a round rectangle height map with a border }
 …
 { Create a precise height map for a round rectangle height map with a border (not grayscale anymore but more precise) }
 function CreateRoundRectanglePreciseMap(width,height,border: integer; options: TRectangleMapOptions = []): TBGRABitmap;
+function CreateRoundRectanglePreciseMap(width,height,borderWidth,borderHeight: integer; options: TRectangleMapOptions = []): TBGRABitmap;
 {---------- Perlin Noise -------------}
 …
 implementation
 uses Types, SysUtils{$IFDEF BGRABITMAP_USE_LCL}, BGRATextFX{$ENDIF}; {GraphType unit used by phongdraw.inc}
+uses Types, Math, SysUtils{$IFDEF BGRABITMAP_USE_LCL}, BGRATextFX{$ENDIF}; {GraphType unit used by phongdraw.inc}
 {$IFDEF BGRABITMAP_USE_LCL}function TextShadow(AWidth, AHeight: Integer; AText: String;
 …
 end;
+procedure MapBorderLimit(width,height: integer; options: TRectangleMapOptions; var borderHoriz,borderVert: integer);
+var maxHoriz,maxVert: integer;
+begin
+  if [rmoNoLeftBorder,rmoNoRightBorder] <= options then maxHoriz := borderHoriz else
+  if [rmoNoLeftBorder,rmoNoRightBorder] * options = [] then maxHoriz := width div 2 else
+    maxHoriz := width;
+  if borderHoriz > maxHoriz then borderHoriz := maxHoriz;
+  if [rmoNoTopBorder,rmoNoBottomBorder] <= options then maxVert := borderVert else
+  if [rmoNoTopBorder,rmoNoBottomBorder] * options = [] then maxVert := height div 2 else
+    maxVert := height;
+  if borderVert > maxVert then borderVert := maxVert;
+end;
 function CreateSpherePreciseMap(width, height: integer): TBGRABitmap;
 var cx,cy,rx,ry,d: single;
 …
      if rmoLinearBorder in options then h := h/border else
        h := sin((h+1/2)/border*Pi/2);
+     p^ := MapHeightToBGRA(h,255);
+     inc(p);
+   end;
+  end;
+  RectangleMapRemoveCorners(result,options);
+end;
+function CreateRectanglePreciseMap(width, height, borderWidth, borderHeight: integer;
+  options: TRectangleMapOptions): TBGRABitmap;
+var xb,yb, minBorder: integer;
+    p: PBGRAPixel;
+    h: single;
+    smallStep: single;
+begin
+  MapBorderLimit(width,height,options,borderWidth,borderHeight);
+  minBorder := min(borderWidth,borderHeight);
+  if minBorder > 0 then smallStep := 1/minBorder else smallStep:= 0;
+  result := TBGRABitmap.Create(width,height);
+  for yb := 0 to height-1 do
+  begin
+   p := result.scanline[yb];
+   for xb := 0 to width-1 do
+   begin
+     if not (rmoNoLeftBorder in options) and (xb < borderWidth) and (yb < borderHeight) then
+        h := min(xb/borderWidth, yb/borderHeight) else
+     if not (rmoNoRightBorder in options) and (xb > width-1-borderWidth) and (yb < borderHeight) then
+        h := min((width-1-xb)/borderWidth, yb/borderHeight) else
+     if not (rmoNoTopBorder in options) and (xb < borderWidth) and (yb > height-1-borderHeight) then
+        h := min(xb/borderWidth, (height-1-yb)/borderHeight) else
+     if not (rmoNoBottomBorder in options) and  (xb > width-1-borderWidth) and (yb > height-1-borderHeight) then
+        h := min((width-1-xb)/borderWidth, (height-1-yb)/borderHeight) else
+     if not (rmoNoLeftBorder in options) and (xb < borderWidth) then h := xb/borderWidth else
+     if not (rmoNoRightBorder in options) and (xb > width-1-borderWidth) then h := (width-1-xb)/borderWidth else
+     if not (rmoNoTopBorder in options) and (yb < borderHeight) then h := yb/borderHeight else
+     if not (rmoNoBottomBorder in options) and (yb > height-1-borderHeight) then h := (height-1-yb)/borderHeight else
+     begin
+       p^ := BGRAWhite;
+       inc(p);
+       Continue;
+     end;
+     if not (rmoLinearBorder in options) then
+       h := sin((h+smallStep*0.5)*Pi*0.5);
      p^ := MapHeightToBGRA(h,255);
 …
 end;
+function CreateRoundRectanglePreciseMap(width, height, borderWidth,
+  borderHeight: integer; options: TRectangleMapOptions): TBGRABitmap;
+var d: single;
+    xb,yb: integer;
+    p: PBGRAPixel;
+    h,smallStep,factor: single;
+    minBorder: integer;
+begin
+  MapBorderLimit(width,height,options,borderWidth,borderHeight);
+  minBorder := min(borderWidth,borderHeight);
+  if minBorder > 0 then smallStep := 1/minBorder else smallStep:= 0;
+  factor := minBorder/(minBorder+1);
+  result := TBGRABitmap.Create(width,height);
+  for yb := 0 to height-1 do
+  begin
+   p := result.scanline[yb];
+   for xb := 0 to width-1 do
+   begin
+     if not (rmoNoLeftBorder in options) and not (rmoNoTopBorder in options) and (xb < borderWidth) and (yb < borderHeight) then
+        d := 1-sqrt(sqr((borderWidth-xb)/borderWidth)+sqr((borderHeight-yb)/borderHeight)) else
+     if not (rmoNoLeftBorder in options) and not (rmoNoBottomBorder in options) and (xb < borderWidth) and (yb > height-1-borderHeight) then
+        d := 1-sqrt(sqr((borderWidth-xb)/borderWidth)+sqr((borderHeight-(height-1-yb))/borderHeight)) else
+     if not (rmoNoRightBorder in options) and not (rmoNoTopBorder in options) and (xb > width-1-borderWidth) and (yb < borderHeight) then
+        d := 1-sqrt(sqr((borderWidth-(width-1-xb))/borderWidth)+sqr((borderHeight-yb)/borderHeight)) else
+     if not (rmoNoRightBorder in options) and not (rmoNoBottomBorder in options) and (xb > width-1-borderWidth) and (yb > height-1-borderHeight) then
+        d := 1-sqrt(sqr((borderWidth-(width-1-xb))/borderWidth)+sqr((borderHeight-(height-1-yb))/borderHeight)) else
+     if not (rmoNoLeftBorder in options) and (xb < borderWidth) then d := xb/borderWidth else
+     if not (rmoNoRightBorder in options) and (xb > width-1-borderWidth) then d := (width-1-xb)/borderWidth else
+     if not (rmoNoTopBorder in options) and (yb < borderHeight) then d := yb/borderHeight else
+     if not (rmoNoBottomBorder in options) and (yb > height-1-borderHeight) then d := (height-1-yb)/borderHeight else
+     begin
+       p^ := BGRAWhite;
+       inc(p);
+       Continue;
+     end;
+     d := (d + smallStep)*factor;
+     if d < 0 then
+       p^ := BGRAPixelTransparent else
+     begin
+       if rmoLinearBorder in options then h := d else
+         h := sin((d+smallStep*0.5)*Pi*0.5);
+       if d < smallStep then p^:= MapHeightToBGRA(h,round(d/smallStep*255)) else
+         p^ := MapHeightToBGRA(h,255);
+     end;
+     inc(p);
+   end;
+  end;
+end;
 initialization

GraphicTest/Packages/bgrabitmap/bgragradientscanner.pas

-              r494
+              r521
 type
+  { TBGRASimpleGradientWithoutGammaCorrection }
+  TBGRASimpleGradientWithoutGammaCorrection = class(TBGRACustomGradient)
+  private
+  TBGRAColorInterpolation = (ciStdRGB, ciLinearRGB, ciLinearHSLPositive, ciLinearHSLNegative, ciGSBPositive, ciGSBNegative);
+  TBGRAGradientRepetition = (grPad, grRepeat, grReflect, grSine);
+  { TBGRASimpleGradient }
+  TBGRASimpleGradient = class(TBGRACustomGradient)
+  protected
     FColor1,FColor2: TBGRAPixel;
     ec1,ec2: TExpandedPixel;
+    FRepetition: TBGRAGradientRepetition;
+    constructor Create(AColor1,AColor2: TBGRAPixel; ARepetition: TBGRAGradientRepetition); overload;
+    constructor Create(AColor1,AColor2: TExpandedPixel; ARepetition: TBGRAGradientRepetition); overload;
+    function InterpolateToBGRA(position: word): TBGRAPixel; virtual; abstract;
+    function InterpolateToExpanded(position: word): TExpandedPixel; virtual; abstract;
   public
+    constructor Create(Color1,Color2: TBGRAPixel);
+    class function CreateAny(AInterpolation: TBGRAColorInterpolation; AColor1,AColor2: TBGRAPixel; ARepetition: TBGRAGradientRepetition): TBGRASimpleGradient; overload;
+    class function CreateAny(AInterpolation: TBGRAColorInterpolation; AColor1,AColor2: TExpandedPixel; ARepetition: TBGRAGradientRepetition): TBGRASimpleGradient; overload;
     function GetColorAt(position: integer): TBGRAPixel; override;
     function GetColorAtF(position: single): TBGRAPixel; override;
 …
     function GetExpandedColorAtF(position: single): TExpandedPixel; override;
     function GetAverageColor: TBGRAPixel; override;
-    function GetMonochrome: boolean; override;
-  end;
-  { TBGRASimpleGradientWithGammaCorrection }
-  TBGRASimpleGradientWithGammaCorrection = class(TBGRACustomGradient)
-  private
-    FColor1,FColor2: TBGRAPixel;
-    ec1,ec2: TExpandedPixel;
-  public
-    constructor Create(Color1,Color2: TBGRAPixel);
-    function GetColorAt(position: integer): TBGRAPixel; override;
-    function GetColorAtF(position: single): TBGRAPixel; override;
-    function GetAverageColor: TBGRAPixel; override;
-    function GetExpandedColorAt(position: integer): TExpandedPixel; override;
-    function GetExpandedColorAtF(position: single): TExpandedPixel; override;
     function GetAverageExpandedColor: TExpandedPixel; override;
     function GetMonochrome: boolean; override;
+  end;
+  THueGradientOption = (hgoRepeat, hgoPositiveDirection, hgoNegativeDirection, hgoHueCorrection, hgoLightnessCorrection);
+    property Repetition: TBGRAGradientRepetition read FRepetition write FRepetition;
+  end;
+  { TBGRASimpleGradientWithoutGammaCorrection }
+  TBGRASimpleGradientWithoutGammaCorrection = class(TBGRASimpleGradient)
+  protected
+    function InterpolateToBGRA(position: word): TBGRAPixel; override;
+    function InterpolateToExpanded(position: word): TExpandedPixel; override;
+  public
+    constructor Create(Color1,Color2: TBGRAPixel; ARepetition: TBGRAGradientRepetition = grPad); overload;
+    constructor Create(Color1,Color2: TExpandedPixel; ARepetition: TBGRAGradientRepetition = grPad); overload;
+  end;
+  { TBGRASimpleGradientWithGammaCorrection }
+  TBGRASimpleGradientWithGammaCorrection = class(TBGRASimpleGradient)
+  protected
+    function InterpolateToBGRA(position: word): TBGRAPixel; override;
+    function InterpolateToExpanded(position: word): TExpandedPixel; override;
+  public
+    constructor Create(Color1,Color2: TBGRAPixel; ARepetition: TBGRAGradientRepetition = grPad); overload;
+    constructor Create(Color1,Color2: TExpandedPixel; ARepetition: TBGRAGradientRepetition = grPad); overload;
+  end;
+  THueGradientOption = (hgoRepeat, hgoReflect,                       //repetition
+                        hgoPositiveDirection, hgoNegativeDirection,  //hue orientation
+                        hgoHueCorrection, hgoLightnessCorrection);   //color interpolation
   THueGradientOptions = set of THueGradientOption;
   { TBGRAHueGradient }
   TBGRAHueGradient = class(TBGRACustomGradient)
+  TBGRAHueGradient = class(TBGRASimpleGradient)
   private
-    FColor1,FColor2: TBGRAPixel;
-    ec1,ec2: TExpandedPixel;
     hsla1,hsla2: THSLAPixel;
     hue1,hue2: longword;
     FOptions: THueGradientOptions;
     procedure Init(c1,c2: THSLAPixel; AOptions: THueGradientOptions);
+    function GetColorNoBoundCheck(position: integer): THSLAPixel;
+    function InterpolateToHSLA(position: word): THSLAPixel;
+  protected
+    function InterpolateToBGRA(position: word): TBGRAPixel; override;
+    function InterpolateToExpanded(position: word): TExpandedPixel; override;
   public
     constructor Create(Color1,Color2: TBGRAPixel; options: THueGradientOptions); overload;
+    constructor Create(Color1,Color2: TExpandedPixel; options: THueGradientOptions); overload;
     constructor Create(Color1,Color2: THSLAPixel; options: THueGradientOptions); overload;
     constructor Create(AHue1,AHue2: Word; Saturation,Lightness: Word; options: THueGradientOptions); overload;
-    function GetColorAt(position: integer): TBGRAPixel; override;
-    function GetColorAtF(position: single): TBGRAPixel; override;
-    function GetAverageColor: TBGRAPixel; override;
-    function GetExpandedColorAt(position: integer): TExpandedPixel; override;
-    function GetExpandedColorAtF(position: single): TExpandedPixel; override;
-    function GetAverageExpandedColor: TExpandedPixel; override;
     function GetMonochrome: boolean; override;
   end;
 …
   end;
+  TBGRAGradientScannerInternalScanNextFunc = function():single of object;
+  TBGRAGradientScannerInternalScanAtFunc = function(const p: TPointF):single of object;
   { TBGRAGradientScanner }
 …
   protected
     FGradientType: TGradientType;
+    FOrigin1,FOrigin2: TPointF;
+    FOrigin,FDir1,FDir2: TPointF;
+    FRelativeFocal: TPointF;
+    FRadius, FFocalRadius: single;
+    FTransform, FHiddenTransform: TAffineMatrix;
     FSinus: Boolean;
-    u: TPointF;
-    len,aFactor,aFactorF: single;
-    mergedColor: TBGRAPixel;
-    mergedExpandedColor: TExpandedPixel;
     FGradient: TBGRACustomGradient;
     FGradientOwner: boolean;
+    FFlipGradient: boolean;
+    FMatrix: TAffineMatrix;
+    FRepeatHoriz, FIsAverage: boolean;
+    FAverageColor: TBGRAPixel;
+    FAverageExpandedColor: TExpandedPixel;
+    FScanNextFunc: TBGRAGradientScannerInternalScanNextFunc;
+    FScanAtFunc: TBGRAGradientScannerInternalScanAtFunc;
+    FFocalDistance: single;
+    FFocalDirection, FFocalNormal: TPointF;
+    FRadialDenominator, FRadialDeltaSign, maxW1, maxW2: single;
+    FPosition: TPointF;
     FHorizColor: TBGRAPixel;
     FHorizExpandedColor: TExpandedPixel;
+    FVertical: boolean;
+    FDotProduct,FDotProductPerp: Single;
+    procedure Init(gtype: TGradientType; o1, o2: TPointF; Sinus: Boolean=False);
+    procedure InitScanInline(x,y: integer);
+    procedure Init(AGradientType: TGradientType; AOrigin, d1: TPointF; ATransform: TAffineMatrix; Sinus: Boolean=False); overload;
+    procedure Init(AGradientType: TGradientType; AOrigin, d1, d2: TPointF; ATransform: TAffineMatrix; Sinus: Boolean=False); overload;
+    procedure Init(AOrigin: TPointF; ARadius: single; AFocal: TPointF; AFocalRadius: single; ATransform: TAffineMatrix; AHiddenTransform: TAffineMatrix); overload;
+    procedure InitGradientType;
+    procedure InitTransform;
+    procedure InitGradient;
+    function ComputeRadialFocal(const p: TPointF): single;
+    function ScanNextLinear: single;
+    function ScanNextReflected: single;
+    function ScanNextDiamond: single;
+    function ScanNextRadial: single;
+    function ScanNextRadial2: single;
+    function ScanNextRadialFocal: single;
+    function ScanNextAngular: single;
+    function ScanAtLinear(const p: TPointF): single;
+    function ScanAtReflected(const p: TPointF): single;
+    function ScanAtDiamond(const p: TPointF): single;
+    function ScanAtRadial(const p: TPointF): single;
+    function ScanAtRadial2(const p: TPointF): single;
+    function ScanAtRadialFocal(const p: TPointF): single;
+    function ScanAtAngular(const p: TPointF): single;
     function ScanNextInline: TBGRAPixel; inline;
     function ScanNextExpandedInline: TExpandedPixel; inline;
+    procedure SetTransform(AValue: TAffineMatrix);
+    procedure SetFlipGradient(AValue: boolean);
+    function GetGradientColor(a: single): TBGRAPixel;
+    function GetGradientExpandedColor(a: single): TExpandedPixel;
   public
+    constructor Create(c1, c2: TBGRAPixel; gtype: TGradientType; o1, o2: TPointF;
+                       gammaColorCorrection: boolean = True; Sinus: Boolean=False);
+    constructor Create(gradient: TBGRACustomGradient; gtype: TGradientType; o1, o2: TPointF; Sinus: Boolean=False; AGradientOwner: Boolean=False);
+    constructor Create(AGradientType: TGradientType; AOrigin, d1: TPointF); overload;
+    constructor Create(AGradientType: TGradientType; AOrigin, d1, d2: TPointF); overload;
+    constructor Create(AOrigin, d1, d2, AFocal: TPointF; ARadiusRatio: single = 1; AFocalRadiusRatio: single = 0); overload;
+    constructor Create(AOrigin: TPointF; ARadius: single; AFocal: TPointF; AFocalRadius: single); overload;
+    constructor Create(c1, c2: TBGRAPixel; AGradientType: TGradientType; AOrigin, d1: TPointF;
+                       gammaColorCorrection: boolean = True; Sinus: Boolean=False); overload;
+    constructor Create(c1, c2: TBGRAPixel; AGradientType: TGradientType; AOrigin, d1, d2: TPointF;
+                       gammaColorCorrection: boolean = True; Sinus: Boolean=False); overload;
+    constructor Create(gradient: TBGRACustomGradient; AGradientType: TGradientType; AOrigin, d1: TPointF;
+                       Sinus: Boolean=False; AGradientOwner: Boolean=False); overload;
+    constructor Create(gradient: TBGRACustomGradient; AGradientType: TGradientType; AOrigin, d1, d2: TPointF;
+                       Sinus: Boolean=False; AGradientOwner: Boolean=False); overload;
+    constructor Create(gradient: TBGRACustomGradient; AOrigin: TPointF; ARadius: single; AFocal: TPointF;
+                       AFocalRadius: single; AGradientOwner: Boolean=False); overload;
+    procedure SetGradient(c1,c2: TBGRAPixel; AGammaCorrection: boolean = true); overload;
+    procedure SetGradient(AGradient: TBGRACustomGradient; AOwner: boolean); overload;
     destructor Destroy; override;
     procedure ScanMoveTo(X, Y: Integer); override;
 …
     procedure ScanPutPixels(pdest: PBGRAPixel; count: integer; mode: TDrawMode); override;
     function IsScanPutPixelsDefined: boolean; override;
+    property Transform: TAffineMatrix read FTransform write SetTransform;
+    property Gradient: TBGRACustomGradient read FGradient;
+    property FlipGradient: boolean read FFlipGradient write SetFlipGradient;
+    property Sinus: boolean Read FSinus write FSinus;
   end;
 …
     FOpacity: byte;
     FGrayscale: boolean;
+    FRandomBuffer, FRandomBufferCount: integer;
   public
     constructor Create(AGrayscale: Boolean; AOpacity: byte);
 …
   private
       FTexture: IBGRAScanner;
+      FOwnedScanner: TBGRACustomScanner;
       FGlobalOpacity: Byte;
       FScanNext : TScanNextPixelFunction;
 …
   public
     constructor Create(ATexture: IBGRAScanner; AGlobalOpacity: Byte = 255);
+    constructor Create(ATexture: TBGRACustomScanner; AGlobalOpacity: Byte; AOwned: boolean);
     destructor Destroy; override;
     function IsScanPutPixelsDefined: boolean; override;
 …
 uses BGRABlend, Math;
+{ TBGRASimpleGradient }
+constructor TBGRASimpleGradient.Create(AColor1, AColor2: TBGRAPixel; ARepetition: TBGRAGradientRepetition);
+begin
+  FColor1 := AColor1;
+  FColor2 := AColor2;
+  ec1 := GammaExpansion(AColor1);
+  ec2 := GammaExpansion(AColor2);
+  FRepetition:= ARepetition;
+end;
+constructor TBGRASimpleGradient.Create(AColor1, AColor2: TExpandedPixel;
+  ARepetition: TBGRAGradientRepetition);
+begin
+  FColor1 := GammaCompression(AColor1);
+  FColor2 := GammaCompression(AColor2);
+  ec1 := AColor1;
+  ec2 := AColor2;
+  FRepetition:= ARepetition;
+end;
+class function TBGRASimpleGradient.CreateAny(AInterpolation: TBGRAColorInterpolation;
+  AColor1, AColor2: TBGRAPixel; ARepetition: TBGRAGradientRepetition): TBGRASimpleGradient;
+begin
+  case AInterpolation of
+    ciStdRGB: result := TBGRASimpleGradientWithoutGammaCorrection.Create(AColor1,AColor2);
+    ciLinearRGB: result := TBGRASimpleGradientWithGammaCorrection.Create(AColor1,AColor2);
+    ciLinearHSLPositive: result := TBGRAHueGradient.Create(AColor1,AColor2,[hgoPositiveDirection]);
+    ciLinearHSLNegative: result := TBGRAHueGradient.Create(AColor1,AColor2,[hgoNegativeDirection]);
+    ciGSBPositive: result := TBGRAHueGradient.Create(AColor1,AColor2,[hgoPositiveDirection, hgoHueCorrection, hgoLightnessCorrection]);
+    ciGSBNegative: result := TBGRAHueGradient.Create(AColor1,AColor2,[hgoNegativeDirection, hgoHueCorrection, hgoLightnessCorrection]);
+  end;
+  result.Repetition := ARepetition;
+end;
+class function TBGRASimpleGradient.CreateAny(AInterpolation: TBGRAColorInterpolation;
+  AColor1, AColor2: TExpandedPixel; ARepetition: TBGRAGradientRepetition): TBGRASimpleGradient;
+begin
+  case AInterpolation of
+    ciStdRGB: result := TBGRASimpleGradientWithoutGammaCorrection.Create(AColor1,AColor2);
+    ciLinearRGB: result := TBGRASimpleGradientWithGammaCorrection.Create(AColor1,AColor2);
+    ciLinearHSLPositive: result := TBGRAHueGradient.Create(AColor1,AColor2,[hgoPositiveDirection]);
+    ciLinearHSLNegative: result := TBGRAHueGradient.Create(AColor1,AColor2,[hgoNegativeDirection]);
+    ciGSBPositive: result := TBGRAHueGradient.Create(AColor1,AColor2,[hgoPositiveDirection, hgoHueCorrection, hgoLightnessCorrection]);
+    ciGSBNegative: result := TBGRAHueGradient.Create(AColor1,AColor2,[hgoNegativeDirection, hgoHueCorrection, hgoLightnessCorrection]);
+  end;
+  result.Repetition := ARepetition;
+end;
+function TBGRASimpleGradient.GetAverageColor: TBGRAPixel;
+begin
+  result := InterpolateToBGRA(32768);
+end;
+function TBGRASimpleGradient.GetAverageExpandedColor: TExpandedPixel;
+begin
+  Result:= InterpolateToExpanded(32768);
+end;
+function TBGRASimpleGradient.GetColorAt(position: integer): TBGRAPixel;
+begin
+  case FRepetition of
+  grSine: begin
+            position := Sin65536(position and $ffff);
+            if position = 65536 then
+              result := FColor2
+            else
+              result := InterpolateToBGRA(position);
+          end;
+  grRepeat: result := InterpolateToBGRA(position and $ffff);
+  grReflect:
+    begin
+      position := position and $1ffff;
+      if position >= $10000 then
+      begin
+        if position = $10000 then
+          result := FColor2
+        else
+          result := InterpolateToBGRA($20000 - position);
+      end
+      else
+        result := InterpolateToBGRA(position);
+    end;
+  else
+    begin
+      if position <= 0 then
+        result := FColor1 else
+      if position >= 65536 then
+        result := FColor2 else
+        result := InterpolateToBGRA(position);
+    end;
+  end;
+end;
+function TBGRASimpleGradient.GetColorAtF(position: single): TBGRAPixel;
+begin
+  if FRepetition <> grPad then
+    result := GetColorAt(round(frac(position*0.5)*131072)) else  //divided by 2 for reflected repetition
+  begin
+    if position <= 0 then
+      result := FColor1 else
+    if position >= 1 then
+      result := FColor2 else
+      result := GetColorAt(round(position*65536));
+  end;
+end;
+function TBGRASimpleGradient.GetExpandedColorAt(position: integer
+  ): TExpandedPixel;
+begin
+  case FRepetition of
+  grSine: begin
+            position := Sin65536(position and $ffff);
+            if position = 65536 then
+              result := ec2
+            else
+              result := InterpolateToExpanded(position);
+          end;
+  grRepeat: result := InterpolateToExpanded(position and $ffff);
+  grReflect:
+    begin
+      position := position and $1ffff;
+      if position >= $10000 then
+      begin
+        if position = $10000 then
+          result := ec2
+        else
+          result := InterpolateToExpanded($20000 - position);
+      end
+      else
+        result := InterpolateToExpanded(position);
+    end;
+  else
+    begin
+      if position <= 0 then
+        result := ec1 else
+      if position >= 65536 then
+        result := ec2 else
+        result := InterpolateToExpanded(position);
+    end;
+  end;
+end;
+function TBGRASimpleGradient.GetExpandedColorAtF(position: single
+  ): TExpandedPixel;
+begin
+  if FRepetition <> grPad then
+    result := GetExpandedColorAt(round(frac(position*0.5)*131072)) else  //divided by 2 for reflected repetition
+  begin
+    if position <= 0 then
+      result := ec1 else
+    if position >= 1 then
+      result := ec2 else
+      result := GetExpandedColorAt(round(position*65536));
+  end;
+end;
+function TBGRASimpleGradient.GetMonochrome: boolean;
+begin
+  Result:= (FColor1 = FColor2);
+end;
 { TBGRAConstantScanner }
 …
   FGrayscale:= AGrayscale;
   FOpacity:= AOpacity;
+  FRandomBufferCount := 0;
 end;
 …
 function TBGRARandomScanner.ScanNextPixel: TBGRAPixel;
+var rgb: integer;
 begin
   if FGrayscale then
   begin
+    result.red := random(256);
+    if FRandomBufferCount = 0 then
+    begin
+      FRandomBuffer := random(256*256*256);
+      FRandomBufferCount := 3;
+    end;
+    result.red := FRandomBuffer and 255;
+    FRandomBuffer:= FRandomBuffer shr 8;
+    FRandomBufferCount -= 1;
     result.green := result.red;
     result.blue := result.red;
     result.alpha:= FOpacity;
   end else
+    Result:= BGRA(random(256),random(256),random(256),FOpacity);
+  begin
+    rgb := random(256*256*256);
+    Result:= BGRA(rgb and 255,(rgb shr 8) and 255,(rgb shr 16) and 255,FOpacity);
+  end;
 end;
 …
 procedure TBGRAHueGradient.Init(c1, c2: THSLAPixel; AOptions: THueGradientOptions);
 begin
-  FColor1 := HSLAToBGRA(c1);
-  FColor2 := HSLAToBGRA(c2);
-  ec1 := GammaExpansion(FColor1);
-  ec2 := GammaExpansion(FColor2);
   FOptions:= AOptions;
   if (hgoLightnessCorrection in AOptions) then
   begin
     hsla1 := BGRAToGSBA(FColor1);
     hsla2 := BGRAToGSBA(FColor2);
+    hsla1 := ExpandedToGSBA(ec1);
+    hsla2 := ExpandedToGSBA(ec2);
   end else
   begin
 …
 end;
 function TBGRAHueGradient.GetColorNoBoundCheck(position: integer): THSLAPixel;
+function TBGRAHueGradient.InterpolateToHSLA(position: word): THSLAPixel;
 var b,b2: LongWord;
 begin
 …
 end;
+function TBGRAHueGradient.InterpolateToBGRA(position: word): TBGRAPixel;
+begin
+  if hgoLightnessCorrection in FOptions then
+    result := GSBAToBGRA(InterpolateToHSLA(position))
+  else
+    result := HSLAToBGRA(InterpolateToHSLA(position));
+end;
+function TBGRAHueGradient.InterpolateToExpanded(position: word): TExpandedPixel;
+begin
+  if hgoLightnessCorrection in FOptions then
+    result := GSBAToExpanded(InterpolateToHSLA(position))
+  else
+    result := HSLAToExpanded(InterpolateToHSLA(position));
+end;
 constructor TBGRAHueGradient.Create(Color1, Color2: TBGRAPixel;options: THueGradientOptions);
 begin
+  if hgoReflect in options then
+    inherited Create(Color1,Color2,grReflect)
+  else if hgoRepeat in options then
+    inherited Create(Color1,Color2,grRepeat)
+  else
+    inherited Create(Color1,Color2,grPad);
   Init(BGRAToHSLA(Color1),BGRAToHSLA(Color2),options);
 end;
+constructor TBGRAHueGradient.Create(Color1, Color2: TExpandedPixel;
+  options: THueGradientOptions);
+begin
+  if hgoReflect in options then
+    inherited Create(Color1,Color2,grReflect)
+  else if hgoRepeat in options then
+    inherited Create(Color1,Color2,grRepeat)
+  else
+    inherited Create(Color1,Color2,grPad);
+  Init(ExpandedToHSLA(Color1),ExpandedToHSLA(Color2),options);
+end;
 constructor TBGRAHueGradient.Create(Color1, Color2: THSLAPixel; options: THueGradientOptions);
 begin
+  if hgoReflect in options then
+    inherited Create(Color1.ToExpanded,Color2.ToExpanded,grReflect)
+  else if hgoRepeat in options then
+    inherited Create(Color1.ToExpanded,Color2.ToExpanded,grRepeat)
+  else
+    inherited Create(Color1.ToExpanded,Color2.ToExpanded,grPad);
   Init(Color1,Color2, options);
 end;
 …
   Lightness: Word; options: THueGradientOptions);
 begin
+  Init(HSLA(AHue1,saturation,lightness), HSLA(AHue2,saturation,lightness), options);
+end;
+function TBGRAHueGradient.GetColorAt(position: integer): TBGRAPixel;
+var interm: THSLAPixel;
+begin
+  if hgoRepeat in FOptions then
+  begin
+    position := position and $ffff;
+    if position = 0 then
+    begin
+      result := FColor1;
+      exit;
+    end;
+  end else
+  begin
+    if position <= 0 then
+    begin
+      result := FColor1;
+      exit
+    end else
+    if position >= 65536 then
+    begin
+      result := FColor2;
+      exit
+    end;
+  end;
+  interm := GetColorNoBoundCheck(position);
+  if hgoLightnessCorrection in FOptions then
+    result := GSBAToBGRA(interm)
+  else
+    result := HSLAToBGRA(interm);
+end;
+function TBGRAHueGradient.GetColorAtF(position: single): TBGRAPixel;
+var interm: THSLAPixel;
+begin
+  if hgoRepeat in FOptions then
+  begin
+    position := frac(position);
+    if position = 0 then
+    begin
+      result := FColor1;
+      exit;
+    end;
+  end else
+  begin
+    if position <= 0 then
+    begin
+      result := FColor1;
+      exit;
+    end else
+    if position >= 1 then
+    begin
+      result := FColor2;
+      exit
+    end;
+  end;
+  interm := GetColorNoBoundCheck(round(position*65536));
+  if hgoLightnessCorrection in FOptions then
+    result := GSBAToBGRA(interm)
+  else
+    result := HSLAToBGRA(interm);
+end;
+function TBGRAHueGradient.GetAverageColor: TBGRAPixel;
+begin
+  Result:= GetColorAt(32768);
+end;
+function TBGRAHueGradient.GetExpandedColorAt(position: integer): TExpandedPixel;
+var interm: THSLAPixel;
+begin
+  if hgoRepeat in FOptions then
+  begin
+    position := position and $ffff;
+    if position = 0 then
+    begin
+      result := ec1;
+      exit;
+    end;
+  end else
+  begin
+    if position <= 0 then
+    begin
+      result := ec1;
+      exit
+    end else
+    if position >= 65536 then
+    begin
+      result := ec2;
+      exit
+    end;
+  end;
+  interm := GetColorNoBoundCheck(position);
+  if hgoLightnessCorrection in FOptions then
+    result := GSBAToExpanded(interm)
+  else
+    result := HSLAToExpanded(interm);
+end;
+function TBGRAHueGradient.GetExpandedColorAtF(position: single): TExpandedPixel;
+var interm: THSLAPixel;
+begin
+  if hgoRepeat in FOptions then
+  begin
+    position := frac(position);
+    if position = 0 then
+    begin
+      result := ec1;
+      exit;
+    end;
+  end else
+  begin
+    if position <= 0 then
+    begin
+      result := ec1;
+      exit;
+    end else
+    if position >= 1 then
+    begin
+      result := ec2;
+      exit
+    end;
+  end;
+  interm := GetColorNoBoundCheck(round(position*65536));
+  if hgoLightnessCorrection in FOptions then
+    result := GSBAToExpanded(interm)
+  else
+    result := HSLAToExpanded(interm);
+end;
+function TBGRAHueGradient.GetAverageExpandedColor: TExpandedPixel;
+begin
+  Result:= GetExpandedColorAt(32768);
+  Create(HSLA(AHue1,saturation,lightness), HSLA(AHue2,saturation,lightness), options);
 end;
 …
 { TBGRASimpleGradientWithGammaCorrection }
+constructor TBGRASimpleGradientWithGammaCorrection.Create(Color1,
+  Color2: TBGRAPixel);
+begin
+  FColor1 := Color1;
+  FColor2 := Color2;
+  ec1 := GammaExpansion(Color1);
+  ec2 := GammaExpansion(Color2);
+end;
+function TBGRASimpleGradientWithGammaCorrection.GetColorAt(position: integer
+function TBGRASimpleGradientWithGammaCorrection.InterpolateToBGRA(position: word
   ): TBGRAPixel;
 var b,b2: cardinal;
     ec: TExpandedPixel;
 begin
+  if position <= 0 then
+    result := FColor1 else
+  if position >= 65536 then
+    result := FColor2 else
+  begin
+    b      := position;
+    b2     := 65536-b;
+    ec.red := (ec1.red * b2 + ec2.red * b + 32767) shr 16;
+    ec.green := (ec1.green * b2 + ec2.green * b + 32767) shr 16;
+    ec.blue := (ec1.blue * b2 + ec2.blue * b + 32767) shr 16;
+    ec.alpha := (ec1.alpha * b2 + ec2.alpha * b + 32767) shr 16;
+    result := GammaCompression(ec);
+  end;
+end;
+function TBGRASimpleGradientWithGammaCorrection.GetColorAtF(position: single): TBGRAPixel;
+  b      := position;
+  b2     := 65536-b;
+  ec.red := (ec1.red * b2 + ec2.red * b + 32767) shr 16;
+  ec.green := (ec1.green * b2 + ec2.green * b + 32767) shr 16;
+  ec.blue := (ec1.blue * b2 + ec2.blue * b + 32767) shr 16;
+  ec.alpha := (ec1.alpha * b2 + ec2.alpha * b + 32767) shr 16;
+  result := GammaCompression(ec);
+end;
+function TBGRASimpleGradientWithGammaCorrection.InterpolateToExpanded(
+  position: word): TExpandedPixel;
 var b,b2: cardinal;
+    ec: TExpandedPixel;
+begin
+  if position <= 0 then
+    result := FColor1 else
+  if position >= 1 then
+    result := FColor2 else
+  begin
+    b      := round(position*65536);
+    b2     := 65536-b;
+    ec.red := (ec1.red * b2 + ec2.red * b + 32767) shr 16;
+    ec.green := (ec1.green * b2 + ec2.green * b + 32767) shr 16;
+    ec.blue := (ec1.blue * b2 + ec2.blue * b + 32767) shr 16;
+    ec.alpha := (ec1.alpha * b2 + ec2.alpha * b + 32767) shr 16;
+    result := GammaCompression(ec);
+  end;
+end;
+function TBGRASimpleGradientWithGammaCorrection.GetAverageColor: TBGRAPixel;
+begin
+  result := GammaCompression(MergeBGRA(ec1,ec2));
+end;
+function TBGRASimpleGradientWithGammaCorrection.GetExpandedColorAt(
+  position: integer): TExpandedPixel;
+begin
+  b      := position;
+  b2     := 65536-b;
+  result.red := (ec1.red * b2 + ec2.red * b + 32767) shr 16;
+  result.green := (ec1.green * b2 + ec2.green * b + 32767) shr 16;
+  result.blue := (ec1.blue * b2 + ec2.blue * b + 32767) shr 16;
+  result.alpha := (ec1.alpha * b2 + ec2.alpha * b + 32767) shr 16;
+end;
+constructor TBGRASimpleGradientWithGammaCorrection.Create(Color1,
+  Color2: TBGRAPixel; ARepetition: TBGRAGradientRepetition);
+begin
+  inherited Create(Color1,Color2,ARepetition);
+end;
+constructor TBGRASimpleGradientWithGammaCorrection.Create(Color1,
+  Color2: TExpandedPixel; ARepetition: TBGRAGradientRepetition);
+begin
+  inherited Create(Color1,Color2,ARepetition);
+end;
+{ TBGRASimpleGradientWithoutGammaCorrection }
+function TBGRASimpleGradientWithoutGammaCorrection.InterpolateToBGRA(
+  position: word): TBGRAPixel;
 var b,b2: cardinal;
 begin
+  if position <= 0 then
+    result := ec1 else
+  if position >= 65536 then
+    result := ec2 else
+  begin
+    b      := position;
+    b2     := 65536-b;
+    result.red := (ec1.red * b2 + ec2.red * b + 32767) shr 16;
+    result.green := (ec1.green * b2 + ec2.green * b + 32767) shr 16;
+    result.blue := (ec1.blue * b2 + ec2.blue * b + 32767) shr 16;
+    result.alpha := (ec1.alpha * b2 + ec2.alpha * b + 32767) shr 16;
+  end;
+end;
+function TBGRASimpleGradientWithGammaCorrection.GetExpandedColorAtF(
+  position: single): TExpandedPixel;
+var b,b2: cardinal;
+begin
+  if position <= 0 then
+    result := ec1 else
+  if position >= 1 then
+    result := ec2 else
+  begin
+    b      := round(position*65536);
+    b2     := 65536-b;
+    result.red := (ec1.red * b2 + ec2.red * b + 32767) shr 16;
+    result.green := (ec1.green * b2 + ec2.green * b + 32767) shr 16;
+    result.blue := (ec1.blue * b2 + ec2.blue * b + 32767) shr 16;
+    result.alpha := (ec1.alpha * b2 + ec2.alpha * b + 32767) shr 16;
+  end;
+end;
+function TBGRASimpleGradientWithGammaCorrection.GetAverageExpandedColor: TExpandedPixel;
+begin
+  result := MergeBGRA(ec1,ec2);
+end;
+function TBGRASimpleGradientWithGammaCorrection.GetMonochrome: boolean;
+begin
+  Result:= (FColor1 = FColor2);
+end;
+{ TBGRASimpleGradientWithoutGammaCorrection }
+constructor TBGRASimpleGradientWithoutGammaCorrection.Create(Color1,
+  Color2: TBGRAPixel);
+begin
+  FColor1 := Color1;
+  FColor2 := Color2;
+  ec1 := GammaExpansion(Color1);
+  ec2 := GammaExpansion(Color2);
+end;
+function TBGRASimpleGradientWithoutGammaCorrection.GetColorAt(position: integer
+  ): TBGRAPixel;
+var b,b2: cardinal;
+begin
+  if position <= 0 then
+    result := FColor1 else
+  if position >= 65536 then
+    result := FColor2 else
+  begin
+    b      := position shr 6;
+    b2     := 1024-b;
+    result.red  := (FColor1.red * b2 + FColor2.red * b + 511) shr 10;
+    result.green := (FColor1.green * b2 + FColor2.green * b + 511) shr 10;
+    result.blue := (FColor1.blue * b2 + FColor2.blue * b + 511) shr 10;
+    result.alpha := (FColor1.alpha * b2 + FColor2.alpha * b + 511) shr 10;
+  end;
+end;
+function TBGRASimpleGradientWithoutGammaCorrection.GetColorAtF(position: single): TBGRAPixel;
+begin
+  if position <= 0 then
+    result := FColor1 else
+  if position >= 1 then
+    result := FColor2 else
+    result := GetColorAt(round(position*65536));
+end;
+function TBGRASimpleGradientWithoutGammaCorrection.GetExpandedColorAt(
+  position: integer): TExpandedPixel;
+  b      := position shr 6;
+  b2     := 1024-b;
+  result.red  := (FColor1.red * b2 + FColor2.red * b + 511) shr 10;
+  result.green := (FColor1.green * b2 + FColor2.green * b + 511) shr 10;
+  result.blue := (FColor1.blue * b2 + FColor2.blue * b + 511) shr 10;
+  result.alpha := (FColor1.alpha * b2 + FColor2.alpha * b + 511) shr 10;
+end;
+function TBGRASimpleGradientWithoutGammaCorrection.InterpolateToExpanded(
+  position: word): TExpandedPixel;
 var b,b2: cardinal;
     rw,gw,bw: word;
 begin
+  if position <= 0 then
+    result := ec1 else
+  if position >= 65536 then
+    result := ec2 else
+  begin
+    b      := position shr 6;
+    b2     := 1024-b;
+    rw  := (FColor1.red * b2 + FColor2.red * b + 511) shr 2;
+    gw := (FColor1.green * b2 + FColor2.green * b + 511) shr 2;
+    bw := (FColor1.blue * b2 + FColor2.blue * b + 511) shr 2;
+  b      := position shr 6;
+  b2     := 1024-b;
+  rw  := (FColor1.red * b2 + FColor2.red * b + 511) shr 2;
+  gw := (FColor1.green * b2 + FColor2.green * b + 511) shr 2;
+  bw := (FColor1.blue * b2 + FColor2.blue * b + 511) shr 2;
+  if rw >= $ff00 then
+    result.red := 65535
+  else
     result.red := (GammaExpansionTab[rw shr 8]*NativeUInt(255 - (rw and 255)) + GammaExpansionTab[(rw shr 8)+1]*NativeUInt(rw and 255)) shr 8;
+  if gw >= $ff00 then
+    result.green := 65535
+  else
     result.green := (GammaExpansionTab[gw shr 8]*NativeUInt(255 - (gw and 255)) + GammaExpansionTab[(gw shr 8)+1]*NativeUInt(gw and 255)) shr 8;
+  if bw >= $ff00 then
+    result.blue := 65535
+  else
     result.blue := (GammaExpansionTab[bw shr 8]*NativeUInt(255 - (bw and 255)) + GammaExpansionTab[(bw shr 8)+1]*NativeUInt(bw and 255)) shr 8;
+    result.alpha := (FColor1.alpha * b2 + FColor2.alpha * b + 511) shr 2;
+  end;
+end;
+function TBGRASimpleGradientWithoutGammaCorrection.GetExpandedColorAtF(
+  position: single): TExpandedPixel;
+begin
+  if position <= 0 then
+    result := ec1 else
+  if position >= 1 then
+    result := ec2 else
+    result := GetExpandedColorAt(round(position*65536));
+end;
+function TBGRASimpleGradientWithoutGammaCorrection.GetAverageColor: TBGRAPixel;
+begin
+  result := MergeBGRA(FColor1,FColor2);
+end;
+function TBGRASimpleGradientWithoutGammaCorrection.GetMonochrome: boolean;
+begin
+  Result:= (FColor1 = FColor2);
+  result.alpha := (FColor1.alpha * b2 + FColor2.alpha * b + 511) shr 2;
+end;
+constructor TBGRASimpleGradientWithoutGammaCorrection.Create(Color1,
+  Color2: TBGRAPixel; ARepetition: TBGRAGradientRepetition);
+begin
+  inherited Create(Color1,Color2,ARepetition);
+end;
+constructor TBGRASimpleGradientWithoutGammaCorrection.Create(Color1,
+  Color2: TExpandedPixel; ARepetition: TBGRAGradientRepetition);
+begin
+  inherited Create(Color1,Color2,ARepetition);
 end;
 …
 { TBGRAGradientScanner }
+procedure TBGRAGradientScanner.Init(gtype: TGradientType; o1, o2: TPointF;
+  Sinus: Boolean);
+begin
+  FGradientType:= gtype;
+  FOrigin1 := o1;
+  FOrigin2 := o2;
+procedure TBGRAGradientScanner.SetTransform(AValue: TAffineMatrix);
+begin
+  if FTransform=AValue then Exit;
+  FTransform:=AValue;
+  InitTransform;
+end;
+constructor TBGRAGradientScanner.Create(AGradientType: TGradientType; AOrigin, d1: TPointF);
+begin
+  FGradient := nil;
+  SetGradient(BGRABlack,BGRAWhite,False);
+  Init(AGradientType,AOrigin,d1,AffineMatrixIdentity,False);
+end;
+constructor TBGRAGradientScanner.Create(AGradientType: TGradientType; AOrigin, d1,d2: TPointF);
+begin
+  FGradient := nil;
+  SetGradient(BGRABlack,BGRAWhite,False);
+  Init(AGradientType,AOrigin,d1,d2,AffineMatrixIdentity,False);
+end;
+constructor TBGRAGradientScanner.Create(AOrigin,
+  d1, d2, AFocal: TPointF; ARadiusRatio: single; AFocalRadiusRatio: single);
+var
+  m, mInv: TAffineMatrix;
+  focalInv: TPointF;
+begin
+  FGradient := nil;
+  SetGradient(BGRABlack,BGRAWhite,False);
+  m := AffineMatrix((d1-AOrigin).x, (d2-AOrigin).x, AOrigin.x,
+                    (d1-AOrigin).y, (d2-AOrigin).y, AOrigin.y);
+  if IsAffineMatrixInversible(m) then
+  begin
+    mInv := AffineMatrixInverse(m);
+    focalInv := mInv*AFocal;
+  end else
+    focalInv := PointF(0,0);
+  Init(PointF(0,0), ARadiusRatio, focalInv, AFocalRadiusRatio, AffineMatrixIdentity, m);
+end;
+constructor TBGRAGradientScanner.Create(AOrigin: TPointF; ARadius: single;
+  AFocal: TPointF; AFocalRadius: single);
+begin
+  FGradient := nil;
+  SetGradient(BGRABlack,BGRAWhite,False);
+  Init(AOrigin, ARadius, AFocal, AFocalRadius, AffineMatrixIdentity, AffineMatrixIdentity);
+end;
+procedure TBGRAGradientScanner.SetFlipGradient(AValue: boolean);
+begin
+  if FFlipGradient=AValue then Exit;
+  FFlipGradient:=AValue;
+end;
+function TBGRAGradientScanner.GetGradientColor(a: single): TBGRAPixel;
+begin
+  if a = EmptySingle then
+    result := BGRAPixelTransparent
+  else
+  begin
+    if FFlipGradient then a := 1-a;
+    if FSinus then
+    begin
+      a := a*65536;
+      if (a <= low(int64)) or (a >= high(int64)) then
+        result := FAverageColor
+      else
+        result := FGradient.GetColorAt(Sin65536(round(a) and 65535));
+    end else
+      result := FGradient.GetColorAtF(a);
+  end;
+end;
+function TBGRAGradientScanner.GetGradientExpandedColor(a: single): TExpandedPixel;
+begin
+  if a = EmptySingle then
+    QWord(result) := 0
+  else
+  begin
+    if FFlipGradient then a := 1-a;
+    if FSinus then
+    begin
+      a *= 65536;
+      if (a <= low(int64)) or (a >= high(int64)) then
+        result := FAverageExpandedColor
+      else
+        result := FGradient.GetExpandedColorAt(Sin65536(round(a) and 65535));
+    end else
+      result := FGradient.GetExpandedColorAtF(a);
+  end;
+end;
+procedure TBGRAGradientScanner.Init(AGradientType: TGradientType; AOrigin, d1: TPointF;
+  ATransform: TAffineMatrix; Sinus: Boolean);
+var d2: TPointF;
+begin
+  with (d1-AOrigin) do
+    d2 := PointF(AOrigin.x+y,AOrigin.y-x);
+  Init(AGradientType,AOrigin,d1,d2,ATransform,Sinus);
+end;
+procedure TBGRAGradientScanner.Init(AGradientType: TGradientType; AOrigin, d1, d2: TPointF;
+  ATransform: TAffineMatrix; Sinus: Boolean);
+begin
+  FGradientType:= AGradientType;
+  FFlipGradient:= false;
+  FOrigin := AOrigin;
+  FDir1 := d1;
+  FDir2 := d2;
   FSinus := Sinus;
+  //compute vector
+  u.x := o2.x - o1.x;
+  u.y := o2.y - o1.y;
+  len := sqrt(sqr(u.x) + sqr(u.y));
+  if len <> 0 then
+  begin
+    u.x /= len;
+    u.y /= len;
+    aFactor := 65536/len;
+    aFactorF := 1/len;
+  end
+  else
+  begin
+    aFactor := 0;
+    aFactorF := 0;
+  end;
+  FVertical := (((gtype =gtLinear) or (gtype=gtReflected)) and (o1.x=o2.x)) or FGradient.Monochrome;
+  mergedColor := FGradient.GetAverageColor;
+  mergedExpandedColor := FGradient.GetAverageExpandedColor;
+end;
+procedure TBGRAGradientScanner.InitScanInline(x, y: integer);
+var p: TPointF;
+begin
+  p.x := X - FOrigin1.x;
+  p.y := Y - FOrigin1.y;
+  FDotProduct := p.x * u.x + p.y * u.y;
+  FDotProductPerp := p.x * u.y - p.y * u.x;
+end;
+function TBGRAGradientScanner.ScanNextInline: TBGRAPixel;
+var
+  a,a2: single;
+  ai: integer;
+begin
+  if FGradientType >= gtDiamond then
+  begin
+    if FGradientType = gtRadial then
+  FTransform := ATransform;
+  FHiddenTransform := AffineMatrixIdentity;
+  FRadius := 1;
+  FRelativeFocal := PointF(0,0);
+  FFocalRadius := 0;
+  InitGradientType;
+  InitTransform;
+end;
+procedure TBGRAGradientScanner.Init(AOrigin: TPointF; ARadius: single;
+  AFocal: TPointF; AFocalRadius: single; ATransform: TAffineMatrix; AHiddenTransform: TAffineMatrix);
+var maxRadius: single;
+begin
+  FGradientType:= gtRadial;
+  FFlipGradient:= false;
+  FOrigin := AOrigin;
+  ARadius := abs(ARadius);
+  AFocalRadius := abs(AFocalRadius);
+  maxRadius := max(ARadius,AFocalRadius);
+  FDir1 := AOrigin+PointF(maxRadius,0);
+  FDir2 := AOrigin+PointF(0,maxRadius);
+  FSinus := False;
+  FTransform := ATransform;
+  FHiddenTransform := AHiddenTransform;
+  FRadius := ARadius/maxRadius;
+  FRelativeFocal := (AFocal - AOrigin)*(1/maxRadius);
+  FFocalRadius := AFocalRadius/maxRadius;
+  InitGradientType;
+  InitTransform;
+end;
+procedure TBGRAGradientScanner.InitGradientType;
+begin
+  case FGradientType of
+    gtReflected: begin
+      FScanNextFunc:= @ScanNextReflected;
+      FScanAtFunc:= @ScanAtReflected;
+    end;
+    gtDiamond: begin
+      FScanNextFunc:= @ScanNextDiamond;
+      FScanAtFunc:= @ScanAtDiamond;
+    end;
+    gtRadial: if (FRelativeFocal.x = 0) and (FRelativeFocal.y = 0) then
     begin
+      a := sqrt(sqr(FDotProduct) + sqr(FDotProductPerp));
+      FDotProduct += u.x;
+      FDotProductPerp += u.y;
+      if (FFocalRadius = 0) and (FRadius = 1) then
+      begin
+        FScanNextFunc:= @ScanNextRadial;
+        FScanAtFunc:= @ScanAtRadial;
+      end else
+      begin
+        FScanNextFunc:= @ScanNextRadial2;
+        FScanAtFunc:= @ScanAtRadial2;
+      end;
     end else
     begin
+      a   := abs(FDotProduct);
+      a2  := abs(FDotProductPerp);
+      if a2 > a then a := a2;
+      FDotProduct += u.x;
+      FDotProductPerp += u.y;
+      FScanNextFunc:= @ScanNextRadialFocal;
+      FScanAtFunc:= @ScanAtRadialFocal;
+      FFocalDirection := FRelativeFocal;
+      FFocalDistance := VectLen(FFocalDirection);
+      if FFocalDistance > 0 then FFocalDirection *= 1/FFocalDistance;
+      FFocalNormal := PointF(-FFocalDirection.y,FFocalDirection.x);
+      FRadialDenominator := sqr(FRadius-FFocalRadius)-sqr(FFocalDistance);
+      //case in which the second circle is bigger and the first circle is within the second
+      if (FRadius < FFocalRadius) and (FFocalDistance <= FFocalRadius-FRadius) then
+        FRadialDeltaSign := -1
+      else
+        FRadialDeltaSign := 1;
+      //clipping afer the apex
+      if (FFocalRadius < FRadius) and (FFocalDistance > FRadius-FFocalRadius) then
+      begin
+        maxW1 := FRadius/(FRadius-FFocalRadius)*FFocalDistance;
+        maxW2 := MaxSingle;
+      end else
+      if (FRadius < FFocalRadius) and (FFocalDistance > FFocalRadius-FRadius) then
+      begin
+        maxW1 := MaxSingle;
+        maxW2 := FFocalRadius/(FFocalRadius-FRadius)*FFocalDistance;
+      end else
+      begin
+        maxW1 := MaxSingle;
+        maxW2 := MaxSingle;
+      end;
     end;
+  end else
+  if FGradientType = gtReflected then
+  begin
+    a := abs(FDotProduct);
+    FDotProduct += u.x;
+  end else
+  begin
+    a := FDotProduct;
+    FDotProduct += u.x;
+  end;
+  if FSinus then
+  begin
+    a *= aFactor;
+    if a <= low(int64) then
+      result := FGradient.GetAverageColor
+    else
+    if a >= high(int64) then
+      result := FGradient.GetAverageColor
+    else
+    begin
+      ai := Sin65536(round(a));
+      result := FGradient.GetColorAt(ai);
+    gtAngular: begin
+      FScanNextFunc:= @ScanNextAngular;
+      FScanAtFunc:= @ScanAtAngular;
     end;
+  end else
+    result := FGradient.GetColorAtF(a*aFactorF);
+end;
+function TBGRAGradientScanner.ScanNextExpandedInline: TExpandedPixel;
+var
+  a,a2: single;
+  ai: integer;
+begin
+  if FGradientType >= gtDiamond then
+  begin
+    if FGradientType = gtRadial then
+    begin
+      a := sqrt(sqr(FDotProduct) + sqr(FDotProductPerp));
+      FDotProduct += u.x;
+      FDotProductPerp += u.y;
+    end else
+    begin
+      a   := abs(FDotProduct);
+      a2  := abs(FDotProductPerp);
+      if a2 > a then a := a2;
+      FDotProduct += u.x;
+      FDotProductPerp += u.y;
+  else
+    {gtLinear:} begin
+      FScanNextFunc:= @ScanNextLinear;
+      FScanAtFunc:= @ScanAtLinear;
     end;
+  end else
+  if FGradientType = gtReflected then
+  begin
+    a := abs(FDotProduct);
+    FDotProduct += u.x;
+  end else
+  begin
+    a := FDotProduct;
+    FDotProduct += u.x;
+  end;
+  if FSinus then
+  begin
+    a *= aFactor;
+    if a <= low(int64) then
+      result := FGradient.GetAverageExpandedColor
+    else
+    if a >= high(int64) then
+      result := FGradient.GetAverageExpandedColor
+    else
+    begin
+      ai := Sin65536(round(a));
+      result := FGradient.GetExpandedColorAt(ai);
+    end;
+  end else
+    result := FGradient.GetExpandedColorAtF(a*aFactorF);
+end;
+constructor TBGRAGradientScanner.Create(c1, c2: TBGRAPixel;
+  gtype: TGradientType; o1, o2: TPointF; gammaColorCorrection: boolean;
+  Sinus: Boolean);
+begin
+  end;
+end;
+procedure TBGRAGradientScanner.SetGradient(c1, c2: TBGRAPixel;
+  AGammaCorrection: boolean);
+begin
+  if Assigned(FGradient) and FGradientOwner then FreeAndNil(FGradient);
   //transparent pixels have no color so
   //take it from other color
+  if c1.alpha = 0 then
+  begin
+    c1.red   := c2.red;
+    c1.green := c2.green;
+    c1.blue  := c2.blue;
+  end
+  else
+  if c2.alpha = 0 then
+  begin
+    c2.red   := c1.red;
+    c2.green := c1.green;
+    c2.blue  := c1.blue;
+  end;
+  if gammaColorCorrection then
+  begin
+    FGradient := TBGRASimpleGradientWithGammaCorrection.Create(c1,c2);
+    FGradientOwner := true;
+  if c1.alpha = 0 then c1 := BGRA(c2.red,c2.green,c2.blue,0);
+  if c2.alpha = 0 then c2 := BGRA(c1.red,c1.green,c1.blue,0);
+  if AGammaCorrection then
+    FGradient := TBGRASimpleGradientWithGammaCorrection.Create(c1,c2)
+  else
+    FGradient := TBGRASimpleGradientWithoutGammaCorrection.Create(c1,c2);
+  FGradientOwner := true;
+  InitGradient;
+end;
+procedure TBGRAGradientScanner.SetGradient(AGradient: TBGRACustomGradient;
+  AOwner: boolean);
+begin
+  if Assigned(FGradient) and FGradientOwner then FreeAndNil(FGradient);
+  FGradient := AGradient;
+  FGradientOwner := AOwner;
+  InitGradient;
+end;
+procedure TBGRAGradientScanner.InitTransform;
+var u,v: TPointF;
+begin
+  u := FDir1-FOrigin;
+  if FGradientType in[gtLinear,gtReflected] then
+    v := PointF(u.y, -u.x)
+  else
+    v := FDir2-FOrigin;
+  FMatrix := FTransform * FHiddenTransform * AffineMatrix(u.x, v.x, FOrigin.x,
+                                                          u.y, v.y, FOrigin.y);
+  if IsAffineMatrixInversible(FMatrix) then
+  begin
+    FMatrix := AffineMatrixInverse(FMatrix);
+    FIsAverage:= false;
   end else
   begin
+    FGradient := TBGRASimpleGradientWithoutGammaCorrection.Create(c1,c2);
+    FGradientOwner := true;
+  end;
+  Init(gtype,o1,o2,Sinus);
+    FMatrix := AffineMatrixIdentity;
+    FIsAverage:= true;
+  end;
+  case FGradientType of
+    gtReflected: FRepeatHoriz := (FMatrix[1,1]=0);
+    gtDiamond,gtAngular: FRepeatHoriz:= FIsAverage;
+    gtRadial: begin
+      if FFocalRadius = FRadius then FIsAverage:= true;
+      FRepeatHoriz:= FIsAverage;
+    end
+  else
+    {gtLinear:} FRepeatHoriz := (FMatrix[1,1]=0);
+  end;
+  if FGradient.Monochrome then
+  begin
+    FRepeatHoriz:= true;
+    FIsAverage:= true;
+  end;
+  FPosition := PointF(0,0);
+end;
+procedure TBGRAGradientScanner.InitGradient;
+begin
+  FAverageColor := FGradient.GetAverageColor;
+  FAverageExpandedColor := FGradient.GetAverageExpandedColor;
+end;
+function TBGRAGradientScanner.ComputeRadialFocal(const p: TPointF): single;
+var
+  w1,w2,h,d1,d2,delta,num: single;
+begin
+  w1 := p*FFocalDirection;
+  w2 := FFocalDistance-w1;
+  if (w1 < maxW1) and (w2 < maxW2) then
+  begin
+    //vertical position and distances
+    h := sqr(p*FFocalNormal);
+    d1 := sqr(w1)+h;
+    d2 := sqr(w2)+h;
+    //finding t
+    delta := sqr(FFocalRadius)*d1 + 2*FRadius*FFocalRadius*(p*(FRelativeFocal-p))+
+             sqr(FRadius)*d2 - sqr(VectDet(p,FRelativeFocal));
+    if delta >= 0 then
+    begin
+      num := -FFocalRadius*(FRadius-FFocalRadius)-(FRelativeFocal*(FRelativeFocal-p));
+      result := (num+FRadialDeltaSign*sqrt(delta))/FRadialDenominator;
+    end else
+      result := EmptySingle;
+  end else
+    result := EmptySingle;
+end;
+function TBGRAGradientScanner.ScanNextLinear: single;
+begin
+  result := FPosition.x;
+end;
+function TBGRAGradientScanner.ScanNextReflected: single;
+begin
+  result := abs(FPosition.x);
+end;
+function TBGRAGradientScanner.ScanNextDiamond: single;
+begin
+  result := max(abs(FPosition.x), abs(FPosition.y));
+end;
+function TBGRAGradientScanner.ScanNextRadial: single;
+begin
+  result := sqrt(sqr(FPosition.x) + sqr(FPosition.y));
+end;
+function TBGRAGradientScanner.ScanNextRadial2: single;
+begin
+  result := (sqrt(sqr(FPosition.x) + sqr(FPosition.y))-FFocalRadius)/(FRadius-FFocalRadius);
+end;
+function TBGRAGradientScanner.ScanNextRadialFocal: single;
+begin
+  result := ComputeRadialFocal(FPosition);
+end;
+function TBGRAGradientScanner.ScanNextAngular: single;
+begin
+  if FPosition.y >= 0 then
+    result := arctan2(FPosition.y,FPosition.x)/(2*Pi)
+  else
+    result := 1-arctan2(-FPosition.y,FPosition.x)/(2*Pi)
+end;
+function TBGRAGradientScanner.ScanAtLinear(const p: TPointF): single;
+begin
+  with (FMatrix*p) do
+    result := x;
+end;
+function TBGRAGradientScanner.ScanAtReflected(const p: TPointF): single;
+begin
+  with (FMatrix*p) do
+    result := abs(x);
+end;
+function TBGRAGradientScanner.ScanAtDiamond(const p: TPointF): single;
+begin
+  with (FMatrix*p) do
+    result := max(abs(x), abs(y));
+end;
+function TBGRAGradientScanner.ScanAtRadial(const p: TPointF): single;
+begin
+  with (FMatrix*p) do
+    result := sqrt(sqr(x) + sqr(y));
+end;
+function TBGRAGradientScanner.ScanAtRadial2(const p: TPointF): single;
+begin
+  with (FMatrix*p) do
+    result := (sqrt(sqr(x) + sqr(y))-FFocalRadius)/(FRadius-FFocalRadius);
+end;
+function TBGRAGradientScanner.ScanAtRadialFocal(const p: TPointF): single;
+begin
+  result := ComputeRadialFocal(FMatrix*p);
+end;
+function TBGRAGradientScanner.ScanAtAngular(const p: TPointF): single;
+begin
+  with (FMatrix*p) do
+  begin
+    if y >= 0 then
+      result := arctan2(y,x)/(2*Pi)
+    else
+      result := 1-arctan2(-y,x)/(2*Pi)
+  end;
+end;
+function TBGRAGradientScanner.ScanNextInline: TBGRAPixel;
+begin
+  if FIsAverage then
+    result := FAverageColor
+  else
+  begin
+    result := GetGradientColor(FScanNextFunc());
+    FPosition += PointF(FMatrix[1,1],FMatrix[2,1]);
+  end;
+end;
+function TBGRAGradientScanner.ScanNextExpandedInline: TExpandedPixel;
+begin
+  if FIsAverage then
+    result := FAverageExpandedColor
+  else
+  begin
+    result := GetGradientExpandedColor(FScanNextFunc());
+    FPosition += PointF(FMatrix[1,1],FMatrix[2,1]);
+  end;
+end;
+constructor TBGRAGradientScanner.Create(c1, c2: TBGRAPixel;
+  AGradientType: TGradientType; AOrigin, d1: TPointF; gammaColorCorrection: boolean;
+  Sinus: Boolean);
+begin
+  FGradient := nil;
+  SetGradient(c1,c2,gammaColorCorrection);
+  Init(AGradientType,AOrigin,d1,AffineMatrixIdentity,Sinus);
+end;
+constructor TBGRAGradientScanner.Create(c1, c2: TBGRAPixel;
+  AGradientType: TGradientType; AOrigin, d1, d2: TPointF; gammaColorCorrection: boolean;
+  Sinus: Boolean);
+begin
+  FGradient := nil;
+  if AGradientType in[gtLinear,gtReflected] then raise EInvalidArgument.Create('Two directions are not required for linear and reflected gradients');
+  SetGradient(c1,c2,gammaColorCorrection);
+  Init(AGradientType,AOrigin,d1,d2,AffineMatrixIdentity,Sinus);
 end;
 constructor TBGRAGradientScanner.Create(gradient: TBGRACustomGradient;
   gtype: TGradientType; o1, o2: TPointF; Sinus: Boolean; AGradientOwner: Boolean=False);
+  AGradientType: TGradientType; AOrigin, d1: TPointF; Sinus: Boolean; AGradientOwner: Boolean=False);
 begin
   FGradient := gradient;
   FGradientOwner := AGradientOwner;
+  Init(gtype,o1,o2,Sinus);
+  Init(AGradientType,AOrigin,d1,AffineMatrixIdentity,Sinus);
+end;
+constructor TBGRAGradientScanner.Create(gradient: TBGRACustomGradient;
+  AGradientType: TGradientType; AOrigin, d1, d2: TPointF; Sinus: Boolean;
+  AGradientOwner: Boolean);
+begin
+  if AGradientType in[gtLinear,gtReflected] then raise EInvalidArgument.Create('Two directions are not required for linear and reflected gradients');
+  FGradient := gradient;
+  FGradientOwner := AGradientOwner;
+  Init(AGradientType,AOrigin,d1,d2,AffineMatrixIdentity,Sinus);
+end;
+constructor TBGRAGradientScanner.Create(gradient: TBGRACustomGradient;
+  AOrigin: TPointF; ARadius: single; AFocal: TPointF; AFocalRadius: single;
+  AGradientOwner: Boolean);
+begin
+  FGradient := gradient;
+  FGradientOwner := AGradientOwner;
+  Init(AOrigin, ARadius, AFocal, AFocalRadius, AffineMatrixIdentity, AffineMatrixIdentity);
 end;
 …
 procedure TBGRAGradientScanner.ScanMoveTo(X, Y: Integer);
 begin
   InitScanInline(X,Y);
   if FVertical then
+  FPosition := FMatrix*PointF(x,y);
+  if FRepeatHoriz then
   begin
     FHorizColor := ScanNextInline;
 …
 function TBGRAGradientScanner.ScanNextPixel: TBGRAPixel;
 begin
   if FVertical then
+  if FRepeatHoriz then
     result := FHorizColor
   else
 …
 function TBGRAGradientScanner.ScanNextExpandedPixel: TExpandedPixel;
 begin
   if FVertical then
+  if FRepeatHoriz then
     result := FHorizExpandedColor
   else
 …
 function TBGRAGradientScanner.ScanAt(X, Y: Single): TBGRAPixel;
+var p: TPointF;
+    a,a2: single;
+    ai: integer;
+begin
+  if len = 0 then
+  begin
+    result := mergedColor;
+    exit;
+  end;
+  p.x := X - FOrigin1.x;
+  p.y := Y - FOrigin1.y;
+  case FGradientType of
+    gtLinear:    a := p.x * u.x + p.y * u.y;
+    gtReflected: a := abs(p.x * u.x + p.y * u.y);
+    gtDiamond:
+        begin
+          a   := abs(p.x * u.x + p.y * u.y);
+          a2  := abs(p.x * u.y - p.y * u.x);
+          if a2 > a then a := a2;
+        end;
+    gtRadial:    a := sqrt(sqr(p.x * u.x + p.y * u.y) + sqr(p.x * u.y - p.y * u.x));
+  end;
+  if FSinus then
+  begin
+    a := a*aFactor;
+    if (a <= low(int64)) or (a >= high(int64)) then
+      result := mergedColor
+    else
+    begin
+      ai := Sin65536(round(a));
+      result := FGradient.GetColorAt(ai);
+    end;
+  end else
+    result := FGradient.GetColorAtF(a*aFactorF);
+begin
+  if FIsAverage then
+    result := FAverageColor
+  else
+    result := GetGradientColor(FScanAtFunc(PointF(X,Y)));
 end;
 function TBGRAGradientScanner.ScanAtExpanded(X, Y: Single): TExpandedPixel;
+var p: TPointF;
+    a,a2: single;
+    ai: integer;
+begin
+  if len = 0 then
+  begin
+    result := mergedExpandedColor;
+    exit;
+  end;
+  p.x := X - FOrigin1.x;
+  p.y := Y - FOrigin1.y;
+  case FGradientType of
+    gtLinear:    a := p.x * u.x + p.y * u.y;
+    gtReflected: a := abs(p.x * u.x + p.y * u.y);
+    gtDiamond:
+        begin
+          a   := abs(p.x * u.x + p.y * u.y);
+          a2  := abs(p.x * u.y - p.y * u.x);
+          if a2 > a then a := a2;
+        end;
+    gtRadial:    a := sqrt(sqr(p.x * u.x + p.y * u.y) + sqr(p.x * u.y - p.y * u.x));
+  end;
+  if FSinus then
+  begin
+    a := a*aFactor;
+    if (a <= low(int64)) or (a >= high(int64)) then
+      result := mergedExpandedColor
+    else
+    begin
+      ai := Sin65536(round(a));
+      result := FGradient.GetExpandedColorAt(ai);
+    end;
+  end else
+    result := FGradient.GetExpandedColorAtF(a*aFactorF);
+begin
+  if FIsAverage then
+    result := FAverageExpandedColor
+  else
+    result := GetGradientExpandedColor(FScanAtFunc(PointF(X,Y)));
 end;
 …
 var c: TBGRAPixel;
 begin
+  if FVertical or (len = 0) then
+  begin
+    if FVertical then c := FHorizColor
+      else c := mergedColor;
+  if FRepeatHoriz then
+  begin
+    c := FHorizColor;
     case mode of
       dmDrawWithTransparency: DrawPixelsInline(pdest,c,count);
 …
   FScanAt := @FTexture.ScanAt;
   FGlobalOpacity:= AGlobalOpacity;
+  FOwnedScanner := nil;
+end;
+constructor TBGRAOpacityScanner.Create(ATexture: TBGRACustomScanner;
+  AGlobalOpacity: Byte; AOwned: boolean);
+begin
+  FTexture := ATexture;
+  FScanNext := @FTexture.ScanNextPixel;
+  FScanAt := @FTexture.ScanAt;
+  FGlobalOpacity:= AGlobalOpacity;
+  if AOwned then
+    FOwnedScanner := ATexture
+  else
+    FOwnedScanner := nil;
 end;
 …
 begin
   fillchar(FTexture,sizeof(FTexture),0);
+  FOwnedScanner.Free;
   inherited Destroy;
 end;

GraphicTest/Packages/bgrabitmap/bgragrayscalemask.pas

-              r494
+              r521
   end;
 procedure DownSamplePutImageGrayscale(sourceData: PByte; sourcePixelSize: NativeInt; sourceRowDelta: NativeInt; sourceWidth, sourceHeight: NativeInt; dest: TGrayscaleMask; ADestRect: TRect);
 procedure DownSamplePutImageGrayscale(source: TBGRACustomBitmap; dest: TGrayscaleMask; ADestRect: TRect);
+procedure DownSamplePutImageGrayscale(sourceData: PByte; sourcePixelSize: NativeInt; sourceRowDelta: NativeInt; sourceWidth, sourceHeight: NativeInt; dest: TGrayscaleMask; ADestRect: TRect); overload;
+procedure DownSamplePutImageGrayscale(source: TBGRACustomBitmap; dest: TGrayscaleMask; ADestRect: TRect); overload;
 procedure BGRAFillClearTypeGrayscaleMask(dest: TBGRACustomBitmap; x,

GraphicTest/Packages/bgrabitmap/bgragtkbitmap.pas

-              r494
+              r521
     FPixBuf: Pointer;
     procedure DrawTransparent(ACanvas: TCanvas; Rect: TRect);
+    procedure DrawOpaque(ACanvas: TCanvas; Rect: TRect);
+    procedure DrawOpaque(ACanvas: TCanvas; ARect: TRect; ASourceRect: TRect);
+    procedure DrawOpaque(ACanvas: TCanvas; ARect: TRect);
   protected
     procedure ReallocData; override;
 …
       AData: Pointer; ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer);
       override;
+    procedure DrawPart(ARect: TRect; ACanvas: TCanvas; x, y: integer; Opaque: boolean); override;
     procedure Draw(ACanvas: TCanvas; x, y: integer; Opaque: boolean = True); override;
     procedure Draw(ACanvas: TCanvas; Rect: TRect; Opaque: boolean = True); override;
+    procedure DataDrawOpaque(ACanvas: TCanvas; Rect: TRect; AData: Pointer;
+      ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer); override;
+    procedure DataDrawOpaque(ACanvas: TCanvas; ARect: TRect; AData: Pointer;
+      ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer); overload; override;
+    procedure DataDrawOpaque(ACanvas: TCanvas; ARect: TRect; ADataFirstRow: Pointer;
+      ARowStride: integer; AWidth, AHeight: integer); overload;
     procedure GetImageFromCanvas(CanvasSource: TCanvas; x, y: integer); override;
   end;
 …
 implementation
 uses BGRABitmapTypes, BGRADefaultBitmap, LCLType,
+uses BGRABitmapTypes, BGRADefaultBitmap, BGRAFilterScanner, LCLType,
   LCLIntf, IntfGraphics,
   {$IFDEF LCLgtk2}
 …
   {$ENDIF}
   FPImage, Dialogs;
-{$IFDEF LCLgtk2}
-type TGtkDeviceContext = TGtk2DeviceContext;
-{$ENDIF}
 procedure TBGRAGtkBitmap.ReallocData;
 …
   end;
+  LoadFromBitmapIfNeeded;
   If not TBGRAPixel_RGBAOrder then SwapRedBlue;
 …
 end;
+procedure TBGRAGtkBitmap.DrawOpaque(ACanvas: TCanvas; Rect: TRect);
+begin
+  DataDrawOpaque(ACanvas,Rect,Data,LineOrder,Width,Height);
+procedure TBGRAGtkBitmap.DrawOpaque(ACanvas: TCanvas; ARect: TRect;
+  ASourceRect: TRect);
+begin
+  DataDrawOpaque(ACanvas,ARect,Data,LineOrder,Width,Height);
+end;
+procedure TBGRAGtkBitmap.DrawOpaque(ACanvas: TCanvas; ARect: TRect);
+begin
+  DrawOpaque(ACanvas, ARect, rect(0,0,Width,Height));
 end;
 …
 end;
+procedure TBGRAGtkBitmap.DrawPart(ARect: TRect; ACanvas: TCanvas; x,
+  y: integer; Opaque: boolean);
+var
+  rowStride,w,h: Integer;
+begin
+  if Opaque then
+  begin
+    if LineOrder = riloTopToBottom then
+      rowStride := Width*sizeof(TBGRAPixel)
+    else
+      rowStride := -Width*sizeof(TBGRAPixel);
+    w:= ARect.Right-ARect.Left;
+    h:= ARect.Bottom-ARect.Top;
+    DataDrawOpaque(ACanvas, rect(x,y,x+w,y+h), Scanline[ARect.Top]+ARect.Left, rowStride, w,h);
+  end
+  else
+    inherited DrawPart(ARect, ACanvas, x, y, Opaque);
+end;
 procedure TBGRAGtkBitmap.Draw(ACanvas: TCanvas; x, y: integer; Opaque: boolean);
 begin
 …
 end;
 procedure TBGRAGtkBitmap.DataDrawOpaque(ACanvas: TCanvas; Rect: TRect;
+procedure TBGRAGtkBitmap.DataDrawOpaque(ACanvas: TCanvas; ARect: TRect;
   AData: Pointer; ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer);
+var ptr: TBGRAPtrBitmap;
+var
+  rowStride: Integer;
+  firstRow: Pointer;
+begin
+  if ALineOrder = riloTopToBottom then
+  begin
+    rowStride := AWidth*sizeof(TBGRAPixel);
+    firstRow := AData;
+  end
+  else
+  begin
+    rowStride := -AWidth*sizeof(TBGRAPixel);
+    firstRow := PBGRAPixel(AData) + (AWidth*(AHeight-1));
+  end;
+  DataDrawOpaque(ACanvas, ARect, firstRow, rowStride, AWidth, AHeight);
+end;
+procedure TBGRAGtkBitmap.DataDrawOpaque(ACanvas: TCanvas; ARect: TRect;
+  ADataFirstRow: Pointer; ARowStride: integer; AWidth, AHeight: integer);
+  procedure DataSwapRedBlue;
+  var
+    y: Integer;
+    p: PByte;
+  begin
+    p := PByte(ADataFirstRow);
+    for y := 0 to AHeight-1 do
+    begin
+      TBGRAFilterScannerSwapRedBlue.ComputeFilterAt(PBGRAPixel(p),PBGRAPixel(p),AWidth,False);
+      inc(p, ARowStride);
+    end;
+  end;
+  procedure DrawStretched;
+  var
+    dataStart: Pointer;
+    ptr: TBGRAPtrBitmap;
     stretched: TBGRACustomBitmap;
+    temp: integer;
+    pos: TPoint;
+    dest: HDC;
+begin
+  if (AHeight = 0) or (AWidth = 0) or (Rect.Left = Rect.Right) or
+    (Rect.Top = Rect.Bottom) then
+    exit;
+  if Rect.Right < Rect.Left then
+  begin
+    temp := Rect.Left;
+    Rect.Left := Rect.Right;
+    Rect.Right := temp;
+  end;
+  if Rect.Bottom < Rect.Top then
+  begin
+    temp := Rect.Top;
+    Rect.Top := Rect.Bottom;
+    Rect.Bottom := temp;
+  end;
+  if (AWidth <> Rect.Right-Rect.Left) or (AHeight <> Rect.Bottom-Rect.Top) then
+  begin
+    ptr := TBGRAPtrBitmap.Create(AWidth,AHeight,AData);
+    ptr.LineOrder := ALineOrder;
+    stretched := ptr.Resample(Rect.Right-Rect.Left,Rect.Bottom-Rect.Top);
+  begin
+    if ARowStride < 0 then
+      dataStart := PByte(ADataFirstRow) + ARowStride*(Height-1)
+    else
+      dataStart := ADataFirstRow;
+    if ARowStride <> abs(AWidth*sizeof(TBGRAPixel)) then
+      raise exception.Create('DataDrawOpaque not supported when using custom row stride and resample');
+    ptr := TBGRAPtrBitmap.Create(AWidth,AHeight,dataStart);
+    if ARowStride < 0 then
+      ptr.LineOrder := riloBottomToTop
+    else
+      ptr.LineOrder := riloTopToBottom;
+    stretched := ptr.Resample(ARect.Right-ARect.Left,ARect.Bottom-ARect.Top);
     ptr.free;
     DataDrawOpaque(ACanvas,Rect,AData,stretched.LineOrder,stretched.Width,stretched.Height);
+    DataDrawOpaque(ACanvas,ARect,stretched.Data,stretched.LineOrder,stretched.Width,stretched.Height);
     stretched.Free;
+    exit;
+  end;
+  dest := ACanvas.Handle;
+  pos := rect.TopLeft;
+  LPtoDP(dest, pos, 1);
+  If ALineOrder = riloBottomToTop then VerticalFlip;
+  If not TBGRAPixel_RGBAOrder then SwapRedBlue;
+  gdk_draw_rgb_32_image(TGtkDeviceContext(dest).Drawable,
+    TGtkDeviceContext(Dest).GC, pos.x,pos.y,
+    AWidth,AHeight, GDK_RGB_DITHER_NORMAL,
+    AData, AWidth*sizeof(TBGRAPixel));
+  If not TBGRAPixel_RGBAOrder then SwapRedBlue;
+  If ALineOrder = riloBottomToTop then VerticalFlip;
+  end;
+var
+  temp: integer;
+  pos: TPoint;
+  dest: HDC;
+begin
+  if (AHeight = 0) or (AWidth = 0) or (ARect.Left = ARect.Right) or
+    (ARect.Top = ARect.Bottom) then exit;
+  if ARect.Right < ARect.Left then
+  begin
+    temp := ARect.Left;
+    ARect.Left := ARect.Right;
+    ARect.Right := temp;
+  end;
+  if ARect.Bottom < ARect.Top then
+  begin
+    temp := ARect.Top;
+    ARect.Top := ARect.Bottom;
+    ARect.Bottom := temp;
+  end;
+  if (AWidth <> ARect.Right-ARect.Left) or (AHeight <> ARect.Bottom-ARect.Top) then
+    DrawStretched
+  else
+  begin
+    dest := ACanvas.Handle;
+    pos := ARect.TopLeft;
+    LPtoDP(dest, pos, 1);
+    if not TBGRAPixel_RGBAOrder then DataSwapRedBlue;
+    gdk_draw_rgb_32_image(TGtkDeviceContext(dest).Drawable,
+      TGtkDeviceContext(Dest).GC, pos.x,pos.y,
+      AWidth,AHeight, GDK_RGB_DITHER_NORMAL,
+      ADataFirstRow, ARowStride);
+    if not TBGRAPixel_RGBAOrder then DataSwapRedBlue;
+    ACanvas.Changed;
+  end;
 end;

GraphicTest/Packages/bgrabitmap/bgralayers.pas

-              r494
+              r521
 {$mode objfpc}{$H+}
+{$MODESWITCH ADVANCEDRECORDS}
 interface
 uses
+  BGRAGraphics, Classes, SysUtils, Types, BGRABitmapTypes, BGRABitmap;
+  BGRAGraphics, Classes, SysUtils, Types, BGRABitmapTypes, BGRABitmap,
+  BGRAMemDirectory, BGRATransform, fgl, BGRALayerOriginal;
 type
 …
   TBGRACustomLayeredBitmapClass = class of TBGRACustomLayeredBitmap;
+  { TBGRALayerOriginalEntry }
+  TBGRALayerOriginalEntry = record
+     Guid: TGuid;
+     Instance: TBGRALayerCustomOriginal;
+     class operator = (const AEntry1,AEntry2: TBGRALayerOriginalEntry): boolean;
+  end;
+function BGRALayerOriginalEntry(AGuid: TGuid): TBGRALayerOriginalEntry;
+function BGRALayerOriginalEntry(AInstance: TBGRALayerCustomOriginal): TBGRALayerOriginalEntry;
+type
+  TBGRALayerOriginalList = specialize TFPGList<TBGRALayerOriginalEntry>;
   TBGRALayeredBitmap = class;
   TBGRALayeredBitmapClass = class of TBGRALayeredBitmap;
   TBGRALayeredBitmapSaveToStreamProc = procedure(AStream: TStream; ALayers: TBGRACustomLayeredBitmap);
+  TBGRALayeredBitmapLoadFromStreamProc = function(AStream: TStream): TBGRALayeredBitmap;
+  TBGRALayeredBitmapLoadFromStreamProc = procedure(AStream: TStream; ALayers: TBGRACustomLayeredBitmap);
+  TBGRALayeredBitmapCheckStreamProc = function(AStream: TStream): boolean;
+  TOriginalRenderStatus = (orsNone, orsDraft, orsPartialDraft, orsProof, orsPartialProof);
   { TBGRACustomLayeredBitmap }
 …
     end;
     FLinearBlend: boolean;
+    FMemDirectory: TMemDirectory;
+    FMemDirectoryOwned: boolean;
     function GetDefaultBlendingOperation: TBlendOperation;
+    function GetHasMemFiles: boolean;
     function GetLinearBlend: boolean;
     procedure SetLinearBlend(AValue: boolean);
 …
   protected
     function GetNbLayers: integer; virtual; abstract;
+    function GetMemDirectory: TMemDirectory;
     function GetBlendOperation(Layer: integer): TBlendOperation; virtual; abstract;
     function GetLayerVisible(layer: integer): boolean; virtual; abstract;
 …
     function GetLayerFrozen(layer: integer): boolean; virtual;
     function GetLayerUniqueId(layer: integer): integer; virtual;
+    function GetLayerOriginal({%H-}layer: integer): TBGRALayerCustomOriginal; virtual;
+    function GetLayerOriginalKnown({%H-}layer: integer): boolean; virtual;
+    function GetLayerOriginalMatrix({%H-}layer: integer): TAffineMatrix; virtual;
+    function GetLayerOriginalGuid({%H-}layer: integer): TGuid; virtual;
+    function GetLayerOriginalRenderStatus({%H-}layer: integer): TOriginalRenderStatus; virtual;
+    function GetOriginalCount: integer; virtual;
+    function GetOriginalByIndex({%H-}AIndex: integer): TBGRALayerCustomOriginal; virtual;
+    function GetOriginalByIndexKnown({%H-}AIndex: integer): boolean; virtual;
+    function GetTransparent: Boolean; override;
+    function GetEmpty: boolean; override;
+    function IndexOfOriginal(AGuid: TGuid): integer; overload; virtual;
+    function IndexOfOriginal(AOriginal: TBGRALayerCustomOriginal): integer; overload; virtual;
+    procedure SetWidth(Value: Integer); override;
+    procedure SetHeight(Value: Integer); override;
+    procedure SetMemDirectory(AValue: TMemDirectory);
+    procedure SetTransparent(Value: Boolean); override;
     procedure SetLayerFrozen(layer: integer; AValue: boolean); virtual;
     function RangeIntersect(first1,last1,first2,last2: integer): boolean;
     procedure RemoveFrozenRange(index: integer);
     function ContainsFrozenRange(first,last: integer): boolean;
-    function GetEmpty: boolean; override;
-    procedure SetWidth(Value: Integer); override;
-    procedure SetHeight(Value: Integer); override;
-    function GetTransparent: Boolean; override;
-    procedure SetTransparent(Value: Boolean); override;
   public
     procedure SaveToFile(const filenameUTF8: string); override;
     procedure SaveToStream(Stream: TStream); override;
+    procedure SaveToStreamAs(Stream: TStream; AExtension: string);
     constructor Create; override;
     destructor Destroy; override;
 …
     function GetLayerBitmapDirectly(layer: integer): TBGRABitmap; virtual;
     function GetLayerBitmapCopy(layer: integer): TBGRABitmap; virtual; abstract;
     function ComputeFlatImage: TBGRABitmap; overload;
     function ComputeFlatImage(firstLayer, lastLayer: integer): TBGRABitmap; overload;
     function ComputeFlatImage(ARect: TRect): TBGRABitmap; overload;
     function ComputeFlatImage(ARect: TRect; firstLayer, lastLayer: integer): TBGRABitmap; overload;
+    function ComputeFlatImage(ASeparateXorMask: boolean = false): TBGRABitmap; overload;
+    function ComputeFlatImage(firstLayer, lastLayer: integer; ASeparateXorMask: boolean = false): TBGRABitmap; overload;
+    function ComputeFlatImage(ARect: TRect; ASeparateXorMask: boolean = false): TBGRABitmap; overload;
+    function ComputeFlatImage(ARect: TRect; firstLayer, lastLayer: integer; ASeparateXorMask: boolean = false): TBGRABitmap; overload;
     procedure Draw(ACanvas: TCanvas; const Rect: TRect); override; overload;
     procedure Draw(Canvas: TCanvas; x,y: integer); overload;
     procedure Draw(Canvas: TCanvas; x,y: integer; firstLayer, lastLayer: integer); overload;
     procedure Draw(Dest: TBGRABitmap; x,y: integer); overload;
+    procedure Draw(Dest: TBGRABitmap; AX,AY: integer; firstLayer, lastLayer: integer); overload;
+    procedure Draw(Dest: TBGRABitmap; x,y: integer; ASeparateXorMask: boolean); overload;
+    procedure Draw(Dest: TBGRABitmap; AX,AY: integer; firstLayer, lastLayer: integer; ASeparateXorMask: boolean = false); overload;
     procedure FreezeExceptOneLayer(layer: integer); overload;
 …
     procedure Unfreeze(layer: integer); overload;
     procedure Unfreeze(firstLayer, lastLayer: integer); overload;
+    procedure NotifyLoaded; virtual;
+    procedure NotifySaving; virtual;
     property NbLayers: integer read GetNbLayers;
 …
     property LayerFrozen[layer: integer]: boolean read GetLayerFrozen;
     property LayerUniqueId[layer: integer]: integer read GetLayerUniqueId;
+    property LayerOriginal[layer: integer]: TBGRALayerCustomOriginal read GetLayerOriginal;
+    property LayerOriginalKnown[layer: integer]: boolean read GetLayerOriginalKnown;
+    property LayerOriginalGuid[layer: integer]: TGuid read GetLayerOriginalGuid;
+    property LayerOriginalMatrix[layer: integer]: TAffineMatrix read GetLayerOriginalMatrix;
+    property LayerOriginalRenderStatus[layer: integer]: TOriginalRenderStatus read GetLayerOriginalRenderStatus;
     property LinearBlend: boolean read GetLinearBlend write SetLinearBlend; //use linear blending unless specified
     property DefaultBlendingOperation: TBlendOperation read GetDefaultBlendingOperation;
+  end;
+    property MemDirectory: TMemDirectory read GetMemDirectory write SetMemDirectory;
+    property MemDirectoryOwned: boolean read FMemDirectoryOwned write FMemDirectoryOwned;
+    property HasMemFiles: boolean read GetHasMemFiles;
+  end;
+  TEmbeddedOriginalChangeEvent = procedure (ASender: TObject; AOriginal: TBGRALayerCustomOriginal) of object;
+  TEmbeddedOriginalEditingChangeEvent = procedure (ASender: TObject; AOriginal: TBGRALayerCustomOriginal) of object;
   TBGRALayerInfo = record
 …
     Owner: boolean;
     Frozen: boolean;
+    OriginalMatrix: TAffineMatrix;
+    OriginalRenderStatus: TOriginalRenderStatus;
+    OriginalGuid: TGuid;
+    OriginalInvalidatedBounds: TRectF;
   end;
 …
     FNbLayers: integer;
     FLayers: array of TBGRALayerInfo;
+    FOriginalChange: TEmbeddedOriginalChangeEvent;
+    FOriginalEditingChange: TEmbeddedOriginalEditingChangeEvent;
     FWidth,FHeight: integer;
+    FOriginals: TBGRALayerOriginalList;
+    FOriginalEditor: TBGRAOriginalEditor;
+    FOriginalEditorOriginal: TBGRALayerCustomOriginal;
+    FOriginalEditorViewMatrix: TAffineMatrix;
+    function GetOriginalGuid(AIndex: integer): TGUID;
   protected
 …
     function GetLayerName(layer: integer): string; override;
     function GetLayerFrozen(layer: integer): boolean; override;
+    function GetLayerUniqueId(layer: integer): integer; override;
+    function GetLayerOriginal(layer: integer): TBGRALayerCustomOriginal; override;
+    function GetLayerOriginalKnown(layer: integer): boolean; override;
+    function GetLayerOriginalMatrix(layer: integer): TAffineMatrix; override;
+    function GetLayerOriginalGuid(layer: integer): TGuid; override;
+    function GetLayerOriginalRenderStatus(layer: integer): TOriginalRenderStatus; override;
+    function GetOriginalCount: integer; override;
+    function GetOriginalByIndex(AIndex: integer): TBGRALayerCustomOriginal; override;
+    function GetOriginalByIndexKnown(AIndex: integer): boolean; override;
     procedure SetBlendOperation(Layer: integer; op: TBlendOperation);
     procedure SetLayerVisible(layer: integer; AValue: boolean);
 …
     procedure SetLayerName(layer: integer; AValue: string);
     procedure SetLayerFrozen(layer: integer; AValue: boolean); override;
-    function GetLayerUniqueId(layer: integer): integer; override;
     procedure SetLayerUniqueId(layer: integer; AValue: integer);
+    procedure SetLayerOriginalMatrix(layer: integer; AValue: TAffineMatrix);
+    procedure SetLayerOriginalGuid(layer: integer; const AValue: TGuid);
+    procedure SetLayerOriginalRenderStatus(layer: integer; AValue: TOriginalRenderStatus);
+    procedure FindOriginal(AGuid: TGuid;
+                out ADir: TMemDirectory;
+                out AClass: TBGRALayerOriginalAny);
+    procedure StoreOriginal(AOriginal: TBGRALayerCustomOriginal);
+    procedure OriginalChange(ASender: TObject; ABounds: PRectF = nil);
+    procedure OriginalEditingChange(ASender: TObject);
   public
     procedure LoadFromFile(const filenameUTF8: string); override;
     procedure LoadFromStream(stream: TStream); override;
+    procedure LoadFromResource(AFilename: string);
     procedure SetSize(AWidth, AHeight: integer); virtual;
     procedure Clear; override;
+    procedure ClearOriginals;
     procedure RemoveLayer(index: integer);
     procedure InsertLayer(index: integer; fromIndex: integer);
 …
     function MoveLayerUp(index: integer): integer;
     function MoveLayerDown(index: integer): integer;
     function AddLayer(Source: TBGRABitmap; Opacity: byte = 255): integer; overload;
     function AddLayer(Source: TBGRABitmap; Position: TPoint; BlendOp: TBlendOperation; Opacity: byte = 255; Shared: boolean = false): integer; overload;
 …
     function AddOwnedLayer(ABitmap: TBGRABitmap; Position: TPoint; Opacity: byte = 255): integer; overload;
     function AddOwnedLayer(ABitmap: TBGRABitmap; BlendOp: TBlendOperation; Opacity: byte = 255): integer; overload;
+    function AddLayerFromOriginal(AGuid: TGuid; Opacity: byte = 255): integer; overload;
+    function AddLayerFromOriginal(AGuid: TGuid; BlendOp: TBlendOperation; Opacity: byte = 255): integer; overload;
+    function AddLayerFromOriginal(AGuid: TGuid; Matrix: TAffineMatrix; Opacity: byte = 255): integer; overload;
+    function AddLayerFromOriginal(AGuid: TGuid; Matrix: TAffineMatrix; BlendOp: TBlendOperation; Opacity: byte = 255): integer; overload;
+    function AddLayerFromOwnedOriginal(AOriginal: TBGRALayerCustomOriginal; Opacity: byte = 255): integer; overload;
+    function AddLayerFromOwnedOriginal(AOriginal: TBGRALayerCustomOriginal; BlendOp: TBlendOperation; Opacity: byte = 255): integer; overload;
+    function AddLayerFromOwnedOriginal(AOriginal: TBGRALayerCustomOriginal; Matrix: TAffineMatrix; Opacity: byte = 255): integer; overload;
+    function AddLayerFromOwnedOriginal(AOriginal: TBGRALayerCustomOriginal; Matrix: TAffineMatrix; BlendOp: TBlendOperation; Opacity: byte = 255): integer; overload;
+    function AddOriginal(AOriginal: TBGRALayerCustomOriginal; AOwned: boolean = true): integer;
+    function AddOriginalFromStream(AStream: TStream; ALateLoad: boolean = false): integer;
+    function AddOriginalFromStorage(AStorage: TBGRAMemOriginalStorage; ALateLoad: boolean = false): integer;
+    procedure SaveOriginalToStream(AIndex: integer; AStream: TStream); overload;
+    procedure SaveOriginalToStream(AGuid: TGUID; AStream: TStream); overload;
+    function RemoveOriginal(AOriginal: TBGRALayerCustomOriginal): boolean;
+    procedure DeleteOriginal(AIndex: integer);
+    procedure NotifyLoaded; override;
+    procedure NotifySaving; override;
+    procedure RenderLayerFromOriginal(layer: integer; ADraft: boolean = false; AFullSizeLayer: boolean = false); overload;
+    procedure RenderLayerFromOriginal(layer: integer; ADraft: boolean; ARenderBounds: TRect; AFullSizeLayer: boolean = false); overload;
+    procedure RenderLayerFromOriginal(layer: integer; ADraft: boolean; ARenderBoundsF: TRectF; AFullSizeLayer: boolean = false); overload;
+    function RenderOriginalsIfNecessary(ADraft: boolean = false): TRect;
+    procedure RemoveUnusedOriginals;
     destructor Destroy; override;
     constructor Create; override; overload;
     constructor Create(AWidth, AHeight: integer); virtual; overload;
+    constructor Create; overload; override;
+    constructor Create(AWidth, AHeight: integer); overload; virtual;
     function GetLayerBitmapDirectly(layer: integer): TBGRABitmap; override;
     function GetLayerBitmapCopy(layer: integer): TBGRABitmap; override;
 …
     procedure RotateCW;
     procedure RotateCCW;
+    procedure HorizontalFlip;
+    procedure VerticalFlip;
+    procedure HorizontalFlip; overload;
+    procedure HorizontalFlip(ALayerIndex: integer); overload;
+    procedure VerticalFlip; overload;
+    procedure VerticalFlip(ALayerIndex: integer); overload;
     procedure Resample(AWidth, AHeight: integer; AResampleMode: TResampleMode; AFineResampleFilter: TResampleFilter = rfLinear);
     procedure SetLayerBitmap(layer: integer; ABitmap: TBGRABitmap; AOwned: boolean);
+    procedure ApplyLayerOffset(ALayerIndex: integer; APadWithTranparentPixels: boolean);
+    function DrawEditor(ADest: TBGRABitmap; ALayerIndex: integer; X, Y: Integer; APointSize: single): TRect; overload;
+    function DrawEditor(ADest: TBGRABitmap; ALayerIndex: integer; AMatrix: TAffineMatrix; APointSize: single): TRect; overload;
+    function GetEditorBounds(ALayerIndex: integer; X, Y: Integer; APointSize: single): TRect; overload;
+    function GetEditorBounds(ADestRect: TRect; ALayerIndex: integer; X, Y: Integer; APointSize: single): TRect; overload;
+    function GetEditorBounds(ALayerIndex: integer; AMatrix: TAffineMatrix; APointSize: single): TRect; overload;
+    function GetEditorBounds(ADestRect: TRect; ALayerIndex: integer; AMatrix: TAffineMatrix; APointSize: single): TRect; overload;
+    procedure MouseMove(Shift: TShiftState; ImageX, ImageY: Single; out ACursor: TOriginalEditorCursor);
+    procedure MouseDown(RightButton: boolean; Shift: TShiftState; ImageX, ImageY: Single; out ACursor: TOriginalEditorCursor);
+    procedure MouseUp(RightButton: boolean; Shift: TShiftState; ImageX, ImageY: Single; out ACursor: TOriginalEditorCursor);
+    procedure MouseMove(Shift: TShiftState; ImageX, ImageY: Single; out ACursor: TOriginalEditorCursor; out AHandled: boolean);
+    procedure MouseDown(RightButton: boolean; Shift: TShiftState; ImageX, ImageY: Single; out ACursor: TOriginalEditorCursor; out AHandled: boolean);
+    procedure MouseUp(RightButton: boolean; Shift: TShiftState; ImageX, ImageY: Single; out ACursor: TOriginalEditorCursor; out AHandled: boolean);
+    procedure KeyDown(Shift: TShiftState; Key: TSpecialKey; out AHandled: boolean);
+    procedure KeyUp(Shift: TShiftState; Key: TSpecialKey; out AHandled: boolean);
+    procedure KeyPress(UTF8Key: string; out AHandled: boolean);
     property Width : integer read GetWidth;
 …
     property LayerOffset[layer: integer]: TPoint read GetLayerOffset write SetLayerOffset;
     property LayerUniqueId[layer: integer]: integer read GetLayerUniqueId write SetLayerUniqueId;
+  end;
+    property LayerOriginal[layer: integer]: TBGRALayerCustomOriginal read GetLayerOriginal;
+    property LayerOriginalKnown[layer: integer]: boolean read GetLayerOriginalKnown;
+    property LayerOriginalGuid[layer: integer]: TGuid read GetLayerOriginalGuid write SetLayerOriginalGuid;
+    property LayerOriginalMatrix[layer: integer]: TAffineMatrix read GetLayerOriginalMatrix write SetLayerOriginalMatrix;
+    property LayerOriginalRenderStatus[layer: integer]: TOriginalRenderStatus read GetLayerOriginalRenderStatus write SetLayerOriginalRenderStatus;
+    function IndexOfOriginal(AGuid: TGuid): integer; overload; override;
+    function IndexOfOriginal(AOriginal: TBGRALayerCustomOriginal): integer; overload; override;
+    property OriginalCount: integer read GetOriginalCount;
+    property Original[AIndex: integer]: TBGRALayerCustomOriginal read GetOriginalByIndex;
+    property OriginalGuid[AIndex: integer]: TGUID read GetOriginalGuid;
+    property OriginalKnown[AIndex: integer]: boolean read GetOriginalByIndexKnown;
+    property OnOriginalChange: TEmbeddedOriginalChangeEvent read FOriginalChange write FOriginalChange;
+    property OnOriginalEditingChange: TEmbeddedOriginalEditingChangeEvent read FOriginalEditingChange write FOriginalEditingChange;
+    property OriginalEditor: TBGRAOriginalEditor read FOriginalEditor;
+  end;
+  TAffineMatrix = BGRABitmapTypes.TAffineMatrix;
 procedure RegisterLayeredBitmapWriter(AExtensionUTF8: string; AWriter: TBGRALayeredBitmapClass);
 procedure RegisterLayeredBitmapReader(AExtensionUTF8: string; AReader: TBGRACustomLayeredBitmapClass);
+function TryCreateLayeredBitmapWriter(AExtensionUTF8: string): TBGRALayeredBitmap;
+function TryCreateLayeredBitmapReader(AExtensionUTF8: string): TBGRACustomLayeredBitmap;
 var
   LayeredBitmapSaveToStreamProc : TBGRALayeredBitmapSaveToStreamProc;
   LayeredBitmapLoadFromStreamProc : TBGRALayeredBitmapLoadFromStreamProc;
+  LayeredBitmapCheckStreamProc: TBGRALayeredBitmapCheckStreamProc;
 type
 …
 implementation
+uses BGRAUTF8;
+uses BGRAUTF8, BGRABlend, BGRAMultiFileType, math;
+const
+  OriginalsDirectory = 'originals';
 var
 …
   end;
+{ TBGRALayerOriginalEntry }
+class operator TBGRALayerOriginalEntry.=(const AEntry1,
+  AEntry2: TBGRALayerOriginalEntry): boolean;
+begin
+  result := AEntry1.Guid = AEntry2.Guid;
+end;
+function BGRALayerOriginalEntry(AGuid: TGuid): TBGRALayerOriginalEntry;
+begin
+  result.Guid := AGuid;
+  result.Instance := nil;
+end;
+function BGRALayerOriginalEntry(AInstance: TBGRALayerCustomOriginal): TBGRALayerOriginalEntry;
+begin
+  result.Guid := AInstance.Guid;
+  result.Instance := AInstance;
+end;
 { TBGRALayeredBitmap }
 …
 end;
+function TBGRALayeredBitmap.GetLayerOriginal(layer: integer): TBGRALayerCustomOriginal;
+var
+  idxOrig: Integer;
+begin
+  if (layer < 0) or (layer >= NbLayers) then
+    raise Exception.Create('Index out of bounds')
+  else
+  begin
+    if FLayers[layer].OriginalGuid = GUID_NULL then exit(nil);
+    idxOrig := IndexOfOriginal(FLayers[layer].OriginalGuid);
+    if idxOrig = -1 then exit(nil);
+    result := Original[idxOrig];
+  end;
+end;
+function TBGRALayeredBitmap.GetLayerOriginalMatrix(layer: integer
+  ): TAffineMatrix;
+begin
+  if (layer < 0) or (layer >= NbLayers) then
+    raise Exception.Create('Index out of bounds')
+  else
+    result := FLayers[layer].OriginalMatrix;
+end;
+function TBGRALayeredBitmap.GetLayerOriginalGuid(layer: integer): TGuid;
+begin
+  if (layer < 0) or (layer >= NbLayers) then
+    raise Exception.Create('Index out of bounds')
+  else
+    result := FLayers[layer].OriginalGuid;
+end;
+function TBGRALayeredBitmap.GetLayerOriginalRenderStatus(layer: integer
+  ): TOriginalRenderStatus;
+begin
+  if (layer < 0) or (layer >= NbLayers) then
+    raise Exception.Create('Index out of bounds')
+  else
+    result := FLayers[layer].OriginalRenderStatus;
+end;
 procedure TBGRALayeredBitmap.SetLayerUniqueId(layer: integer; AValue: integer);
 var i: integer;
 …
   begin
     for i := 0 to NbLayers-1 do
       if (i <> layer) and (FLayers[layer].UniqueId = AValue) then
+      if (i <> layer) and (FLayers[i].UniqueId = AValue) then
         raise Exception.Create('Another layer has the same identifier');
     FLayers[layer].UniqueId := AValue;
   end;
+end;
+procedure TBGRALayeredBitmap.SetLayerOriginalMatrix(layer: integer;
+  AValue: TAffineMatrix);
+begin
+  if (layer < 0) or (layer >= NbLayers) then
+    raise Exception.Create('Index out of bounds')
+  else
+  begin
+    if FLayers[layer].OriginalMatrix = AValue then exit;
+    FLayers[layer].OriginalMatrix := AValue;
+    if FLayers[layer].OriginalGuid <> GUID_NULL then
+    begin
+      FLayers[layer].OriginalRenderStatus := orsNone;
+      Unfreeze(layer);
+    end;
+  end;
+end;
+procedure TBGRALayeredBitmap.SetLayerOriginalGuid(layer: integer;
+  const AValue: TGuid);
+begin
+  if (layer < 0) or (layer >= NbLayers) then
+    raise Exception.Create('Index out of bounds')
+  else
+  begin
+    if FLayers[layer].OriginalGuid = AValue then exit;
+    FLayers[layer].OriginalGuid := AValue;
+    if (AValue <> GUID_NULL) and (IndexOfOriginal(AValue) <> -1) then
+    begin
+      FLayers[layer].OriginalRenderStatus := orsNone;
+      Unfreeze(layer);
+    end;
+  end;
+end;
+procedure TBGRALayeredBitmap.SetLayerOriginalRenderStatus(layer: integer;
+  AValue: TOriginalRenderStatus);
+begin
+  if (layer < 0) or (layer >= NbLayers) then
+    raise Exception.Create('Index out of bounds')
+  else
+  begin
+    if FLayers[layer].OriginalRenderStatus = AValue then exit;
+    FLayers[layer].OriginalRenderStatus := AValue;
+    Unfreeze(layer);
+  end;
+end;
+procedure TBGRALayeredBitmap.FindOriginal(AGuid: TGuid; out
+  ADir: TMemDirectory; out AClass: TBGRALayerOriginalAny);
+var
+  c: String;
+begin
+  ADir := nil;
+  AClass := nil;
+  if HasMemFiles then
+  begin
+    ADir := MemDirectory.FindPath(OriginalsDirectory+'/'+GUIDToString(AGuid));
+    if ADir <> nil then
+    begin
+      c := ADir.RawStringByFilename['class'];
+      AClass := FindLayerOriginalClass(c);
+    end;
+  end;
+end;
+procedure TBGRALayeredBitmap.StoreOriginal(AOriginal: TBGRALayerCustomOriginal);
+var
+  dir, subdir: TMemDirectory;
+  storage: TBGRAMemOriginalStorage;
+begin
+  if AOriginal.Guid = GUID_NULL then raise exception.Create('Original GUID undefined');
+  dir := MemDirectory.Directory[MemDirectory.AddDirectory(OriginalsDirectory)];
+  subdir := dir.Directory[dir.AddDirectory(GUIDToString(AOriginal.Guid))];
+  storage := TBGRAMemOriginalStorage.Create(subdir);
+  try
+    AOriginal.SaveToStorage(storage);
+    storage.RawString['class'] := AOriginal.StorageClassName;
+  finally
+    storage.Free;
+  end;
+end;
+procedure TBGRALayeredBitmap.OriginalChange(ASender: TObject; ABounds: PRectF);
+var
+  i: Integer;
+  orig: TBGRALayerCustomOriginal;
+  transfBounds: TRectF;
+begin
+  orig := TBGRALayerCustomOriginal(ASender);
+  if not (Assigned(ABounds) and IsEmptyRectF(ABounds^)) then
+  begin
+    for i := 0 to NbLayers-1 do
+      if LayerOriginalGuid[i] = orig.Guid then
+      begin
+        if ABounds = nil then
+          LayerOriginalRenderStatus[i] := orsNone
+        else
+        begin
+          transfBounds := (LayerOriginalMatrix[i]*TAffineBox.AffineBox(ABounds^)).RectBoundsF;
+          case LayerOriginalRenderStatus[i] of
+          orsDraft: begin
+                      LayerOriginalRenderStatus[i] := orsPartialDraft;
+                      FLayers[i].OriginalInvalidatedBounds := transfBounds;
+                    end;
+          orsProof: begin
+                      LayerOriginalRenderStatus[i] := orsPartialProof;
+                      FLayers[i].OriginalInvalidatedBounds := transfBounds;
+                    end;
+          orsPartialDraft: FLayers[i].OriginalInvalidatedBounds :=
+                             FLayers[i].OriginalInvalidatedBounds.Union(transfBounds, true);
+          orsPartialProof: FLayers[i].OriginalInvalidatedBounds :=
+                             FLayers[i].OriginalInvalidatedBounds.Union(transfBounds, true);
+          end;
+        end;
+      end;
+  end;
+  if Assigned(FOriginalChange) then
+    FOriginalChange(self, orig);
+end;
+procedure TBGRALayeredBitmap.OriginalEditingChange(ASender: TObject);
+var
+  orig: TBGRALayerCustomOriginal;
+begin
+  orig := TBGRALayerCustomOriginal(ASender);
+  if Assigned(FOriginalEditingChange) then
+    FOriginalEditingChange(self, orig);
+end;
+function TBGRALayeredBitmap.GetOriginalCount: integer;
+begin
+  if Assigned(FOriginals) then
+    result := FOriginals.Count
+  else
+    result := 0;
+end;
+function TBGRALayeredBitmap.GetOriginalByIndex(AIndex: integer
+  ): TBGRALayerCustomOriginal;
+var
+  dir: TMemDirectory;
+  c: TBGRALayerOriginalAny;
+  guid: TGuid;
+  storage: TBGRAMemOriginalStorage;
+begin
+  if (AIndex < 0) or (AIndex >= OriginalCount) then
+    raise ERangeError.Create('Index out of bounds');
+  result := FOriginals[AIndex].Instance;
+  guid := FOriginals[AIndex].Guid;
+  // load original on the fly
+  if (result = nil) and (guid <> GUID_NULL) then
+  begin
+    FindOriginal(guid, dir, c);
+    if not Assigned(dir) then
+      raise exception.Create('Original directory not found');
+    if not Assigned(c) then
+      raise exception.Create('Original class not found (it can be registered with the RegisterLayerOriginal function)');
+    result := c.Create;
+    result.Guid := guid;
+    storage := TBGRAMemOriginalStorage.Create(dir);
+    try
+      result.LoadFromStorage(storage);
+    finally
+      storage.Free;
+    end;
+    FOriginals[AIndex] := BGRALayerOriginalEntry(result);
+    result.OnChange:= @OriginalChange;
+    result.OnEditingChange:= @OriginalEditingChange;
+  end;
+end;
+function TBGRALayeredBitmap.GetLayerOriginalKnown(layer: integer): boolean;
+var
+  idxOrig: Integer;
+begin
+  if (layer < 0) or (layer >= NbLayers) then
+    raise Exception.Create('Index out of bounds')
+  else
+  begin
+    if FLayers[layer].OriginalGuid = GUID_NULL then exit(true);
+    idxOrig := IndexOfOriginal(FLayers[layer].OriginalGuid);
+    if idxOrig = -1 then exit(false);
+    result := OriginalKnown[idxOrig];
+  end;
+end;
+function TBGRALayeredBitmap.GetOriginalByIndexKnown(AIndex: integer): boolean;
+var
+  dir: TMemDirectory;
+  c: TBGRALayerOriginalAny;
+  guid: TGuid;
+begin
+  if (AIndex < 0) or (AIndex >= OriginalCount) then
+    raise ERangeError.Create('Index out of bounds');
+  if Assigned(FOriginals[AIndex].Instance) then exit(true);
+  guid := FOriginals[AIndex].Guid;
+  if guid = GUID_NULL then exit(true);
+  FindOriginal(guid, dir, c);
+  result:= Assigned(dir) and Assigned(c);
+end;
+function TBGRALayeredBitmap.GetOriginalGuid(AIndex: integer): TGUID;
+begin
+  if (AIndex < 0) or (AIndex >= OriginalCount) then
+    raise ERangeError.Create('Index out of bounds');
+  result := FOriginals[AIndex].Guid;
 end;
 …
       (FLayers[layer].y <> AValue.y) then
     begin
+      if FLayers[layer].OriginalGuid <> GUID_NULL then
+        raise exception.Create('The offset of the layer is computed from an original. You can change it by changing the layer original matrix.');
       FLayers[layer].x := AValue.x;
       FLayers[layer].y := AValue.y;
 …
 end;
+function TBGRALayeredBitmap.GetLayerBitmapDirectly(layer: integer
+  ): TBGRABitmap;
+function TBGRALayeredBitmap.GetLayerBitmapDirectly(layer: integer): TBGRABitmap;
 begin
   if (layer < 0) or (layer >= NbLayers) then
     result := nil
   else
+  begin
+    if FLayers[layer].OriginalRenderStatus = orsNone then
+      RenderLayerFromOriginal(layer, true)
+    else if FLayers[layer].OriginalRenderStatus in [orsPartialDraft,orsPartialProof] then
+      RenderLayerFromOriginal(layer, true, FLayers[layer].OriginalInvalidatedBounds);
     Result:= FLayers[layer].Source;
+  end;
 end;
 procedure TBGRALayeredBitmap.LoadFromFile(const filenameUTF8: string);
 var bmp: TBGRABitmap;
-    index: integer;
     ext: string;
     temp: TBGRACustomLayeredBitmap;
     i: integer;
+    stream: TFileStreamUTF8;
 begin
   ext := UTF8LowerCase(ExtractFileExt(filenameUTF8));
 …
     end;
+  bmp := TBGRABitmap.Create(filenameUTF8, True);
+  Clear;
+  SetSize(bmp.Width,bmp.Height);
+  index := AddSharedLayer(bmp);
+  FLayers[index].Owner:= true;
+  //when using "data" extension, simply deserialize
+  if (ext='.dat') or (ext='.data') then
+  begin
+    if Assigned(LayeredBitmapLoadFromStreamProc) then
+    begin
+      stream := TFileStreamUTF8.Create(filenameUTF8, fmOpenRead, fmShareDenyWrite);
+      try
+        LayeredBitmapLoadFromStreamProc(stream, self);
+      finally
+        stream.Free;
+      end;
+    end else
+      raise exception.Create('Enable layer deserialization by calling BGRAStreamLayers.RegisterStreamLayers');
+  end else
+  begin
+    bmp := TBGRABitmap.Create(filenameUTF8, True);
+    Clear;
+    SetSize(bmp.Width,bmp.Height);
+    AddOwnedLayer(bmp);
+  end;
 end;
 procedure TBGRALayeredBitmap.LoadFromStream(stream: TStream);
 var bmp: TBGRABitmap;
-   index: integer;
-   temp: TBGRALayeredBitmap;
 begin
   if Assigned(LayeredBitmapLoadFromStreamProc) then
   begin
+    temp := LayeredBitmapLoadFromStreamProc(Stream);
+    if temp <> nil then
+    begin
+      Assign(temp);
+      temp.Free;
+    if not Assigned(LayeredBitmapCheckStreamProc) or
+      LayeredBitmapCheckStreamProc(stream) then
+    begin
+      LayeredBitmapLoadFromStreamProc(Stream, self);
       exit;
     end;
   end;
   bmp := TBGRABitmap.Create(stream);
   Clear;
   SetSize(bmp.Width,bmp.Height);
+  index := AddSharedLayer(bmp);
+  FLayers[index].Owner:= true;
+  AddOwnedLayer(bmp);
+end;
+procedure TBGRALayeredBitmap.LoadFromResource(AFilename: string);
+var
+  stream: TStream;
+begin
+  stream := BGRAResource.GetResourceStream(AFilename);
+  try
+    LoadFromStream(stream);
+  finally
+    stream.Free;
+  end;
 end;
 …
   for i := NbLayers-1 downto 0 do
     RemoveLayer(i);
+  MemDirectory := nil;
+  ClearOriginals;
+end;
+procedure TBGRALayeredBitmap.ClearOriginals;
+var
+  i: Integer;
+begin
+  if Assigned(FOriginals) then
+  begin
+    for i := 0 to OriginalCount-1 do
+      FOriginals[i].Instance.Free;
+    FreeAndNil(FOriginals);
+  end;
 end;
 …
 procedure TBGRALayeredBitmap.Assign(ASource: TBGRACustomLayeredBitmap; ASharedLayerIds: boolean);
+var i,idx: integer;
+begin
+var i,idx,idxOrig,idxNewOrig: integer;
+    usedOriginals: array of record
+       used: boolean;
+       sourceGuid,newGuid: TGuid;
+    end;
+    orig: TBGRALayerCustomOriginal;
+    stream: TMemoryStream;
+begin
+  if ASource = nil then
+    raise exception.Create('Unexpected nil reference');
   Clear;
   SetSize(ASource.Width,ASource.Height);
   LinearBlend:= ASource.LinearBlend;
+  setlength(usedOriginals, ASource.GetOriginalCount);
+  for idxOrig := 0 to high(usedOriginals) do
+  with usedOriginals[idxOrig] do
+  begin
+    used:= false;
+    newGuid := GUID_NULL;
+  end;
+  for i := 0 to ASource.NbLayers-1 do
+  if (ASource.LayerOriginalGuid[i]<>GUID_NULL) and
+     (ASource.LayerOriginalKnown[i] or (ASource is TBGRALayeredBitmap)) then
+  begin
+    idxOrig := ASource.IndexOfOriginal(ASource.LayerOriginalGuid[i]);
+    if not usedOriginals[idxOrig].used then
+    begin
+      if ASource.LayerOriginalKnown[i] then
+      begin
+        orig := ASource.GetOriginalByIndex(idxOrig);
+        idxNewOrig := AddOriginal(orig, false);
+        usedOriginals[idxOrig].sourceGuid := orig.Guid;
+      end else
+      begin
+        stream := TMemoryStream.Create;
+        (ASource as TBGRALayeredBitmap).SaveOriginalToStream(idxOrig, stream);
+        stream.Position:= 0;
+        idxNewOrig := AddOriginalFromStream(stream,true);
+        stream.Free;
+        usedOriginals[idxOrig].sourceGuid := (ASource as TBGRALayeredBitmap).OriginalGuid[idxOrig];
+      end;
+      usedOriginals[idxOrig].newGuid := OriginalGuid[idxNewOrig];
+      usedOriginals[idxOrig].used := true;
+    end;
+  end;
   for i := 0 to ASource.NbLayers-1 do
   begin
 …
     LayerVisible[idx] := ASource.LayerVisible[i];
     if ASharedLayerIds and (ASource is TBGRALayeredBitmap) then
+      LayerUniqueId[idx] := TBGRALayeredBitmap(ASource).LayerUniqueId[idx];
+      LayerUniqueId[idx] := TBGRALayeredBitmap(ASource).LayerUniqueId[i];
+    for idxOrig := 0 to high(usedOriginals) do
+      if usedOriginals[i].sourceGuid = ASource.LayerOriginalGuid[i] then
+      begin
+        LayerOriginalGuid[idx] := usedOriginals[i].newGuid;
+        LayerOriginalMatrix[idx] := ASource.LayerOriginalMatrix[i];
+        LayerOriginalRenderStatus[idx] := ASource.LayerOriginalRenderStatus[i];
+      end;
   end;
 end;
 …
   FLayers[FNbLayers].Frozen := false;
   FLayers[FNbLayers].UniqueId := ProduceLayerUniqueId;
+  FLayers[FNbLayers].OriginalMatrix := AffineMatrixIdentity;
+  FLayers[FNbLayers].OriginalRenderStatus := orsNone;
+  FLayers[FNbLayers].OriginalGuid := GUID_NULL;
   if Shared then
   begin
 …
 end;
+function TBGRALayeredBitmap.AddLayerFromOriginal(AGuid: TGuid;
+  Opacity: byte): integer;
+begin
+  result := AddLayerFromOriginal(AGuid, DefaultBlendingOperation, Opacity);
+end;
+function TBGRALayeredBitmap.AddLayerFromOriginal(AGuid: TGuid;
+  BlendOp: TBlendOperation; Opacity: byte): integer;
+begin
+  result := AddLayerFromOriginal(AGuid, AffineMatrixIdentity, BlendOp, Opacity);
+end;
+function TBGRALayeredBitmap.AddLayerFromOriginal(AGuid: TGuid;
+  Matrix: TAffineMatrix; Opacity: byte): integer;
+begin
+  result := AddLayerFromOriginal(AGuid, Matrix, DefaultBlendingOperation, Opacity);
+end;
+function TBGRALayeredBitmap.AddLayerFromOriginal(AGuid: TGuid;
+  Matrix: TAffineMatrix; BlendOp: TBlendOperation; Opacity: byte): integer;
+begin
+  result := AddOwnedLayer(TBGRABitmap.Create, BlendOp, Opacity);
+  LayerOriginalGuid[result] := AGuid;
+  LayerOriginalMatrix[result] := Matrix;
+  if not Assigned(LayerOriginal[result]) then
+    raise exception.Create('Original data or class not found');
+end;
+function TBGRALayeredBitmap.AddLayerFromOwnedOriginal(
+  AOriginal: TBGRALayerCustomOriginal; Opacity: byte): integer;
+begin
+  if IndexOfOriginal(AOriginal) = -1 then AddOriginal(AOriginal);
+  result := AddLayerFromOriginal(AOriginal.Guid, Opacity);
+end;
+function TBGRALayeredBitmap.AddLayerFromOwnedOriginal(
+  AOriginal: TBGRALayerCustomOriginal; BlendOp: TBlendOperation; Opacity: byte): integer;
+begin
+  if IndexOfOriginal(AOriginal) = -1 then AddOriginal(AOriginal);
+  result := AddLayerFromOriginal(AOriginal.Guid, BlendOp, Opacity);
+end;
+function TBGRALayeredBitmap.AddLayerFromOwnedOriginal(
+  AOriginal: TBGRALayerCustomOriginal; Matrix: TAffineMatrix; Opacity: byte): integer;
+begin
+  if IndexOfOriginal(AOriginal) = -1 then AddOriginal(AOriginal);
+  result := AddLayerFromOriginal(AOriginal.Guid, Matrix, Opacity);
+end;
+function TBGRALayeredBitmap.AddLayerFromOwnedOriginal(
+  AOriginal: TBGRALayerCustomOriginal; Matrix: TAffineMatrix;
+  BlendOp: TBlendOperation; Opacity: byte): integer;
+begin
+  if IndexOfOriginal(AOriginal) = -1 then AddOriginal(AOriginal);
+  result := AddLayerFromOriginal(AOriginal.Guid, Matrix, BlendOp, Opacity);
+end;
+function TBGRALayeredBitmap.AddOriginal(AOriginal: TBGRALayerCustomOriginal; AOwned: boolean): integer;
+var
+  newGuid: TGuid;
+begin
+  if AOriginal = nil then
+    raise exception.Create('Unexpected nil reference');;
+  if AOriginal.Guid = GUID_NULL then
+  begin
+    if CreateGUID(newGuid)<> 0 then
+    begin
+      if AOwned then AOriginal.Free;
+      raise exception.Create('Error while creating GUID');
+    end;
+    AOriginal.Guid := newGuid;
+  end else
+  begin
+    if IndexOfOriginal(AOriginal) <> -1 then
+    begin
+      if AOwned then AOriginal.Free;
+      raise exception.Create('Original already added');
+    end;
+    if IndexOfOriginal(AOriginal.Guid) <> -1 then
+    begin
+      if AOwned then AOriginal.Free;
+      raise exception.Create('GUID is already in use');
+    end;
+  end;
+  StoreOriginal(AOriginal);
+  if FOriginals = nil then FOriginals := TBGRALayerOriginalList.Create;
+  if AOwned then
+  begin
+    result := FOriginals.Add(BGRALayerOriginalEntry(AOriginal));
+    AOriginal.OnChange:= @OriginalChange;
+    AOriginal.OnEditingChange:= @OriginalEditingChange;
+  end
+  else
+    result := FOriginals.Add(BGRALayerOriginalEntry(AOriginal.Guid));
+end;
+function TBGRALayeredBitmap.AddOriginalFromStream(AStream: TStream;
+  ALateLoad: boolean): integer;
+var
+  storage: TBGRAMemOriginalStorage;
+begin
+  storage:= TBGRAMemOriginalStorage.Create;
+  storage.LoadFromStream(AStream);
+  try
+    result := AddOriginalFromStorage(storage, ALateLoad);
+  finally
+    storage.Free;
+  end;
+end;
+function TBGRALayeredBitmap.AddOriginalFromStorage(AStorage: TBGRAMemOriginalStorage; ALateLoad: boolean): integer;
+var
+  origClassName: String;
+  origClass: TBGRALayerOriginalAny;
+  orig: TBGRALayerCustomOriginal;
+  newGuid: TGuid;
+  dir, subdir: TMemDirectory;
+begin
+  result := -1;
+  origClassName := AStorage.RawString['class'];
+  if origClassName = '' then raise Exception.Create('Original class name not defined');
+  if ALateLoad then
+  begin
+    if CreateGUID(newGuid)<> 0 then
+      raise exception.Create('Error while creating GUID');
+    if IndexOfOriginal(newGuid)<>-1 then
+      raise exception.Create('Duplicate GUID');
+    dir := MemDirectory.Directory[MemDirectory.AddDirectory(OriginalsDirectory)];
+    subdir := dir.Directory[dir.AddDirectory(GUIDToString(newGuid))];
+    AStorage.CopyTo(subdir);
+    if FOriginals = nil then FOriginals := TBGRALayerOriginalList.Create;
+    result := FOriginals.Add(BGRALayerOriginalEntry(newGuid));
+  end else
+  begin
+    origClass := FindLayerOriginalClass(origClassName);
+    if origClass = nil then raise exception.Create('Original class not found (it can be registered with the RegisterLayerOriginal function)');
+    orig := origClass.Create;
+    try
+      orig.LoadFromStorage(AStorage);
+      result := AddOriginal(orig, true);
+    except on ex:exception do
+      begin
+        orig.Free;
+        raise exception.Create('Error loading original. '+ ex.Message);
+      end;
+    end;
+  end;
+end;
+procedure TBGRALayeredBitmap.SaveOriginalToStream(AIndex: integer;
+  AStream: TStream);
+var
+  dir: TMemDirectory;
+  c: TBGRALayerOriginalAny;
+begin
+  if (AIndex < 0) or (AIndex >= OriginalCount) then
+    raise ERangeError.Create('Index out of bounds');
+  if Assigned(FOriginals[AIndex].Instance) then
+    FOriginals[AIndex].Instance.SaveToStream(AStream)
+  else
+  begin
+    FindOriginal(FOriginals[AIndex].Guid, dir, c);
+    if dir = nil then
+      raise exception.Create('Originals directory not found');
+    dir.SaveToStream(AStream);
+  end;
+end;
+procedure TBGRALayeredBitmap.SaveOriginalToStream(AGuid: TGUID; AStream: TStream);
+var
+  idxOrig: Integer;
+begin
+  idxOrig := IndexOfOriginal(AGuid);
+  if idxOrig = -1 then raise exception.Create('Original not found');
+  SaveOriginalToStream(idxOrig, AStream);
+end;
+function TBGRALayeredBitmap.RemoveOriginal(AOriginal: TBGRALayerCustomOriginal): boolean;
+var
+  idx: Integer;
+begin
+  idx := IndexOfOriginal(AOriginal);
+  if idx = -1 then exit(false);
+  DeleteOriginal(idx);
+  result := true;
+end;
+procedure TBGRALayeredBitmap.DeleteOriginal(AIndex: integer);
+var
+  dir: TMemDirectory;
+  i: Integer;
+  guid: TGuid;
+begin
+  if (AIndex < 0) or (AIndex >= OriginalCount) then
+    raise ERangeError.Create('Index out of bounds');
+  guid := FOriginals[AIndex].Guid;
+  for i := 0 to NbLayers-1 do
+    if LayerOriginalGuid[i] = guid then
+    begin
+      LayerOriginalGuid[i] := GUID_NULL;
+      LayerOriginalMatrix[i] := AffineMatrixIdentity;
+    end;
+  dir := MemDirectory.Directory[MemDirectory.AddDirectory(OriginalsDirectory)];
+  dir.Delete(GUIDToString(guid),'');
+  FOriginals[AIndex].Instance.Free;
+  FOriginals.Delete(AIndex); //AOriginals freed
+end;
+procedure TBGRALayeredBitmap.NotifyLoaded;
+var
+  foundGuid: array of TGuid;
+  nbFoundGuid: integer;
+  procedure AddGuid(const AGuid: TGuid);
+  begin
+    foundGuid[nbFoundGuid] := AGuid;
+    inc(nbFoundGuid);
+  end;
+  function IndexOfGuid(AGuid: TGuid): integer;
+  var
+    i: Integer;
+  begin
+    for i := 0 to nbFoundGuid-1 do
+      if foundGuid[i] = AGuid then exit(i);
+    result := -1;
+  end;
+var
+  i: Integer;
+  dir: TMemDirectory;
+  newGuid: TGUID;
+begin
+  inherited NotifyLoaded;
+  //if there are no files in memory, we are sure that there are no originals
+  if not HasMemFiles then
+  begin
+    ClearOriginals;
+    exit;
+  end;
+  //determine list of GUID of originals
+  dir := MemDirectory.Directory[MemDirectory.AddDirectory(OriginalsDirectory)];
+  setlength(foundGuid, dir.Count);
+  nbFoundGuid:= 0;
+  for i := 0 to dir.Count-1 do
+    if dir.IsDirectory[i] and (dir.Entry[i].Extension = '') then
+    begin
+      if TryStringToGUID(dir.Entry[i].Name, newGuid) then
+        AddGuid(newGuid);
+    end;
+  //remove originals that do not exist anymore
+  for i := OriginalCount-1 downto 0 do
+    if IndexOfGuid(FOriginals[i].Guid) = -1 then
+      DeleteOriginal(i);
+  //add originals from memory directory
+  for i := 0 to nbFoundGuid-1 do
+  begin
+    if IndexOfOriginal(foundGuid[i]) = -1 then
+    begin
+      if FOriginals = nil then FOriginals := TBGRALayerOriginalList.Create;
+      FOriginals.Add(BGRALayerOriginalEntry(foundGuid[i]));
+    end;
+  end;
+end;
+procedure TBGRALayeredBitmap.NotifySaving;
+var
+  i: Integer;
+begin
+  inherited NotifySaving;
+  RenderOriginalsIfNecessary;
+  for i := 0 to OriginalCount-1 do
+    if Assigned(FOriginals[i].Instance) then
+      StoreOriginal(FOriginals[i].Instance);
+end;
+procedure TBGRALayeredBitmap.RenderLayerFromOriginal(layer: integer;
+  ADraft: boolean; AFullSizeLayer: boolean = false);
+begin
+  RenderLayerFromOriginal(layer, ADraft, rectF(0,0,Width,Height), AFullSizeLayer);
+end;
+procedure TBGRALayeredBitmap.RenderLayerFromOriginal(layer: integer;
+  ADraft: boolean; ARenderBounds: TRect; AFullSizeLayer: boolean = false);
+var
+  orig: TBGRALayerCustomOriginal;
+  rAll, rNewBounds, rInterRender: TRect;
+  newSource: TBGRABitmap;
+  procedure FreeSource;
+  begin
+    if FLayers[layer].Owner then
+      FreeAndNil(FLayers[layer].Source)
+    else
+      FLayers[layer].Source := nil;
+  end;
+begin
+  if (layer < 0) or (layer >= NbLayers) then
+    raise Exception.Create('Index out of bounds');
+  orig := LayerOriginal[layer];
+  if Assigned(orig) then
+  begin
+    rAll := rect(0,0,Width,Height);
+    if AFullSizeLayer then
+      rNewBounds := rAll
+    else
+    begin
+      rNewBounds := orig.GetRenderBounds(rAll,FLayers[layer].OriginalMatrix);
+      IntersectRect({%H-}rNewBounds, rNewBounds, rAll);
+    end;
+    IntersectRect({%H-}rInterRender, ARenderBounds, rNewBounds);
+    if (FLayers[layer].x = rNewBounds.Left) and
+      (FLayers[layer].y = rNewBounds.Top) and
+      (FLayers[layer].Source.Width = rNewBounds.Width) and
+      (FLayers[layer].Source.Height = rNewBounds.Height) then
+    begin
+      OffsetRect(rInterRender, -rNewBounds.Left, -rNewBounds.Top);
+      FLayers[layer].Source.FillRect(rInterRender, BGRAPixelTransparent, dmSet);
+      FLayers[layer].Source.ClipRect := rInterRender;
+      orig.Render(FLayers[layer].Source, AffineMatrixTranslation(-rNewBounds.Left,-rNewBounds.Top)*FLayers[layer].OriginalMatrix, ADraft);
+      FLayers[layer].Source.NoClip;
+    end else
+    begin
+      if rInterRender = rNewBounds then
+      begin
+        FreeSource;
+        newSource := TBGRABitmap.Create(rNewBounds.Width,rNewBounds.Height);
+        orig.Render(newSource, AffineMatrixTranslation(-rNewBounds.Left,-rNewBounds.Top)*FLayers[layer].OriginalMatrix, ADraft);
+      end else
+      begin
+        newSource := TBGRABitmap.Create(rNewBounds.Width,rNewBounds.Height);
+        newSource.PutImage(FLayers[layer].x - rNewBounds.Left, FLayers[layer].y - rNewBounds.Top, FLayers[layer].Source, dmSet);
+        FreeSource;
+        OffsetRect(rInterRender, -rNewBounds.Left, -rNewBounds.Top);
+        if not IsRectEmpty(rInterRender) then
+        begin
+          newSource.FillRect(rInterRender, BGRAPixelTransparent, dmSet);
+          newSource.ClipRect := rInterRender;
+          orig.Render(newSource, AffineMatrixTranslation(-rNewBounds.Left,-rNewBounds.Top)*FLayers[layer].OriginalMatrix, ADraft);
+          newSource.NoClip;
+        end;
+      end;
+      FLayers[layer].Source := newSource;
+      FLayers[layer].x := rNewBounds.Left;
+      FLayers[layer].y := rNewBounds.Top;
+    end;
+  end;
+  if ADraft then
+    FLayers[layer].OriginalRenderStatus := orsDraft
+  else
+    FLayers[layer].OriginalRenderStatus := orsProof;
+  FLayers[layer].OriginalInvalidatedBounds := EmptyRectF;
+end;
+procedure TBGRALayeredBitmap.RenderLayerFromOriginal(layer: integer;
+  ADraft: boolean; ARenderBoundsF: TRectF; AFullSizeLayer: boolean = false);
+var
+  r: TRect;
+begin
+  with ARenderBoundsF do
+    r := Rect(floor(Left),floor(Top),ceil(Right),ceil(Bottom));
+  RenderLayerFromOriginal(layer, ADraft, r, AFullSizeLayer);
+end;
+function TBGRALayeredBitmap.RenderOriginalsIfNecessary(ADraft: boolean): TRect;
+  procedure UnionLayerArea(ALayer: integer);
+  var
+    r: TRect;
+  begin
+    if (FLayers[ALayer].Source = nil) or
+      (FLayers[ALayer].Source.Width = 0) or
+      (FLayers[ALayer].Source.Height = 0) then exit;
+    r := RectWithSize(LayerOffset[ALayer].X, LayerOffset[ALayer].Y,
+                      FLayers[ALayer].Source.Width, FLayers[ALayer].Source.Height);
+    if IsRectEmpty(result) then result := r else
+      UnionRect(result,result,r);
+  end;
+var
+  i: Integer;
+  r: TRect;
+begin
+  result:= EmptyRect;
+  for i := 0 to NbLayers-1 do
+    case LayerOriginalRenderStatus[i] of
+    orsNone:
+         begin
+           UnionLayerArea(i);
+           RenderLayerFromOriginal(i, ADraft);
+           UnionLayerArea(i);
+         end;
+    orsDraft: if not ADraft then
+         begin
+           UnionLayerArea(i);
+           RenderLayerFromOriginal(i, ADraft);
+           UnionLayerArea(i);
+         end;
+    orsPartialDraft,orsPartialProof:
+         if not ADraft and (LayerOriginalRenderStatus[i] = orsPartialDraft) then
+         begin
+           UnionLayerArea(i);
+           RenderLayerFromOriginal(i, ADraft, rect(0,0,Width,Height), true);
+           UnionLayerArea(i);
+         end
+         else
+         begin
+           with FLayers[i].OriginalInvalidatedBounds do
+             r := Rect(floor(Left),floor(Top),ceil(Right),ceil(Bottom));
+           RenderLayerFromOriginal(i, ADraft, r, true);
+           if not IsRectEmpty(r) then
+           begin
+             if IsRectEmpty(result) then
+               result := r
+             else
+               UnionRect(result, result, r);
+           end;
+         end;
+    end;
+end;
+procedure TBGRALayeredBitmap.RemoveUnusedOriginals;
+var useCount: array of integer;
+  i, idxOrig: Integer;
+begin
+  if OriginalCount = 0 then exit;
+  setlength(useCount, OriginalCount);
+  for i := 0 to NbLayers-1 do
+  begin
+    idxOrig := IndexOfOriginal(LayerOriginalGuid[i]);
+    if idxOrig <> -1 then useCount[idxOrig] += 1;
+  end;
+  for i := high(useCount) downto 0 do
+    if useCount[i] = 0 then DeleteOriginal(i);
+end;
 destructor TBGRALayeredBitmap.Destroy;
 begin
+  FOriginalEditor.Free;
   inherited Destroy;
 end;
 …
   FHeight := 0;
   FNbLayers:= 0;
+  FOriginals := nil;
 end;
 …
 procedure TBGRALayeredBitmap.RotateCW;
 var i: integer;
+  newBmp: TBGRABitmap;
+  newOfs: TPointF;
+  m: TAffineMatrix;
 begin
   SetSize(Height,Width); //unfreeze
+  m := AffineMatrixTranslation(Width,0)*AffineMatrixRotationDeg(90);
   for i := 0 to NbLayers-1 do
+    SetLayerBitmap(i, LayerBitmap[i].RotateCW as TBGRABitmap, True);
+  begin
+    newOfs:= m*PointF(FLayers[i].x,FLayers[i].y+FLayers[i].Source.Height);
+    newBmp := FLayers[i].Source.RotateCW as TBGRABitmap;
+    if FLayers[i].Owner then FreeAndNil(FLayers[i].Source);
+    FLayers[i].Source := newBmp;
+    FLayers[i].Owner := true;
+    FLayers[i].x := round(newOfs.x);
+    FLayers[i].y := round(newOfs.y);
+    FLayers[i].OriginalMatrix := m*FLayers[i].OriginalMatrix;
+  end;
 end;
 procedure TBGRALayeredBitmap.RotateCCW;
 var i: integer;
+  newBmp: TBGRABitmap;
+  newOfs: TPointF;
+  m: TAffineMatrix;
 begin
   SetSize(Height,Width); //unfreeze
+  m := AffineMatrixTranslation(0,Height)*AffineMatrixRotationDeg(-90);
   for i := 0 to NbLayers-1 do
+    SetLayerBitmap(i, LayerBitmap[i].RotateCCW as TBGRABitmap, True);
+  begin
+    newOfs:= m*PointF(FLayers[i].x+FLayers[i].Source.Width,FLayers[i].y);
+    newBmp := FLayers[i].Source.RotateCCW as TBGRABitmap;
+    if FLayers[i].Owner then FreeAndNil(FLayers[i].Source);
+    FLayers[i].Source := newBmp;
+    FLayers[i].Owner := true;
+    FLayers[i].x := round(newOfs.x);
+    FLayers[i].y := round(newOfs.y);
+    FLayers[i].OriginalMatrix := m*FLayers[i].OriginalMatrix;
+  end;
 end;
 …
   Unfreeze;
   for i := 0 to NbLayers-1 do
+  begin
+    if FLayers[i].Owner then
+      FLayers[i].Source.HorizontalFlip
+    else
+    begin
+      FLayers[i].Source := FLayers[i].Source.Duplicate(True) as TBGRABitmap;
+      FLayers[i].Source.HorizontalFlip;
+      FLayers[i].Owner := true;
+    end;
+  end;
+    HorizontalFlip(i);
+end;
+procedure TBGRALayeredBitmap.HorizontalFlip(ALayerIndex: integer);
+begin
+  if (ALayerIndex < 0) or (ALayerIndex >= NbLayers) then
+    raise ERangeError.Create('Index out of bounds');
+  Unfreeze(ALayerIndex);
+  if FLayers[ALayerIndex].Owner then
+    FLayers[ALayerIndex].Source.HorizontalFlip
+  else
+  begin
+    FLayers[ALayerIndex].Source := FLayers[ALayerIndex].Source.Duplicate(True) as TBGRABitmap;
+    FLayers[ALayerIndex].Source.HorizontalFlip;
+    FLayers[ALayerIndex].Owner := true;
+  end;
+  FLayers[ALayerIndex].x := Width-FLayers[ALayerIndex].x-FLayers[ALayerIndex].Source.Width;
+  FLayers[ALayerIndex].OriginalMatrix := AffineMatrixTranslation(+Width/2,0)*AffineMatrixScale(-1,1)*AffineMatrixTranslation(-Width/2,0)*FLayers[ALayerIndex].OriginalMatrix;
 end;
 …
   Unfreeze;
   for i := 0 to NbLayers-1 do
+  begin
+    if FLayers[i].Owner then
+      FLayers[i].Source.VerticalFlip
+    else
+    begin
+      FLayers[i].Source := FLayers[i].Source.Duplicate(True) as TBGRABitmap;
+      FLayers[i].Source.VerticalFlip;
+      FLayers[i].Owner := true;
+    end;
+  end;
+    VerticalFlip(i);
+end;
+procedure TBGRALayeredBitmap.VerticalFlip(ALayerIndex: integer);
+begin
+  if (ALayerIndex < 0) or (ALayerIndex >= NbLayers) then
+    raise ERangeError.Create('Index out of bounds');
+  Unfreeze(ALayerIndex);
+  if FLayers[ALayerIndex].Owner then
+    FLayers[ALayerIndex].Source.VerticalFlip
+  else
+  begin
+    FLayers[ALayerIndex].Source := FLayers[ALayerIndex].Source.Duplicate(True) as TBGRABitmap;
+    FLayers[ALayerIndex].Source.VerticalFlip;
+    FLayers[ALayerIndex].Owner := true;
+  end;
+  FLayers[ALayerIndex].y := Height-FLayers[ALayerIndex].y-FLayers[ALayerIndex].Source.Height;
+  FLayers[ALayerIndex].OriginalMatrix := AffineMatrixTranslation(0,+Height/2)*AffineMatrixScale(1,-1)*AffineMatrixTranslation(0,-Height/2)*FLayers[ALayerIndex].OriginalMatrix;
 end;
 procedure TBGRALayeredBitmap.Resample(AWidth, AHeight: integer;
   AResampleMode: TResampleMode; AFineResampleFilter: TResampleFilter);
 var i: integer;
+var i, prevWidth, prevHeight: integer;
     resampled: TBGRABitmap;
     oldFilter : TResampleFilter;
 …
   if (AWidth < 0) or (AHeight < 0) then
     raise exception.Create('Invalid size');
+  prevWidth := Width;
+  if prevWidth < 1 then prevWidth := AWidth;
+  prevHeight := Height;
+  if prevHeight < 1 then prevHeight := AHeight;
   SetSize(AWidth, AHeight); //unfreeze
   for i := 0 to NbLayers-1 do
+  if (FLayers[i].OriginalGuid <> GUID_NULL) and LayerOriginalKnown[i] then
+    LayerOriginalMatrix[i] := AffineMatrixScale(AWidth/prevWidth,AHeight/prevHeight)*LayerOriginalMatrix[i]
+  else
   begin
     oldFilter := LayerBitmap[i].ResampleFilter;
 …
     SetLayerBitmap(i, resampled, True);
   end;
+  if AResampleMode = rmFineResample then RenderOriginalsIfNecessary;
 end;
 …
     FLayers[layer].Source := ABitmap;
     FLayers[layer].Owner := AOwned;
+  end;
+    FLayers[layer].OriginalGuid := GUID_NULL;
+    FLayers[layer].OriginalMatrix := AffineMatrixIdentity;
+  end;
+end;
+procedure TBGRALayeredBitmap.ApplyLayerOffset(ALayerIndex: integer;
+  APadWithTranparentPixels: boolean);
+var
+  r: TRect;
+  newBmp: TBGRABitmap;
+begin
+  if APadWithTranparentPixels then
+  begin
+    if (LayerOffset[ALayerIndex].X=0) and (LayerOffset[ALayerIndex].Y=0) and
+       (LayerBitmap[ALayerIndex].Width=Width) and (LayerBitmap[ALayerIndex].Height=Height) then exit;
+    newBmp := TBGRABitmap.Create(Width,Height);
+    newBmp.PutImage(LayerOffset[ALayerIndex].X, LayerOffset[ALayerIndex].Y, LayerBitmap[ALayerIndex], dmSet);
+    if FLayers[ALayerIndex].Owner then FLayers[ALayerIndex].Source.Free;
+    FLayers[ALayerIndex].Source := newBmp;
+    FLayers[ALayerIndex].Owner := true;
+    FLayers[ALayerIndex].x := 0;
+    FLayers[ALayerIndex].y := 0;
+  end else
+  begin
+    if (LayerOffset[ALayerIndex].X>=0) and (LayerOffset[ALayerIndex].Y>=0) and
+       (LayerOffset[ALayerIndex].X+LayerBitmap[ALayerIndex].Width <= Width) and
+       (LayerOffset[ALayerIndex].Y+LayerBitmap[ALayerIndex].Height <= Height) then exit;
+    r := RectWithSize(LayerOffset[ALayerIndex].X, LayerOffset[ALayerIndex].Y,
+                      LayerBitmap[ALayerIndex].Width, LayerBitmap[ALayerIndex].Height);
+    IntersectRect(r, r, rect(0,0,Width,Height));
+    newBmp := TBGRABitmap.Create(r.Width,r.Height);
+    newBmp.PutImage(LayerOffset[ALayerIndex].X - r.Left, LayerOffset[ALayerIndex].Y - r.Top, LayerBitmap[ALayerIndex], dmSet);
+    if FLayers[ALayerIndex].Owner then FLayers[ALayerIndex].Source.Free;
+    FLayers[ALayerIndex].Source := newBmp;
+    FLayers[ALayerIndex].Owner := true;
+    FLayers[ALayerIndex].x := r.Left;
+    FLayers[ALayerIndex].y := r.Top;
+  end;
+end;
+function TBGRALayeredBitmap.DrawEditor(ADest: TBGRABitmap;
+  ALayerIndex: integer; X, Y: Integer; APointSize: single): TRect;
+begin
+  result := DrawEditor(ADest, ALayerIndex, AffineMatrixTranslation(X,Y), APointSize);
+end;
+function TBGRALayeredBitmap.DrawEditor(ADest: TBGRABitmap; ALayerIndex: integer;
+  AMatrix: TAffineMatrix; APointSize: single): TRect;
+var
+  orig: TBGRALayerCustomOriginal;
+begin
+  orig := LayerOriginal[ALayerIndex];
+  if orig <> FOriginalEditorOriginal then
+  begin
+    FreeAndNil(FOriginalEditor);
+    FOriginalEditorOriginal := orig;
+  end;
+  if Assigned(orig) then
+  begin
+    if FOriginalEditor = nil then
+    begin
+      FOriginalEditor := orig.CreateEditor;
+    end;
+    FOriginalEditor.Clear;
+    orig.ConfigureEditor(FOriginalEditor);
+    FOriginalEditorViewMatrix := AffineMatrixTranslation(-0.5,-0.5)*AMatrix*AffineMatrixTranslation(0.5,0.5);
+    FOriginalEditor.Matrix := AffineMatrixTranslation(-0.5,-0.5)*AMatrix*LayerOriginalMatrix[ALayerIndex]*AffineMatrixTranslation(0.5,0.5);
+    FOriginalEditor.PointSize := APointSize;
+    result := FOriginalEditor.Render(ADest, rect(0,0,ADest.Width,ADest.Height));
+  end else
+    result := EmptyRect;
+end;
+function TBGRALayeredBitmap.GetEditorBounds(ALayerIndex: integer; X,
+  Y: Integer; APointSize: single): TRect;
+begin
+  result := GetEditorBounds(ALayerIndex, AffineMatrixTranslation(X,Y), APointSize);
+end;
+function TBGRALayeredBitmap.GetEditorBounds(ADestRect: TRect;
+  ALayerIndex: integer; X, Y: Integer; APointSize: single): TRect;
+begin
+  result := GetEditorBounds(ADestRect, ALayerIndex, AffineMatrixTranslation(X,Y), APointSize);
+end;
+function TBGRALayeredBitmap.GetEditorBounds(ALayerIndex: integer;
+  AMatrix: TAffineMatrix; APointSize: single): TRect;
+begin
+  result := GetEditorBounds(rect(-maxLongint,-maxLongint,maxLongint,maxLongint), ALayerIndex, AMatrix, APointSize);
+end;
+function TBGRALayeredBitmap.GetEditorBounds(ADestRect: TRect; ALayerIndex: integer;
+  AMatrix: TAffineMatrix; APointSize: single): TRect;
+var
+  orig: TBGRALayerCustomOriginal;
+begin
+  orig := LayerOriginal[ALayerIndex];
+  if orig <> FOriginalEditorOriginal then
+  begin
+    FreeAndNil(FOriginalEditor);
+    FOriginalEditorOriginal := orig;
+  end;
+  if Assigned(orig) then
+  begin
+    if FOriginalEditor = nil then
+    begin
+      FOriginalEditor := orig.CreateEditor;
+      if FOriginalEditor = nil then
+        raise exception.Create('Unexpected nil value');
+    end;
+    FOriginalEditor.Clear;
+    orig.ConfigureEditor(FOriginalEditor);
+    FOriginalEditorViewMatrix := AffineMatrixTranslation(-0.5,-0.5)*AMatrix*AffineMatrixTranslation(0.5,0.5);
+    FOriginalEditor.Matrix := AffineMatrixTranslation(-0.5,-0.5)*AMatrix*LayerOriginalMatrix[ALayerIndex]*AffineMatrixTranslation(0.5,0.5);
+    FOriginalEditor.PointSize := APointSize;
+    result := FOriginalEditor.GetRenderBounds(ADestRect);
+  end else
+    result := EmptyRect;
+end;
+procedure TBGRALayeredBitmap.MouseMove(Shift: TShiftState; ImageX, ImageY: Single; out
+  ACursor: TOriginalEditorCursor);
+var
+  handled: boolean;
+begin
+  MouseMove(Shift, ImageX,ImageY, ACursor, handled);
+end;
+procedure TBGRALayeredBitmap.MouseDown(RightButton: boolean;
+  Shift: TShiftState; ImageX, ImageY: Single; out ACursor: TOriginalEditorCursor);
+var
+  handled: boolean;
+begin
+  MouseDown(RightButton, Shift, ImageX,ImageY, ACursor, handled);
+end;
+procedure TBGRALayeredBitmap.MouseUp(RightButton: boolean; Shift: TShiftState;
+  ImageX, ImageY: Single; out ACursor: TOriginalEditorCursor);
+var
+  handled: boolean;
+begin
+  MouseUp(RightButton, Shift, ImageX,ImageY, ACursor, handled);
+end;
+procedure TBGRALayeredBitmap.MouseMove(Shift: TShiftState; ImageX, ImageY: Single; out
+  ACursor: TOriginalEditorCursor; out AHandled: boolean);
+var
+  viewPt: TPointF;
+begin
+  if Assigned(FOriginalEditor) then
+  begin
+    viewPt := FOriginalEditorViewMatrix*PointF(ImageX,ImageY);
+    FOriginalEditor.MouseMove(Shift, viewPt.X, viewPt.Y, ACursor, AHandled);
+  end
+  else
+  begin
+    ACursor:= oecDefault;
+    AHandled:= false;
+  end;
+end;
+procedure TBGRALayeredBitmap.MouseDown(RightButton: boolean;
+  Shift: TShiftState; ImageX, ImageY: Single; out ACursor: TOriginalEditorCursor; out
+  AHandled: boolean);
+var
+  viewPt: TPointF;
+begin
+  if Assigned(FOriginalEditor) then
+  begin
+    viewPt := FOriginalEditorViewMatrix*PointF(ImageX,ImageY);
+    FOriginalEditor.MouseDown(RightButton, Shift, viewPt.X, viewPt.Y, ACursor, AHandled);
+  end
+  else
+  begin
+    ACursor:= oecDefault;
+    AHandled:= false;
+  end;
+end;
+procedure TBGRALayeredBitmap.MouseUp(RightButton: boolean; Shift: TShiftState;
+  ImageX, ImageY: Single; out ACursor: TOriginalEditorCursor; out AHandled: boolean);
+var
+  viewPt: TPointF;
+begin
+  if Assigned(FOriginalEditor) then
+  begin
+    viewPt := FOriginalEditorViewMatrix*PointF(ImageX,ImageY);
+    FOriginalEditor.MouseUp(RightButton, Shift, viewPt.X,viewPt.Y, ACursor, AHandled);
+  end
+  else
+  begin
+    ACursor:= oecDefault;
+    AHandled:= false;
+  end;
+end;
+procedure TBGRALayeredBitmap.KeyDown(Shift: TShiftState; Key: TSpecialKey; out
+  AHandled: boolean);
+begin
+  if Assigned(FOriginalEditor) then
+    FOriginalEditor.KeyDown(Shift, Key, AHandled)
+  else
+    AHandled := false;
+end;
+procedure TBGRALayeredBitmap.KeyUp(Shift: TShiftState; Key: TSpecialKey; out
+  AHandled: boolean);
+begin
+  if Assigned(FOriginalEditor) then
+    FOriginalEditor.KeyUp(Shift, Key, AHandled)
+  else
+    AHandled := false;
+end;
+procedure TBGRALayeredBitmap.KeyPress(UTF8Key: string; out AHandled: boolean);
+begin
+  if Assigned(FOriginalEditor) then
+    FOriginalEditor.KeyPress(UTF8Key, AHandled)
+  else
+    AHandled := false;
+end;
+function TBGRALayeredBitmap.IndexOfOriginal(AGuid: TGuid): integer;
+var
+  i: Integer;
+begin
+  for i := 0 to OriginalCount-1 do
+    if FOriginals[i].Guid = AGuid then
+    begin
+      result := i;
+      exit;
+    end;
+  result := -1
+end;
+function TBGRALayeredBitmap.IndexOfOriginal(AOriginal: TBGRALayerCustomOriginal): integer;
+begin
+  if Assigned(FOriginals) then
+    result := FOriginals.IndexOf(BGRALayerOriginalEntry(AOriginal))
+  else
+    result := -1;
 end;
 …
 end;
+function TBGRACustomLayeredBitmap.GetMemDirectory: TMemDirectory;
+begin
+  if FMemDirectory = nil then
+  begin
+    FMemDirectory:= TMemDirectory.Create;
+    FMemDirectoryOwned := true;
+  end;
+  result := FMemDirectory;
+end;
 function TBGRACustomLayeredBitmap.GetDefaultBlendingOperation: TBlendOperation;
 begin
   result := boTransparent;
+end;
+function TBGRACustomLayeredBitmap.GetHasMemFiles: boolean;
+begin
+  result := assigned(FMemDirectory) and (FMemDirectory.Count > 0);
+end;
+function TBGRACustomLayeredBitmap.GetLayerOriginalGuid(layer: integer): TGuid;
+begin
+  result := GUID_NULL;
+end;
+function TBGRACustomLayeredBitmap.GetLayerOriginalRenderStatus(layer: integer): TOriginalRenderStatus;
+begin
+  result := orsProof;
+end;
+function TBGRACustomLayeredBitmap.GetOriginalCount: integer;
+begin
+  result := 0;
+end;
+function TBGRACustomLayeredBitmap.GetOriginalByIndex(AIndex: integer): TBGRALayerCustomOriginal;
+begin
+  result := nil;
+  raise exception.Create('Not implemented');
+end;
+function TBGRACustomLayeredBitmap.GetOriginalByIndexKnown(AIndex: integer): boolean;
+begin
+  result := true;
+end;
+function TBGRACustomLayeredBitmap.GetLayerOriginal(layer: integer): TBGRALayerCustomOriginal;
+begin
+  result := nil;
+end;
+function TBGRACustomLayeredBitmap.GetLayerOriginalKnown(layer: integer): boolean;
+begin
+  result := true;
+end;
+function TBGRACustomLayeredBitmap.GetLayerOriginalMatrix(layer: integer): TAffineMatrix;
+begin
+  result := AffineMatrixIdentity;
 end;
 …
   Unfreeze;
   FLinearBlend := AValue;
+end;
+procedure TBGRACustomLayeredBitmap.SetMemDirectory(AValue: TMemDirectory);
+begin
+  if AValue = FMemDirectory then exit;
+  if FMemDirectoryOwned then FMemDirectory.Free;
+  FMemDirectory := AValue;
+  FMemDirectoryOwned := false;
 end;
 …
 end;
+function TBGRACustomLayeredBitmap.IndexOfOriginal(AGuid: TGuid): integer;
+begin
+  result := -1;
+end;
+function TBGRACustomLayeredBitmap.IndexOfOriginal(
+  AOriginal: TBGRALayerCustomOriginal): integer;
+begin
+  result := -1;
+end;
 procedure TBGRACustomLayeredBitmap.SetWidth(Value: Integer);
 begin
 …
     temp: TBGRALayeredBitmap;
     i: integer;
+    stream: TFileStreamUTF8;
 begin
   ext := UTF8LowerCase(ExtractFileExt(filenameUTF8));
 …
     end;
+  //when using "data" extension, simply serialize
+  if (ext='.dat') or (ext='.data') then
+  begin
+    if Assigned(LayeredBitmapLoadFromStreamProc) then
+    begin
+      stream := TFileStreamUTF8.Create(filenameUTF8, fmCreate);
+      try
+        LayeredBitmapSaveToStreamProc(stream, self);
+      finally
+        stream.Free;
+      end;
+    end else
+      raise exception.Create('Enable layer serialization by calling BGRAStreamLayers.RegisterStreamLayers');
+  end else
+  begin
+    bmp := ComputeFlatImage;
+    try
+      bmp.SaveToFileUTF8(filenameUTF8);
+    finally
+      bmp.Free;
+    end;
+  end;
+end;
+procedure TBGRACustomLayeredBitmap.SaveToStream(Stream: TStream);
+begin
+  if Assigned(LayeredBitmapSaveToStreamProc) then
+    LayeredBitmapSaveToStreamProc(Stream, self)
+  else
+    raise exception.Create('Call BGRAStreamLayers.RegisterStreamLayers first');
+end;
+procedure TBGRACustomLayeredBitmap.SaveToStreamAs(Stream: TStream;
+  AExtension: string);
+var bmp: TBGRABitmap;
+    ext: string;
+    format: TBGRAImageFormat;
+    temp: TBGRALayeredBitmap;
+    i: integer;
+begin
+  ext := UTF8LowerCase(AExtension);
+  if ext[1] <> '.' then ext := '.'+ext;
+  for i := 0 to high(LayeredBitmapWriters) do
+    if '.'+LayeredBitmapWriters[i].extension = ext then
+    begin
+      temp := LayeredBitmapWriters[i].theClass.Create;
+      try
+        temp.Assign(self);
+        temp.SaveToStream(Stream);
+      finally
+        temp.Free;
+      end;
+      exit;
+    end;
+  format := SuggestImageFormat(ext);
   bmp := ComputeFlatImage;
   try
     bmp.SaveToFileUTF8(filenameUTF8);
+    bmp.SaveToStreamAs(Stream, format);
   finally
     bmp.Free;
 …
 end;
-procedure TBGRACustomLayeredBitmap.SaveToStream(Stream: TStream);
-begin
-  if Assigned(LayeredBitmapSaveToStreamProc) then
-    LayeredBitmapSaveToStreamProc(Stream, self)
-  else
-    raise exception.Create('Call BGRAStreamLayers.RegisterStreamLayers first');
-end;
 constructor TBGRACustomLayeredBitmap.Create;
 begin
   FFrozenRange := nil;
   FLinearBlend:= True;
+  FMemDirectory := nil;
+  FMemDirectoryOwned:= false;
 end;
 …
 end;
 function TBGRACustomLayeredBitmap.ComputeFlatImage: TBGRABitmap;
 begin
   result := ComputeFlatImage(rect(0,0,Width,Height), 0, NbLayers - 1);
+function TBGRACustomLayeredBitmap.ComputeFlatImage(ASeparateXorMask: boolean): TBGRABitmap;
+begin
+  result := ComputeFlatImage(rect(0,0,Width,Height), 0, NbLayers - 1, ASeparateXorMask);
 end;
 function TBGRACustomLayeredBitmap.ComputeFlatImage(firstLayer,
+  lastLayer: integer): TBGRABitmap;
+begin
+  result := ComputeFlatImage(rect(0,0,Width,Height), firstLayer,LastLayer);
+end;
+function TBGRACustomLayeredBitmap.ComputeFlatImage(ARect: TRect): TBGRABitmap;
+begin
+  result := ComputeFlatImage(ARect,0, NbLayers - 1);
+  lastLayer: integer; ASeparateXorMask: boolean): TBGRABitmap;
+begin
+  result := ComputeFlatImage(rect(0,0,Width,Height), firstLayer,LastLayer,ASeparateXorMask);
+end;
+function TBGRACustomLayeredBitmap.ComputeFlatImage(ARect: TRect;
+  ASeparateXorMask: boolean): TBGRABitmap;
+begin
+  result := ComputeFlatImage(ARect,0, NbLayers - 1, ASeparateXorMask);
 end;
 …
 end;
 function TBGRACustomLayeredBitmap.ComputeFlatImage(ARect: TRect; firstLayer, lastLayer: integer): TBGRABitmap;
+function TBGRACustomLayeredBitmap.ComputeFlatImage(ARect: TRect; firstLayer, lastLayer: integer; ASeparateXorMask: boolean): TBGRABitmap;
 var
   tempLayer: TBGRABitmap;
 …
   op: TBlendOperation;
 begin
+  if (firstLayer < 0) or (lastLayer > NbLayers-1) then
+    raise ERangeError.Create('Layer index out of bounds');
   If (ARect.Right <= ARect.Left) or (ARect.Bottom <= ARect.Top) then
   begin
 …
       begin
         op := BlendOperation[i];
+        //XOR mask
+        if (op = boXor) and ASeparateXorMask then
+        begin
+          result.NeedXorMask;
+          result.XorMask.BlendImageOver(x-ARect.Left,y-ARect.Top, tempLayer, op, LayerOpacity[i], LinearBlend);
+        end else
         //first layer is simply the background
         if i = firstLayer then
 …
     inc(i);
   end;
+  if result.XorMask <> nil then
+    AlphaFillInline(result.XorMask.Data, 0, result.XorMask.NbPixels);
 end;
 …
 end;
+procedure TBGRACustomLayeredBitmap.Draw(Dest: TBGRABitmap; AX, AY: integer; firstLayer, lastLayer: integer);
+procedure TBGRACustomLayeredBitmap.Draw(Dest: TBGRABitmap; x, y: integer;
+  ASeparateXorMask: boolean);
+begin
+  Draw(Dest,x,y,0,NbLayers-1,ASeparateXorMask);
+end;
+procedure TBGRACustomLayeredBitmap.Draw(Dest: TBGRABitmap; AX, AY: integer; firstLayer, lastLayer: integer; ASeparateXorMask: boolean);
 var
   temp: TBGRABitmap;
 …
     if LayerVisible[i] and not (BlendOperation[i] in[boTransparent,boLinearBlend]) then
     begin
       temp := ComputeFlatImage(rect(NewClipRect.Left-AX,NewClipRect.Top-AY,NewClipRect.Right-AX,NewClipRect.Bottom-AY));
+      temp := ComputeFlatImage(rect(NewClipRect.Left-AX,NewClipRect.Top-AY,NewClipRect.Right-AX,NewClipRect.Bottom-AY), ASeparateXorMask);
       if self.LinearBlend then
         Dest.PutImage(NewClipRect.Left,NewClipRect.Top,temp,dmLinearBlend)
 …
     end;
     if LayerVisible[i] then
-    with LayerOffset[i] do
     begin
       tempLayer := GetLayerBitmapDirectly(i);
 …
       end;
       if tempLayer <> nil then
+      with LayerOffset[i] do
       begin
         if (BlendOperation[i] = boTransparent) and not self.LinearBlend then //here it is specified not to use linear blending
           Dest.PutImage(AX+x,AY+y,GetLayerBitmapDirectly(i),dmDrawWithTransparency, LayerOpacity[i])
+          Dest.PutImage(AX+x,AY+y,tempLayer,dmDrawWithTransparency, LayerOpacity[i])
         else
           Dest.PutImage(AX+x,AY+y,GetLayerBitmapDirectly(i),dmLinearBlend, LayerOpacity[i]);
+          Dest.PutImage(AX+x,AY+y,tempLayer,dmLinearBlend, LayerOpacity[i]);
         if mustFreeCopy then tempLayer.Free;
       end;
 …
 end;
+procedure TBGRACustomLayeredBitmap.NotifyLoaded;
+begin
+  //nothing
+end;
+procedure TBGRACustomLayeredBitmap.NotifySaving;
+begin
+  //nothing
+end;
 procedure RegisterLayeredBitmapReader(AExtensionUTF8: string; AReader: TBGRACustomLayeredBitmapClass);
 begin
 …
     theClass := AReader;
   end;
+end;
+function TryCreateLayeredBitmapWriter(AExtensionUTF8: string): TBGRALayeredBitmap;
+var
+  i: Integer;
+begin
+  AExtensionUTF8:= UTF8LowerCase(AExtensionUTF8);
+  if (AExtensionUTF8 = '') or (AExtensionUTF8[1] <> '.') then
+    AExtensionUTF8:= '.'+AExtensionUTF8;
+  for i := 0 to high(LayeredBitmapWriters) do
+    if '.'+LayeredBitmapWriters[i].extension = AExtensionUTF8 then
+    begin
+      result := LayeredBitmapWriters[i].theClass.Create;
+      exit;
+    end;
+  result := nil;
+end;
+function TryCreateLayeredBitmapReader(AExtensionUTF8: string): TBGRACustomLayeredBitmap;
+var
+  i: Integer;
+begin
+  AExtensionUTF8:= UTF8LowerCase(AExtensionUTF8);
+  if (AExtensionUTF8 = '') or (AExtensionUTF8[1] <> '.') then
+    AExtensionUTF8:= '.'+AExtensionUTF8;
+  for i := 0 to high(LayeredBitmapReaders) do
+    if '.'+LayeredBitmapReaders[i].extension = AExtensionUTF8 then
+    begin
+      result := LayeredBitmapReaders[i].theClass.Create;
+      exit;
+    end;
+  result := nil;
 end;

GraphicTest/Packages/bgrabitmap/bgralazresource.pas

-              r494
+              r521
     constructor Create(AContainer: TMultiFileContainer; AName: utf8string; AValueType: utf8string; AContent: TStream);
     destructor Destroy; override;
     function CopyTo(ADestination: TStream): integer; override;
+    function CopyTo(ADestination: TStream): int64; override;
   end;
 …
     constructor Create(AContainer: TMultiFileContainer; AName: utf8string; ABinaryContent: TStream);
     destructor Destroy; override;
     function CopyTo(ADestination: TStream): integer; override;
+    function CopyTo(ADestination: TStream): int64; override;
   end;
 …
 end;
 function TFormDataEntry.CopyTo(ADestination: TStream): integer;
+function TFormDataEntry.CopyTo(ADestination: TStream): int64;
 begin
   RequireTextContent;
 …
 end;
 function TLazResourceEntry.CopyTo(ADestination: TStream): integer;
+function TLazResourceEntry.CopyTo(ADestination: TStream): int64;
 begin
   if FContent.Size = 0 then

GraphicTest/Packages/bgrabitmap/bgralclbitmap.pas

-              r494
+              r521
       ): TBGRAPtrBitmap; override;
     procedure AssignRasterImage(ARaster: TRasterImage); virtual;
+    procedure ExtractXorMask;
   public
     procedure Assign(Source: TPersistent); override;
+    procedure LoadFromResource(AFilename: string; AOptions: TBGRALoadingOptions); overload; override;
     procedure DataDrawTransparent(ACanvas: TCanvas; Rect: TRect;
       AData: Pointer; ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer); override;
     procedure DataDrawOpaque(ACanvas: TCanvas; Rect: TRect; AData: Pointer;
+    procedure DataDrawOpaque(ACanvas: TCanvas; ARect: TRect; AData: Pointer;
       ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer); override;
     procedure GetImageFromCanvas(CanvasSource: TCanvas; x, y: integer); override;
     procedure LoadFromDevice({%H-}DC: System.THandle); override;
     procedure LoadFromDevice({%H-}DC: System.THandle; {%H-}ARect: TRect); override;
+    procedure LoadFromDevice({%H-}DC: HDC); override;
+    procedure LoadFromDevice({%H-}DC: HDC; {%H-}ARect: TRect); override;
     procedure TakeScreenshotOfPrimaryMonitor; override;
     procedure TakeScreenshot({%H-}ARect: TRect); override;
 …
 implementation
 uses BGRAText, LCLType, LCLIntf, FPimage;
+uses Types, BGRAText, LCLType, LCLIntf, FPimage;
 type
   TCopyPixelProc = procedure (psrc: PByte; pdest: PBGRAPixel; count: NativeInt; sourcePixelSize: PtrInt; defaultOpacity: byte);
+procedure ApplyMask1bit(psrc: PByte; pdest: PBGRAPixel; count: NativeInt; {%H-}sourcePixelSize: PtrInt; {%H-}defaultOpacity: byte);
+var currentBit: byte;
+begin
+  currentBit := 1;
+  while count > 0 do
+  begin
+    if psrc^ and currentBit <> 0 then pdest^.alpha := 0;
+    inc(pdest);
+    if currentBit = 128 then
+    begin
+      currentBit := 1;
+      inc(psrc);
+    end else
+      currentBit := currentBit shl 1;
+    dec(count);
+  end;
+end;
+procedure ApplyMask1bitRev(psrc: PByte; pdest: PBGRAPixel; count: NativeInt; {%H-}sourcePixelSize: PtrInt; {%H-}defaultOpacity: byte);
+var currentBit: byte;
+begin
+  currentBit := 128;
+  while count > 0 do
+  begin
+    if psrc^ and currentBit <> 0 then pdest^.alpha := 0;
+    inc(pdest);
+    if currentBit = 1 then
+    begin
+      currentBit := 128;
+      inc(psrc);
+    end else
+      currentBit := currentBit shr 1;
+    dec(count);
+  end;
+end;
+procedure CopyFromBW_SetAlpha(psrc: PByte; pdest: PBGRAPixel; count: NativeInt; {%H-}sourcePixelSize: PtrInt; defaultOpacity: byte);
+var currentBit: byte;
+begin
+  currentBit := 1;
+  while count > 0 do
+  begin
+    if psrc^ and currentBit <> 0 then
+      pdest^ := BGRAWhite
+    else
+      pdest^ := BGRABlack;
+    pdest^.alpha := DefaultOpacity;
+    inc(pdest);
+    if currentBit = 128 then
+    begin
+      currentBit := 1;
+      inc(psrc);
+    end else
+      currentBit := currentBit shl 1;
+    dec(count);
+  end;
+end;
+procedure CopyFromBW_SetAlphaBitRev(psrc: PByte; pdest: PBGRAPixel; count: NativeInt; {%H-}sourcePixelSize: PtrInt; defaultOpacity: byte);
+var currentBit: byte;
+begin
+  currentBit := 128;
+  while count > 0 do
+  begin
+    if psrc^ and currentBit <> 0 then
+      pdest^ := BGRAWhite
+    else
+      pdest^ := BGRABlack;
+    pdest^.alpha := DefaultOpacity;
+    inc(pdest);
+    if currentBit = 1 then
+    begin
+      currentBit := 128;
+      inc(psrc);
+    end else
+      currentBit := currentBit shr 1;
+    dec(count);
+  end;
+end;
 procedure CopyFrom24Bit(psrc: PByte; pdest: PBGRAPixel; count: NativeInt; sourcePixelSize: PtrInt; defaultOpacity: byte);
 …
 end;
+{ Load raw image data. It must be 32bit or 24 bits per pixel}
+function LoadFromRawImageImplementation(ADestination: TBGRADefaultBitmap; ARawImage: TRawImage;
+  DefaultOpacity: byte; AlwaysReplaceAlpha: boolean; RaiseErrorOnInvalidPixelFormat: boolean): boolean;
+var
+procedure DoCopyProc(ADestination: TBGRACustomBitmap; ACopyProc: TCopyPixelProc; AData: PByte; ABytesPerLine, ABitsPerPixel: integer; ALineOrder: TRawImageLineOrder; ADefaultOpacity: byte);
+var
+  n: integer;
   psource_byte, pdest_byte,
   psource_first, pdest_first: PByte;
   psource_delta, pdest_delta: integer;
+  n: integer;
+begin
+  if (ALineOrder = ADestination.LineOrder) and
+    (ABytesPerLine = (ABitsPerPixel shr 3) * cardinal(ADestination.Width)) then
+    ACopyProc(AData, ADestination.Data, ADestination.NbPixels, ABitsPerPixel shr 3, ADefaultOpacity)
+  else
+  begin
+    if ALineOrder = riloTopToBottom then
+    begin
+      psource_first := AData;
+      psource_delta := ABytesPerLine;
+    end else
+    begin
+      psource_first := AData + (ADestination.Height-1) * ABytesPerLine;
+      psource_delta := -ABytesPerLine;
+    end;
+    if ADestination.LineOrder = riloTopToBottom then
+    begin
+      pdest_first := PByte(ADestination.Data);
+      pdest_delta := ADestination.Width*sizeof(TBGRAPixel);
+    end else
+    begin
+      pdest_first := PByte(ADestination.Data) + (ADestination.Height-1)*ADestination.Width*sizeof(TBGRAPixel);
+      pdest_delta := -ADestination.Width*sizeof(TBGRAPixel);
+    end;
+    psource_byte := psource_first;
+    pdest_byte := pdest_first;
+    for n := ADestination.Height-1 downto 0 do
+    begin
+      ACopyProc(psource_byte, PBGRAPixel(pdest_byte), ADestination.Width, ABitsPerPixel shr 3, ADefaultOpacity);
+      inc(psource_byte, psource_delta);
+      inc(pdest_byte, pdest_delta);
+    end;
+  end;
+end;
+procedure ApplyRawImageMask(ADestination: TBGRACustomBitmap; const ARawImage: TRawImage);
+var
+  copyProc: TCopyPixelProc;
+begin
+  if (ARawImage.Description.MaskBitsPerPixel = 1) and (ARawImage.Mask <> nil) then
+  begin
+    if ARawImage.Description.BitOrder = riboBitsInOrder then
+      copyProc := @ApplyMask1bit
+    else
+      copyProc := @ApplyMask1bitRev;
+    DoCopyProc(ADestination, copyProc, ARawImage.Mask, ARawImage.Description.MaskBytesPerLine, ARawImage.Description.MaskBitsPerPixel, ARawImage.Description.LineOrder, 0);
+    ADestination.InvalidateBitmap;
+  end;
+end;
+{ Load raw image data. It must be 32bit, 24 bits or 1bit per pixel}
+function LoadFromRawImageImplementation(ADestination: TBGRADefaultBitmap; const ARawImage: TRawImage;
+  DefaultOpacity: byte; AlwaysReplaceAlpha: boolean; RaiseErrorOnInvalidPixelFormat: boolean): boolean;
+var
   mustSwapRedBlue: boolean;
   copyProc: TCopyPixelProc;
 …
   end;
+  if ((ARawImage.Description.BitsPerPixel and 7) <> 0) then
+  begin
+    result := FormatError(IntToStr(ARawImage.Description.Depth) + 'bit found but multiple of 8bit expected');
+    exit;
+  end;
+  if (ARawImage.Description.BitsPerPixel < 24) then
+  begin
+    result := FormatError(IntToStr(ARawImage.Description.Depth) + 'bit found but at least 24bit expected');
+    exit;
+  end;
+  nbColorChannels := 0;
+  if (ARawImage.Description.RedPrec > 0)  then inc(nbColorChannels);
+  if (ARawImage.Description.GreenPrec > 0)  then inc(nbColorChannels);
+  if (ARawImage.Description.BluePrec > 0)  then inc(nbColorChannels);
+  if (nbColorChannels < 3) then
+  begin
+    result := FormatError('One or more color channel is missing (RGB expected)');
+    exit;
+  end;
+  //channels are in ARGB order
+  if (ARawImage.Description.BitsPerPixel >= 32) and
+     (ARawImage.Description.AlphaPrec = 8) and
+    (((ARawImage.Description.AlphaShift = 0) and
+    (ARawImage.Description.RedShift = 8) and
+    (ARawImage.Description.GreenShift = 16) and
+    (ARawImage.Description.BlueShift = 24) and
+    (ARawImage.Description.ByteOrder = riboLSBFirst)) or
+    ((ARawImage.Description.AlphaShift = ARawImage.Description.BitsPerPixel - 8) and
+    (ARawImage.Description.RedShift = ARawImage.Description.BitsPerPixel - 16) and
+    (ARawImage.Description.GreenShift = ARawImage.Description.BitsPerPixel - 24) and
+    (ARawImage.Description.BlueShift = ARawImage.Description.BitsPerPixel - 32) and
+    (ARawImage.Description.ByteOrder = riboMSBFirst))) then
+    begin
+      if AlwaysReplaceAlpha then
+        copyProc := @CopyFromARGB_SetAlpha
+      else if DefaultOpacity = 0 then
+        copyProc := @CopyFromARGB_KeepAlpha
+  if ARawImage.Description.BitsPerPixel = 1 then
+  begin
+    if ARawImage.Description.BitOrder = riboBitsInOrder then
+      copyProc := @CopyFromBW_SetAlpha
+    else
+      copyProc := @CopyFromBW_SetAlphaBitRev;
+    DefaultOpacity := 255;
+  end else
+  begin
+    if ((ARawImage.Description.BitsPerPixel and 7) <> 0) then
+    begin
+      result := FormatError(IntToStr(ARawImage.Description.Depth) + 'bit found but multiple of 8bit expected');
+      exit;
+    end;
+    if (ARawImage.Description.BitsPerPixel < 24) then
+    begin
+      result := FormatError(IntToStr(ARawImage.Description.Depth) + 'bit found but at least 24bit expected');
+      exit;
+    end;
+    nbColorChannels := 0;
+    if (ARawImage.Description.RedPrec > 0)  then inc(nbColorChannels);
+    if (ARawImage.Description.GreenPrec > 0)  then inc(nbColorChannels);
+    if (ARawImage.Description.BluePrec > 0)  then inc(nbColorChannels);
+    if (nbColorChannels < 3) then
+    begin
+      result := FormatError('One or more color channel is missing (RGB expected)');
+      exit;
+    end;
+    //channels are in ARGB order
+    if (ARawImage.Description.BitsPerPixel >= 32) and
+       (ARawImage.Description.AlphaPrec = 8) and
+      (((ARawImage.Description.AlphaShift = 0) and
+      (ARawImage.Description.RedShift = 8) and
+      (ARawImage.Description.GreenShift = 16) and
+      (ARawImage.Description.BlueShift = 24) and
+      (ARawImage.Description.ByteOrder = riboLSBFirst)) or
+      ((ARawImage.Description.AlphaShift = ARawImage.Description.BitsPerPixel - 8) and
+      (ARawImage.Description.RedShift = ARawImage.Description.BitsPerPixel - 16) and
+      (ARawImage.Description.GreenShift = ARawImage.Description.BitsPerPixel - 24) and
+      (ARawImage.Description.BlueShift = ARawImage.Description.BitsPerPixel - 32) and
+      (ARawImage.Description.ByteOrder = riboMSBFirst))) then
+      begin
+        if AlwaysReplaceAlpha then
+          copyProc := @CopyFromARGB_SetAlpha
+        else if DefaultOpacity = 0 then
+          copyProc := @CopyFromARGB_KeepAlpha
+        else
+          copyProc := @CopyFromARGB_ReplaceZeroAlpha;
+      end
+    else //channels are in ARGB order but alpha is not used
+    if (ARawImage.Description.BitsPerPixel >= 32) and
+       (ARawImage.Description.AlphaPrec = 0) and
+      (((ARawImage.Description.RedShift = 8) and
+      (ARawImage.Description.GreenShift = 16) and
+      (ARawImage.Description.BlueShift = 24) and
+      (ARawImage.Description.ByteOrder = riboLSBFirst)) or
+      ((ARawImage.Description.RedShift = ARawImage.Description.BitsPerPixel - 16) and
+      (ARawImage.Description.GreenShift = ARawImage.Description.BitsPerPixel - 24) and
+      (ARawImage.Description.BlueShift = ARawImage.Description.BitsPerPixel - 32) and
+      (ARawImage.Description.ByteOrder = riboMSBFirst))) then
+      begin
+        DefaultOpacity := 255;
+        copyProc := @CopyFromARGB_SetAlpha;
+      end
+    else
+    begin
+      //channels are in RGB order (alpha channel may follow)
+      if (ARawImage.Description.BitsPerPixel >= 24) and
+         (((ARawImage.Description.RedShift = 0) and
+           (ARawImage.Description.GreenShift = 8) and
+           (ARawImage.Description.BlueShift = 16) and
+           (ARawImage.Description.ByteOrder = riboLSBFirst)) or
+          ((ARawImage.Description.RedShift = ARawImage.Description.BitsPerPixel - 8) and
+           (ARawImage.Description.GreenShift = ARawImage.Description.BitsPerPixel - 16) and
+           (ARawImage.Description.BlueShift = ARawImage.Description.BitsPerPixel - 24) and
+           (ARawImage.Description.ByteOrder = riboMSBFirst))) then
+      begin
+        mustSwapRedBlue:= not TBGRAPixel_RGBAOrder;
+      end
       else
+        copyProc := @CopyFromARGB_ReplaceZeroAlpha;
+    end
+  else //channels are in ARGB order but alpha is not used
+  if (ARawImage.Description.BitsPerPixel >= 32) and
+     (ARawImage.Description.AlphaPrec = 0) and
+    (((ARawImage.Description.RedShift = 8) and
+    (ARawImage.Description.GreenShift = 16) and
+    (ARawImage.Description.BlueShift = 24) and
+    (ARawImage.Description.ByteOrder = riboLSBFirst)) or
+    ((ARawImage.Description.RedShift = ARawImage.Description.BitsPerPixel - 16) and
+    (ARawImage.Description.GreenShift = ARawImage.Description.BitsPerPixel - 24) and
+    (ARawImage.Description.BlueShift = ARawImage.Description.BitsPerPixel - 32) and
+    (ARawImage.Description.ByteOrder = riboMSBFirst))) then
+    begin
+      DefaultOpacity := 255;
+      copyProc := @CopyFromARGB_SetAlpha;
+    end
+  else
+  begin
+    //channels are in RGB order (alpha channel may follow)
+    if (ARawImage.Description.BitsPerPixel >= 24) and
+       (((ARawImage.Description.RedShift = 0) and
+         (ARawImage.Description.GreenShift = 8) and
+         (ARawImage.Description.BlueShift = 16) and
+         (ARawImage.Description.ByteOrder = riboLSBFirst)) or
+        ((ARawImage.Description.RedShift = ARawImage.Description.BitsPerPixel - 8) and
+         (ARawImage.Description.GreenShift = ARawImage.Description.BitsPerPixel - 16) and
+         (ARawImage.Description.BlueShift = ARawImage.Description.BitsPerPixel - 24) and
+         (ARawImage.Description.ByteOrder = riboMSBFirst))) then
+    begin
+      mustSwapRedBlue:= not TBGRAPixel_RGBAOrder;
+    end
+    else
+    //channels are in BGR order (alpha channel may follow)
+    if (ARawImage.Description.BitsPerPixel >= 24) and
+       (((ARawImage.Description.BlueShift = 0) and
+         (ARawImage.Description.GreenShift = 8) and
+         (ARawImage.Description.RedShift = 16) and
+         (ARawImage.Description.ByteOrder = riboLSBFirst)) or
+        ((ARawImage.Description.BlueShift = ARawImage.Description.BitsPerPixel - 8) and
+         (ARawImage.Description.GreenShift = ARawImage.Description.BitsPerPixel - 16) and
+         (ARawImage.Description.RedShift = ARawImage.Description.BitsPerPixel - 24) and
+         (ARawImage.Description.ByteOrder = riboMSBFirst))) then
+    begin
+      mustSwapRedBlue:= TBGRAPixel_RGBAOrder;
+    end
+    else
+    begin
+      result := FormatError('BitsPerPixel: ' + IntToStr(ARawImage.Description.BitsPerPixel) + ', '
+        + 'RedShit: ' + IntToStr(ARawImage.Description.RedShift) + ', Prec: ' + IntToStr(ARawImage.Description.RedPrec)+ ', '
+        + 'GreenShit: ' + IntToStr(ARawImage.Description.GreenShift) + ', Prec: ' + IntToStr(ARawImage.Description.GreenPrec)+ ', '
+        + 'BlueShift: ' + IntToStr(ARawImage.Description.BlueShift) + ', Prec: ' + IntToStr(ARawImage.Description.BluePrec)+ ', '
+        + 'AlphaShift: ' + IntToStr(ARawImage.Description.AlphaShift) + ', Prec: ' + IntToStr(ARawImage.Description.AlphaPrec) );
+      exit;
+    end;
+    if not mustSwapRedBlue then
+    begin
+      if ARawImage.Description.BitsPerPixel = 24 then
+        copyProc := @CopyFrom24Bit
+      //channels are in BGR order (alpha channel may follow)
+      if (ARawImage.Description.BitsPerPixel >= 24) and
+         (((ARawImage.Description.BlueShift = 0) and
+           (ARawImage.Description.GreenShift = 8) and
+           (ARawImage.Description.RedShift = 16) and
+           (ARawImage.Description.ByteOrder = riboLSBFirst)) or
+          ((ARawImage.Description.BlueShift = ARawImage.Description.BitsPerPixel - 8) and
+           (ARawImage.Description.GreenShift = ARawImage.Description.BitsPerPixel - 16) and
+           (ARawImage.Description.RedShift = ARawImage.Description.BitsPerPixel - 24) and
+           (ARawImage.Description.ByteOrder = riboMSBFirst))) then
+      begin
+        mustSwapRedBlue:= TBGRAPixel_RGBAOrder;
+      end
       else
+      if AlwaysReplaceAlpha or (ARawImage.Description.AlphaPrec = 0) then
+        copyProc := @CopyFrom32Bit_SetAlpha
+      else if DefaultOpacity = 0 then
+        copyProc := @CopyFrom32Bit_KeepAlpha
+      else
+        copyProc := @CopyFrom32Bit_ReplaceZeroAlpha;
+    end else
+    begin
+      if ARawImage.Description.BitsPerPixel = 24 then
+        copyProc := @CopyFrom24Bit_SwapRedBlue
+      else
+      if AlwaysReplaceAlpha or (ARawImage.Description.AlphaPrec = 0) then
+        copyProc := @CopyFrom32Bit_SwapRedBlue_SetAlpha
+      else if DefaultOpacity = 0 then
+        copyProc := @CopyFrom32Bit_SwapRedBlue_KeepAlpha
+      else
+        copyProc := @CopyFrom32Bit_SwapRedBlue_ReplaceZeroAlpha;
+    end;
+  end;
+  if (ARawImage.Description.LineOrder = ADestination.LineOrder) and
+    (ARawImage.Description.BytesPerLine = (ARawImage.Description.BitsPerPixel shr 3) * cardinal(ADestination.Width)) then
+    copyProc(ARawImage.Data, ADestination.Data, ADestination.NbPixels, ARawImage.Description.BitsPerPixel shr 3, DefaultOpacity)
+  else
+  begin
+    if ARawImage.Description.LineOrder = riloTopToBottom then
+    begin
+      psource_first := ARawImage.Data;
+      psource_delta := ARawImage.Description.BytesPerLine;
+    end else
+    begin
+      psource_first := ARawImage.Data + (ARawImage.Description.Height-1) * ARawImage.Description.BytesPerLine;
+      psource_delta := -ARawImage.Description.BytesPerLine;
+    end;
+    if ADestination.LineOrder = riloTopToBottom then
+    begin
+      pdest_first := PByte(ADestination.Data);
+      pdest_delta := ADestination.Width*sizeof(TBGRAPixel);
+    end else
+    begin
+      pdest_first := PByte(ADestination.Data) + (ADestination.Height-1)*ADestination.Width*sizeof(TBGRAPixel);
+      pdest_delta := -ADestination.Width*sizeof(TBGRAPixel);
+    end;
+    psource_byte := psource_first;
+    pdest_byte := pdest_first;
+    for n := ADestination.Height-1 downto 0 do
+    begin
+      copyProc(psource_byte, PBGRAPixel(pdest_byte), ADestination.Width, ARawImage.Description.BitsPerPixel shr 3, DefaultOpacity);
+      inc(psource_byte, psource_delta);
+      inc(pdest_byte, pdest_delta);
+    end;
+  end;
+      begin
+        result := FormatError('BitsPerPixel: ' + IntToStr(ARawImage.Description.BitsPerPixel) + ', '
+          + 'RedShit: ' + IntToStr(ARawImage.Description.RedShift) + ', Prec: ' + IntToStr(ARawImage.Description.RedPrec)+ ', '
+          + 'GreenShit: ' + IntToStr(ARawImage.Description.GreenShift) + ', Prec: ' + IntToStr(ARawImage.Description.GreenPrec)+ ', '
+          + 'BlueShift: ' + IntToStr(ARawImage.Description.BlueShift) + ', Prec: ' + IntToStr(ARawImage.Description.BluePrec)+ ', '
+          + 'AlphaShift: ' + IntToStr(ARawImage.Description.AlphaShift) + ', Prec: ' + IntToStr(ARawImage.Description.AlphaPrec) );
+        exit;
+      end;
+      if not mustSwapRedBlue then
+      begin
+        if ARawImage.Description.BitsPerPixel = 24 then
+          copyProc := @CopyFrom24Bit
+        else
+        if AlwaysReplaceAlpha or (ARawImage.Description.AlphaPrec = 0) then
+          copyProc := @CopyFrom32Bit_SetAlpha
+        else if DefaultOpacity = 0 then
+          copyProc := @CopyFrom32Bit_KeepAlpha
+        else
+          copyProc := @CopyFrom32Bit_ReplaceZeroAlpha;
+      end else
+      begin
+        if ARawImage.Description.BitsPerPixel = 24 then
+          copyProc := @CopyFrom24Bit_SwapRedBlue
+        else
+        if AlwaysReplaceAlpha or (ARawImage.Description.AlphaPrec = 0) then
+          copyProc := @CopyFrom32Bit_SwapRedBlue_SetAlpha
+        else if DefaultOpacity = 0 then
+          copyProc := @CopyFrom32Bit_SwapRedBlue_KeepAlpha
+        else
+          copyProc := @CopyFrom32Bit_SwapRedBlue_ReplaceZeroAlpha;
+      end;
+    end;
+  end;
+  DoCopyProc(ADestination, copyProc, ARawImage.Data, ARawImage.Description.BytesPerLine, ARawImage.Description.BitsPerPixel, ARawImage.Description.LineOrder, DefaultOpacity);
   ADestination.InvalidateBitmap;
+  ApplyRawImageMask(ADestination, ARawImage);
   result := true;
 end;
 …
 begin
   if FBitmap <> nil then
+  begin
     LoadFromRawImage(FBitmap.RawImage, FCanvasOpacity);
+    if FAlphaCorrectionNeeded then DoAlphaCorrection;
+  end;
 end;
 …
   FBitmap.Canvas.AntialiasingMode := amOff;
   FBitmapModified := False;
+  FAlphaCorrectionNeeded:= false;
 end;
 …
   end else
     inherited Assign(Source);
+  if Source is TCursorImage then
+  begin
+    HotSpot := TCursorImage(Source).HotSpot;
+    ExtractXorMask;
+  end
+  else if Source is TIcon then
+  begin
+    HotSpot := Point(0,0);
+    ExtractXorMask;
+  end;
+end;
+procedure TBGRALCLBitmap.LoadFromResource(AFilename: string;
+  AOptions: TBGRALoadingOptions);
+var
+  icon: TCustomIcon;
+  ext: String;
+begin
+  if BGRAResource.IsWinResource(AFilename) then
+  begin
+    ext:= Uppercase(ExtractFileExt(AFilename));
+    if (ext = '.ICO') or (ext = '.CUR') then
+    begin
+      if ext= '.ICO' then icon := TIcon.Create
+      else icon := TCursorImage.Create;
+      try
+        icon.LoadFromResourceName(HInstance, ChangeFileExt(AFilename,''));
+        icon.Current:= icon.GetBestIndexForSize(Size(65536,65536));
+        self.AssignRasterImage(icon);
+      finally
+        icon.Free;
+      end;
+      exit;
+    end;
+  end;
+  inherited LoadFromResource(AFilename, AOptions);
 end;
 …
   DiscardBitmapChange;
   SetSize(ARaster.Width, ARaster.Height);
+  if not LoadFromRawImage(ARaster.RawImage,0,False,False) then
+  if ARaster is TBitmap then
+  if LoadFromRawImage(ARaster.RawImage,0,False,False) then
+  begin
+    If Empty then
+    begin
+      AlphaFill(255); // if bitmap seems to be empty, assume
+                      // it is an opaque bitmap without alpha channel
+      ApplyRawImageMask(self, ARaster.RawImage);
+    end;
+  end else
+  if (ARaster is TBitmap) or (ARaster is TCustomIcon) then
   begin //try to convert
     TempBmp := TBitmap.Create;
 …
     TempBmp.Canvas.Draw(0,0,ARaster);
     try
+      LoadFromRawImage(TempBmp.RawImage,0,False,true);
+      LoadFromRawImage(TempBmp.RawImage,255,False,true);
+      ApplyRawImageMask(self, ARaster.RawImage);
     finally
       TempBmp.Free;
 …
   end else
     raise Exception.Create('Unable to convert image to 24 bit');
+  If Empty then AlphaFill(255); // if bitmap seems to be empty, assume
+                                // it is an opaque bitmap without alpha channel
+end;
+procedure TBGRALCLBitmap.ExtractXorMask;
+var
+  y, x: Integer;
+  p: PBGRAPixel;
+begin
+  DiscardXorMask;
+  for y := 0 to Height-1 do
+  begin
+    p := ScanLine[y];
+    for x := 0 to Width-1 do
+    begin
+      if (p^.alpha = 0) and (PDWord(p)^<>0) then
+      begin
+        NeedXorMask;
+        XorMask.SetPixel(x,y, p^);
+      end;
+      inc(p);
+    end;
+  end;
 end;
 …
 end;
 procedure TBGRALCLBitmap.DataDrawOpaque(ACanvas: TCanvas; Rect: TRect;
+procedure TBGRALCLBitmap.DataDrawOpaque(ACanvas: TCanvas; ARect: TRect;
   AData: Pointer; ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer);
 begin
   DataDrawOpaqueImplementation(ACanvas, Rect, AData, ALineOrder, AWidth, AHeight);
+  DataDrawOpaqueImplementation(ACanvas, ARect, AData, ALineOrder, AWidth, AHeight);
 end;
 …
 end;
 procedure TBGRALCLBitmap.LoadFromDevice(DC: System.THandle);
+procedure TBGRALCLBitmap.LoadFromDevice(DC: HDC);
 var
   rawImage: TRawImage;
 …
 end;
 procedure TBGRALCLBitmap.LoadFromDevice(DC: System.THandle; ARect: TRect);
+procedure TBGRALCLBitmap.LoadFromDevice(DC: HDC; ARect: TRect);
 var
   rawImage: TRawImage;

GraphicTest/Packages/bgrabitmap/bgramatrix3d.pas

-              r494
+              r521
 operator*(constref A: TMatrix3D; var M: TPoint3D_128): TPoint3D_128;
 {$IFDEF BGRASSE_AVAILABLE}var oldMt: single; {$ENDIF}
+{$IFDEF BGRASSE_AVAILABLE}var oldMt: single; resultAddr: pointer;{$ENDIF}
 begin
   {$IFDEF BGRASSE_AVAILABLE}
 …
     oldMt := M.t;
     M.t := SingleConst1;
+    resultAddr := @result;
+    {$IFDEF cpux86_64}
     if UseSSE3 then
     asm
       mov eax, A
       movups xmm5, [eax]
       movups xmm6, [eax+16]
       movups xmm7, [eax+32]
       mov eax, M
       movups xmm0, [eax]
       mov eax, result
+      mov rax, A
+      movups xmm5, [rax]
+      movups xmm6, [rax+16]
+      movups xmm7, [rax+32]
+      mov rax, M
+      movups xmm0, [rax]
+      mov rax, resultAddr
       movaps xmm4,xmm0
 …
       haddps xmm4,xmm4
       haddps xmm4,xmm4
       movss [eax], xmm4
+      movss [rax], xmm4
       movaps xmm4,xmm0
 …
       haddps xmm4,xmm4
       haddps xmm4,xmm4
       movss [eax+4], xmm4
+      movss [rax+4], xmm4
       mulps xmm0,xmm7
       haddps xmm0,xmm0
       haddps xmm0,xmm0
       movss [eax+8], xmm0
+      movss [rax+8], xmm0
     end else
     asm
       mov eax, A
       movups xmm5, [eax]
       movups xmm6, [eax+16]
       movups xmm7, [eax+32]
       mov eax, M
       movups xmm0, [eax]
       mov eax, result
+      mov rax, A
+      movups xmm5, [rax]
+      movups xmm6, [rax+16]
+      movups xmm7, [rax+32]
+      mov rax, M
+      movups xmm0, [rax]
+      mov rax, resultAddr
       movaps xmm4,xmm0
 …
       addps xmm4, xmm3
       movss [eax], xmm4
+      movss [rax], xmm4
       movaps xmm4,xmm0
 …
       addps xmm4, xmm3
       movss [eax+4], xmm4
+      movss [rax+4], xmm4
       mulps xmm0,xmm7
 …
       addps xmm0, xmm3
+      movss [rax+8], xmm0
+    end;
+    {$ELSE}
+    if UseSSE3 then
+    asm
+      mov eax, A
+      movups xmm5, [eax]
+      movups xmm6, [eax+16]
+      movups xmm7, [eax+32]
+      mov eax, M
+      movups xmm0, [eax]
+      mov eax, resultAddr
+      movaps xmm4,xmm0
+      mulps xmm4,xmm5
+      haddps xmm4,xmm4
+      haddps xmm4,xmm4
+      movss [eax], xmm4
+      movaps xmm4,xmm0
+      mulps xmm4,xmm6
+      haddps xmm4,xmm4
+      haddps xmm4,xmm4
+      movss [eax+4], xmm4
+      mulps xmm0,xmm7
+      haddps xmm0,xmm0
+      haddps xmm0,xmm0
+      movss [eax+8], xmm0
+    end else
+    asm
+      mov eax, A
+      movups xmm5, [eax]
+      movups xmm6, [eax+16]
+      movups xmm7, [eax+32]
+      mov eax, M
+      movups xmm0, [eax]
+      mov eax, resultAddr
+      movaps xmm4,xmm0
+      mulps xmm4,xmm5
+      //mix1
+      movaps xmm3, xmm4
+      shufps xmm3, xmm3, $4e
+      addps xmm4, xmm3
+      //mix2
+      movaps xmm3, xmm4
+      shufps xmm3, xmm3, $11
+      addps xmm4, xmm3
+      movss [eax], xmm4
+      movaps xmm4,xmm0
+      mulps xmm4,xmm6
+      //mix1
+      movaps xmm3, xmm4
+      shufps xmm3, xmm3, $4e
+      addps xmm4, xmm3
+      //mix2
+      movaps xmm3, xmm4
+      shufps xmm3, xmm3, $11
+      addps xmm4, xmm3
+      movss [eax+4], xmm4
+      mulps xmm0,xmm7
+      //mix1
+      movaps xmm3, xmm0
+      shufps xmm3, xmm3, $4e
+      addps xmm0, xmm3
+      //mix2
+      movaps xmm3, xmm0
+      shufps xmm3, xmm3, $11
+      addps xmm0, xmm3
       movss [eax+8], xmm0
     end;
+    {$ENDIF}
     M.t := oldMt;
     result.t := 0;

GraphicTest/Packages/bgrabitmap/bgramultifiletype.pas

-              r494
+              r521
 {$mode objfpc}{$H+}
+{$MODESWITCH ADVANCEDRECORDS}
 interface
 …
 uses
   Classes, SysUtils, fgl;
+type
+  { TEntryFilename }
+  TEntryFilename = record
+  private
+    FExtension: utf8string;
+    FName: utf8string;
+    function GetFilename: utf8string;
+    function GetIsEmpty: boolean;
+    procedure SetExtension(AValue: utf8string);
+    procedure SetFilename(AValue: utf8string);
+    procedure SetName(AValue: utf8string);
+  public
+    class operator =(const AValue1,AValue2: TEntryFilename): boolean;
+    property Filename: utf8string read GetFilename write SetFilename;
+    property Name: utf8string read FName write SetName;
+    property Extension: utf8string read FExtension write SetExtension;
+    property IsEmpty: boolean read GetIsEmpty;
+  end;
+function EntryFilename(AName,AExtension: string): TEntryFilename; overload;
+function EntryFilename(AFilename: string): TEntryFilename; overload;
 type
 …
   public
     constructor Create(AContainer: TMultiFileContainer);
     function CopyTo({%H-}ADestination: TStream): integer; virtual;
+    function CopyTo({%H-}ADestination: TStream): int64; virtual;
     property Name: utf8string read GetName write SetName;
     property Extension: utf8string read GetExtension;
 …
   protected
     procedure Init; virtual;
     function AddEntry(AEntry: TMultiFileEntry): integer;
+    function AddEntry(AEntry: TMultiFileEntry; AIndex: integer = -1): integer;
     function GetCount: integer;
     function GetEntry(AIndex: integer): TMultiFileEntry;
     function CreateEntry(AName: utf8string; AExtension: utf8string; AContent: TStream): TMultiFileEntry; virtual; abstract;
+    function GetRawString(AIndex: integer): RawByteString;
+    function GetRawStringByFilename(AFilename: string): RawByteString;
+    procedure SetRawString(AIndex: integer; AValue: RawByteString);
+    procedure SetRawStringByFilename(AFilename: string; AValue: RawByteString);
   public
+    constructor Create;
+    constructor Create(AFilename: utf8string);
+    constructor Create(AStream: TStream);
+    constructor Create(AStream: TStream; AStartPos: Int64);
+    function Add(AName: utf8string; AExtension: utf8string; AContent: TStream; AOverwrite: boolean = false; AOwnStream: boolean = true): integer;
+    function Add(AName: utf8string; AExtension: utf8string; AContent: utf8String; AOverwrite: boolean = false): integer;
+    constructor Create; overload;
+    constructor Create(AFilename: utf8string); overload;
+    constructor Create(AStream: TStream); overload;
+    constructor Create(AStream: TStream; AStartPos: Int64); overload;
+    function Add(AName: utf8string; AExtension: utf8string; AContent: TStream; AOverwrite: boolean = false; AOwnStream: boolean = true): integer; overload;
+    function Add(AName: utf8string; AExtension: utf8string; AContent: RawByteString; AOverwrite: boolean = false): integer; overload;
+    function Add(AFilename: TEntryFilename; AContent: TStream; AOverwrite: boolean = false; AOwnStream: boolean = true): integer; overload;
+    function Add(AFilename: TEntryFilename; AContent: RawByteString; AOverwrite: boolean = false): integer; overload;
     procedure Clear; virtual;
     destructor Destroy; override;
     procedure LoadFromFile(AFilename: utf8string);
     procedure LoadFromStream(AStream: TStream); virtual; abstract;
+    procedure LoadFromResource(AFilename: string); virtual;
     procedure SaveToFile(AFilename: utf8string);
     procedure SaveToStream(ADestination: TStream); virtual; abstract;
     procedure Remove(AEntry: TMultiFileEntry); virtual;
+    procedure Delete(AIndex: integer); virtual; overload;
+    function Delete(AName: utf8string; AExtension: utf8string;ACaseSensitive: boolean = True): boolean; overload;
+    function IndexOf(AEntry: TMultiFileEntry): integer;
+    function IndexOf(AName: utf8string; AExtenstion: utf8string; ACaseSensitive: boolean = True): integer; virtual;
+    procedure Delete(AIndex: integer); overload; virtual;
+    function Delete(AName: utf8string; AExtension: utf8string; ACaseSensitive: boolean = True): boolean; overload;
+    function Delete(AFilename: TEntryFilename; ACaseSensitive: boolean = True): boolean; overload;
+    function IndexOf(AEntry: TMultiFileEntry): integer; overload;
+    function IndexOf(AName: utf8string; AExtenstion: utf8string; ACaseSensitive: boolean = True): integer; overload; virtual;
+    function IndexOf(AFilename: TEntryFilename; ACaseSensitive: boolean = True): integer; overload;
     property Count: integer read GetCount;
     property Entry[AIndex: integer]: TMultiFileEntry read GetEntry;
+    property RawString[AIndex: integer]: RawByteString read GetRawString write SetRawString;
+    property RawStringByFilename[AFilename: string]: RawByteString read GetRawStringByFilename write SetRawStringByFilename;
   end;
 implementation
+uses BGRAUTF8;
+uses BGRAUTF8, strutils, BGRABitmapTypes;
+{ TEntryFilename }
+function TEntryFilename.GetFilename: utf8string;
+begin
+  if Extension = '' then
+    result := Name
+  else
+    result := Name+'.'+Extension;
+end;
+function TEntryFilename.GetIsEmpty: boolean;
+begin
+  result := (FName='') and (FExtension = '');
+end;
+procedure TEntryFilename.SetExtension(AValue: utf8string);
+var
+  i: Integer;
+begin
+  if FExtension=AValue then Exit;
+  for i := 1 to length(AValue) do
+    if AValue[i] in ['.','/'] then
+      raise Exception.Create('Invalid extension');
+  FExtension:=AValue;
+end;
+procedure TEntryFilename.SetFilename(AValue: utf8string);
+var
+  idxDot: SizeInt;
+begin
+  idxDot := RPos('.',AValue);
+  if idxDot = 0 then
+  begin
+    Name := AValue;
+    Extension := '';
+  end
+  else
+  begin
+    Name := copy(AValue,1,idxDot-1);
+    Extension := copy(AValue,idxDot+1,length(AValue)-idxDot);
+  end;
+end;
+procedure TEntryFilename.SetName(AValue: utf8string);
+var
+  i: Integer;
+begin
+  if FName=AValue then Exit;
+  for i := 1 to length(AValue) do
+    if AValue[i] = '/' then
+      raise Exception.Create('Invalid name');
+  FName:=AValue;
+end;
+function EntryFilename(AName, AExtension: string): TEntryFilename;
+begin
+  result.Name := AName;
+  result.Extension:= AExtension;
+end;
+function EntryFilename(AFilename: string): TEntryFilename;
+begin
+  result.Filename:= AFilename;
+end;
+class operator TEntryFilename.=(const AValue1, AValue2: TEntryFilename): boolean;
+begin
+  result := (AValue1.Name = AValue2.Name) and (AValue1.Extension = AValue2.Extension);
+end;
 { TMultiFileEntry }
 …
 end;
 function TMultiFileEntry.CopyTo(ADestination: TStream): integer;
+function TMultiFileEntry.CopyTo(ADestination: TStream): int64;
 begin
   result := 0;
 …
 function TMultiFileContainer.GetCount: integer;
 begin
+  result := FEntries.Count;
+  if Assigned(FEntries) then
+    result := FEntries.Count
+  else
+    result := 0;
 end;
 …
 end;
+function TMultiFileContainer.GetRawString(AIndex: integer): RawByteString;
+var s: TStringStream;
+begin
+  s := TStringStream.Create('');
+  try
+    Entry[AIndex].CopyTo(s);
+    result := s.DataString;
+  finally
+    s.Free;
+  end;
+end;
+function TMultiFileContainer.GetRawStringByFilename(AFilename: string
+  ): RawByteString;
+var
+  idx: Integer;
+begin
+  idx := IndexOf(EntryFilename(AFilename));
+  if idx = -1 then
+    result := ''
+  else
+    result := GetRawString(idx);
+end;
+procedure TMultiFileContainer.SetRawString(AIndex: integer;
+  AValue: RawByteString);
+begin
+  with Entry[AIndex] do
+    Add(Name, Extension, AValue, true);
+end;
+procedure TMultiFileContainer.SetRawStringByFilename(AFilename: string;
+  AValue: RawByteString);
+var
+  f: TEntryFilename;
+begin
+  f := EntryFilename(AFilename);
+  Add(f.Name,f.Extension,AValue,true);
+end;
 procedure TMultiFileContainer.Init;
 begin
 …
 end;
+function TMultiFileContainer.AddEntry(AEntry: TMultiFileEntry): integer;
+begin
+  result := FEntries.Add(AEntry);
+function TMultiFileContainer.AddEntry(AEntry: TMultiFileEntry; AIndex: integer): integer;
+begin
+  if not Assigned(FEntries) then
+    raise exception.Create('Entry list not created');
+  if (AIndex >= 0) and (AIndex < FEntries.Count) then
+  begin
+    FEntries.Insert(AIndex, AEntry);
+    result := AIndex;
+  end
+  else
+    result := FEntries.Add(AEntry);
 end;
 …
     newEntry := CreateEntry(AName, AExtension, AContent);
   if Assigned(newEntry) then
     result := AddEntry(newEntry)
+    result := AddEntry(newEntry, index)
   else
     raise exception.Create('Unable to create entry');
 …
 function TMultiFileContainer.Add(AName: utf8string; AExtension: utf8string;
   AContent: utf8String; AOverwrite: boolean): integer;
+  AContent: RawByteString; AOverwrite: boolean): integer;
 var stream: TMemoryStream;
 begin
   stream := TMemoryStream.Create;
   stream.Write(AContent[1],length(AContent));
+  if length(AContent) > 0 then stream.Write(AContent[1],length(AContent));
   result := Add(AName,AExtension,stream,AOverwrite);
+end;
+function TMultiFileContainer.Add(AFilename: TEntryFilename; AContent: TStream;
+  AOverwrite: boolean; AOwnStream: boolean): integer;
+begin
+  result := Add(AFilename.Name,AFilename.Extension, AContent, AOverwrite, AOwnStream);
+end;
+function TMultiFileContainer.Add(AFilename: TEntryFilename;
+  AContent: RawByteString; AOverwrite: boolean): integer;
+begin
+  result := Add(AFilename.Name,AFilename.Extension, AContent, AOverwrite);
 end;
 …
   LoadFromStream(stream);
   stream.Free;
+end;
+procedure TMultiFileContainer.LoadFromResource(AFilename: string);
+var
+  stream: TStream;
+begin
+  stream := BGRAResource.GetResourceStream(AFilename);
+  try
+    LoadFromStream(stream);
+  finally
+    stream.Free;
+  end;
 end;
 …
     result := true;
   end;
+end;
+function TMultiFileContainer.Delete(AFilename: TEntryFilename;
+  ACaseSensitive: boolean): boolean;
+begin
+  result := Delete(AFilename.Name,AFilename.Extension,ACaseSensitive);
 end;
 …
 end;
+function TMultiFileContainer.IndexOf(AFilename: TEntryFilename;
+  ACaseSensitive: boolean): integer;
+begin
+  result := IndexOf(AFilename.Name,AFilename.Extension,ACaseSensitive);
+end;
 procedure TMultiFileContainer.Clear;
 var

GraphicTest/Packages/bgrabitmap/bgranoguibitmap.pas

-              r494
+              r521
     procedure TakeScreenshot({%H-}ARect: TRect); override; //not available
     procedure TakeScreenshotOfPrimaryMonitor; override; //not available
     procedure LoadFromDevice({%H-}DC: System.THandle); override; //not available
     procedure LoadFromDevice({%H-}DC: System.THandle; {%H-}ARect: TRect); override; //not available
+    procedure LoadFromDevice({%H-}DC: HDC); override; //not available
+    procedure LoadFromDevice({%H-}DC: HDC; {%H-}ARect: TRect); override; //not available
     property Canvas: TBGRACanvas read GetPseudoCanvas;
   end;
 …
 end;
 procedure TBGRANoGUIBitmap.LoadFromDevice(DC: System.THandle);
+procedure TBGRANoGUIBitmap.LoadFromDevice(DC: HDC);
 begin
   NotAvailable;
 end;
 procedure TBGRANoGUIBitmap.LoadFromDevice(DC: System.THandle; ARect: TRect);
+procedure TBGRANoGUIBitmap.LoadFromDevice(DC: HDC; ARect: TRect);
 begin
   NotAvailable;

GraphicTest/Packages/bgrabitmap/bgraopengl.pas

-              r494
+              r521
   Classes, SysUtils, FPimage, BGRAGraphics,
   BGRAOpenGLType, BGRASpriteGL, BGRACanvasGL, GL, GLext, GLU, BGRABitmapTypes,
   BGRAFontGL, BGRASSE;
+  BGRAFontGL, BGRASSE, BGRAMatrix3D;
 type
 …
     property Width: integer read GetWidth;
     property Height: integer read GetHeight;
+  end;
+  { TBGLFrameBuffer }
+  TBGLFrameBuffer = class(TBGLCustomFrameBuffer)
+  protected
+    FHeight: integer;
+    FMatrix: TAffineMatrix;
+    FProjectionMatrix: TMatrix4D;
+    FTexture: IBGLTexture;
+    FFrameBufferId, FRenderBufferId: GLuint;
+    FWidth: integer;
+    FSettingMatrices: boolean;
+    function GetTexture: IBGLTexture; override;
+    function GetHandle: pointer; override;
+    function GetHeight: integer; override;
+    function GetMatrix: TAffineMatrix; override;
+    function GetProjectionMatrix: TMatrix4D; override;
+    function GetWidth: integer; override;
+    procedure SetMatrix(AValue: TAffineMatrix); override;
+    procedure SetProjectionMatrix(AValue: TMatrix4D); override;
+  public
+    constructor Create(AWidth,AHeight: integer);
+    function MakeTextureAndFree: IBGLTexture; override;
+    destructor Destroy; override;
   end;
 …
 implementation
+uses BGRATransform{$IFDEF BGRABITMAP_USE_LCL}, BGRAText, BGRATextFX{$ENDIF}
+    ,BGRAMatrix3D;
+uses BGRABlurGL, BGRATransform{$IFDEF BGRABITMAP_USE_LCL}, BGRAText, BGRATextFX{$ENDIF};
 type
 …
     procedure ToggleFlipY; override;
     procedure Bind(ATextureNumber: integer); override;
+    function FilterBlurMotion(ARadius: single; ABlurType: TRadialBlurType; ADirection: TPointF): IBGLTexture; override;
+    function FilterBlurRadial(ARadius: single; ABlurType: TRadialBlurType): IBGLTexture; override;
   end;
 …
     procedure InternalStartPolygon(const pt: TPointF); override;
     procedure InternalStartTriangleFan(const pt: TPointF); override;
     procedure InternalContinueShape(const pt: TPointF); override;
     procedure InternalContinueShape(const pt: TPoint3D); override;
     procedure InternalContinueShape(const pt: TPoint3D_128); override;
     procedure InternalContinueShape(const pt, normal: TPoint3D_128); override;
+    procedure InternalContinueShape(const pt: TPointF); overload; override;
+    procedure InternalContinueShape(const pt: TPoint3D); overload; override;
+    procedure InternalContinueShape(const pt: TPoint3D_128); overload; override;
+    procedure InternalContinueShape(const pt, normal: TPoint3D_128); overload; override;
     procedure InternalEndShape; override;
 …
     function GetBlendMode: TOpenGLBlendMode; override;
     procedure SetBlendMode(AValue: TOpenGLBlendMode); override;
+    procedure SetActiveFrameBuffer(AValue: TBGLCustomFrameBuffer); override;
   public
     destructor Destroy; override;
 …
     procedure EndZBuffer; override;
     procedure WaitForGPU(AOption: TWaitForGPUOption); override;
+    function GetImage(x, y, w, h: integer): TBGRACustomBitmap; override;
+    function CreateFrameBuffer(AWidth, AHeight: integer): TBGLCustomFrameBuffer; override;
   end;
 …
     function GetUniformVariable(AProgram: DWord; AName: string): DWord; override;
     function GetAttribVariable(AProgram: DWord; AName: string): DWord; override;
     procedure SetUniformSingle(AVariable: DWord; const AValue; ACount: integer); override;
     procedure SetUniformInteger(AVariable: DWord; const AValue; ACount: integer); override;
+    procedure SetUniformSingle(AVariable: DWord; const AValue; AElementCount, AComponentCount: integer); override;
+    procedure SetUniformInteger(AVariable: DWord; const AValue; AElementCount, AComponentCount: integer); override;
     procedure BindAttribute(AAttribute: TAttributeVariable); override;
     procedure UnbindAttribute(AAttribute: TAttributeVariable); override;
   end;
+{ TBGLFrameBuffer }
+procedure TBGLFrameBuffer.SetMatrix(AValue: TAffineMatrix);
+begin
+  if FSettingMatrices then Exit;
+  FSettingMatrices := true;
+  FMatrix:=AValue;
+  if FCanvas <> nil then
+    TBGLCustomCanvas(FCanvas).Matrix := AValue;
+  FSettingMatrices := false;
+end;
+function TBGLFrameBuffer.GetMatrix: TAffineMatrix;
+begin
+  result := FMatrix;
+end;
+function TBGLFrameBuffer.GetTexture: IBGLTexture;
+begin
+  result := FTexture.FlipY;
+end;
+function TBGLFrameBuffer.GetHandle: pointer;
+begin
+  result := @FFrameBufferId;
+end;
+function TBGLFrameBuffer.GetHeight: integer;
+begin
+  result := FHeight;
+end;
+function TBGLFrameBuffer.GetProjectionMatrix: TMatrix4D;
+begin
+  result := FProjectionMatrix;
+end;
+function TBGLFrameBuffer.GetWidth: integer;
+begin
+  result := FWidth;
+end;
+procedure TBGLFrameBuffer.SetProjectionMatrix(AValue: TMatrix4D);
+begin
+  if FSettingMatrices then Exit;
+  FSettingMatrices := true;
+  FProjectionMatrix:= AValue;
+  if FCanvas <> nil then
+    TBGLCustomCanvas(FCanvas).ProjectionMatrix := AValue;
+  FSettingMatrices := false;
+end;
+constructor TBGLFrameBuffer.Create(AWidth, AHeight: integer);
+var frameBufferStatus: GLenum;
+begin
+  if not Load_GL_version_3_0 then
+      raise exception.Create('Cannot load OpenGL 3.0');
+  FWidth := AWidth;
+  FHeight := AHeight;
+  FTexture := BGLTextureFactory.Create(nil,AWidth,AHeight,AWidth,AHeight);
+  //depth and stencil
+  glGenRenderbuffers(1, @FRenderBufferId);
+  glBindRenderbuffer(GL_RENDERBUFFER, FRenderBufferId);
+  glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, AWidth,AHeight);
+  glBindRenderbuffer(GL_RENDERBUFFER, 0);
+  glGenFramebuffers(1, @FFrameBufferId);
+  glBindFramebuffer(GL_FRAMEBUFFER, FFrameBufferId);
+  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, PGLuint(FTexture.Handle)^, 0);
+  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, FFrameBufferId);
+  frameBufferStatus:= glCheckFramebufferStatus(GL_FRAMEBUFFER);
+  glBindFramebuffer(GL_FRAMEBUFFER, 0);
+  if frameBufferStatus <> GL_FRAMEBUFFER_COMPLETE then
+  begin
+    glDeleteFramebuffers(1, @FFrameBufferId);
+    glDeleteRenderbuffers(1, @FRenderBufferId);
+    FTexture := nil;
+    raise exception.Create('Error ' + inttostr(frameBufferStatus) + ' while initializing frame buffer');
+  end;
+  UseOrthoProjection;
+  Matrix := AffineMatrixIdentity;
+end;
+function TBGLFrameBuffer.MakeTextureAndFree: IBGLTexture;
+begin
+  result := FTexture;
+  FTexture := nil;
+  Free;
+end;
+destructor TBGLFrameBuffer.Destroy;
+begin
+  glDeleteFramebuffers(1, @FFrameBufferId);
+  glDeleteRenderbuffers(1, @FRenderBufferId);
+  FTexture := nil;
+  inherited Destroy;
+end;
 procedure ApplyBlendMode(ABlendMode: TOpenGLBlendMode);
 …
 procedure TBGLLighting.SetUniformSingle(AVariable: DWord;
   const AValue; ACount: integer);
+  const AValue; AElementCount, AComponentCount: integer);
 begin
   NeedOpenGL2_0;
+  glUniform1fv(AVariable, ACount, @AValue);
+  case AComponentCount of
+: glUniform1fv(AVariable, AElementCount, @AValue);
+: glUniform2fv(AVariable, AElementCount, @AValue);
+: glUniform3fv(AVariable, AElementCount, @AValue);
+: glUniform4fv(AVariable, AElementCount, @AValue);
+: glUniformMatrix3fv(AVariable, AElementCount, GL_FALSE, @AValue);
+: glUniformMatrix4fv(AVariable, AElementCount, GL_FALSE, @AValue);
+  else
+    raise exception.Create('Unexpected number of components');
+  end;
 end;
 procedure TBGLLighting.SetUniformInteger(AVariable: DWord;
   const AValue; ACount: integer);
+  const AValue; AElementCount, AComponentCount: integer);
 begin
   NeedOpenGL2_0;
+  glUniform1iv(AVariable, ACount, @AValue);
+  case AComponentCount of
+: glUniform1iv(AVariable, AElementCount, @AValue);
+: glUniform2iv(AVariable, AElementCount, @AValue);
+: glUniform3iv(AVariable, AElementCount, @AValue);
+: glUniform4iv(AVariable, AElementCount, @AValue);
+  else
+    raise exception.Create('Unexpected number of components');
+  end;
 end;
 …
 function TBGLCanvas.GetMatrix: TAffineMatrix;
 begin
+  result := FMatrix;
+  if ActiveFrameBuffer <> nil then
+    result := ActiveFrameBuffer.Matrix
+  else
+    result := FMatrix;
 end;
 …
   m := AffineMatrixToMatrix4D(AValue);
   glLoadMatrixf(@m);
+  FMatrix := AValue;
+  if ActiveFrameBuffer <> nil then
+    ActiveFrameBuffer.Matrix := AValue
+  else
+    FMatrix := AValue;
 end;
 function TBGLCanvas.GetProjectionMatrix: TMatrix4D;
 begin
+  result := FProjectionMatrix;
+  if ActiveFrameBuffer <> nil then
+    result := ActiveFrameBuffer.ProjectionMatrix
+  else
+    result := FProjectionMatrix;
 end;
 procedure TBGLCanvas.SetProjectionMatrix(const AValue: TMatrix4D);
 begin
-  FProjectionMatrix := AValue;
   glMatrixMode(GL_PROJECTION);
   glLoadMatrixf(@AValue);
   glMatrixMode(GL_MODELVIEW);
+  if ActiveFrameBuffer <> nil then
+    ActiveFrameBuffer.ProjectionMatrix := AValue
+  else
+    FProjectionMatrix := AValue;
 end;
 …
 end;
+function TBGLCanvas.GetImage(x, y, w, h: integer): TBGRACustomBitmap;
+begin
+  NeedOpenGL2_0;
+  result := BGRABitmapFactory.Create(w,h);
+  if TBGRAPixel_RGBAOrder then
+    glReadPixels(x,self.Height-y-h, w,h, GL_RGBA, GL_UNSIGNED_BYTE, result.Data)
+  else
+    glReadPixels(x,self.Height-y-h, w,h, GL_BGRA, GL_UNSIGNED_BYTE, result.Data);
+end;
+function TBGLCanvas.CreateFrameBuffer(AWidth, AHeight: integer): TBGLCustomFrameBuffer;
+begin
+  Result:= TBGLFrameBuffer.Create(AWidth,AHeight);
+end;
 procedure TBGLCanvas.EnableScissor(AValue: TRect);
 begin
 …
 begin
   FBlendMode := AValue;
+end;
+procedure TBGLCanvas.SetActiveFrameBuffer(AValue: TBGLCustomFrameBuffer);
+var
+  m: TMatrix4D;
+begin
+  if AValue = ActiveFrameBuffer then exit;
+  inherited SetActiveFrameBuffer(AValue);
+  if AValue = nil then
+    glBindFramebuffer(GL_FRAMEBUFFER, 0)
+  else
+    glBindFramebuffer(GL_FRAMEBUFFER, PGLuint(AValue.Handle)^);
+  glViewPort(0,0,Width,Height);
+  glMatrixMode(GL_PROJECTION);
+  m := ProjectionMatrix;
+  glLoadMatrixf(@m);
+  glMatrixMode(GL_MODELVIEW);
+  m := AffineMatrixToMatrix4D(Matrix);
+  glLoadMatrixf(@m);
 end;
 …
 procedure TBGLTexture.ToggleFlipY;
 begin
   FFlipX := not FFlipY;
+  FFlipY := not FFlipY;
 end;
 …
 end;
+function TBGLTexture.FilterBlurMotion(ARadius: single; ABlurType: TRadialBlurType; ADirection: TPointF): IBGLTexture;
+var shader: TBGLCustomShader;
+  blurName: string;
+begin
+  blurName := 'TBGLBlurShader(' + RadialBlurTypeToStr[ABlurType] + ')';
+  shader := BGLCanvas.Lighting.Shader[blurName];
+  if shader = nil then
+  begin
+    shader := TBGLBlurShader.Create(BGLCanvas, ABlurType);
+    BGLCanvas.Lighting.Shader[blurName] := shader;
+  end;
+  with (shader as TBGLBlurShader) do
+  begin
+    Radius := ARadius;
+    Direction := ADirection;
+    result := FilterBlurMotion(self);
+  end;
+end;
+function TBGLTexture.FilterBlurRadial(ARadius: single; ABlurType: TRadialBlurType): IBGLTexture;
+var shader: TBGLCustomShader;
+  blurName: String;
+begin
+  blurName := 'TBGLBlurShader(' + RadialBlurTypeToStr[ABlurType] + ')';
+  shader := BGLCanvas.Lighting.Shader[blurName];
+  if shader = nil then
+  begin
+    shader := TBGLBlurShader.Create(BGLCanvas, ABlurType);
+    BGLCanvas.Lighting.Shader[blurName] := shader;
+  end;
+  with (shader as TBGLBlurShader) do
+  begin
+    Radius := ARadius;
+    result := FilterBlurRadial(self);
+  end;
+end;
 procedure TBGLTexture.Init(ATexture: TBGLTextureHandle; AWidth,
   AHeight: integer; AOwned: boolean);

GraphicTest/Packages/bgrabitmap/bgraopengl3d.pas

-              r494
+              r521
   end;
+  { TUniformVariableMatrix4D }
+  TUniformVariableMatrix4D = object(TUniformVariable)
+  private
+    FValue: TMatrix4D;
+    procedure SetValue(const AValue: TMatrix4D);
+  public
+    procedure Update;
+    property Value: TMatrix4D read FValue write SetValue;
+  end;
   { TAttributeVariableSingle }
 …
     function GetUniformVariableInteger(AName: string): TUniformVariableInteger;
     function GetUniformVariablePoint(AName: string): TUniformVariablePoint;
+    function GetUniformVariableMatrix4D(AName: string): TUniformVariableMatrix4D;
     function GetAttributeVariableInteger(AName: string): TAttributeVariableInteger;
     function GetAttributeVariablePoint(AName: string): TAttributeVariablePoint;
 …
     function GetAttributeVariablePointF(AName: string): TAttributeVariablePointF;
     function GetAttributeVariablePoint3D(AName: string): TAttributeVariablePoint3D;
     procedure SetUniformSingle(AVariable: DWord; const AValue; ACount: integer);
     procedure SetUniformInteger(AVariable: DWord; const AValue; ACount: integer);
+    procedure SetUniformSingle(AVariable: DWord; const AValue; AElementCount: integer; AComponentCount: integer);
+    procedure SetUniformInteger(AVariable: DWord; const AValue; AElementCount: integer; AComponentCount: integer);
     procedure CheckUsage(AUsing: boolean);
     procedure StartUse; override;
     procedure EndUse; override;
+    property Canvas: TBGLCustomCanvas read FCanvas;
   public
     constructor Create(ACanvas: TBGLCustomCanvas; AVertexShaderSource: string;
         AFragmentShaderSource: string; AVaryingVariables: string = '';
         AVersion: string = '110');
+        AVersion: string = '120');
     destructor Destroy; override;
     property UniformSingle[AName: string]: TUniformVariableSingle read GetUniformVariableSingle;
 …
     property UniformInteger[AName: string]: TUniformVariableInteger read GetUniformVariableInteger;
     property UniformPoint[AName: string]: TUniformVariablePoint read GetUniformVariablePoint;
+    property UniformMatrix4D[AName: string]: TUniformVariableMatrix4D read GetUniformVariableMatrix4D;
     property AttributeSingle[AName: string]: TAttributeVariableSingle read GetAttributeVariableSingle;
     property AttributePointF[AName: string]: TAttributeVariablePointF read GetAttributeVariablePointF;
 …
 end;
+{ TUniformVariableMatrix4D }
+procedure TUniformVariableMatrix4D.SetValue(const AValue: TMatrix4D);
+begin
+  if CompareMem(@AValue, @FValue, sizeof(FValue)) then Exit;
+  FValue:=AValue;
+  if FProgram.IsUsed then Update;
+end;
+procedure TUniformVariableMatrix4D.Update;
+begin
+  FProgram.SetUniformSingle(FVariable, FValue, 1, 16);
+end;
 { TShaderWithTexture }
 …
 procedure TUniformVariablePoint.Update;
 begin
   FProgram.SetUniformInteger(FVariable, FValue, 2);
+  FProgram.SetUniformInteger(FVariable, FValue, 1, 2);
 end;
 …
 procedure TUniformVariableInteger.Update;
 begin
   FProgram.SetUniformInteger(FVariable, FValue, 1);
+  FProgram.SetUniformInteger(FVariable, FValue, 1, 1);
 end;
 …
 procedure TUniformVariablePoint3D.Update;
 begin
   FProgram.SetUniformSingle(FVariable, FValue, 3);
+  FProgram.SetUniformSingle(FVariable, FValue, 1, 3);
 end;
 …
 procedure TUniformVariablePointF.Update;
 begin
   FProgram.SetUniformSingle(FVariable, FValue, 2);
+  FProgram.SetUniformSingle(FVariable, FValue, 1, 2);
 end;
 …
 procedure TUniformVariableSingle.Update;
 begin
   FProgram.SetUniformSingle(FVariable, FValue, 1);
+  FProgram.SetUniformSingle(FVariable, FValue, 1, 1);
 end;
 …
 end;
+function TBGLShader3D.GetUniformVariableMatrix4D(AName: string): TUniformVariableMatrix4D;
+begin
+  {$push}{$hints off}
+  fillchar(result,sizeof(result),0);
+  result.Init(self, FCanvas.Lighting.GetUniformVariable(FProgram, AName));
+  {$pop}
+end;
 procedure TBGLShader3D.CheckUsage(AUsing: boolean);
 begin
 …
 end;
 procedure TBGLShader3D.SetUniformSingle(AVariable: DWord; const AValue; ACount: integer);
+procedure TBGLShader3D.SetUniformSingle(AVariable: DWord; const AValue; AElementCount: integer; AComponentCount: integer);
 begin
   CheckUsage(True);
   FCanvas.Lighting.SetUniformSingle(AVariable, AValue, ACount);
 end;
 procedure TBGLShader3D.SetUniformInteger(AVariable: DWord; const AValue; ACount: integer);
+  FCanvas.Lighting.SetUniformSingle(AVariable, AValue, AElementCount, AComponentCount);
+end;
+procedure TBGLShader3D.SetUniformInteger(AVariable: DWord; const AValue; AElementCount: integer; AComponentCount: integer);
 begin
   CheckUsage(True);
   FCanvas.Lighting.SetUniformInteger(AVariable, AValue, ACount);
+  FCanvas.Lighting.SetUniformInteger(AVariable, AValue, AElementCount, AComponentCount);
 end;
 …
   FCanvas := ACanvas;
   FLighting := FCanvas.Lighting;
   FVertexShaderSource:= '#define version ' + AVersion + #10 + AVaryingVariables + #10 + AVertexShaderSource;
   FFragmentShaderSource:= '#define version ' + AVersion + #10 + AVaryingVariables + #10 + AFragmentShaderSource;
+  FVertexShaderSource:= '#version ' + AVersion + #10 + AVaryingVariables + #10 + AVertexShaderSource;
+  FFragmentShaderSource:= '#version ' + AVersion + #10 + AVaryingVariables + #10 + AFragmentShaderSource;
   FVertexShader := 0;
   FFragmentShader := 0;

GraphicTest/Packages/bgrabitmap/bgraopengltype.pas

-              r494
+              r521
     procedure TextRect(ARect: TRectF; const Text : UTF8String; AHorizAlign: TAlignment; AVertAlign: TTextLayout; AColor: TBGRAPixel); overload;
     function TextWidth(const Text: UTF8String): single; virtual; abstract;
     function TextHeight(const Text: UTF8String): single; virtual; abstract; overload;
     function TextHeight(const Text: UTF8String; AWidth: single): single; virtual; abstract; overload;
+    function TextHeight(const Text: UTF8String): single; overload; virtual; abstract;
+    function TextHeight(const Text: UTF8String; AWidth: single): single; overload; virtual; abstract;
     procedure SetGradientColors(ATopLeft, ATopRight, ABottomRight, ABottomLeft: TBGRAPixel); virtual; abstract;
 …
     procedure ToggleFlipY;
     procedure ToggleMask;
+    function FilterBlurMotion(ARadius: single; ABlurType: TRadialBlurType; ADirection: TPointF): IBGLTexture;
+    function FilterBlurRadial(ARadius: single; ABlurType: TRadialBlurType): IBGLTexture;
     procedure SetFrame(AIndex: integer);
     procedure FreeMemory;
 …
     procedure DrawAffine(x,y: single; const AMatrix: TAffineMatrix; AAlpha: byte = 255); overload;
     procedure DrawAffine(x,y: single; const AMatrix: TAffineMatrix; AColor: TBGRAPixel); overload;
     procedure DrawTriangle(const APoints: array of TPointF; const ATexCoords: array of TPointF);
     procedure DrawTriangle(const APoints: array of TPointF; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawTriangle(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF);
     procedure DrawTriangle(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF);
     procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF);
     procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawQuad(const APoints: array of TPointF; const ATexCoords: array of TPointF);
     procedure DrawQuad(const APoints: array of TPointF; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawQuad(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF);
     procedure DrawQuad(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF);
     procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF);
     procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF);
+    procedure DrawTriangle(const APoints: array of TPointF; const ATexCoords: array of TPointF); overload;
+    procedure DrawTriangle(const APoints: array of TPointF; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawTriangle(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF); overload;
+    procedure DrawTriangle(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF); overload;
+    procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF); overload;
+    procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawQuad(const APoints: array of TPointF; const ATexCoords: array of TPointF); overload;
+    procedure DrawQuad(const APoints: array of TPointF; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawQuad(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF); overload;
+    procedure DrawQuad(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF); overload;
+    procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF); overload;
+    procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
     property Width: integer read GetWidth;
 …
     procedure NoClip; override;
     destructor Destroy; override;
     procedure SwapRedBlue; override; overload;
+    procedure SwapRedBlue; overload; override;
     function Resample(newWidth, newHeight: integer; mode: TResampleMode=rmFineResample): TBGRACustomBitmap; override;
     procedure ApplyGlobalOpacity(alpha: byte); override; overload;
     procedure ReplaceColor(before, after: TColor); override; overload;
     procedure ReplaceColor(before, after: TBGRAPixel); override; overload;
     procedure ReplaceTransparent(after: TBGRAPixel); override; overload;
+    procedure ApplyGlobalOpacity(alpha: byte); overload; override;
+    procedure ReplaceColor(before, after: TColor); overload; override;
+    procedure ReplaceColor(before, after: TBGRAPixel); overload; override;
+    procedure ReplaceTransparent(after: TBGRAPixel); overload; override;
     procedure SetClipRect(const AValue: TRect); override;
     procedure SetSize(AWidth, AHeight: integer); override;
 …
     procedure ToggleFlipY; virtual; abstract;
     procedure ToggleMask; virtual;
+    function FilterBlurMotion({%H-}ARadius: single; {%H-}ABlurType: TRadialBlurType; {%H-}ADirection: TPointF): IBGLTexture; virtual;
+    function FilterBlurRadial({%H-}ARadius: single; {%H-}ABlurType: TRadialBlurType): IBGLTexture; virtual;
     procedure SetFrameSize(x,y: integer);
 …
     procedure DrawAffine(x,y: single; const AMatrix: TAffineMatrix; AAlpha: byte = 255); overload;
     procedure DrawAffine(x,y: single; const AMatrix: TAffineMatrix; AColor: TBGRAPixel); overload;
     procedure DrawTriangle(const APoints: array of TPointF; const ATexCoords: array of TPointF);
     procedure DrawTriangle(const APoints: array of TPointF; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawTriangle(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF);
     procedure DrawTriangle(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF);
     procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF);
     procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawQuad(const APoints: array of TPointF; const ATexCoords: array of TPointF);
     procedure DrawQuad(const APoints: array of TPointF; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawQuad(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF);
     procedure DrawQuad(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF);
     procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF);
     procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF);
     procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF);
+    procedure DrawTriangle(const APoints: array of TPointF; const ATexCoords: array of TPointF); overload;
+    procedure DrawTriangle(const APoints: array of TPointF; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawTriangle(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF); overload;
+    procedure DrawTriangle(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF); overload;
+    procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF); overload;
+    procedure DrawTriangle(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawQuad(const APoints: array of TPointF; const ATexCoords: array of TPointF); overload;
+    procedure DrawQuad(const APoints: array of TPointF; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawQuad(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF); overload;
+    procedure DrawQuad(const APoints: array of TPointF; const APointsZ: array of Single; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF); overload;
+    procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
+    procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF); overload;
+    procedure DrawQuad(const APoints3D: array of TPoint3D_128; const ANormals3D: array of TPoint3D_128; const ATexCoords: array of TPointF; const AColors: array of TColorF); overload;
     property Width: integer read GetWidth;
 …
   end;
+  { TBGLCustomFrameBuffer }
+  TBGLCustomFrameBuffer = class
+  protected
+    FCanvas: pointer;
+    function GetTexture: IBGLTexture; virtual; abstract;
+    function GetHandle: pointer; virtual; abstract;
+    function GetMatrix: TAffineMatrix; virtual; abstract;
+    function GetHeight: integer; virtual; abstract;
+    function GetProjectionMatrix: TMatrix4D; virtual; abstract;
+    function GetWidth: integer; virtual; abstract;
+    procedure SetMatrix(AValue: TAffineMatrix); virtual; abstract;
+    procedure SetProjectionMatrix(AValue: TMatrix4D); virtual; abstract;
+  public
+    procedure UseOrthoProjection; overload; virtual;
+    procedure UseOrthoProjection(AMinX,AMinY,AMaxX,AMaxY: single); overload; virtual;
+    function MakeTextureAndFree: IBGLTexture; virtual;
+    procedure SetCanvas(ACanvas: Pointer); //for internal use
+    property Matrix: TAffineMatrix read GetMatrix write SetMatrix;
+    property ProjectionMatrix: TMatrix4D read GetProjectionMatrix write SetProjectionMatrix;
+    property Width: integer read GetWidth;
+    property Height: integer read GetHeight;
+    property Handle: pointer read GetHandle;
+    property Texture: IBGLTexture read GetTexture;
+  end;
 type
   TBGLBitmapAny = class of TBGLCustomBitmap;
 …
 uses BGRAFilterScanner;
+procedure TBGLCustomFrameBuffer.UseOrthoProjection;
+begin
+  ProjectionMatrix := OrthoProjectionToOpenGL(0,0,Width,Height);
+end;
+procedure TBGLCustomFrameBuffer.UseOrthoProjection(AMinX, AMinY, AMaxX, AMaxY: single);
+begin
+  ProjectionMatrix := OrthoProjectionToOpenGL(AMinX,AMinY,AMaxX,AMaxY);
+end;
+function TBGLCustomFrameBuffer.MakeTextureAndFree: IBGLTexture;
+begin
+  result := nil;
+  raise exception.create('Not implemented');
+end;
+procedure TBGLCustomFrameBuffer.SetCanvas(ACanvas: Pointer);
+begin
+  FCanvas := ACanvas;
+end;
 function OrthoProjectionToOpenGL(AMinX, AMinY, AMaxX, AMaxY: Single): TMatrix4D;
 …
 end;
+function TBGLCustomTexture.FilterBlurMotion(ARadius: single; ABlurType: TRadialBlurType;
+  ADirection: TPointF): IBGLTexture;
+begin
+  result := nil;
+  raise exception.Create('Not implemented');
+end;
+function TBGLCustomTexture.FilterBlurRadial(ARadius: single; ABlurType: TRadialBlurType): IBGLTexture;
+begin
+  result := nil;
+  raise exception.Create('Not implemented');
+end;
 procedure TBGLCustomTexture.Update(ARGBAData: PDWord; AllocatedWidth,
   AllocatedHeight, ActualWidth, ActualHeight: integer; RGBAOrder: boolean);
 …
     begin
       if not TBGRAPixel_RGBAOrder and not SupportsBGRAOrder then SwapRedBlue;
+      if LineOrder = riloBottomToTop then VerticalFlip;
       InitFromData(PDWord(Data), Width,Height, Width,Height, TBGRAPixel_RGBAOrder or not SupportsBGRAOrder);
+      if LineOrder = riloBottomToTop then VerticalFlip;
       if not TBGRAPixel_RGBAOrder and not SupportsBGRAOrder then SwapRedBlue;
     end;
 …
   AAlpha: byte);
 begin
+  {$PUSH}{$OPTIMIZATION OFF}
   DoDrawAffine(Origin,HAxis,VAxis, BGRA(255,255,255,AAlpha));
+  {$POP}
 end;
 …
   AColor: TBGRAPixel);
 begin
+  {$PUSH}{$OPTIMIZATION OFF}
   DoDrawAffine(Origin,HAxis,VAxis, AColor);
+  {$POP}
 end;

GraphicTest/Packages/bgrabitmap/bgraopenraster.pas

-              r494
+              r521
     procedure SetMemoryStreamAsString(AFilename: string; AContent: string);
     function GetMemoryStreamAsString(AFilename: string): string;
     procedure UnzipFromStream(AStream: TStream);
+    procedure UnzipFromStream(AStream: TStream; AFileList: TStrings = nil);
     procedure UnzipFromFile(AFilenameUTF8: string);
     procedure ZipToFile(AFilenameUTF8: string);
     procedure ZipToStream(AStream: TStream);
     procedure CopyThumbnailToMemoryStream(AMaxWidth, AMaxHeight: integer);
     procedure AnalyzeZip;
     procedure PrepareZipToSave;
+    procedure AnalyzeZip; virtual;
+    procedure PrepareZipToSave; virtual;
     function GetMimeType: string; override;
   public
     constructor Create; override; overload;
     constructor Create(AWidth, AHeight: integer); override; overload;
+    constructor Create; overload; override;
+    constructor Create(AWidth, AHeight: integer); overload; override;
     procedure Clear; override;
     function CheckMimeType(AStream: TStream): boolean;
+    procedure LoadFlatImageFromStream(AStream: TStream;
+              out ANbLayers: integer;
+              out ABitmap: TBGRABitmap);
     procedure LoadFromStream(AStream: TStream); override;
     procedure LoadFromFile(const filenameUTF8: string); override;
 …
   UnzipperExt;
+const
+  MergedImageFilename = 'mergedimage.png';
+  LayerStackFilename = 'stack.xml';
 function IsZipStream(stream: TStream): boolean;
 var
 …
   oldPos := stream.Position;
   {$PUSH}{$HINTS OFF}
   BytesRead := Stream.Read(magic,sizeof(magic));
+  BytesRead := Stream.Read({%H-}magic,sizeof(magic));
   {$POP}
   stream.Position:= OldPos;
 …
   layeredImage := TBGRAOpenRasterDocument.Create;
   try
+    layeredImage.LoadFromStream(Stream);
+    flat := layeredImage.ComputeFlatImage;
+    try
+    layeredImage.LoadFlatImageFromStream(Stream, FNbLayers, flat);
+    if Assigned(flat) then
+    begin
+      FWidth := flat.Width;
+      FHeight := flat.Height;
+    end else
+    begin
+      layeredImage.LoadFromStream(Stream);
+      flat := layeredImage.ComputeFlatImage;
       FWidth:= layeredImage.Width;
       FHeight:= layeredImage.Height;
       FNbLayers:= layeredImage.NbLayers;
+    end;
+    try
       if Img is TBGRACustomBitmap then
         TBGRACustomBitmap(img).Assign(flat)
 …
       flat.free;
     end;
     layeredImage.Free;
+    FreeAndNil(layeredImage);
   except
     on ex: Exception do
 …
   gammastr: string;
 begin
+  inherited Clear;
   if MimeType <> OpenRasterMimeType then
     raise Exception.Create('Invalid mime type');
   StackStream := GetMemoryStream('stack.xml');
+  StackStream := GetMemoryStream(LayerStackFilename);
   if StackStream = nil then
     raise Exception.Create('Layer stack not found');
 …
       attr := imagenode.Attributes[i];
       if lowercase(attr.NodeName) = 'w' then
         w := strToInt(attr.NodeValue) else
+        w := strToInt(string(attr.NodeValue)) else
       if lowercase(attr.NodeName) = 'h' then
         h := strToInt(attr.NodeValue) else
+        h := strToInt(string(attr.NodeValue)) else
       if lowercase(attr.NodeName) = 'gamma-correction' then
         linearBlend := (attr.NodeValue = 'no') or (attr.NodeValue = '0');
 …
           end else
           if lowercase(attr.NodeName) = 'gamma-correction' then
             gammastr := attr.NodeValue else
+            gammastr := string(attr.NodeValue) else
           if lowercase(attr.NodeName) = 'visibility' then
             LayerVisible[idx] := (attr.NodeValue = 'visible') or (attr.NodeValue = 'yes') or (attr.NodeValue = '1') else
 …
           if lowercase(attr.NodeName) = 'composite-op' then
           begin
             opstr := StringReplace(lowercase(attr.NodeValue),'_','-',[rfReplaceAll]);
+            opstr := StringReplace(lowercase(string(attr.NodeValue)),'_','-',[rfReplaceAll]);
             if (pos(':',opstr) = 0) and (opstr <> 'xor') then opstr := 'svg:'+opstr;
             //parse composite op
 …
   imageNode := TDOMElement(StackXML.CreateElement('image'));
   StackXML.AppendChild(imageNode);
   imageNode.SetAttribute('w',inttostr(Width));
   imageNode.SetAttribute('h',inttostr(Height));
+  imageNode.SetAttribute('w',widestring(inttostr(Width)));
+  imageNode.SetAttribute('h',widestring(inttostr(Height)));
   if LinearBlend then
     imageNode.SetAttribute('gamma-correction','no')
 …
       layerNode.SetAttribute('name', UTF8Decode(LayerName[i]));
       str(LayerOpacity[i]/255:0:3,strval);
       layerNode.SetAttribute('opacity',strval);
       layerNode.SetAttribute('src',layerFilename);
+      layerNode.SetAttribute('opacity',widestring(strval));
+      layerNode.SetAttribute('src',widestring(layerFilename));
       if LayerVisible[i] then
         layerNode.SetAttribute('visibility','visible')
       else
         layerNode.SetAttribute('visibility','hidden');
       layerNode.SetAttribute('x',inttostr(LayerOffset[i].x));
       layerNode.SetAttribute('y',inttostr(LayerOffset[i].y));
+      layerNode.SetAttribute('x',widestring(inttostr(LayerOffset[i].x)));
+      layerNode.SetAttribute('y',widestring(inttostr(LayerOffset[i].y)));
       strval := '';
       case BlendOperation[i] of
 …
         else strval := 'svg:src-over';
       end;
       layerNode.SetAttribute('composite-op',strval);
+      layerNode.SetAttribute('composite-op',widestring(strval));
       if BlendOperation[i] <> boTransparent then //in 'transparent' case, linear blending depends on general setting
       begin
 …
              boSubtract,boExclusion,boNegation] then
           strval := 'yes' else strval := 'no';
         layerNode.SetAttribute('gamma-correction',strval);
+        layerNode.SetAttribute('gamma-correction',widestring(strval));
       end;
     end;
 …
   PrepareZipToSave;
   ZipToFile(filenameUTF8);
+  ClearFiles;
 end;
 …
   PrepareZipToSave;
   ZipToStream(AStream);
+  ClearFiles;
 end;
 …
 end;
+procedure TBGRAOpenRasterDocument.UnzipFromStream(AStream: TStream);
+procedure TBGRAOpenRasterDocument.UnzipFromStream(AStream: TStream;
+          AFileList: TStrings = nil);
 var unzip: TUnZipper;
 begin
   Clear;
+  ClearFiles;
   unzip := TUnZipper.Create;
   try
 …
     unzip.OnCloseInputStream := @ZipOnCloseInputStream;
     FZipInputStream := AStream;
+    unzip.UnZipAllFiles;
+    if Assigned(AFileList) then
+    begin
+      if AFileList.Count > 0 then
+        unzip.UnZipFiles(AFileList);
+    end else
+      unzip.UnZipAllFiles;
   finally
     FZipInputStream := nil;
 …
 var unzip: TUnZipper;
 begin
   Clear;
+  ClearFiles;
   unzip := TUnZipper.Create;
   try
 …
   if (Width = 0) or (Height = 0) then exit;
   thumbnail := ComputeFlatImage;
   CopyBitmapToMemoryStream(thumbnail,'mergedimage.png');
+  CopyBitmapToMemoryStream(thumbnail,MergedImageFilename);
   if (thumbnail.Width > AMaxWidth) or
    (thumbnail.Height > AMaxHeight) then
 …
 end;
+procedure TBGRAOpenRasterDocument.LoadFlatImageFromStream(AStream: TStream; out
+  ANbLayers: integer; out ABitmap: TBGRABitmap);
+var fileList: TStringList;
+  imgStream, stackStream: TMemoryStream;
+  imageNode, stackNode: TDOMNode;
+  i: integer;
+begin
+  fileList := TStringList.Create;
+  fileList.Add(MergedImageFilename);
+  fileList.Add(LayerStackFilename);
+  imgStream := nil;
+  try
+    UnzipFromStream(AStream, fileList);
+    imgStream := GetMemoryStream(MergedImageFilename);
+    if imgStream = nil then
+      ABitmap := nil
+    else
+      ABitmap := TBGRABitmap.Create(imgStream);
+    ANbLayers := 1;
+    stackStream := GetMemoryStream(LayerStackFilename);
+    ReadXMLFile(FStackXML, StackStream);
+    imageNode := StackXML.FindNode('image');
+    if Assigned(imagenode) then
+    begin
+      stackNode := imageNode.FindNode('stack');
+      if Assigned(stackNode) then
+      begin
+        ANbLayers:= 0;
+        for i := stackNode.ChildNodes.Length-1 downto 0 do
+        begin
+          if stackNode.ChildNodes[i].NodeName = 'layer' then
+            inc(ANbLayers);
+        end;
+      end;
+    end;
+  finally
+    fileList.Free;
+    ClearFiles;
+  end;
+end;
 procedure TBGRAOpenRasterDocument.LoadFromStream(AStream: TStream);
 begin
 …
   finally
     OnLayeredBitmapLoaded;
+    ClearFiles;
   end;
 end;

GraphicTest/Packages/bgrabitmap/bgrapalette.pas

-              r494
+              r521
     procedure ExceptionInvalidPaletteFormat;
   public
     constructor Create(ABitmap: TBGRACustomBitmap); virtual; overload;
     constructor Create(APalette: TBGRACustomPalette); virtual; overload;
     constructor Create(AColors: ArrayOfTBGRAPixel); virtual; overload;
     constructor Create(AColors: ArrayOfWeightedColor); virtual; overload;
+    constructor Create(ABitmap: TBGRACustomBitmap); overload; virtual;
+    constructor Create(APalette: TBGRACustomPalette); overload; virtual;
+    constructor Create(AColors: ArrayOfTBGRAPixel); overload; virtual;
+    constructor Create(AColors: ArrayOfWeightedColor); overload; virtual;
     function AddColor(AValue: TBGRAPixel): boolean; virtual;
     procedure AddColors(ABitmap: TBGRACustomBitmap); virtual; overload;
     procedure AddColors(APalette: TBGRACustomPalette); virtual; overload;
+    procedure AddColors(ABitmap: TBGRACustomBitmap); overload; virtual;
+    procedure AddColors(APalette: TBGRACustomPalette); overload; virtual;
     function RemoveColor(AValue: TBGRAPixel): boolean; virtual;
     procedure LoadFromFile(AFilenameUTF8: string); virtual;
     procedure LoadFromStream(AStream: TStream; AFormat: TBGRAPaletteFormat); virtual;
+    procedure LoadFromResource(AFilename: string; AFormat: TBGRAPaletteFormat);
     procedure SaveToFile(AFilenameUTF8: string); virtual;
     procedure SaveToStream(AStream: TStream; AFormat: TBGRAPaletteFormat); virtual;
     function DetectPaletteFormat(AStream: TStream): TBGRAPaletteFormat; virtual;
     function DetectPaletteFormat(AFilenameUTF8: string): TBGRAPaletteFormat;
+    function DetectPaletteFormat(AStream: TStream): TBGRAPaletteFormat; overload; virtual;
+    function DetectPaletteFormat(AFilenameUTF8: string): TBGRAPaletteFormat; overload;
     function SuggestPaletteFormat(AFilenameUTF8: string): TBGRAPaletteFormat; virtual;
   end;
 …
   public
     function FindNearestColor(AValue: TBGRAPixel; AIgnoreAlpha: boolean): TBGRAPixel; overload;
     function FindNearestColor(AValue: TBGRAPixel): TBGRAPixel; virtual; abstract; overload;
+    function FindNearestColor(AValue: TBGRAPixel): TBGRAPixel; overload; virtual; abstract;
     function FindNearestColorIndex(AValue: TBGRAPixel; AIgnoreAlpha: boolean): integer; overload;
     function FindNearestColorIndex(AValue: TBGRAPixel): integer; virtual; abstract; overload;
+    function FindNearestColorIndex(AValue: TBGRAPixel): integer; overload; virtual; abstract;
     property Weight[AIndex: Integer]: UInt32 read GetWeightByIndex;
   end;
 …
     procedure SetReductionColorCount(AValue: Integer); virtual; abstract;
   public
+    constructor Create(APalette: TBGRACustomPalette; ASeparateAlphaChannel: boolean); virtual; abstract; overload;
+    constructor Create(ABitmap: TBGRACustomBitmap; AAlpha: TAlphaChannelPaletteOption); virtual; abstract; overload;
+    constructor Create(APalette: TBGRACustomPalette; ASeparateAlphaChannel: boolean; AReductionColorCount: integer); virtual; abstract; overload;
+    constructor Create(ABitmap: TBGRACustomBitmap; AAlpha: TAlphaChannelPaletteOption; AReductionColorCount: integer); virtual; abstract; overload;
+    procedure ApplyDitheringInplace(AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap; ABounds: TRect); virtual; abstract; overload;
+    constructor Create(APalette: TBGRACustomPalette; ASeparateAlphaChannel: boolean); overload; virtual; abstract;
+    constructor Create(AColors: array of TBGRAPixel; ASeparateAlphaChannel: boolean); overload;
+    constructor Create(ABitmap: TBGRACustomBitmap; AAlpha: TAlphaChannelPaletteOption); overload; virtual; abstract;
+    constructor Create(APalette: TBGRACustomPalette; ASeparateAlphaChannel: boolean; AReductionColorCount: integer); overload; virtual; abstract;
+    constructor Create(AColors: array of TBGRAPixel; ASeparateAlphaChannel: boolean; AReductionColorCount: integer); overload;
+    constructor Create(ABitmap: TBGRACustomBitmap; AAlpha: TAlphaChannelPaletteOption; AReductionColorCount: integer); overload; virtual; abstract;
+    procedure ApplyDitheringInplace(AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap; ABounds: TRect); overload; virtual; abstract;
     procedure ApplyDitheringInplace(AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap); overload;
     function GetDitheredBitmap(AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap; ABounds: TRect): TBGRACustomBitmap; virtual; abstract; overload;
+    function GetDitheredBitmap(AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap; ABounds: TRect): TBGRACustomBitmap; overload; virtual; abstract;
     function GetDitheredBitmap(AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap): TBGRACustomBitmap; overload;
     procedure SaveBitmapToFile(AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap; AFilenameUTF8: string); overload;
 …
     function GetDitheredBitmapIndexedData(ABitDepth: integer; AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap): Pointer; overload;
     function GetDitheredBitmapIndexedData(ABitDepth: integer; AByteOrder: TRawImageByteOrder; AAlgorithm: TDitheringAlgorithm;
       ABitmap: TBGRACustomBitmap; out AScanlineSize: PtrInt): Pointer; virtual; abstract; overload;
+      ABitmap: TBGRACustomBitmap; out AScanlineSize: PtrInt): Pointer; overload; virtual; abstract;
     property SourceColorCount: Integer read GetSourceColorCount;
     property SourceColor[AIndex: integer]: TBGRAPixel read GetSourceColor;
 …
 end;
+constructor TBGRACustomColorQuantizer.Create(AColors: array of TBGRAPixel;
+  ASeparateAlphaChannel: boolean);
+var palette: TBGRAPalette;
+  i: Integer;
+begin
+  palette := TBGRAPalette.Create;
+  for i := 0 to high(AColors) do
+    palette.AddColor(AColors[i]);
+  Create(palette, ASeparateAlphaChannel);
+  palette.Free;
+end;
+constructor TBGRACustomColorQuantizer.Create(AColors: array of TBGRAPixel;
+  ASeparateAlphaChannel: boolean; AReductionColorCount: integer);
+var palette: TBGRAPalette;
+  i: Integer;
+begin
+  palette := TBGRAPalette.Create;
+  for i := 0 to high(AColors) do
+    palette.AddColor(AColors[i]);
+  Create(palette, ASeparateAlphaChannel, AReductionColorCount);
+  palette.Free;
+end;
 procedure TBGRACustomColorQuantizer.ApplyDitheringInplace(
   AAlgorithm: TDitheringAlgorithm; ABitmap: TBGRACustomBitmap);
 …
 { TBGRACustomApproxPalette }
+function TBGRACustomApproxPalette.FindNearestColorIgnoreAlpha(AValue: TBGRAPixel
+  ): TBGRAPixel;
+const AlphaMask : DWord = {$IFDEF ENDIAN_LITTLE}$ff000000{$ELSE}$000000ff{$endif};
+function TBGRACustomApproxPalette.FindNearestColorIgnoreAlpha(AValue: TBGRAPixel): TBGRAPixel;
+var saveAlpha: byte;
 begin
   if AValue.alpha = 0 then
 …
   else
   begin
+    result := FindNearestColor(TBGRAPixel(DWord(AValue) or AlphaMask));
+    result.alpha := AValue.alpha;
+    saveAlpha := AValue.alpha;
+    AValue.alpha := 255;
+    result := FindNearestColor(AValue);
+    result.alpha := saveAlpha;
   end;
 end;
 …
 function TBGRACustomApproxPalette.FindNearestColorIndexIgnoreAlpha(
   AValue: TBGRAPixel): integer;
-const AlphaMask : DWord = {$IFDEF ENDIAN_LITTLE}$ff000000{$ELSE}$000000ff{$endif};
 begin
   if AValue.alpha = 0 then
 …
   else
   begin
+    result := FindNearestColorIndex(TBGRAPixel(DWord(AValue) or AlphaMask));
+    AValue.alpha := 255;
+    result := FindNearestColorIndex(AValue);
   end;
 end;
 …
 end;
+procedure TBGRAPalette.LoadFromResource(AFilename: string; AFormat: TBGRAPaletteFormat);
+var
+  stream: TStream;
+begin
+  stream := BGRAResource.GetResourceStream(AFilename);
+  try
+    LoadFromStream(stream, AFormat);
+  finally
+    stream.Free;
+  end;
+end;
 procedure TBGRAPalette.SaveToFile(AFilenameUTF8: string);
 var

GraphicTest/Packages/bgrabitmap/bgrapath.pas

-              r494
+              r521
   { TBGRAPath }
   TBGRAPath = class(IBGRAPath)
+  TBGRAPath = class(TBGRACustomPath)
   protected
     FData: PByte;
 …
     function LastCoordDefined: boolean; inline;
     function GetPolygonalApprox(APos: IntPtr; AAcceptedDeviation: single; AIncludeFirstPoint: boolean): ArrayOfTPointF;
+    function getPoints: ArrayOfTPointF;
+    function getPoints(AMatrix: TAffineMatrix): ArrayOfTPointF;
+    function getCursor: TBGRACustomPathCursor;
+    function getPoints: ArrayOfTPointF; overload;override;
+    function getPoints(AMatrix: TAffineMatrix): ArrayOfTPointF; overload;override;
+    function getLength: single; override;
+    function getCursor: TBGRACustomPathCursor; override;
     procedure InternalDraw(ADrawProc: TBGRAPathDrawProc; const AMatrix: TAffineMatrix; AAcceptedDeviation: single; AData: pointer);
     procedure BitmapDrawSubPathProc(const APoints: array of TPointF; AClosed: boolean; AData: pointer);
     function CorrectAcceptedDeviation(AAcceptedDeviation: single; const AMatrix: TAffineMatrix): single;
   public
     constructor Create; overload;
+    constructor Create; overload; override;
     constructor Create(ASvgString: string); overload;
     constructor Create(const APoints: ArrayOfTPointF); overload;
     constructor Create(APath: IBGRAPath); overload;
     destructor Destroy; override;
     procedure beginPath;
+    procedure beginPath; override;
     procedure beginSubPath;
     procedure closePath;
+    procedure closePath; override;
     procedure translate(x,y: single);
     procedure resetTransform;
 …
     procedure moveTo(x,y: single); overload;
     procedure lineTo(x,y: single); overload;
     procedure moveTo(const pt: TPointF); overload;
     procedure lineTo(const pt: TPointF); overload;
+    procedure moveTo(constref pt: TPointF); overload; override;
+    procedure lineTo(constref pt: TPointF); overload; override;
     procedure polyline(const pts: array of TPointF);
     procedure polylineTo(const pts: array of TPointF);
+    procedure polylineTo(const pts: array of TPointF); override;
     procedure polygon(const pts: array of TPointF);
     procedure quadraticCurveTo(cpx,cpy,x,y: single); overload;
     procedure quadraticCurveTo(const cp,pt: TPointF); overload;
+    procedure quadraticCurveTo(constref cp,pt: TPointF); overload; override;
     procedure quadraticCurve(const curve: TQuadraticBezierCurve); overload;
     procedure quadraticCurve(p1,cp,p2: TPointF); overload;
 …
     procedure smoothQuadraticCurveTo(const pt: TPointF); overload;
     procedure bezierCurveTo(cp1x,cp1y,cp2x,cp2y,x,y: single); overload;
     procedure bezierCurveTo(const cp1,cp2,pt: TPointF); overload;
+    procedure bezierCurveTo(constref cp1,cp2,pt: TPointF); overload; override;
     procedure bezierCurve(const curve: TCubicBezierCurve); overload;
     procedure bezierCurve(p1,cp1,cp2,p2: TPointF); overload;
 …
     procedure arcTo(x1, y1, x2, y2, radius: single); overload;
     procedure arcTo(const p1,p2: TPointF; radius: single); overload;
     procedure arc(const arcDef: TArcDef); overload;
+    procedure arc(constref arcDef: TArcDef); overload; override;
     procedure arc(cx, cy, rx,ry: single; xAngleRadCW, startAngleRadCW, endAngleRadCW: single); overload;
     procedure arc(cx, cy, rx,ry, xAngleRadCW, startAngleRadCW, endAngleRadCW: single; anticlockwise: boolean); overload;
     procedure arcTo(rx,ry, xAngleRadCW: single; largeArc, anticlockwise: boolean; x,y:single);
     procedure copyTo(dest: IBGRAPath);
+    procedure arcTo(rx,ry, xAngleRadCW: single; largeArc, anticlockwise: boolean; x,y:single); overload;
+    procedure copyTo(dest: IBGRAPath); override;
     procedure addPath(const AValue: string); overload;
     procedure addPath(source: IBGRAPath); overload;
     procedure openedSpline(const pts: array of TPointF; style: TSplineStyle);
     procedure closedSpline(const pts: array of TPointF; style: TSplineStyle);
+    procedure openedSpline(const pts: array of TPointF; style: TSplineStyle); override;
+    procedure closedSpline(const pts: array of TPointF; style: TSplineStyle); override;
     property SvgString: string read GetSvgString write SetSvgString;
     function ComputeLength(AAcceptedDeviation: single = 0.1): single;
 …
     function GetBounds(AAcceptedDeviation: single = 0.1): TRectF;
     procedure SetPoints(const APoints: ArrayOfTPointF);
     procedure stroke(ABitmap: TBGRACustomBitmap; AColor: TBGRAPixel; AWidth: single; AAcceptedDeviation: single = 0.1);
     procedure stroke(ABitmap: TBGRACustomBitmap; ATexture: IBGRAScanner; AWidth: single; AAcceptedDeviation: single = 0.1);
     procedure stroke(ABitmap: TBGRACustomBitmap; x,y: single; AColor: TBGRAPixel; AWidth: single; AAcceptedDeviation: single = 0.1);
     procedure stroke(ABitmap: TBGRACustomBitmap; x,y: single; ATexture: IBGRAScanner; AWidth: single; AAcceptedDeviation: single = 0.1);
     procedure stroke(ABitmap: TBGRACustomBitmap; const AMatrix: TAffineMatrix; AColor: TBGRAPixel; AWidth: single; AAcceptedDeviation: single = 0.1);
     procedure stroke(ABitmap: TBGRACustomBitmap; const AMatrix: TAffineMatrix; ATexture: IBGRAScanner; AWidth: single; AAcceptedDeviation: single = 0.1);
     procedure stroke(ADrawProc: TBGRAPathDrawProc; const AMatrix: TAffineMatrix; AAcceptedDeviation: single = 0.1; AData: pointer = nil);
     procedure fill(ABitmap: TBGRACustomBitmap; AColor: TBGRAPixel; AAcceptedDeviation: single = 0.1);
     procedure fill(ABitmap: TBGRACustomBitmap; ATexture: IBGRAScanner; AAcceptedDeviation: single = 0.1);
     procedure fill(ABitmap: TBGRACustomBitmap; x,y: single; AColor: TBGRAPixel; AAcceptedDeviation: single = 0.1);
     procedure fill(ABitmap: TBGRACustomBitmap; x,y: single; ATexture: IBGRAScanner; AAcceptedDeviation: single = 0.1);
     procedure fill(ABitmap: TBGRACustomBitmap; const AMatrix: TAffineMatrix; AColor: TBGRAPixel; AAcceptedDeviation: single = 0.1);
     procedure fill(ABitmap: TBGRACustomBitmap; const AMatrix: TAffineMatrix; ATexture: IBGRAScanner; AAcceptedDeviation: single = 0.1);
     procedure fill(AFillProc: TBGRAPathFillProc; const AMatrix: TAffineMatrix; AAcceptedDeviation: single = 0.1; AData: pointer = nil);
+    procedure stroke(ABitmap: TBGRACustomBitmap; AColor: TBGRAPixel; AWidth: single; AAcceptedDeviation: single = 0.1); overload;
+    procedure stroke(ABitmap: TBGRACustomBitmap; ATexture: IBGRAScanner; AWidth: single; AAcceptedDeviation: single = 0.1); overload;
+    procedure stroke(ABitmap: TBGRACustomBitmap; x,y: single; AColor: TBGRAPixel; AWidth: single; AAcceptedDeviation: single = 0.1); overload;
+    procedure stroke(ABitmap: TBGRACustomBitmap; x,y: single; ATexture: IBGRAScanner; AWidth: single; AAcceptedDeviation: single = 0.1); overload;
+    procedure stroke(ABitmap: TBGRACustomBitmap; const AMatrix: TAffineMatrix; AColor: TBGRAPixel; AWidth: single; AAcceptedDeviation: single = 0.1); overload;
+    procedure stroke(ABitmap: TBGRACustomBitmap; const AMatrix: TAffineMatrix; ATexture: IBGRAScanner; AWidth: single; AAcceptedDeviation: single = 0.1); overload;
+    procedure stroke(ADrawProc: TBGRAPathDrawProc; const AMatrix: TAffineMatrix; AAcceptedDeviation: single = 0.1; AData: pointer = nil); overload;
+    procedure fill(ABitmap: TBGRACustomBitmap; AColor: TBGRAPixel; AAcceptedDeviation: single = 0.1); overload;
+    procedure fill(ABitmap: TBGRACustomBitmap; ATexture: IBGRAScanner; AAcceptedDeviation: single = 0.1); overload;
+    procedure fill(ABitmap: TBGRACustomBitmap; x,y: single; AColor: TBGRAPixel; AAcceptedDeviation: single = 0.1); overload;
+    procedure fill(ABitmap: TBGRACustomBitmap; x,y: single; ATexture: IBGRAScanner; AAcceptedDeviation: single = 0.1); overload;
+    procedure fill(ABitmap: TBGRACustomBitmap; const AMatrix: TAffineMatrix; AColor: TBGRAPixel; AAcceptedDeviation: single = 0.1); overload;
+    procedure fill(ABitmap: TBGRACustomBitmap; const AMatrix: TAffineMatrix; ATexture: IBGRAScanner; AAcceptedDeviation: single = 0.1); overload;
+    procedure fill(AFillProc: TBGRAPathFillProc; const AMatrix: TAffineMatrix; AAcceptedDeviation: single = 0.1; AData: pointer = nil); overload;
     function CreateCursor(AAcceptedDeviation: single = 0.1): TBGRAPathCursor;
     procedure Fit(ARect: TRectF; AAcceptedDeviation: single = 0.1);
     procedure FitInto(ADest: TBGRAPath; ARect: TRectF; AAcceptedDeviation: single = 0.1);
-  protected
-    function QueryInterface({$IFDEF FPC_HAS_CONSTREF}constref{$ELSE}const{$ENDIF} IID: TGUID; out Obj): HResult; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
-    function _AddRef: Integer; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
-    function _Release: Integer; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
   end;
 …
 function ComputeOpenedSpline(const points: array of TPointF; Style: TSplineStyle; EndCoeff: single = 0.25; AAcceptedDeviation: single = 0.1): ArrayOfTPointF;
 function ClosedSplineStartPoint(const points: array of TPointF; Style: TSplineStyle): TPointF;
+function ComputeEasyBezier(const curve: TEasyBezierCurve; AAcceptedDeviation: single = 0.1): ArrayOfTPointF;
 { Compute points to draw an antialiased ellipse }
+function ComputeEllipse(x,y,rx,ry: single; quality: single = 1): ArrayOfTPointF;
+function ComputeArc65536(x, y, rx, ry: single; start65536,end65536: word; quality: single = 1): ArrayOfTPointF;
+function ComputeArcRad(x, y, rx, ry: single; startRadCCW,endRadCCW: single; quality: single = 1): ArrayOfTPointF;
+function ComputeEllipse(x,y,rx,ry: single; quality: single = 1): ArrayOfTPointF; overload;
+function ComputeEllipse(AOrigin, AXAxis, AYAxis: TPointF; quality: single = 1): ArrayOfTPointF; overload;
+function ComputeArc65536(x, y, rx, ry: single; start65536,end65536: word; quality: single = 1): ArrayOfTPointF; overload;
+function ComputeArc65536(AOrigin, AXAxis, AYAxis: TPointF; start65536,end65536: word; quality: single = 1): ArrayOfTPointF; overload;
+function ComputeArcRad(x, y, rx, ry: single; startRadCCW,endRadCCW: single; quality: single = 1): ArrayOfTPointF; overload;
+function ComputeArcRad(AOrigin, AXAxis, AYAxis: TPointF; startRadCCW,endRadCCW: single; quality: single = 1): ArrayOfTPointF; overload;
 function ComputeArc(const arc: TArcDef; quality: single = 1): ArrayOfTPointF;
 function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; quality: single = 1): ArrayOfTPointF; overload;
 …
 begin
+  if Style = ssEasyBezier then
+  begin
+    result := ComputeEasyBezier(EasyBezierCurve(points, true, cmCurve));
+    exit;
+  end;
   if length(points) <= 2 then
   begin
 …
   kernel: TWideKernelFilter;
 begin
+  if Style = ssEasyBezier then
+  begin
+    result := ComputeEasyBezier(EasyBezierCurve(points, false, cmCurve));
+    exit;
+  end;
   if length(points) <= 2 then
   begin
 …
   ptNext2: TPointF;
 begin
+  if length(points) = 0 then
+    result := EmptyPointF
+  else
+  if length(points)<=2 then
+    result := points[0]
+  else
+  begin
+    kernel := CreateInterpolator(style);
+    ptPrev2 := points[high(points)];
+    ptPrev  := points[0];
+    ptNext  := points[1];
+    ptNext2 := points[2];
+    result := ptPrev2*kernel.Interpolation(1) + ptPrev*kernel.Interpolation(0) +
+              ptNext*kernel.Interpolation(-1)  + ptNext2*kernel.Interpolation(-2);
+    kernel.free;
+  end;
+  if Style = ssEasyBezier then
+  begin
+    result := EasyBezierCurve(points, true, cmCurve).CurveStartPoint;
+  end else
+  begin
+    if length(points) = 0 then
+      result := EmptyPointF
+    else
+    if length(points)<=2 then
+      result := points[0]
+    else
+    begin
+      kernel := CreateInterpolator(style);
+      ptPrev2 := points[high(points)];
+      ptPrev  := points[0];
+      ptNext  := points[1];
+      ptNext2 := points[2];
+      result := ptPrev2*kernel.Interpolation(1) + ptPrev*kernel.Interpolation(0) +
+                ptNext*kernel.Interpolation(-1)  + ptNext2*kernel.Interpolation(-2);
+      kernel.free;
+    end;
+  end;
+end;
+function ComputeEasyBezier(const curve: TEasyBezierCurve;
+  AAcceptedDeviation: single): ArrayOfTPointF;
+var
+  path: TBGRAPath;
+begin
+  path := TBGRAPath.Create;
+  curve.CopyToPath(path);
+  result := path.ToPoints(AAcceptedDeviation);
+  path.Free;
 end;
 …
 end;
+function ComputeEllipse(AOrigin, AXAxis, AYAxis: TPointF; quality: single): ArrayOfTPointF;
+begin
+  result := ComputeArcRad(AOrigin, AXAxis, AYAxis, 0,0, quality);
+end;
+function ComputeArc65536(AOrigin, AXAxis, AYAxis: TPointF; start65536,
+  end65536: word; quality: single): ArrayOfTPointF;
+begin
+  //go back temporarily to radians
+  result := ComputeArcRad(AOrigin,AXAxis,AYAxis, start65536*Pi/326768, end65536*Pi/326768, quality);
+end;
 function ComputeArcRad(x, y, rx, ry: single; startRadCCW, endRadCCW: single;
   quality: single): ArrayOfTPointF;
 …
   result[0] := PointF(x+cos(startRadCCW)*rx,y-sin(startRadCCW)*ry);
   result[high(result)] := PointF(x+cos(endRadCCW)*rx,y-sin(endRadCCW)*ry);
+end;
+function ComputeArcRad(AOrigin, AXAxis, AYAxis: TPointF; startRadCCW,endRadCCW: single; quality: single): ArrayOfTPointF;
+var
+  u, v: TPointF;
+  lenU, lenV: Single;
+  m: TAffineMatrix;
+  i: Integer;
+begin
+  u := AXAxis-AOrigin;
+  lenU := VectLen(u);
+  v := AYAxis-AOrigin;
+  lenV := VectLen(v);
+  if (lenU = 0) and (lenV = 0) then exit(PointsF([AOrigin]));
+  result := ComputeArcRad(0, 0, lenU, lenV, startRadCCW, endRadCCW, quality);
+  if lenU <> 0 then u *= 1/lenU;
+  if lenV <> 0 then v *= 1/lenV;
+  m := AffineMatrix(u, v, AOrigin);
+  for i := 0 to high(result) do
+    result[i] := m*result[i];
 end;
 …
 end;
+function TBGRAPath.getLength: single;
+begin
+  result := ComputeLength;
+end;
 function TBGRAPath.getCursor: TBGRACustomPathCursor;
 begin
 …
   var numberStart: integer;
       errPos: integer;
+      decimalFind: boolean;
+    procedure parseFloatInternal;
+    begin
+      if (p <= length(AValue)) and (AValue[p] in['+','-']) then inc(p);
+      decimalFind:= false;
+      while (p <= length(AValue)) and (AValue[p] in['0'..'9','.']) do
+      begin
+        if AValue[p] = '.' then
+          if decimalFind then
+            Break
+          else
+            decimalFind:= true;
+        inc(p);
+      end;
+    end;
   begin
     while (p <= length(AValue)) and (AValue[p] in[#0..#32,',']) do inc(p);
     numberStart:= p;
+    if (p <= length(AValue)) and (AValue[p] in['+','-']) then inc(p);
+    while (p <= length(AValue)) and (AValue[p] in['0'..'9','.']) do inc(p);
+    parseFloatInternal;
     if (p <= length(AValue)) and (AValue[p] in['e','E']) then
     begin
       inc(p);
+      if (p <= length(AValue)) and (AValue[p] in['+','-']) then inc(p);
+      while (p <= length(AValue)) and (AValue[p] in['0'..'9','.']) do inc(p);
+      parseFloatInternal;
     end;
     val(copy(AValue,numberStart,p-numberStart),result,errPos);
 …
              moveTo(p1);
              lastCoord := p1;
+             startCoord := p1;
            end;
            if relative then implicitCommand:= 'l' else
 …
 begin
   OnModify;
+  count += 4; //avoid memory error
   if FDataPos + count > FDataCapacity then
   begin
 …
 end;
 procedure TBGRAPath.moveTo(const pt: TPointF);
+procedure TBGRAPath.moveTo(constref pt: TPointF);
 begin
   if FLastSubPathElementType <> peMoveTo then
 …
 end;
 procedure TBGRAPath.lineTo(const pt: TPointF);
+procedure TBGRAPath.lineTo(constref pt: TPointF);
 var lastTransfCoord, newTransfCoord: TPointF;
 begin
 …
 end;
 procedure TBGRAPath.quadraticCurveTo(const cp, pt: TPointF);
+procedure TBGRAPath.quadraticCurveTo(constref cp, pt: TPointF);
 begin
   if LastCoordDefined then
 …
 end;
 procedure TBGRAPath.bezierCurveTo(const cp1, cp2, pt: TPointF);
+procedure TBGRAPath.bezierCurveTo(constref cp1, cp2, pt: TPointF);
 begin
   if not LastCoordDefined then moveTo(cp1);
 …
 end;
 procedure TBGRAPath.arc(const arcDef: TArcDef);
+procedure TBGRAPath.arc(constref arcDef: TArcDef);
 var transformedArc: TArcElement;
 begin
 …
 end;
+function TBGRAPath.QueryInterface({$IFDEF FPC_HAS_CONSTREF}constref{$ELSE}const{$ENDIF} IID: TGUID; out Obj): HResult; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
+begin
+  if GetInterface(iid, obj) then
+    Result := S_OK
+  else
+    Result := longint(E_NOINTERFACE);
+end;
+{ There is no automatic reference counting, but it is compulsory to define these functions }
+function TBGRAPath._AddRef: Integer; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
+begin
+  result := 0;
+end;
+function TBGRAPath._Release: Integer; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
+begin
+  result := 0;
+end;
+initialization
+  BGRAPathFactory := TBGRAPath;
 end.

GraphicTest/Packages/bgrabitmap/bgrapen.pas

-              r494
+              r521
 type
+  TPenJoinStyle = BGRAGraphics.TPenJoinStyle;
+  TPenEndCap = BGRAGraphics.TPenEndCap;
   { TBGRAPenStroker }
 …
       constructor Create;
       destructor Destroy; override;
       function ComputePolyline(const APoints: array of TPointF; AWidth: single; AClosedCap: boolean = true): ArrayOfTPointF; override;
       function ComputePolyline(const APoints: array of TPointF; AWidth: single; APenColor: TBGRAPixel; AClosedCap: boolean = true): ArrayOfTPointF; override;
+      function ComputePolyline(const APoints: array of TPointF; AWidth: single; AClosedCap: boolean = true): ArrayOfTPointF; overload; override;
+      function ComputePolyline(const APoints: array of TPointF; AWidth: single; APenColor: TBGRAPixel; AClosedCap: boolean = true): ArrayOfTPointF; overload; override;
       function ComputePolylineAutocycle(const APoints: array of TPointF; AWidth: single): ArrayOfTPointF; override;
       function ComputePolygon(const APoints: array of TPointF; AWidth: single): ArrayOfTPointF; override;
 …
 //antialiased version
 procedure BGRADrawLineAntialias({%H-}dest: TBGRACustomBitmap; x1, y1, x2, y2: integer;
   c: TBGRAPixel; DrawLastPixel: boolean; LinearBlend : boolean = false);
+  c: TBGRAPixel; DrawLastPixel: boolean; LinearBlend : boolean = false); overload;
 procedure BGRAEraseLineAntialias(dest: TBGRACustomBitmap; x1, y1, x2, y2: integer;
   calpha: byte; DrawLastPixel: boolean);
+  calpha: byte; DrawLastPixel: boolean); overload;
 //antialiased version with bicolor dashes (to draw a frame)
 procedure BGRADrawLineAntialias(dest: TBGRACustomBitmap; x1, y1, x2, y2: integer;
   c1, c2: TBGRAPixel; dashLen: integer; DrawLastPixel: boolean; var DashPos: integer; LinearBlend : boolean = false);
+  c1, c2: TBGRAPixel; dashLen: integer; DrawLastPixel: boolean; var DashPos: integer; LinearBlend : boolean = false); overload;
 //length added to ensure accepable alpha join (using TBGRAMultishapeFiller is still better)
 …
 function IsClearPenStyle(ACustomPenStyle: TBGRAPenStyle): boolean;
 function DuplicatePenStyle(ACustomPenStyle: array of single): TBGRAPenStyle;
+function PenStyleEqual(AStyle1, AStyle2: TBGRAPenStyle): boolean;
+function BGRAToPenStyle(ACustomPenStyle: TBGRAPenStyle): TPenStyle;
 implementation
 …
 end;
+function BGRAToPenStyle(ACustomPenStyle: TBGRAPenStyle): TPenStyle;
+begin
+  if IsSolidPenStyle(ACustomPenStyle) then exit(psSolid);
+  if IsClearPenStyle(ACustomPenStyle) then exit(psClear);
+  if PenStyleEqual(ACustomPenStyle, DashPenStyle) then exit(psDash);
+  if PenStyleEqual(ACustomPenStyle, DotPenStyle) then exit(psDot);
+  if PenStyleEqual(ACustomPenStyle, DashDotPenStyle) then exit(psDashDot);
+  if PenStyleEqual(ACustomPenStyle, DashDotDotPenStyle) then exit(psDashDotDot);
+  exit(psPattern);
+end;
+function PenStyleEqual(AStyle1, AStyle2: TBGRAPenStyle): boolean;
+var
+  i: Integer;
+begin
+  if length(AStyle1)<>length(AStyle2) then exit(false);
+  for i := 0 to high(AStyle1) do
+    if AStyle1[i] <> AStyle2[i] then exit(false);
+  exit(true);
+end;
 procedure ApplyPenStyle(const leftPts, rightPts: array of TPointF; const penstyle: TBGRAPenStyle;
     width: single; var posstyle: single; out styledPts: ArrayOfTPointF);
 …
   begin
     dashStartIndex := index;
+    dashLeftStartPos := leftPts[index] + (leftPts[index+1]-leftPts[index])*t;
+    dashRightStartPos := rightPts[index] + (rightPts[index+1]-rightPts[index])*t;
+    if t = 0 then
+    begin
+      dashLeftStartPos := leftPts[index];
+      dashRightStartPos := rightPts[index];
+    end else
+    begin
+      dashLeftStartPos := leftPts[index] + (leftPts[index+1]-leftPts[index])*t;
+      dashRightStartPos := rightPts[index] + (rightPts[index+1]-rightPts[index])*t;
+    end;
     betweenDash := false;
   end;

GraphicTest/Packages/bgrabitmap/bgraphongtypes.pas

-              r494
+              r521
      indicate the global height of the map. }
    procedure Draw(dest: TBGRACustomBitmap; map: TBGRACustomBitmap; mapAltitude: integer; ofsX,ofsY: integer;
                   Color : TBGRAPixel); virtual; abstract;
+                  Color : TBGRAPixel);  overload; virtual; abstract;
    { Render with a color map of the same size as the height map. Map altitude
      indicate the global height of the map. }
    procedure Draw(dest: TBGRACustomBitmap; map: TBGRACustomBitmap; mapAltitude: integer; ofsX,ofsY: integer;
                   ColorMap : TBGRACustomBitmap); virtual; abstract;
+                  ColorMap : TBGRACustomBitmap);  overload; virtual; abstract;
    { Render with a scanner. Map altitude

GraphicTest/Packages/bgrabitmap/bgraphoxo.pas

-              r494
+              r521
     procedure AddLayerFromPhoxoData(const ABlockHeader: TPhoxoBlockHeader; ABlockData: PByte);
   public
     constructor Create; override; overload;
     constructor Create(AWidth, AHeight: integer); override; overload;
+    constructor Create; overload; override;
+    constructor Create(AWidth, AHeight: integer); overload; override;
     procedure LoadFromStream(AStream: TStream); override;
     procedure LoadFromFile(const filenameUTF8: string); override;

GraphicTest/Packages/bgrabitmap/bgrapixel.inc

-              r494
+              r521
       {$ENDIF}
       {$IFDEF DARWIN}
+        {$DEFINE BGRABITMAP_RGBAPIXEL}
+                {$IFNDEF LCLQt}
+                        {$DEFINE BGRABITMAP_RGBAPIXEL}
+                {$ENDIF}
       {$ENDIF}
     {$ENDIF}
 …
   {** Returns the lightness of a pixel. The lightness is the
      perceived brightness, 0 being black and 65535 being white }
   function GetLightness(c: TBGRAPixel): word;
+  function GetLightness(c: TBGRAPixel): word; overload;
   {** Sets the lightness of a pixel }
   function SetLightness(c: TBGRAPixel; lightness: word): TBGRAPixel;
+  function SetLightness(c: TBGRAPixel; lightness: word): TBGRAPixel; overload;
   {** Sets the lightness quickly, by fading towards black if ''lightness'' is
       less than 32768, and fading towards white if ''lightness'' is more
 …
 {$i basiccolorspace.inc}
+{$DEFINE INCLUDE_INTERFACE}
+{$i extendedcolorspace.inc}
 {$ENDIF}
 …
 {$DEFINE INCLUDE_IMPLEMENTATION}
 {$i basiccolorspace.inc}
+{$DEFINE INCLUDE_IMPLEMENTATION}
+{$i extendedcolorspace.inc}
 function StrToBlendOperation(str: string): TBlendOperation;
 …
 {$ELSE}
 begin
+  result := int64(lightness1)*lightness2 shr 15;
+  if (lightness1 < 0) xor (lightness2 < 0) then
+    result := -(int64(-lightness1)*lightness2 shr 15)
+  else
+    result := int64(lightness1)*lightness2 shr 15;
 end;
 {$ENDIF}
 …
 end;
+{ Convert a TColor value to a TBGRAPixel value. Note that
+  you need to call ColorToRGB first if you use a system
+  color identifier like clWindow. }
+{ Convert a TColor value to a TBGRAPixel value }
 {$PUSH}{$R-}
 function ColorToBGRA(color: TColor): TBGRAPixel; overload;
 begin
+  if (color < 0) or (color > $ffffff) then color := ColorToRGB(color);
   RedGreenBlue(color, Result.red,Result.green,Result.blue);
   Result.alpha := 255;
 …
 function ColorToBGRA(color: TColor; opacity: byte): TBGRAPixel; overload;
 begin
+  if (color < 0) or (color > $ffffff) then color := ColorToRGB(color);
   RedGreenBlue(color, Result.red,Result.green,Result.blue);
   Result.alpha := opacity;
 …
 {$UNDEF INCLUDE_INIT}
   BGRASetGamma();
+  {$DEFINE INCLUDE_INITIALIZATION}
+  {$i extendedcolorspace.inc}
 {$ENDIF}

GraphicTest/Packages/bgrabitmap/bgrapolygon.pas

-              r494
+              r521
         color: TExpandedPixel;
         bounds: TRect;
+      end;
+    procedure AddShape(AInfo: TBGRACustomFillInfo; AInternalInfo: boolean; ATexture: IBGRAScanner; AInternalTexture: TObject; AColor: TBGRAPixel);
+        fillMode: TFillMode;
+        fillModeOverride: boolean;
+      end;
+    function AddShape(AInfo: TBGRACustomFillInfo; AInternalInfo: boolean; ATexture: IBGRAScanner; AInternalTexture: TObject; AColor: TBGRAPixel): integer; overload;
     function CheckRectangleBorderBounds(var x1, y1, x2, y2: single; w: single): boolean;
     procedure InternalAddStroke(const APoints: array of TPointF; AClosed: boolean; AData: Pointer);
 …
     constructor Create;
     destructor Destroy; override;
     procedure AddShape(AShape: TBGRACustomFillInfo; AColor: TBGRAPixel);
     procedure AddShape(AShape: TBGRACustomFillInfo; ATexture: IBGRAScanner);
     procedure AddPolygon(const points: array of TPointF; AColor: TBGRAPixel);
     procedure AddPolygon(const points: array of TPointF; ATexture: IBGRAScanner);
     procedure AddPathStroke(APath: TBGRAPath; AColor: TBGRAPixel; AWidth: single; AStroker: TBGRACustomPenStroker);
     procedure AddPathStroke(APath: TBGRAPath; ATexture: IBGRAScanner; AWidth: single; AStroker: TBGRACustomPenStroker);
     procedure AddPathStroke(APath: TBGRAPath; AMatrix: TAffineMatrix; AColor: TBGRAPixel; AWidth: single; AStroker: TBGRACustomPenStroker);
     procedure AddPathStroke(APath: TBGRAPath; AMatrix: TAffineMatrix; ATexture: IBGRAScanner; AWidth: single; AStroker: TBGRACustomPenStroker);
     procedure AddPathFill(APath: TBGRAPath; AColor: TBGRAPixel);
     procedure AddPathFill(APath: TBGRAPath; ATexture: IBGRAScanner);
     procedure AddPathFill(APath: TBGRAPath; AMatrix: TAffineMatrix; AColor: TBGRAPixel);
     procedure AddPathFill(APath: TBGRAPath; AMatrix: TAffineMatrix; ATexture: IBGRAScanner);
     procedure AddPolylineStroke(const points: array of TPointF; AColor: TBGRAPixel; AWidth: single; AStroker: TBGRACustomPenStroker);
     procedure AddPolylineStroke(const points: array of TPointF; ATexture: IBGRAScanner; AWidth: single; AStroker: TBGRACustomPenStroker);
     procedure AddPolygonStroke(const points: array of TPointF; AColor: TBGRAPixel; AWidth: single; AStroker: TBGRACustomPenStroker);
     procedure AddPolygonStroke(const points: array of TPointF; ATexture: IBGRAScanner; AWidth: single; AStroker: TBGRACustomPenStroker);
     procedure AddTriangleLinearColor(pt1, pt2, pt3: TPointF; c1, c2, c3: TBGRAPixel);
     procedure AddTriangleLinearMapping(pt1, pt2, pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF);
+    function AddShape(AShape: TBGRACustomFillInfo; AColor: TBGRAPixel): integer; overload;
+    function AddShape(AShape: TBGRACustomFillInfo; ATexture: IBGRAScanner): integer; overload;
+    function AddPolygon(const points: array of TPointF; AColor: TBGRAPixel): integer; overload;
+    function AddPolygon(const points: array of TPointF; ATexture: IBGRAScanner): integer; overload;
+    procedure AddPathStroke(APath: TBGRAPath; AColor: TBGRAPixel; AWidth: single; AStroker: TBGRACustomPenStroker); overload;
+    procedure AddPathStroke(APath: TBGRAPath; ATexture: IBGRAScanner; AWidth: single; AStroker: TBGRACustomPenStroker); overload;
+    procedure AddPathStroke(APath: TBGRAPath; AMatrix: TAffineMatrix; AColor: TBGRAPixel; AWidth: single; AStroker: TBGRACustomPenStroker); overload;
+    procedure AddPathStroke(APath: TBGRAPath; AMatrix: TAffineMatrix; ATexture: IBGRAScanner; AWidth: single; AStroker: TBGRACustomPenStroker); overload;
+    function AddPathFill(APath: TBGRAPath; AColor: TBGRAPixel): integer; overload;
+    function AddPathFill(APath: TBGRAPath; ATexture: IBGRAScanner): integer; overload;
+    function AddPathFill(APath: TBGRAPath; AMatrix: TAffineMatrix; AColor: TBGRAPixel): integer; overload;
+    function AddPathFill(APath: TBGRAPath; AMatrix: TAffineMatrix; ATexture: IBGRAScanner): integer; overload;
+    function AddPolylineStroke(const points: array of TPointF; AColor: TBGRAPixel; AWidth: single; AStroker: TBGRACustomPenStroker): integer; overload;
+    function AddPolylineStroke(const points: array of TPointF; ATexture: IBGRAScanner; AWidth: single; AStroker: TBGRACustomPenStroker): integer; overload;
+    function AddPolygonStroke(const points: array of TPointF; AColor: TBGRAPixel; AWidth: single; AStroker: TBGRACustomPenStroker): integer; overload;
+    function AddPolygonStroke(const points: array of TPointF; ATexture: IBGRAScanner; AWidth: single; AStroker: TBGRACustomPenStroker): integer; overload;
+    function AddTriangleLinearColor(pt1, pt2, pt3: TPointF; c1, c2, c3: TBGRAPixel): integer;
+    function AddTriangleLinearMapping(pt1, pt2, pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF): integer;
     procedure AddQuadLinearColor(pt1, pt2, pt3, pt4: TPointF; c1, c2, c3, c4: TBGRAPixel);
     procedure AddQuadLinearMapping(pt1, pt2, pt3, pt4: TPointF; texture: IBGRAScanner; tex1, tex2, {%H-}tex3, tex4: TPointF;
        ACulling: TFaceCulling = fcNone);
     procedure AddQuadPerspectiveMapping(pt1, pt2, pt3, pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF);
+    procedure AddEllipse(x, y, rx, ry: single; AColor: TBGRAPixel);
+    procedure AddEllipse(x, y, rx, ry: single; ATexture: IBGRAScanner);
+    procedure AddEllipseBorder(x, y, rx, ry, w: single; AColor: TBGRAPixel);
+    procedure AddEllipseBorder(x, y, rx, ry, w: single; ATexture: IBGRAScanner);
+    procedure AddRoundRectangle(x1, y1, x2, y2, rx, ry: single; AColor: TBGRAPixel; options: TRoundRectangleOptions= []);
+    procedure AddRoundRectangle(x1, y1, x2, y2, rx, ry: single; ATexture: IBGRAScanner; options: TRoundRectangleOptions= []);
+    procedure AddRoundRectangleBorder(x1, y1, x2, y2, rx, ry, w: single; AColor: TBGRAPixel; options: TRoundRectangleOptions= []);
+    procedure AddRoundRectangleBorder(x1, y1, x2, y2, rx, ry, w: single; ATexture: IBGRAScanner; options: TRoundRectangleOptions= []);
+    procedure AddRectangle(x1, y1, x2, y2: single; AColor: TBGRAPixel);
+    procedure AddRectangle(x1, y1, x2, y2: single; ATexture: IBGRAScanner);
+    procedure AddRectangleBorder(x1, y1, x2, y2, w: single; AColor: TBGRAPixel);
+    procedure AddRectangleBorder(x1, y1, x2, y2, w: single; ATexture: IBGRAScanner);
+    function AddEllipse(x, y, rx, ry: single; AColor: TBGRAPixel): integer; overload;
+    function AddEllipse(x, y, rx, ry: single; ATexture: IBGRAScanner): integer; overload;
+    function AddEllipseBorder(x, y, rx, ry, w: single; AColor: TBGRAPixel): integer; overload;
+    function AddEllipseBorder(x, y, rx, ry, w: single; ATexture: IBGRAScanner): integer; overload;
+    function AddRoundRectangle(x1, y1, x2, y2, rx, ry: single; AColor: TBGRAPixel; options: TRoundRectangleOptions= []): integer; overload;
+    function AddRoundRectangle(x1, y1, x2, y2, rx, ry: single; ATexture: IBGRAScanner; options: TRoundRectangleOptions= []): integer; overload;
+    function AddRoundRectangleBorder(x1, y1, x2, y2, rx, ry, w: single; AColor: TBGRAPixel; options: TRoundRectangleOptions= []): integer; overload;
+    function AddRoundRectangleBorder(x1, y1, x2, y2, rx, ry, w: single; ATexture: IBGRAScanner; options: TRoundRectangleOptions= []): integer; overload;
+    function AddRectangle(x1, y1, x2, y2: single; AColor: TBGRAPixel): integer; overload;
+    function AddRectangle(x1, y1, x2, y2: single; ATexture: IBGRAScanner): integer; overload;
+    function AddRectangleBorder(x1, y1, x2, y2, w: single; AColor: TBGRAPixel): integer; overload;
+    function AddRectangleBorder(x1, y1, x2, y2, w: single; ATexture: IBGRAScanner): integer; overload;
+    procedure OverrideFillMode(AShapeIndex: integer; AFillMode: TFillMode);
     procedure Draw(dest: TBGRACustomBitmap; ADrawMode: TDrawMode = dmDrawWithTransparency);
+    property ShapeCount: integer read nbShapes;
   end;
 procedure FillPolyAliased(bmp: TBGRACustomBitmap; points: array of TPointF;
   c: TBGRAPixel; EraseMode: boolean; NonZeroWinding: boolean; drawmode: TDrawMode);
+  c: TBGRAPixel; EraseMode: boolean; NonZeroWinding: boolean; drawmode: TDrawMode; APixelCenteredCoordinates: boolean = true);
 procedure FillPolyAliasedWithTexture(bmp: TBGRACustomBitmap; points: array of TPointF;
   scan: IBGRAScanner; NonZeroWinding: boolean; drawmode: TDrawMode);
+  scan: IBGRAScanner; NonZeroWinding: boolean; drawmode: TDrawMode; APixelCenteredCoordinates: boolean = true);
 procedure FillPolyAntialias(bmp: TBGRACustomBitmap; points: array of TPointF;
   c: TBGRAPixel; EraseMode: boolean; NonZeroWinding: boolean; LinearBlend: boolean = false);
+  c: TBGRAPixel; EraseMode: boolean; NonZeroWinding: boolean; LinearBlend: boolean = false; APixelCenteredCoordinates: boolean = true);
 procedure FillPolyAntialiasWithTexture(bmp: TBGRACustomBitmap; points: array of TPointF;
   scan: IBGRAScanner; NonZeroWinding: boolean; LinearBlend: boolean = false);
+  scan: IBGRAScanner; NonZeroWinding: boolean; LinearBlend: boolean = false; APixelCenteredCoordinates: boolean = true);
 procedure FillEllipseAntialias(bmp: TBGRACustomBitmap; x, y, rx, ry: single;
 …
   scan: IBGRAScanner; LinearBlend: boolean = false);
+procedure BorderEllipse(bmp: TBGRACustomBitmap; x, y, rx, ry, w: single;
+  c: TBGRAPixel; EraseMode: boolean; drawmode: TDrawMode);
+procedure BorderEllipseWithTexture(bmp: TBGRACustomBitmap; x, y, rx, ry, w: single;
+  scan: IBGRAScanner; drawmode: TDrawMode);
 procedure FillRoundRectangleAntialias(bmp: TBGRACustomBitmap; x1, y1, x2, y2, rx, ry: single;
   options: TRoundRectangleOptions; c: TBGRAPixel; EraseMode: boolean; LinearBlend: boolean = false);
+  options: TRoundRectangleOptions; c: TBGRAPixel; EraseMode: boolean; LinearBlend: boolean = false; APixelCenteredCoordinates: boolean = true);
 procedure FillRoundRectangleAntialiasWithTexture(bmp: TBGRACustomBitmap; x1, y1, x2, y2, rx, ry: single;
   options: TRoundRectangleOptions; scan: IBGRAScanner; LinearBlend: boolean = false);
+  options: TRoundRectangleOptions; scan: IBGRAScanner; LinearBlend: boolean = false; APixelCenteredCoordinates: boolean = true);
 procedure BorderRoundRectangleAntialias(bmp: TBGRACustomBitmap; x1, y1, x2, y2, rx, ry, w: single;
   options: TRoundRectangleOptions; c: TBGRAPixel; EraseMode: boolean; LinearBlend: boolean = false);
+  options: TRoundRectangleOptions; c: TBGRAPixel; EraseMode: boolean; LinearBlend: boolean = false; APixelCenteredCoordinates: boolean = true);
 procedure BorderRoundRectangleAntialiasWithTexture(bmp: TBGRACustomBitmap; x1, y1, x2, y2, rx, ry, w: single;
   options: TRoundRectangleOptions; scan: IBGRAScanner; LinearBlend: boolean = false);
+  options: TRoundRectangleOptions; scan: IBGRAScanner; LinearBlend: boolean = false; APixelCenteredCoordinates: boolean = true);
 procedure BorderAndFillRoundRectangleAntialias(bmp: TBGRACustomBitmap; x1, y1, x2, y2, rx, ry, w: single;
   options: TRoundRectangleOptions; bordercolor,fillcolor: TBGRAPixel; bordertexture,filltexture: IBGRAScanner; EraseMode: boolean);
+  options: TRoundRectangleOptions; bordercolor,fillcolor: TBGRAPixel; bordertexture,filltexture: IBGRAScanner; EraseMode: boolean; APixelCenteredCoordinates: boolean = true);
 implementation
 …
   miny, maxy, minx, maxx,
   densMinX, densMaxX: integer;
+  joinDensity, nextJoinDensity: boolean;
   density: PDensity;
 …
       if optimised then
       begin
+        nextJoinDensity := false;
         for i := 0 to firstScan.nbinter div 2 - 1 do
         begin
+          joinDensity := nextJoinDensity;
           x1 := firstScan.inter[i+i].interX;
           x1b := lastScan.inter[i+i].interX;
           x2 := firstScan.inter[i+i+1].interX;
           x2b := lastScan.inter[i+i+1].interX;
+          nextJoinDensity := not ((i+i+2 >= firstScan.nbInter) or
+              ((firstScan.inter[i+i+2].interX >= x2+1) and
+               (lastScan.inter[i+i+2].interX >= x2b+1)));
           if (abs(x1-x1b)<oneOver512) and (abs(x2-x2b)<oneOver512) and
+             ((i+i+2 >= firstScan.nbInter) or
+              ((firstScan.inter[i+i+2].interX >= x2+1) and
+               (lastScan.inter[i+i+2].interX >= x2b+1))) then
+              not joinDensity and not nextJoinDensity then
           begin
             x1 := (x1+x1b)*0.5;
             x2 := (x2+x2b)*0.5;
+            if x1 < minx then x1 := minx;
             ix1 := floor(x1);
+            ix2 := floor(x2);
+            if ix1 < minx then ix1 := minx;
+            if x2 >= maxx+1 then
+            begin
+              x2 := maxx+1;
+              ix2 := maxx;
+            end else
+              ix2 := floor(x2);
             if ix2 > maxx then ix2 := maxx;
             if ix1>ix2 then continue;
             if ix1=ix2 then
 …
 procedure FillPolyAliased(bmp: TBGRACustomBitmap; points: array of TPointF;
   c: TBGRAPixel; EraseMode: boolean; NonZeroWinding: boolean; drawmode: TDrawMode);
+  c: TBGRAPixel; EraseMode: boolean; NonZeroWinding: boolean; drawmode: TDrawMode; APixelCenteredCoordinates: boolean);
 var
   info: TCustomFillPolyInfo;
 …
     exit;
   info := TOnePassFillPolyInfo.Create(points);
+  info := TOnePassFillPolyInfo.Create(points, APixelCenteredCoordinates);
   FillShapeAliased(bmp, info, c, EraseMode, nil, NonZeroWinding, drawmode);
   info.Free;
 …
 procedure FillPolyAliasedWithTexture(bmp: TBGRACustomBitmap;
   points: array of TPointF; scan: IBGRAScanner; NonZeroWinding: boolean; drawmode: TDrawMode);
+  points: array of TPointF; scan: IBGRAScanner; NonZeroWinding: boolean; drawmode: TDrawMode; APixelCenteredCoordinates: boolean);
 var
   info: TCustomFillPolyInfo;
 …
     exit;
   info := TOnePassFillPolyInfo.Create(points);
+  info := TOnePassFillPolyInfo.Create(points, APixelCenteredCoordinates);
   FillShapeAliased(bmp, info, BGRAPixelTransparent,False,scan, NonZeroWinding, drawmode);
   info.Free;
 …
 procedure FillPolyAntialias(bmp: TBGRACustomBitmap; points: array of TPointF;
   c: TBGRAPixel; EraseMode: boolean; NonZeroWinding: boolean; LinearBlend: boolean);
+  c: TBGRAPixel; EraseMode: boolean; NonZeroWinding: boolean; LinearBlend: boolean; APixelCenteredCoordinates: boolean);
 var
   info: TCustomFillPolyInfo;
 …
     exit;
   info := TOnePassFillPolyInfo.Create(points);
+  info := TOnePassFillPolyInfo.Create(points, APixelCenteredCoordinates);
   FillShapeAntialias(bmp, info, c, EraseMode, nil, NonZeroWinding, LinearBlend);
   info.Free;
 …
 procedure FillPolyAntialiasWithTexture(bmp: TBGRACustomBitmap;
   points: array of TPointF; scan: IBGRAScanner; NonZeroWinding: boolean; LinearBlend: boolean);
+  points: array of TPointF; scan: IBGRAScanner; NonZeroWinding: boolean; LinearBlend: boolean; APixelCenteredCoordinates: boolean);
 var
   info: TCustomFillPolyInfo;
 …
     exit;
   info := TOnePassFillPolyInfo.Create(points);
+  info := TOnePassFillPolyInfo.Create(points, APixelCenteredCoordinates);
   FillShapeAntialiasWithTexture(bmp, info, scan, NonZeroWinding, LinearBlend);
   info.Free;
 …
 { TBGRAMultishapeFiller }
 procedure TBGRAMultishapeFiller.AddShape(AInfo: TBGRACustomFillInfo; AInternalInfo: boolean; ATexture: IBGRAScanner; AInternalTexture: TObject; AColor: TBGRAPixel);
+function TBGRAMultishapeFiller.AddShape(AInfo: TBGRACustomFillInfo; AInternalInfo: boolean; ATexture: IBGRAScanner; AInternalTexture: TObject; AColor: TBGRAPixel): integer;
 begin
   if length(shapes) = nbShapes then
     setlength(shapes, (length(shapes)+1)*2);
+  with shapes[nbShapes] do
+  result := nbShapes;
+  inc(nbShapes);
+  with shapes[result] do
   begin
     info := AInfo;
 …
     internalTexture:= AInternalTexture;
     color := GammaExpansion(AColor);
   end;
   inc(nbShapes);
+    fillModeOverride:= false;
+  end;
 end;
 …
   const APoints: array of TPointF; AClosed: boolean; AData: Pointer);
 var pts: ArrayOfTPointF;
+  idxShape: Integer;
 begin
   with TPathStrokeData(AData^) do
 …
       pts := Stroker.ComputePolylineAutoCycle(APoints, Width);
     if Texture <> nil then
       AddPolygon(pts, Texture)
+      idxShape := AddPolygon(pts, Texture)
     else
+      AddPolygon(pts, Color);
+      idxShape := AddPolygon(pts, Color);
+    OverrideFillMode(idxShape, fmWinding);
   end;
 end;
 …
 end;
+procedure TBGRAMultishapeFiller.AddShape(AShape: TBGRACustomFillInfo; AColor: TBGRAPixel);
+begin
+  AddShape(AShape,False,nil,nil,AColor);
+end;
+procedure TBGRAMultishapeFiller.AddShape(AShape: TBGRACustomFillInfo;
+  ATexture: IBGRAScanner);
+begin
+  AddShape(AShape,False,ATexture,nil,BGRAPixelTransparent);
+end;
+procedure TBGRAMultishapeFiller.AddPolygon(const points: array of TPointF;
+  AColor: TBGRAPixel);
+begin
+  if length(points) <= 2 then exit;
+  AddShape(TOnePassFillPolyInfo.Create(points),True,nil,nil,AColor);
+end;
+procedure TBGRAMultishapeFiller.AddPolygon(const points: array of TPointF;
+  ATexture: IBGRAScanner);
+begin
+  if length(points) <= 2 then exit;
+  AddShape(TOnePassFillPolyInfo.Create(points),True,ATexture,nil,BGRAPixelTransparent);
+function TBGRAMultishapeFiller.AddShape(AShape: TBGRACustomFillInfo;
+  AColor: TBGRAPixel): integer;
+begin
+  result := AddShape(AShape,False,nil,nil,AColor);
+end;
+function TBGRAMultishapeFiller.AddShape(AShape: TBGRACustomFillInfo;
+  ATexture: IBGRAScanner): integer;
+begin
+  result := AddShape(AShape,False,ATexture,nil,BGRAPixelTransparent);
+end;
+function TBGRAMultishapeFiller.AddPolygon(const points: array of TPointF;
+  AColor: TBGRAPixel): integer;
+begin
+  if length(points) <= 2 then exit(-1);
+  result := AddShape(TOnePassFillPolyInfo.Create(points),True,nil,nil,AColor);
+end;
+function TBGRAMultishapeFiller.AddPolygon(const points: array of TPointF;
+  ATexture: IBGRAScanner): integer;
+begin
+  if length(points) <= 2 then exit(-1);
+  result := AddShape(TOnePassFillPolyInfo.Create(points),True,ATexture,nil,BGRAPixelTransparent);
 end;
 …
 end;
 procedure TBGRAMultishapeFiller.AddPathFill(APath: TBGRAPath; AColor: TBGRAPixel);
 begin
   AddPolygon(APath.ToPoints, AColor);
 end;
 procedure TBGRAMultishapeFiller.AddPathFill(APath: TBGRAPath;
   ATexture: IBGRAScanner);
 begin
   AddPolygon(APath.ToPoints, ATexture);
 end;
 procedure TBGRAMultishapeFiller.AddPathFill(APath: TBGRAPath;
   AMatrix: TAffineMatrix; AColor: TBGRAPixel);
 begin
   AddPolygon(APath.ToPoints(AMatrix), AColor);
 end;
 procedure TBGRAMultishapeFiller.AddPathFill(APath: TBGRAPath;
   AMatrix: TAffineMatrix; ATexture: IBGRAScanner);
 begin
   AddPolygon(APath.ToPoints(AMatrix), ATexture);
 end;
 procedure TBGRAMultishapeFiller.AddPolylineStroke(
+function TBGRAMultishapeFiller.AddPathFill(APath: TBGRAPath; AColor: TBGRAPixel): integer;
+begin
+  result := AddPolygon(APath.ToPoints, AColor);
+end;
+function TBGRAMultishapeFiller.AddPathFill(APath: TBGRAPath;
+  ATexture: IBGRAScanner): integer;
+begin
+  result := AddPolygon(APath.ToPoints, ATexture);
+end;
+function TBGRAMultishapeFiller.AddPathFill(APath: TBGRAPath;
+  AMatrix: TAffineMatrix; AColor: TBGRAPixel): integer;
+begin
+  result := AddPolygon(APath.ToPoints(AMatrix), AColor);
+end;
+function TBGRAMultishapeFiller.AddPathFill(APath: TBGRAPath;
+  AMatrix: TAffineMatrix; ATexture: IBGRAScanner): integer;
+begin
+  result := AddPolygon(APath.ToPoints(AMatrix), ATexture);
+end;
+function TBGRAMultishapeFiller.AddPolylineStroke(
   const points: array of TPointF; AColor: TBGRAPixel; AWidth: single;
   AStroker: TBGRACustomPenStroker);
 begin
   AddPolygon(AStroker.ComputePolyline(points,AWidth,AColor), AColor);
 end;
 procedure TBGRAMultishapeFiller.AddPolylineStroke(
+  AStroker: TBGRACustomPenStroker): integer;
+begin
+  result := AddPolygon(AStroker.ComputePolyline(points,AWidth,AColor), AColor);
+end;
+function TBGRAMultishapeFiller.AddPolylineStroke(
   const points: array of TPointF; ATexture: IBGRAScanner; AWidth: single;
+  AStroker: TBGRACustomPenStroker);
+begin
+  AddPolygon(AStroker.ComputePolyline(points,AWidth), ATexture);
+end;
+procedure TBGRAMultishapeFiller.AddPolygonStroke(
+  const points: array of TPointF; AColor: TBGRAPixel; AWidth: single;
+  AStroker: TBGRACustomPenStroker);
+begin
+  AddPolygon(AStroker.ComputePolygon(points,AWidth), AColor);
+end;
+procedure TBGRAMultishapeFiller.AddPolygonStroke(
+  const points: array of TPointF; ATexture: IBGRAScanner; AWidth: single;
+  AStroker: TBGRACustomPenStroker);
+begin
+  AddPolygon(AStroker.ComputePolygon(points,AWidth), ATexture);
+end;
+procedure TBGRAMultishapeFiller.AddTriangleLinearColor(pt1, pt2, pt3: TPointF; c1, c2,
+  c3: TBGRAPixel);
+  AStroker: TBGRACustomPenStroker): integer;
+begin
+  result := AddPolygon(AStroker.ComputePolyline(points,AWidth), ATexture);
+end;
+function TBGRAMultishapeFiller.AddPolygonStroke(const points: array of TPointF;
+  AColor: TBGRAPixel; AWidth: single; AStroker: TBGRACustomPenStroker): integer;
+begin
+  result := AddPolygon(AStroker.ComputePolygon(points,AWidth), AColor);
+end;
+function TBGRAMultishapeFiller.AddPolygonStroke(const points: array of TPointF;
+  ATexture: IBGRAScanner; AWidth: single; AStroker: TBGRACustomPenStroker
+  ): integer;
+begin
+  result := AddPolygon(AStroker.ComputePolygon(points,AWidth), ATexture);
+end;
+function TBGRAMultishapeFiller.AddTriangleLinearColor(pt1, pt2, pt3: TPointF;
+  c1, c2, c3: TBGRAPixel): integer;
 var grad: TBGRAGradientTriangleScanner;
 begin
   if (c1 = c2) and (c2 = c3) then
     AddPolygon([pt1,pt2,pt3],c1)
+    result := AddPolygon([pt1,pt2,pt3],c1)
   else
   begin
     grad := TBGRAGradientTriangleScanner.Create(pt1,pt2,pt3, c1,c2,c3);
     AddShape(TOnePassFillPolyInfo.Create([pt1,pt2,pt3]),True,grad,grad,BGRAPixelTransparent);
   end;
 end;
+procedure TBGRAMultishapeFiller.AddTriangleLinearMapping(pt1, pt2,
   pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF);
+    result := AddShape(TOnePassFillPolyInfo.Create([pt1,pt2,pt3]),True,grad,grad,BGRAPixelTransparent);
+  end;
+end;
+function TBGRAMultishapeFiller.AddTriangleLinearMapping(pt1, pt2, pt3: TPointF;
+  texture: IBGRAScanner; tex1, tex2, tex3: TPointF): integer;
 var
   mapping: TBGRATriangleLinearMapping;
 begin
   mapping := TBGRATriangleLinearMapping.Create(texture, pt1,pt2,pt3, tex1, tex2, tex3);
   AddShape(TOnePassFillPolyInfo.Create([pt1,pt2,pt3]),True,mapping,mapping,BGRAPixelTransparent);
+  result := AddShape(TOnePassFillPolyInfo.Create([pt1,pt2,pt3]),True,mapping,mapping,BGRAPixelTransparent);
 end;
 …
 end;
+procedure TBGRAMultishapeFiller.AddEllipse(x, y, rx, ry: single; AColor: TBGRAPixel
   );
 begin
   AddShape(TFillEllipseInfo.Create(x,y,rx,ry),True,nil,nil,AColor);
 end;
 procedure TBGRAMultishapeFiller.AddEllipse(x, y, rx, ry: single;
   ATexture: IBGRAScanner);
 begin
   AddShape(TFillEllipseInfo.Create(x,y,rx,ry),True,ATexture,nil,BGRAPixelTransparent);
 end;
 procedure TBGRAMultishapeFiller.AddEllipseBorder(x, y, rx, ry, w: single;
   AColor: TBGRAPixel);
 begin
   AddShape(TFillBorderEllipseInfo.Create(x,y,rx,ry,w),True,nil,nil,AColor);
 end;
 procedure TBGRAMultishapeFiller.AddEllipseBorder(x, y, rx, ry, w: single;
   ATexture: IBGRAScanner);
 begin
   AddShape(TFillBorderEllipseInfo.Create(x,y,rx,ry,w),True,ATexture,nil,BGRAPixelTransparent);
 end;
+procedure TBGRAMultishapeFiller.AddRoundRectangle(x1, y1, x2, y2, rx, ry: single;
   AColor: TBGRAPixel; options: TRoundRectangleOptions);
 begin
   AddShape(TFillRoundRectangleInfo.Create(x1, y1, x2, y2, rx, ry,options),True,nil,nil,AColor);
 end;
+procedure TBGRAMultishapeFiller.AddRoundRectangle(x1, y1, x2, y2, rx, ry: single;
   ATexture: IBGRAScanner; options: TRoundRectangleOptions);
 begin
   AddShape(TFillRoundRectangleInfo.Create(x1, y1, x2, y2, rx, ry,options),True,
+function TBGRAMultishapeFiller.AddEllipse(x, y, rx, ry: single;
+  AColor: TBGRAPixel): integer;
+begin
+  result := AddShape(TFillEllipseInfo.Create(x,y,rx,ry),True,nil,nil,AColor);
+end;
+function TBGRAMultishapeFiller.AddEllipse(x, y, rx, ry: single;
+  ATexture: IBGRAScanner): integer;
+begin
+  result := AddShape(TFillEllipseInfo.Create(x,y,rx,ry),True,ATexture,nil,BGRAPixelTransparent);
+end;
+function TBGRAMultishapeFiller.AddEllipseBorder(x, y, rx, ry, w: single;
+  AColor: TBGRAPixel): integer;
+begin
+  result := AddShape(TFillBorderEllipseInfo.Create(x,y,rx,ry,w),True,nil,nil,AColor);
+end;
+function TBGRAMultishapeFiller.AddEllipseBorder(x, y, rx, ry, w: single;
+  ATexture: IBGRAScanner): integer;
+begin
+  result := AddShape(TFillBorderEllipseInfo.Create(x,y,rx,ry,w),True,ATexture,nil,BGRAPixelTransparent);
+end;
+function TBGRAMultishapeFiller.AddRoundRectangle(x1, y1, x2, y2, rx,
+  ry: single; AColor: TBGRAPixel; options: TRoundRectangleOptions): integer;
+begin
+  result := AddShape(TFillRoundRectangleInfo.Create(x1, y1, x2, y2, rx, ry,options),True,nil,nil,AColor);
+end;
+function TBGRAMultishapeFiller.AddRoundRectangle(x1, y1, x2, y2, rx,
+  ry: single; ATexture: IBGRAScanner; options: TRoundRectangleOptions): integer;
+begin
+  result := AddShape(TFillRoundRectangleInfo.Create(x1, y1, x2, y2, rx, ry,options),True,
      ATexture,nil,BGRAPixelTransparent);
 end;
 procedure TBGRAMultishapeFiller.AddRoundRectangleBorder(x1, y1, x2, y2, rx,
   ry, w: single; AColor: TBGRAPixel; options: TRoundRectangleOptions);
 begin
   AddShape(TFillBorderRoundRectInfo.Create(x1, y1, x2, y2, rx, ry,w,options),True,
+function TBGRAMultishapeFiller.AddRoundRectangleBorder(x1, y1, x2, y2, rx, ry,
+  w: single; AColor: TBGRAPixel; options: TRoundRectangleOptions): integer;
+begin
+  result := AddShape(TFillBorderRoundRectInfo.Create(x1, y1, x2, y2, rx, ry,w,options),True,
     nil,nil,AColor);
 end;
 procedure TBGRAMultishapeFiller.AddRoundRectangleBorder(x1, y1, x2, y2, rx, ry,
   w: single; ATexture: IBGRAScanner; options: TRoundRectangleOptions);
 begin
   AddShape(TFillBorderRoundRectInfo.Create(x1, y1, x2, y2, rx, ry,w,options),True,
+function TBGRAMultishapeFiller.AddRoundRectangleBorder(x1, y1, x2, y2, rx, ry,
+  w: single; ATexture: IBGRAScanner; options: TRoundRectangleOptions): integer;
+begin
+  result := AddShape(TFillBorderRoundRectInfo.Create(x1, y1, x2, y2, rx, ry,w,options),True,
     ATexture,nil,BGRAPixelTransparent);
 end;
 procedure TBGRAMultishapeFiller.AddRectangle(x1, y1, x2, y2: single;
   AColor: TBGRAPixel);
 begin
   AddPolygon([PointF(x1,y1),PointF(x2,y1),PointF(x2,y2),PointF(x1,y2)],AColor);
 end;
 procedure TBGRAMultishapeFiller.AddRectangle(x1, y1, x2, y2: single;
   ATexture: IBGRAScanner);
 begin
   AddPolygon([PointF(x1,y1),PointF(x2,y1),PointF(x2,y2),PointF(x1,y2)],ATexture);
 end;
+procedure TBGRAMultishapeFiller.AddRectangleBorder(x1, y1, x2, y2,
   w: single; AColor: TBGRAPixel);
+function TBGRAMultishapeFiller.AddRectangle(x1, y1, x2, y2: single;
+  AColor: TBGRAPixel): integer;
+begin
+  result := AddPolygon([PointF(x1,y1),PointF(x2,y1),PointF(x2,y2),PointF(x1,y2)],AColor);
+end;
+function TBGRAMultishapeFiller.AddRectangle(x1, y1, x2, y2: single;
+  ATexture: IBGRAScanner): integer;
+begin
+  result := AddPolygon([PointF(x1,y1),PointF(x2,y1),PointF(x2,y2),PointF(x1,y2)],ATexture);
+end;
+function TBGRAMultishapeFiller.AddRectangleBorder(x1, y1, x2, y2, w: single;
+  AColor: TBGRAPixel): integer;
 var hw : single;
 begin
   hw := w/2;
   if not CheckRectangleBorderBounds(x1,y1,x2,y2,w) then
     AddRectangle(x1-hw,y1-hw,x2+hw,y2+hw,AColor) else
     AddPolygon([PointF(x1-hw,y1-hw),PointF(x2+hw,y1-hw),PointF(x2+hw,y2+hw),PointF(x1-hw,y2+hw),EmptyPointF,
+    result := AddRectangle(x1-hw,y1-hw,x2+hw,y2+hw,AColor) else
+    result := AddPolygon([PointF(x1-hw,y1-hw),PointF(x2+hw,y1-hw),PointF(x2+hw,y2+hw),PointF(x1-hw,y2+hw),EmptyPointF,
                 PointF(x1+hw,y2-hw),PointF(x2-hw,y2-hw),PointF(x2-hw,y1+hw),PointF(x1+hw,y1+hw)],AColor);
 end;
+procedure TBGRAMultishapeFiller.AddRectangleBorder(x1, y1, x2, y2,
   w: single; ATexture: IBGRAScanner);
+function TBGRAMultishapeFiller.AddRectangleBorder(x1, y1, x2, y2, w: single;
+  ATexture: IBGRAScanner): integer;
 var hw : single;
 begin
   hw := w/2;
   if not CheckRectangleBorderBounds(x1,y1,x2,y2,w) then
     AddRectangle(x1-hw,y1-hw,x2+hw,y2+hw,ATexture) else
     AddPolygon([PointF(x1-hw,y1-hw),PointF(x2+hw,y1-hw),PointF(x2+hw,y2+hw),PointF(x1-hw,y2+hw),EmptyPointF,
+    result := AddRectangle(x1-hw,y1-hw,x2+hw,y2+hw,ATexture) else
+    result := AddPolygon([PointF(x1-hw,y1-hw),PointF(x2+hw,y1-hw),PointF(x2+hw,y2+hw),PointF(x1-hw,y2+hw),EmptyPointF,
                 PointF(x1+hw,y2-hw),PointF(x2-hw,y2-hw),PointF(x2-hw,y1+hw),PointF(x1+hw,y1+hw)],ATexture);
+end;
+procedure TBGRAMultishapeFiller.OverrideFillMode(AShapeIndex: integer;
+  AFillMode: TFillMode);
+begin
+  if AShapeIndex < 0 then exit;
+  if AShapeIndex >= nbShapes then raise exception.Create('Index out of bounds');
+  shapes[AShapeIndex].fillMode := AFillMode;
+  shapes[AShapeIndex].fillModeOverride := true;
 end;
 …
       begin
         //find intersections
         info.ComputeAndSort(cury, inter, nbInter, FillMode=fmWinding);
+        info.ComputeAndSort(cury, inter, nbInter, fillMode=fmWinding);
         nbInter := nbInter and not 1; //even
       end;
 …
             if ix2 > densMaxx then densMaxx := ix2;
+            FillWord(density[ix1-minx],ix2-ix1+1,256);
+            if ix2 >= ix1 then
+              FillWord(density[ix1-minx],ix2-ix1+1,256);
           end;
         end else
                   {$DEFINE INCLUDE_FILLDENSITY}
+          {$DEFINE INCLUDE_FILLDENSITY}
           {$i density256.inc}
       end;
 …
   bounds: TRect;
   xb, yb, yc, j,k: integer;
+  xb, yb, yc, k: integer;
   pdest:    PBGRAPixel;
   curSum,nextSum: ^TCardinalSum;
   sums: array of TCardinalSum;
+  curAlpha: byte;
   pdens: PDensity;
   w: cardinal;
+  w: UInt32or64;
   ec: TExpandedPixel;
   count: integer;
 …
 begin
   if nbShapes = 0 then exit;
+  for k := 0 to nbShapes-1 do
+    if not shapes[k].fillModeOverride then shapes[k].fillMode:= fillMode;
   useAA := Antialiasing and (ADrawMode in [dmDrawWithTransparency,dmLinearBlend]);
   if nbShapes = 1 then
   begin
     if useAA then
       FillShapeAntialias(dest,shapes[0].info,GammaCompression(shapes[0].color),False,shapes[0].texture,FillMode = fmWinding, ADrawMode=dmLinearBlend) else
       FillShapeAliased(dest,shapes[0].info,GammaCompression(shapes[0].color),False,shapes[0].texture,FillMode = fmWinding, ADrawMode,
+      FillShapeAntialias(dest,shapes[0].info,GammaCompression(shapes[0].color),False,shapes[0].texture,shapes[0].fillMode = fmWinding, ADrawMode=dmLinearBlend) else
+      FillShapeAliased(dest,shapes[0].info,GammaCompression(shapes[0].color),False,shapes[0].texture,shapes[0].fillMode = fmWinding, ADrawMode,
         AliasingIncludeBottomRight);
     exit;
 …
     AliasingOfs := PointF(-0.0001,-0.0001);
   setlength(sums,maxx-minx+2); //more for safety
+  setlength(sums,maxx-minx+1);
   setlength(shapeRowsList, nbShapes);
 …
     end;
+    rowminx := minx;
+    rowmaxx := maxx;
+    if rowminx < minx then rowminx := minx;
+    if rowmaxx > maxx then rowmaxx := maxx;
     if rowminx <= rowmaxx then
     begin
-      if rowminx < minx then rowminx := minx;
-      if rowmaxx > maxx then rowmaxx := maxx;
       FillChar(sums[rowminx-minx],(rowmaxx-rowminx+1)*sizeof(sums[0]),0);
 …
                 ec.green := (sumG+sumA shr 1) div sumA;
                 ec.blue := (sumB+sumA shr 1) div sumA;
                 if sumA > 255 then sumA := 255;
                 ec.alpha := sumA shl 8 + sumA;
+                if sumA > 255 then curAlpha := 255 else curAlpha := sumA;
+                ec.alpha := curAlpha shl 8 + curAlpha;
                 count := 1;
                 while (xb < rowmaxx) and (nextSum^.sumA = sumA) and (nextSum^.sumB = sumB)
 …
                 end;
                 if count = 1 then
                   DrawExpandedPixelInlineNoAlphaCheck(pdest,ec,sumA) else
+                  DrawExpandedPixelInlineNoAlphaCheck(pdest,ec,curAlpha) else
                    DrawExpandedPixelsInline(pdest, ec, count );
                 inc(pdest,count-1);
 …
                 ec.green := (sumG+sumA shr 1) div sumA;
                 ec.blue := (sumB+sumA shr 1) div sumA;
                 if sumA > 255 then sumA := 255;
                 ec.alpha := sumA shl 8 + sumA;
+                if sumA > 255 then curAlpha := 255 else curAlpha := sumA;
+                ec.alpha := curAlpha shl 8 + curAlpha;
                 count := 1;
                 while (xb < rowmaxx) and (nextSum^.sumA = sumA) and (nextSum^.sumB = sumB)
 …
                 if count = 1 then
                   DrawPixelInlineNoAlphaCheck(pdest,GammaCompression(ec)) else
+                begin
                    DrawPixelsInline(pdest, GammaCompression(ec), count );
+                inc(pdest,count-1);
+                   inc(pdest,count-1);
+                end;
               end;
             end;
 …
                 ec.green := (sumG+sumA shr 1) div sumA;
                 ec.blue := (sumB+sumA shr 1) div sumA;
                 if sumA > 255 then sumA := 255;
                 ec.alpha := sumA shl 8 + sumA;
+                if sumA > 255 then curAlpha := 255 else curAlpha := sumA;
+                ec.alpha := curAlpha shl 8 + curAlpha;
                 count := 1;
                 while (xb < rowmaxx) and (nextSum^.sumA = sumA) and (nextSum^.sumB = sumB)
 …
                 ec.green := (sumG+sumA shr 1) div sumA;
                 ec.blue := (sumB+sumA shr 1) div sumA;
                 if sumA > 255 then sumA := 255;
                 ec.alpha := sumA shl 8 + sumA;
+                if sumA > 255 then curAlpha := 255 else curAlpha := sumA;
+                ec.alpha := curAlpha shl 8 + curAlpha;
                 count := 1;
                 while (xb < rowmaxx) and (nextSum^.sumA = sumA) and (nextSum^.sumB = sumB)
 …
                 ec.green := (sumG+sumA shr 1) div sumA;
                 ec.blue := (sumB+sumA shr 1) div sumA;
                 if sumA > 255 then sumA := 255;
                 ec.alpha := sumA shl 8 + sumA;
+                if sumA > 255 then curAlpha := 255 else curAlpha := sumA;
+                ec.alpha := curAlpha shl 8 + curAlpha;
                 count := 1;
                 while (xb < rowmaxx) and (nextSum^.sumA = sumA) and (nextSum^.sumB = sumB)
 …
 end;
+procedure BorderEllipse(bmp: TBGRACustomBitmap; x, y, rx, ry, w: single;
+  c: TBGRAPixel; EraseMode: boolean; drawmode: TDrawMode);
+var
+  info: TFillBorderEllipseInfo;
+begin
+  if ((rx = 0) and (ry = 0)) or (w=0) or (x = EmptySingle) or (y = EmptySingle) then
+    exit;
+  info := TFillBorderEllipseInfo.Create(x, y, rx, ry, w);
+  FillShapeAliased(bmp, info, c, EraseMode, nil, False, drawmode);
+  info.Free;
+end;
+procedure BorderEllipseWithTexture(bmp: TBGRACustomBitmap; x, y, rx, ry,
+  w: single; scan: IBGRAScanner; drawmode: TDrawMode);
+var
+  info: TFillBorderEllipseInfo;
+begin
+  if ((rx = 0) and (ry = 0)) or (w=0) or (x = EmptySingle) or (y = EmptySingle) then
+    exit;
+  info := TFillBorderEllipseInfo.Create(x, y, rx, ry, w);
+  FillShapeAliased(bmp, info, BGRAPixelTransparent, False, scan, false, drawmode);
+  info.Free;
+end;
 procedure FillRoundRectangleAntialias(bmp: TBGRACustomBitmap; x1, y1, x2, y2,
   rx, ry: single; options: TRoundRectangleOptions; c: TBGRAPixel; EraseMode: boolean; LinearBlend: boolean);
+  rx, ry: single; options: TRoundRectangleOptions; c: TBGRAPixel; EraseMode: boolean; LinearBlend: boolean; APixelCenteredCoordinates: boolean);
 var
   info: TFillRoundRectangleInfo;
 begin
   if (x1 = x2) or (y1 = y2) then exit;
   info := TFillRoundRectangleInfo.Create(x1, y1, x2, y2, rx, ry, options);
+  info := TFillRoundRectangleInfo.Create(x1, y1, x2, y2, rx, ry, options, APixelCenteredCoordinates);
   FillShapeAntialias(bmp, info, c, EraseMode,nil, False, LinearBlend);
   info.Free;
 …
 procedure FillRoundRectangleAntialiasWithTexture(bmp: TBGRACustomBitmap; x1,
   y1, x2, y2, rx, ry: single; options: TRoundRectangleOptions;
   scan: IBGRAScanner; LinearBlend: boolean);
+  scan: IBGRAScanner; LinearBlend: boolean; APixelCenteredCoordinates: boolean);
 var
   info: TFillRoundRectangleInfo;
 begin
   if (x1 = x2) or (y1 = y2) then exit;
   info := TFillRoundRectangleInfo.Create(x1, y1, x2, y2, rx, ry, options);
+  info := TFillRoundRectangleInfo.Create(x1, y1, x2, y2, rx, ry, options, APixelCenteredCoordinates);
   FillShapeAntialiasWithTexture(bmp, info, scan, False, LinearBlend);
   info.Free;
 …
 procedure BorderRoundRectangleAntialias(bmp: TBGRACustomBitmap; x1, y1, x2,
   y2, rx, ry, w: single; options: TRoundRectangleOptions; c: TBGRAPixel;
   EraseMode: boolean; LinearBlend: boolean);
+  EraseMode: boolean; LinearBlend: boolean; APixelCenteredCoordinates: boolean);
 var
   info: TFillShapeInfo;
 …
     exit;
   end;
   info := TFillBorderRoundRectInfo.Create(x1, y1, x2,y2, rx, ry, w, options);
+  info := TFillBorderRoundRectInfo.Create(x1, y1, x2,y2, rx, ry, w, options, APixelCenteredCoordinates);
   FillShapeAntialias(bmp, info, c, EraseMode, nil, False, LinearBlend);
   info.Free;
 …
 procedure BorderRoundRectangleAntialiasWithTexture(bmp: TBGRACustomBitmap; x1,
   y1, x2, y2, rx, ry, w: single; options: TRoundRectangleOptions;
   scan: IBGRAScanner; LinearBlend: boolean);
+  scan: IBGRAScanner; LinearBlend: boolean; APixelCenteredCoordinates: boolean);
 var
   info: TFillBorderRoundRectInfo;
 …
     exit;
   end;
   info := TFillBorderRoundRectInfo.Create(x1, y1, x2,y2, rx, ry, w, options);
+  info := TFillBorderRoundRectInfo.Create(x1, y1, x2,y2, rx, ry, w, options, APixelCenteredCoordinates);
   FillShapeAntialiasWithTexture(bmp, info, scan, False, LinearBlend);
   info.Free;
 …
 procedure BorderAndFillRoundRectangleAntialias(bmp: TBGRACustomBitmap; x1, y1,
   x2, y2, rx, ry, w: single; options: TRoundRectangleOptions; bordercolor,
   fillcolor: TBGRAPixel; bordertexture,filltexture: IBGRAScanner; EraseMode: boolean);
+  fillcolor: TBGRAPixel; bordertexture,filltexture: IBGRAScanner; EraseMode: boolean; APixelCenteredCoordinates: boolean);
 var
   info: TFillBorderRoundRectInfo;
 …
 begin
   if (rx = 0) or (ry = 0) then exit;
   info := TFillBorderRoundRectInfo.Create(x1, y1, x2,y2, rx, ry, w, options);
+  info := TFillBorderRoundRectInfo.Create(x1, y1, x2,y2, rx, ry, w, options, APixelCenteredCoordinates);
   if not EraseMode then
   begin

GraphicTest/Packages/bgrabitmap/bgrapolygonaliased.pas

-              r494
+              r521
       ANumSegment: integer; dy: single; AData: pointer); override;
   public
     constructor Create(const points: array of TPointF; const texCoords: array of TPointF);
     constructor Create(const points: array of TPointF; const texCoords: array of TPointF; const lightnesses: array of word);
+    constructor Create(const points: array of TPointF; const texCoords: array of TPointF); overload;
+    constructor Create(const points: array of TPointF; const texCoords: array of TPointF; const lightnesses: array of word); overload;
     function CreateSegmentData(numPt,nextPt: integer; x,y: single): pointer; override;
     function CreateIntersectionInfo: TIntersectionInfo; override;
 …
       ANumSegment: integer; dy: single; AData: pointer); override;
   public
     constructor Create(const points: array of TPointF; const pointsZ: array of single; const texCoords: array of TPointF);
     constructor Create(const points: array of TPointF; const pointsZ: array of single; const texCoords: array of TPointF; const lightnesses: array of word);
+    constructor Create(const points: array of TPointF; const pointsZ: array of single; const texCoords: array of TPointF); overload;
+    constructor Create(const points: array of TPointF; const pointsZ: array of single; const texCoords: array of TPointF; const lightnesses: array of word); overload;
     function CreateSegmentData(numPt,nextPt: integer; x,y: single): pointer; override;
     function CreateIntersectionInfo: TIntersectionInfo; override;
 …
       ANumSegment: integer; dy: single; AData: pointer); override;
   public
     constructor Create(const points: array of TPointF; const points3D: array of TPoint3D; const normals: array of TPoint3D; const texCoords: array of TPointF);
     constructor Create(const points: array of TPointF; const points3D: array of TPoint3D_128; const normals: array of TPoint3D_128; const texCoords: array of TPointF);
+    constructor Create(const points: array of TPointF; const points3D: array of TPoint3D; const normals: array of TPoint3D; const texCoords: array of TPointF); overload;
+    constructor Create(const points: array of TPointF; const points3D: array of TPoint3D_128; const normals: array of TPoint3D_128; const texCoords: array of TPointF); overload;
     function CreateSegmentData(numPt,nextPt: integer; x,y: single): pointer; override;
     function CreateIntersectionInfo: TIntersectionInfo; override;
 …
   DX, DY: integer; BorderColor, FillColor: TBGRAPixel; FillTexture: IBGRAScanner = nil; ADrawMode: TDrawMode = dmDrawWithTransparency;
   skipFill: boolean = false);
+procedure BGRAFillRoundRectAliased(dest: TBGRACustomBitmap; X1, Y1, X2, Y2: integer;
+  DX, DY: integer; FillColor: TBGRAPixel; FillTexture: IBGRAScanner = nil; ADrawMode: TDrawMode = dmDrawWithTransparency);
 implementation
 uses Math, BGRABlend;
+uses Math, BGRABlend, BGRAPolygon;
 { TPolygonPerspectiveColorGradientInfo }
 …
 end;
+procedure BGRAFillRoundRectAliased(dest: TBGRACustomBitmap; X1, Y1, X2,
+  Y2: integer; DX, DY: integer; FillColor: TBGRAPixel;
+  FillTexture: IBGRAScanner; ADrawMode: TDrawMode);
+var
+  fi: TFillRoundRectangleInfo;
+begin
+  fi := TFillRoundRectangleInfo.Create(x1,y1,x2,y2,dx/2,dy/2,[rrDefault],false);
+  FillShapeAliased(dest, fi, FillColor, false, FillTexture, true, ADrawMode);
+  fi.Free;
+end;
 end.

GraphicTest/Packages/bgrabitmap/bgraqtbitmap.pas

-              r494
+              r521
   public
     procedure DataDrawTransparent(ACanvas: TCanvas; Rect: TRect;
+      AData: Pointer; ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer);
+      override;
+      AData: Pointer; ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer); override;
+    procedure DataDrawOpaque(ACanvas: TCanvas; ARect: TRect; AData: Pointer;
+      ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer); override;
     procedure Draw(ACanvas: TCanvas; x, y: integer; Opaque: boolean = True); override;
     procedure Draw(ACanvas: TCanvas; Rect: TRect; Opaque: boolean = True); override;
 …
   SlowDrawTransparent(Temp, ACanvas, Rect);
   Temp.Free;
+end;
+procedure TBGRAQtBitmap.DataDrawOpaque(ACanvas: TCanvas; ARect: TRect;
+  AData: Pointer; ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer);
+var psrc,pdest: PBGRAPixel;
+  bmp: TBGRAQtBitmap;
+begin
+  {$IFDEF DARWIN}
+  bmp := TBGRAQtBitmap.Create(AWidth,AHeight);
+  try
+    if ALineOrder = riloTopToBottom then psrc := AData
+    else psrc := PBGRAPixel(AData) + (AWidth*AHeight);
+    for y := 0 to AHeight-1 do
+    begin
+      pdest := bmp.ScanLine[y];
+      for x := 0 to AWidth-1 do
+      begin
+        pdest^.red := psrc^.red;
+        pdest^.green:= psrc^.green;
+        pdest^.blue := psrc^.blue;
+        pdest^.alpha := 255;
+      end;
+      if ALineOrder = riloBottomToTop then psrc -= 2*AWidth;
+    end;
+    bmp.Draw(ACanvas, ARect, false);
+  finally
+    bmp.Free;
+  end;
+  {$ELSE}
+  inherited DataDrawOpaque(ACanvas, ARect, AData, ALineOrder, AWidth, AHeight);
+  {$ENDIF}
 end;

GraphicTest/Packages/bgrabitmap/bgrareadbmp.pas

-              r494
+              r521
    - direct access to pixels with TBGRABitmap
    - vertical shrink option with MinifyHeight,WantedHeight,OutputHeight (useful for thumbnails)
+/2017 by circular:
+   - support for OS/2 1.x format
+   - support for headerless files
+}
 …
 type
   TBMPTransparencyOption = (toAuto, toTransparent, toOpaque);
+  TBitMapInfoHeader = BMPcomn.TBitMapInfoHeader;
+  TBitMapFileHeader = BMPcomn.TBitMapFileHeader;
+  TOS2BitmapHeader = packed record
+    bcSize: DWORD;
+    bcWidth: Word;
+    bcHeight: Word;
+    bcPlanes: Word;
+    bcBitCount: Word;
+  end;
+  TMinimumBitmapHeader = packed record
+    Size:longint;
+    Width:longint;
+    Height:longint;
+    Planes:word;
+    BitCount:word;
+  end;
+  TBitmapSubFormat = (bsfWithFileHeader, bsfHeaderless, bsfHeaderlessWithMask);
+  TReadScanlineProc = procedure(Row : Integer; Stream : TStream) of object;
+  TWriteScanlineProc = procedure(Row : Integer; Img : TFPCustomImage) of object;
+  TProgressProc = procedure(Percent: integer; var ShouldContinue: boolean) of object;
   { TBGRAReaderBMP }
   TBGRAReaderBMP = class (TFPCustomImageReader)
+  TBGRAReaderBMP = class (TBGRAImageReader)
     Private
       DeltaX, DeltaY : integer; // Used for the never-used delta option in RLE
       TopDown : boolean;        // If set, bitmap is stored top down instead of bottom up
-      continue : boolean;       // needed for onprogress event
-      Rect : TRect;
       Procedure FreeBufs;       // Free (and nil) buffers.
     protected
       ReadSize : Integer;       // Size (in bytes) of 1 scanline.
+      BFI : TBitMapInfoHeader;  // The header as read from the stream.
+      BFH: TBitMapFileHeader;    // The file header
+      BFI: TBitMapInfoHeader;  // The header as read from the stream.
+      FPaletteEntrySize: integer;  // 4 for Windows, 3 for OS/2 1.x
       FPalette : PFPcolor;      // Buffer with Palette entries. (useless now)
       FBGRAPalette : PBGRAPixel;
 …
       FBufferStream: TStream;
       FHasAlphaValues: boolean;
+      FMaskData: PByte;
+      FMaskDataSize: integer;
       // SetupRead will allocate the needed buffers, and read the colormap if needed.
       procedure SetupRead(nPalette, nRowBits: Integer; Stream : TStream); virtual;
 …
       procedure WriteScanLine(Row : Integer; Img : TFPCustomImage); virtual;
       procedure WriteScanLineBGRA(Row : Integer; Img : TFPCustomImage); virtual;
+      procedure ReadMaskLine({%H-}Row : Integer; Stream : TStream); virtual;
+      procedure SkipMaskLine({%H-}Row : Integer; Stream : TStream); virtual;
+      procedure WriteMaskLine(Row : Integer; Img : TFPCustomImage); virtual;
       // required by TFPCustomImageReader
       procedure InternalRead  (Stream:TStream; Img:TFPCustomImage); override;
 …
       function GetNextBufferByte: byte;
       procedure MakeOpaque(Img: TFPCustomImage);
+      procedure LoadMask(Stream:TStream; Img:TFPCustomImage; var ShouldContinue: boolean);
+      procedure MainProgressProc(Percent: integer; var ShouldContinue: boolean);
+      procedure ImageVerticalLoop(Stream:TStream; Img:TFPCustomImage;
+        ReadProc, SkipProc: TReadScanlineProc; WriteProc: TWriteScanlineProc;
+        ProgressProc: TProgressProc; var ShouldContinue: boolean);
     public
       MinifyHeight,WantedHeight: integer;
+      Hotspot: TPoint;
+      Subformat: TBitmapSubFormat;
       constructor Create; override;
       destructor Destroy; override;
 …
       property OutputHeight: integer read FOutputHeight;
       property TransparencyOption: TBMPTransparencyOption read FTransparencyOption write FTransparencyOption;
+  end;
+      function GetQuickInfo(AStream: TStream): TQuickImageInfo; override;
+      function GetBitmapDraft(AStream: TStream; {%H-}AMaxWidth, AMaxHeight: integer; out AOriginalWidth,AOriginalHeight: integer): TBGRACustomBitmap; override;
+  end;
+function MakeBitmapFileHeader(AData: TStream): TBitMapFileHeader;
 implementation
+type
+  TWriteScanlineProc = procedure (Row : Integer; Img : TFPCustomImage) of object;
+uses math;
+function MakeBitmapFileHeader(AData: TStream): TBitMapFileHeader;
+var header: PBitMapInfoHeader;
+  headerSize: integer;
+  extraSize: integer;
+  os2header: TOS2BitmapHeader;
+begin
+  AData.Position := 0;
+  headerSize := LEtoN(AData.ReadDWord);
+  if headerSize = sizeof(TOS2BitmapHeader) then //OS2 1.x
+  begin
+    AData.ReadBuffer({%H-}os2header,sizeof(os2header));
+    if LEtoN(os2header.bcBitCount) in [1,2,4,8] then
+    begin
+      extraSize := 3*(1 shl LEtoN(os2header.bcBitCount));
+    end else
+      extraSize := 0;
+    result.bfType:= Word('BM');
+    result.bfSize := NtoLE(Integer(sizeof(TBitMapFileHeader) + AData.Size));
+    result.bfReserved:= 0;
+    result.bfOffset := NtoLE(Integer(sizeof(TBitMapFileHeader) + headerSize + extraSize));
+  end else
+  begin
+    if (headerSize < 16) or (headerSize > AData.Size) or (headerSize > 1024) then
+      raise exception.Create('Invalid header size');
+    getmem(header, headerSize);
+    try
+      fillchar(header^, headerSize,0);
+      header^.Size := NtoLE(headerSize);
+      AData.ReadBuffer((PByte(header)+4)^, headerSize-4);
+      if LEtoN(header^.Compression) = BI_BITFIELDS then
+        extraSize := 4*3
+      else if LEtoN(header^.BitCount) in [1,2,4,8] then
+      begin
+        if header^.ClrUsed > 0 then
+          extraSize := 4*header^.ClrUsed
+        else
+          extraSize := 4*(1 shl header^.BitCount);
+      end else
+        extraSize := 0;
+      result.bfType:= Word('BM');
+      result.bfSize := NtoLE(Integer(sizeof(TBitMapFileHeader) + AData.Size));
+      result.bfReserved:= 0;
+      result.bfOffset := NtoLE(Integer(sizeof(TBitMapFileHeader) + headerSize + extraSize));
+    finally
+      freemem(header);
+    end;
+  end;
+end;
 function RGBAToFPColor(Const RGBA: TColorRGBA) : TFPcolor;
 begin
   with Result, RGBA do
 …
   inherited create;
   FTransparencyOption := toTransparent;
+  Subformat:= bsfWithFileHeader;
 end;
 …
 end;
+function TBGRAReaderBMP.GetQuickInfo(AStream: TStream): TQuickImageInfo;
+var headerSize: dword;
+  os2header: TOS2BitmapHeader;
+  minHeader: TMinimumBitmapHeader;
+  totalDepth: integer;
+  headerPos: int64;
+begin
+  fillchar({%H-}result, sizeof(result), 0);
+  headerPos := AStream.Position;
+  if AStream.Read({%H-}headerSize, sizeof(headerSize)) <> sizeof(headerSize) then exit;
+  headerSize := LEtoN(headerSize);
+  //check presence of file header
+  if (headerSize and $ffff) = BMmagic then
+  begin
+    headerPos += sizeof(TBitMapFileHeader);
+    AStream.Position := headerPos;
+    if AStream.Read(headerSize, sizeof(headerSize)) <> sizeof(headerSize) then exit;
+    headerSize := LEtoN(headerSize);
+  end;
+  AStream.Position := headerPos;
+  if headerSize = sizeof(TOS2BitmapHeader) then //OS2 1.x
+  begin
+    if AStream.Read({%H-}os2header, sizeof(os2header)) <> sizeof(os2header) then exit;
+    result.width := LEtoN(os2header.bcWidth);
+    result.height := LEtoN(os2header.bcHeight);
+    result.colorDepth := LEtoN(os2header.bcBitCount);
+    result.alphaDepth := 0;
+  end
+  else
+  if headerSize >= sizeof(minHeader) then
+  begin
+    if AStream.Read({%H-}minHeader, sizeof(minHeader)) <> sizeof(minHeader) then exit;
+    result.width := LEtoN(minHeader.Width);
+    result.height := LEtoN(minHeader.Height);
+    totalDepth := LEtoN(minHeader.BitCount);
+    if totalDepth > 24 then
+    begin
+      result.colorDepth:= 24;
+      result.alphaDepth:= 8;
+    end else
+    begin
+      result.colorDepth := totalDepth;
+      result.alphaDepth:= 0;
+    end;
+  end else
+  begin
+    result.width := 0;
+    result.height:= 0;
+    result.colorDepth:= 0;
+    result.alphaDepth:= 0;
+  end;
+end;
+function TBGRAReaderBMP.GetBitmapDraft(AStream: TStream; AMaxWidth,
+  AMaxHeight: integer; out AOriginalWidth, AOriginalHeight: integer): TBGRACustomBitmap;
+var
+  bmpFormat: TBGRAReaderBMP;
+  prevStreamPos: Int64;
+begin
+  bmpFormat:= TBGRAReaderBMP.Create;
+  bmpFormat.Subformat:= Subformat;
+  bmpFormat.MinifyHeight := AMaxHeight*2;
+  result := BGRABitmapFactory.Create;
+  prevStreamPos := AStream.Position;
+  try
+    result.LoadFromStream(AStream, bmpFormat);
+    AOriginalWidth:= result.Width;
+    AOriginalHeight:= bmpFormat.OriginalHeight;
+  finally
+    bmpFormat.Free;
+    AStream.Position := prevStreamPos;
+  end;
+end;
 procedure TBGRAReaderBMP.FreeBufs;
 begin
   If (LineBuf<>Nil) then
 …
 var
   ColInfo: ARRAY OF TColorRGBA;
+  i: Integer;
+  ColInfo3: packed array of TColorRGB;
+  i,colorPresent: Integer;
 begin
 …
     SetLength(ColInfo, nPalette);
     if BFI.ClrUsed>0 then
+      Stream.Read(ColInfo[0],BFI.ClrUsed*SizeOf(TColorRGBA))
+    else // Seems to me that this is dangerous.
+      Stream.Read(ColInfo[0],nPalette*SizeOf(TColorRGBA));
+      colorPresent:= min(BFI.ClrUsed,nPalette)
+    else
+      colorPresent:= nPalette;
+    if FPaletteEntrySize = 3 then
+    begin
+      setlength(ColInfo3, nPalette);
+      Stream.Read(ColInfo3[0],colorPresent*SizeOf(TColorRGB));
+      for i := 0 to colorPresent-1 do
+        ColInfo[i].RGB := ColInfo3[i];
+    end
+    else
+    begin
+      Stream.Read(ColInfo[0],colorPresent*SizeOf(TColorRGBA));
+    end;
     for i := 0 to High(ColInfo) do
     begin
 …
 Var
   PrevSourceRow,SourceRow, i, pallen, SourceRowDelta, SourceLastRow : Integer;
+  i, pallen : Integer;
   BadCompression : boolean;
   WriteScanlineProc: TWriteScanlineProc;
+  SourceRowAdd: integer;
+  SourceRowAcc,SourceRowMod: integer;
+  SourceRowAccAdd: integer;
+  OutputLastRow, OutputRow, OutputRowDelta: integer;
+  prevPercent, percent, percentAdd : byte;
+  percentMod : longword;
+  percentAcc, percentAccAdd : longword;
+begin
+  Rect.Left:=0; Rect.Top:=0; Rect.Right:=0; Rect.Bottom:=0;
+  continue:=true;
+  Progress(psStarting,0,false,Rect,'',continue);
+  if not continue then exit;
+  Stream.Read(BFI,SizeOf(BFI));
+  {$IFDEF ENDIAN_BIG}
+  SwapBMPInfoHeader(BFI);
+  {$ENDIF}
+  headerSize: longword;
+  os2header: TOS2BitmapHeader;
+  shouldContinue: boolean;
+begin
+  shouldContinue:=true;
+  Progress(psStarting,0,false,EmptyRect,'',shouldContinue);
+  if not shouldContinue then exit;
+  headerSize := LEtoN(Stream.ReadDWord);
+  fillchar({%H-}BFI,SizeOf(BFI),0);
+  if headerSize = sizeof(TOS2BitmapHeader) then
+  begin
+    fillchar({%H-}os2header,SizeOf(os2header),0);
+    Stream.Read(os2header.bcWidth,min(SizeOf(os2header),headerSize)-sizeof(DWord));
+    BFI.Size := 16;
+    BFI.Width := LEtoN(os2header.bcWidth);
+    BFI.Height := LEtoN(os2header.bcHeight);
+    BFI.Planes := LEtoN(os2header.bcPlanes);
+    BFI.BitCount := LEtoN(os2header.bcBitCount);
+    FPaletteEntrySize:= 3;
+  end else
+  begin
+    Stream.Read(BFI.Width,min(SizeOf(BFI),headerSize)-sizeof(DWord));
+    {$IFDEF ENDIAN_BIG}
+    SwapBMPInfoHeader(BFI);
+    {$ENDIF}
+    BFI.Size := headerSize;
+    FPaletteEntrySize:= 4;
+  end;
   { This will move past any junk after the BFI header }
   Stream.Position:=Stream.Position-SizeOf(BFI)+BFI.Size;
 …
 :
         SetupRead(0,Width*8*4,Stream);
+    end;
+  end;
+    else raise exception.Create('Invalid bit depth ('+inttostr(BFI.BitCount)+')');
+    end;
+  end;
+  if Subformat = bsfHeaderlessWithMask then BFI.Height := BFI.Height div 2;
   Try
     { Note: it would be better to Fill the image palette in setupread instead of creating FPalette.
 …
     if pallen>0 then
     begin
+      if FPalette = nil then raise exception.Create('Internal error: palette object not initialized');
       Img.Palette.Count:=pallen;
       for i:=0 to pallen-1 do
         Img.Palette.Color[i]:=FPalette[i];
     end;
+    if MinifyHeight < BFI.Height then FOutputHeight:= MinifyHeight else
+    if WantedHeight <> 0 then FOutputHeight:= WantedHeight else
+      FOutputHeight:= 0;
+    percent:=0;
+    percentAdd := 100 div BFI.Height;
+    percentAcc:=BFI.Height div 2;
+    percentAccAdd := 100 mod BFI.Height;
+    percentMod:=BFI.Height;
+    DeltaX:=-1; DeltaY:=-1;
+    if TopDown then
+    begin
+      SourceRowDelta := 1;
+      SourceRow := 0;
+      SourceLastRow := BFI.Height-1;
+    end else
+    begin
+      SourceRowDelta := -1;
+      SourceRow := BFI.Height-1;
+      SourceLastRow := 0;
+    end;
+    OutputRowDelta:= SourceRowDelta;
+    if (OutputHeight <= 0) or (OutputHeight = BFI.Height) then
+    begin
+      SourceRowAdd := SourceRowDelta;
+      SourceRowAcc := 0;
+      SourceRowAccAdd := 0;
+      SourceRowMod := 1;
+      OutputRow := SourceRow;
+      OutputLastRow := SourceLastRow;
+      Img.SetSize(BFI.Width,BFI.Height);
+    end else
+    begin
+      SourceRowAdd := (BFI.Height div OutputHeight)*SourceRowDelta;
+      SourceRowAcc := OutputHeight div 2;
+      SourceRowAccAdd := BFI.Height mod OutputHeight;
+      SourceRowMod := OutputHeight;
+      If TopDown then
+      begin
+        OutputRow := 0;
+        OutputLastRow := OutputHeight-1;
+      end
+      else
+      begin
+        OutputRow := OutputHeight-1;
+        OutputLastRow := 0;
+      end;
+      Img.SetSize(BFI.Width,OutputHeight);
+    end;
+    if (MinifyHeight > 0) and (MinifyHeight < BFI.Height) then FOutputHeight:= MinifyHeight else
+    if WantedHeight > 0 then FOutputHeight:= WantedHeight else
+      FOutputHeight:= BFI.Height;
+    if (BFI.Compression=BI_RLE8) or(BFI.Compression=BI_RLE4) then InitReadBuffer(Stream,2048);
+    FHasAlphaValues:= false;
+    Img.SetSize(BFI.Width,FOutputHeight);
     if Img is TBGRACustomBitmap then
       WriteScanlineProc := @WriteScanLineBGRA else
         WriteScanlineProc := @WriteScanLine;
+    PrevSourceRow := SourceRow-SourceRowDelta;
+    if (BFI.Compression=BI_RLE8) or(BFI.Compression=BI_RLE4) then InitReadBuffer(Stream,2048);
+    FHasAlphaValues:= false;
+    while SourceRow <> SourceLastRow+SourceRowDelta do
+    begin
+      while PrevSourceRow <> SourceRow do
+      begin
+        inc(PrevSourceRow, SourceRowDelta);
+        if PrevSourceRow = SourceRow then
+          ReadScanLine(PrevSourceRow,Stream)
+        else
+          SkipScanLine(PrevSourceRow,Stream);
+      end;
+      WriteScanLineProc(OutputRow,Img);
+      if OutputRow = OutputLastRow then break;
+      if not continue then exit;
+      inc(OutputRow,OutputRowDelta);
+      inc(SourceRow,SourceRowAdd);
+      inc(SourceRowAcc,SourceRowAccAdd);
+      if SourceRowAcc >= SourceRowMod then
+      begin
+       dec(SourceRowAcc,SourceRowMod);
+       Inc(SourceRow,SourceRowDelta);
+      end;
+      prevPercent := percent;
+      inc(percent,percentAdd);
+      inc(percentAcc,percentAccAdd);
+      if percentAcc>=percentMod then inc(percent);
+      if percent<>prevPercent then Progress(psRunning,percent,false,Rect,'',continue);
+    end;
+    if not FHasAlphaValues and (TransparencyOption = toAuto) and (BFI.BitCount = 32) then
+      MakeOpaque(Img);
+    Progress(psEnding,100,false,Rect,'',continue);
+    ImageVerticalLoop(Stream, Img, @ReadScanLine, @SkipScanLine, WriteScanlineProc,
+                      @MainProgressProc, shouldContinue);
+    if shouldContinue then
+    begin
+      if not FHasAlphaValues and (TransparencyOption = toAuto) and (BFI.BitCount = 32) then
+        MakeOpaque(Img);
+      if (BFI.Compression=BI_RLE8) or(BFI.Compression=BI_RLE4) then CloseReadBuffer;
+      if Subformat = bsfHeaderlessWithMask then LoadMask(Stream,Img, shouldContinue);
+      Progress(psEnding,100,false,EmptyRect,'',shouldContinue);
+    end;
   finally
-    if (BFI.Compression=BI_RLE8) or(BFI.Compression=BI_RLE4) then CloseReadBuffer;
     FreeBufs;
   end;
 …
         for Column:=0 to img.Width-1 do
         begin
           PDest^:= BGRA((PSrc)^,(PSrc+1)^,(PSrc+2)^,(PSrc+3)^);
+          PDest^:= BGRA((PSrc+2)^,(PSrc+1)^,(PSrc)^,(PSrc+3)^);
           if PDest^.alpha <> 0 then FHasAlphaValues:= true;
           inc(PDest);
 …
 end;
+procedure TBGRAReaderBMP.ReadMaskLine(Row: Integer; Stream: TStream);
+begin
+  FillChar(FMaskData^, FMaskDataSize, 0);
+  Stream.Read(FMaskData^, FMaskDataSize);
+end;
+procedure TBGRAReaderBMP.SkipMaskLine(Row: Integer; Stream: TStream);
+begin
+  Stream.Position := Stream.Position+FMaskDataSize;
+end;
+procedure TBGRAReaderBMP.WriteMaskLine(Row: Integer; Img: TFPCustomImage);
+var x, maskPos: integer;
+  bit: byte;
+  bmp: TBGRACustomBitmap;
+  pimg: PBGRAPixel;
+begin
+  if Img is TBGRACustomBitmap then
+    bmp := TBGRACustomBitmap(Img)
+  else
+    exit;
+  maskPos := 0;
+  bit := $80;
+  pimg := bmp.ScanLine[Row];
+  for x := 0 to bmp.Width-1 do
+  begin
+    if (FMaskData[maskPos] and bit) <> 0 then //if AND mask is non zero, value is kept
+    begin
+      if pimg^.alpha = 255 then
+      begin
+        pimg^.alpha := 0;
+        if dword(pimg^) <> 0 then
+        begin
+         bmp.NeedXorMask;
+         bmp.XorMask.SetPixel(x,Row,pimg^);
+        end;
+      end;
+    end;
+    inc(pimg);
+    bit := bit shr 1;
+    if bit = 0 then
+    begin
+      bit := $80;
+      inc(maskPos);
+    end;
+  end;
+end;
 function  TBGRAReaderBMP.InternalCheck (Stream:TStream) : boolean;
+var
+  {%H-}BFH:TBitMapFileHeader;
+begin
+  stream.Read({%H-}BFH,SizeOf(BFH));
+  {$IFDEF ENDIAN_BIG}
+  SwapBMPFileHeader(BFH);
+  {$ENDIF}
+  With BFH do
+    Result:=(bfType=BMmagic); // Just check magic number
+begin
+  fillchar(BFH, sizeof(BFH), 0);
+  if Subformat in [bsfHeaderless,bsfHeaderlessWithMask] then
+  begin
+   result := true;
+   Hotspot := Point(0,0);
+  end else
+  begin
+    if stream.Read(BFH,SizeOf(BFH)) <> sizeof(BFH) then
+    begin
+      result := false;
+      exit;
+    end;
+    Hotspot := Point(LEtoN(PWord(@BFH.bfReserved)^),LEtoN((PWord(@BFH.bfReserved)+1)^));
+    {$IFDEF ENDIAN_BIG}
+    SwapBMPFileHeader(BFH);
+    {$ENDIF}
+    With BFH do
+      Result:=(bfType=BMmagic); // Just check magic number
+  end;
 end;
 …
 end;
+procedure TBGRAReaderBMP.LoadMask(Stream: TStream; Img: TFPCustomImage; var ShouldContinue: boolean);
+begin
+  if Img is TBGRACustomBitmap then TBGRACustomBitmap(Img).DiscardXorMask;
+  FMaskDataSize := ((Img.Width+31) div 32)*4; //padded to dword
+  getmem(FMaskData, FMaskDataSize);
+  try
+    ImageVerticalLoop(Stream,Img, @ReadMaskLine, @SkipMaskLine, @WriteMaskLine, nil, ShouldContinue);
+  finally
+    freemem(FMaskData);
+    FMaskData := nil;
+    FMaskDataSize := 0;
+  end;
+end;
+procedure TBGRAReaderBMP.MainProgressProc(Percent: integer;
+  var ShouldContinue: boolean);
+begin
+  Progress(psRunning,Percent,false,EmptyRect,'',ShouldContinue);
+end;
+procedure TBGRAReaderBMP.ImageVerticalLoop(Stream: TStream;
+  Img: TFPCustomImage; ReadProc, SkipProc: TReadScanlineProc;
+  WriteProc: TWriteScanlineProc; ProgressProc: TProgressProc;
+  var ShouldContinue: boolean);
+var
+  prevPercent, percent, percentAdd : byte;
+  percentMod : longword;
+  percentAcc, percentAccAdd : longword;
+  PrevSourceRow,SourceRow, SourceRowDelta, SourceLastRow: integer;
+  SourceRowAdd: integer;
+  SourceRowAcc,SourceRowMod: integer;
+  SourceRowAccAdd: integer;
+  OutputLastRow, OutputRow, OutputRowDelta: integer;
+begin
+  if OutputHeight <= 0 then exit;
+  percent:=0;
+  percentAdd := 100 div BFI.Height;
+  percentAcc:=BFI.Height div 2;
+  percentAccAdd := 100 mod BFI.Height;
+  percentMod:=BFI.Height;
+  DeltaX:=-1; DeltaY:=-1;
+  if TopDown then
+  begin
+    SourceRowDelta := 1;
+    SourceRow := 0;
+    SourceLastRow := BFI.Height-1;
+  end else
+  begin
+    SourceRowDelta := -1;
+    SourceRow := BFI.Height-1;
+    SourceLastRow := 0;
+  end;
+  OutputRowDelta:= SourceRowDelta;
+  SourceRowAdd := (BFI.Height div OutputHeight)*SourceRowDelta;
+  SourceRowAcc := OutputHeight div 2;
+  SourceRowAccAdd := BFI.Height mod OutputHeight;
+  SourceRowMod := OutputHeight;
+  If TopDown then
+  begin
+    OutputRow := 0;
+    OutputLastRow := OutputHeight-1;
+  end
+  else
+  begin
+    OutputRow := OutputHeight-1;
+    OutputLastRow := 0;
+  end;
+  PrevSourceRow := SourceRow-SourceRowDelta;
+  while ShouldContinue and (SourceRow <> SourceLastRow+SourceRowDelta) do
+  begin
+    while PrevSourceRow <> SourceRow do
+    begin
+      inc(PrevSourceRow, SourceRowDelta);
+      if PrevSourceRow = SourceRow then
+        ReadProc(PrevSourceRow,Stream)
+      else
+        SkipProc(PrevSourceRow,Stream);
+    end;
+    WriteProc(OutputRow,Img);
+    if OutputRow = OutputLastRow then break;
+    inc(OutputRow,OutputRowDelta);
+    inc(SourceRow,SourceRowAdd);
+    inc(SourceRowAcc,SourceRowAccAdd);
+    if SourceRowAcc >= SourceRowMod then
+    begin
+     dec(SourceRowAcc,SourceRowMod);
+     Inc(SourceRow,SourceRowDelta);
+    end;
+    prevPercent := percent;
+    inc(percent,percentAdd);
+    inc(percentAcc,percentAccAdd);
+    if percentAcc>=percentMod then inc(percent);
+    if (percent<>prevPercent) and Assigned(ProgressProc) then ProgressProc(percent, ShouldContinue);
+  end;
+end;
 initialization

GraphicTest/Packages/bgrabitmap/bgrareadico.pas

-              r494
+              r521
 uses
   Classes, SysUtils, FPimage;
+  Classes, SysUtils, FPimage{$IFDEF BGRABITMAP_USE_LCL}, Graphics{$ENDIF};
 type
+  {$IFDEF BGRABITMAP_USE_LCL}TCustomIconClass = class of TCustomIcon;{$ENDIF}
+  TByteSet = set of byte;
   { TBGRAReaderIco }
+  { TBGRAReaderIcoOrCur }
   TBGRAReaderIco = class(TFPCustomImageReader)
+  TBGRAReaderIcoOrCur = class(TFPCustomImageReader)
   protected
     procedure InternalRead({%H-}Str: TStream; {%H-}Img: TFPCustomImage); override;
     function InternalCheck(Str: TStream): boolean; override;
+    function ExpectedMagic: TByteSet; virtual; abstract;
+    {$IFDEF BGRABITMAP_USE_LCL}function LazClass: TCustomIconClass; virtual; abstract;{$ENDIF}
   public
     WantedWidth, WantedHeight : integer;
   end;
+  TBGRAReaderIco = class(TBGRAReaderIcoOrCur)
+  protected
+    function ExpectedMagic: TByteSet; override;
+    {$IFDEF BGRABITMAP_USE_LCL}function LazClass: TCustomIconClass; override;{$ENDIF}
+  end;
+  { TBGRAReaderCur }
+  TBGRAReaderCur = class(TBGRAReaderIcoOrCur)
+  protected
+    function ExpectedMagic: TByteSet; override;
+    {$IFDEF BGRABITMAP_USE_LCL}function LazClass: TCustomIconClass; override;{$ENDIF}
+  end;
 implementation
+uses BGRABitmapTypes{$IFDEF BGRABITMAP_USE_LCL}, Graphics{$ENDIF};
+uses BGRABitmapTypes{$IFNDEF BGRABITMAP_USE_LCL}, BGRAIconCursor{$ENDIF};
+{ TBGRAReaderCur }
+function TBGRAReaderCur.ExpectedMagic: TByteSet;
+begin
+  result := [2];
+end;
+{$IFDEF BGRABITMAP_USE_LCL}function TBGRAReaderCur.LazClass: TCustomIconClass;
+begin
+  result := TCursorImage;
+end;{$ENDIF}
 { TBGRAReaderIco }
+procedure TBGRAReaderIco.InternalRead(Str: TStream; Img: TFPCustomImage);
+function TBGRAReaderIco.ExpectedMagic: TByteSet;
+begin
+  result := [1,2];
+end;
+{$IFDEF BGRABITMAP_USE_LCL}function TBGRAReaderIco.LazClass: TCustomIconClass;
+begin
+  result := TIcon;
+end;{$ENDIF}
+{ TBGRAReaderIcoOrCur }
+procedure TBGRAReaderIcoOrCur.InternalRead(Str: TStream; Img: TFPCustomImage);
 {$IFDEF BGRABITMAP_USE_LCL}
 var ico: TIcon; i,bestIdx: integer;
+var ico: TCustomIcon; i,bestIdx: integer;
     height,width: word; format:TPixelFormat;
     bestHeight,bestWidth: integer; maxFormat: TPixelFormat;
 …
   if WantedWidth > 0 then compWidth:= WantedWidth else compWidth:= 65536;
   if WantedHeight > 0 then compHeight:= WantedHeight else compHeight:= 65536;
   ico := TIcon.Create;
+  ico := LazClass.Create;
   try
     ico.LoadFromStream(Str);
 …
       ico.GetDescription(i,format,height,width);
       if (bestIdx = -1) or (abs(height-compHeight)+abs(width-compWidth) < abs(bestHeight-compHeight)+abs(bestWidth-compWidth)) or
       ((height = bestHeight) or (width = bestWidth) and (format > maxFormat)) then
+      ((height = bestHeight) and (width = bestWidth) and (format > maxFormat)) then
       begin
         bestIdx := i;
 …
     begin
       ico.Current := bestIdx;
       (Img as TBGRACustomBitmap).Assign(ico);
+      Img.Assign(ico);
     end;
   finally
 …
 end;
 {$ELSE}
+var icoCur: TBGRAIconCursor;
+    compWidth,compHeight: integer;
+    bmp: TBGRACustomBitmap;
 begin
+  raise exception.create('Not implemented');
+  if WantedWidth > 0 then compWidth:= WantedWidth else compWidth:= 65536;
+  if WantedHeight > 0 then compHeight:= WantedHeight else compHeight:= 65536;
+  icoCur := TBGRAIconCursor.Create(Str);
+  try
+    bmp := icoCur.GetBestFitBitmap(compWidth,compHeight);
+    try
+      Img.Assign(bmp);
+    finally
+      bmp.Free;
+    end;
+  finally
+    icoCur.Free;
+  end;
 end;
 {$ENDIF}
 function TBGRAReaderIco.InternalCheck(Str: TStream): boolean;
+function TBGRAReaderIcoOrCur.InternalCheck(Str: TStream): boolean;
 var {%H-}magic: packed array[0..5] of byte;
     oldPos: int64;
 …
   str.Position:= oldPos;
   if result then
     result := (magic[0] = $00) and (magic[1] = $00) and (magic[2] in[$01,$02]) and (magic[3] = $00) and
+    result := (magic[0] = $00) and (magic[1] = $00) and (magic[2] in ExpectedMagic) and (magic[3] = $00) and
              (magic[4] + (magic[5] shl 8) > 0);
 end;
 …
   DefaultBGRAImageReader[ifIco] := TBGRAReaderIco;
+  DefaultBGRAImageReader[ifCur] := TBGRAReaderCur;
 end.

GraphicTest/Packages/bgrabitmap/bgrareadlzp.pas

-              r494
+              r521
     str.Position:= oldPos;
     InternalReadCompressableBitmap(str,Img);
     if Str.Position < Str.Size then InternalReadLayers(Str,Img);
+    if (Str.Position < Str.Size) and (FCaption = 'Preview') then InternalReadLayers(Str,Img);
   end;
 end;
 …
   nameLen := LEtoN(str.ReadDWord);
   setlength(ACaption, nameLen);
+  {$PUSH}{$RANGECHECKS OFF}
   str.ReadBuffer(ACaption[1], nameLen);
+  {$POP}
   channelFlags := str.ReadByte;
   NbPixels := w*h;

GraphicTest/Packages/bgrabitmap/bgrareadpng.pas

-              r494
+              r521
   { TBGRAReaderPNG }
   TBGRAReaderPNG = class (TFPCustomImageReader)
+  TBGRAReaderPNG = class (TBGRAImageReader)
     private
 …
       property OriginalWidth: integer read GetOriginalWidth;
       property OriginalHeight: integer read GetOriginalHeight;
+      function GetQuickInfo(AStream: TStream): TQuickImageInfo; override;
+      function GetBitmapDraft(AStream: TStream; {%H-}AMaxWidth, AMaxHeight: integer; out AOriginalWidth,AOriginalHeight: integer): TBGRACustomBitmap; override;
   end;
 implementation
+uses math;
 const StartPoints : array[0..7, 0..1] of word =
 …
 end;
+function TBGRAReaderPNG.GetQuickInfo(AStream: TStream): TQuickImageInfo;
+const headerChunkSize = 13;
+var
+  {%H-}FileHeader : packed array[0..7] of byte;
+  {%H-}ChunkHeader : TChunkHeader;
+  {%H-}HeaderChunk : THeaderChunk;
+begin
+  fillchar({%H-}result, sizeof(result), 0);
+  if AStream.Read({%H-}FileHeader, sizeof(FileHeader))<> sizeof(FileHeader) then exit;
+  if QWord(FileHeader) <> QWord(PNGComn.Signature) then exit;
+  if AStream.Read({%H-}ChunkHeader, sizeof(ChunkHeader))<> sizeof(ChunkHeader) then exit;
+  if ChunkHeader.CType <> ChunkTypes[ctIHDR] then exit;
+  if BEtoN(ChunkHeader.CLength) < headerChunkSize then exit;
+  if AStream.Read({%H-}HeaderChunk, headerChunkSize) <> headerChunkSize then exit;
+  result.width:= BEtoN(HeaderChunk.Width);
+  result.height:= BEtoN(HeaderChunk.height);
+  case HeaderChunk.ColorType and 3 of
+,3: {grayscale, palette}
+      if HeaderChunk.BitDepth > 8 then
+        result.colorDepth := 8
+      else
+        result.colorDepth := HeaderChunk.BitDepth;
+: {color} result.colorDepth := HeaderChunk.BitDepth*3;
+  end;
+  if (HeaderChunk.ColorType and 4) = 4 then
+    result.alphaDepth := HeaderChunk.BitDepth
+  else
+    result.alphaDepth := 0;
+end;
+function TBGRAReaderPNG.GetBitmapDraft(AStream: TStream; AMaxWidth,
+  AMaxHeight: integer; out AOriginalWidth, AOriginalHeight: integer): TBGRACustomBitmap;
+var
+  png: TBGRAReaderPNG;
+begin
+  png:= TBGRAReaderPNG.Create;
+  result := BGRABitmapFactory.Create;
+  try
+    png.MinifyHeight := AMaxHeight;
+    result.LoadFromStream(AStream, png);
+    AOriginalWidth:= result.Width;
+    AOriginalHeight:= png.OriginalHeight;
+  finally
+    png.Free;
+  end;
+end;
 procedure TBGRAReaderPNG.ReadChunk;
 var {%H-}ChunkHeader : TChunkHeader;
     readCRC : longword;
 …
   UsingBitGroup := 0;
   DataIndex := 0;
+  {$PUSH}{$RANGECHECKS OFF} //because PByteArray is limited to 32767
   if (UsingBitGroup = 0) and (Header.BitDepth <> 16) then
     case ByteWidth of
 …
          end;
     end;
+  {$POP}
   X := StartX;
 …
 end;
 function TBGRAReaderPNG.ColorGray1 (const CD:TColorDAta) : TFPColor;
+function TBGRAReaderPNG.ColorGray1(const CD: TColorData): TFPColor;
 begin
   if CD = 0 then
 …
 end;
 function TBGRAReaderPNG.ColorGray2 (const CD:TColorDAta) : TFPColor;
+function TBGRAReaderPNG.ColorGray2(const CD: TColorData): TFPColor;
 var c : NativeUint;
 begin
 …
 end;
 function TBGRAReaderPNG.ColorGray4 (const CD:TColorDAta) : TFPColor;
+function TBGRAReaderPNG.ColorGray4(const CD: TColorData): TFPColor;
 var c : NativeUint;
 begin
 …
 end;
 function TBGRAReaderPNG.ColorGray8 (const CD:TColorDAta) : TFPColor;
+function TBGRAReaderPNG.ColorGray8(const CD: TColorData): TFPColor;
 var c : NativeUint;
 begin
 …
 end;
 function TBGRAReaderPNG.ColorGray16 (const CD:TColorDAta) : TFPColor;
+function TBGRAReaderPNG.ColorGray16(const CD: TColorData): TFPColor;
 var c : NativeUint;
 begin
 …
     while Count4 > 0 do
     begin
       {$push}{$r-}
+      {$push}{$r-}{$q-}
       PDWord(p)^ := (((PDWord(pPrev)^ and $00FF00FF) + (PDWord(p)^ and $00FF00FF)) and $00FF00FF)
         or (((PDWord(pPrev)^ and $FF00FF00) + (PDWord(p)^ and $FF00FF00)) and $FF00FF00);
 …
     // Check IHDR
     ReadChunk;
+    move (chunk.data^, FHeader, sizeof(Header));
+    fillchar(FHeader, sizeof(FHeader), 0);
+    move (chunk.data^, FHeader, min(sizeof(Header), chunk.alength));
     with header do
       begin

GraphicTest/Packages/bgrabitmap/bgraresample.pas

-              r494
+              r521
   NewWidth, NewHeight: integer): TBGRACustomBitmap;
 procedure StretchPutImage(bmp: TBGRACustomBitmap;
   NewWidth, NewHeight: integer; dest: TBGRACustomBitmap; OffsetX,OffsetY: Integer; ADrawMode: TDrawMode; AOpacity: byte);
+  NewWidth, NewHeight: integer; dest: TBGRACustomBitmap; OffsetX,OffsetY: Integer; ADrawMode: TDrawMode; AOpacity: byte; ANoTransition: boolean = false);
 procedure DownSamplePutImage(source: TBGRACustomBitmap; factorX,factorY: integer; dest: TBGRACustomBitmap; OffsetX,OffsetY: Integer; ADrawMode: TDrawMode);
 function DownSample(source: TBGRACustomBitmap; factorX,factorY: integer): TBGRACustomBitmap;
 …
   public
     Coeff: single;
     constructor Create;
     constructor Create(ACoeff: single);
+    constructor Create; overload;
+    constructor Create(ACoeff: single); overload;
     function Interpolation(t: single): single; override;
     function ShouldCheckRange: boolean; override;
 …
 procedure StretchPutImage(bmp: TBGRACustomBitmap; NewWidth, NewHeight: integer;
   dest: TBGRACustomBitmap; OffsetX, OffsetY: Integer; ADrawMode: TDrawMode; AOpacity: byte);
+  dest: TBGRACustomBitmap; OffsetX, OffsetY: Integer; ADrawMode: TDrawMode; AOpacity: byte; ANoTransition: boolean);
 type
   TTransitionState = (tsNone, tsPlain, tsLeft, tsMiddle, tsRight);
 …
     newTransition: TTransitionState;
   begin
     if DeltaSrc=0 then
+    if (DeltaSrc=0) or ANoTransition then
     begin
       PDest^ := PSrc^;
 …
       begin
         transition:= tsMiddle;
+        asum := psrc^.alpha + (psrc+DeltaSrc)^.alpha;
+        if asum = 0 then
+          pdest^ := BGRAPixelTransparent
+        else if asum = 510 then
+        begin
+          pdest^.alpha := 255;
+        if ADrawMode = dmXor then
+        begin
+          pdest^.alpha := (psrc^.alpha + (psrc+DeltaSrc)^.alpha + 1) shr 1;
           pdest^.red := (psrc^.red + (psrc+DeltaSrc)^.red + 1) shr 1;
           pdest^.green := (psrc^.green + (psrc+DeltaSrc)^.green + 1) shr 1;
 …
         end else
         begin
+          pdest^.alpha := asum shr 1;
+          a1 := psrc^.alpha;
+          a2 := (psrc+DeltaSrc)^.alpha;
+          pdest^.red := (psrc^.red*a1 + (psrc+DeltaSrc)^.red*a2 + (asum shr 1)) div asum;
+          pdest^.green := (psrc^.green*a1 + (psrc+DeltaSrc)^.green*a2 + (asum shr 1)) div asum;
+          pdest^.blue := (psrc^.blue*a1 + (psrc+DeltaSrc)^.blue*a2 + (asum shr 1)) div asum;
+          asum := psrc^.alpha + (psrc+DeltaSrc)^.alpha;
+          if asum = 0 then
+            pdest^ := BGRAPixelTransparent
+          else if asum = 510 then
+          begin
+            pdest^.alpha := 255;
+            pdest^.red := (psrc^.red + (psrc+DeltaSrc)^.red + 1) shr 1;
+            pdest^.green := (psrc^.green + (psrc+DeltaSrc)^.green + 1) shr 1;
+            pdest^.blue := (psrc^.blue + (psrc+DeltaSrc)^.blue + 1) shr 1;
+          end else
+          begin
+            pdest^.alpha := asum shr 1;
+            a1 := psrc^.alpha;
+            a2 := (psrc+DeltaSrc)^.alpha;
+            pdest^.red := (psrc^.red*a1 + (psrc+DeltaSrc)^.red*a2 + (asum shr 1)) div asum;
+            pdest^.green := (psrc^.green*a1 + (psrc+DeltaSrc)^.green*a2 + (asum shr 1)) div asum;
+            pdest^.blue := (psrc^.blue*a1 + (psrc+DeltaSrc)^.blue*a2 + (asum shr 1)) div asum;
+          end;
         end;
       end else
 …
       begin
         transition := tsRight;
+        asum := psrc^.alpha + (psrc+DeltaSrc)^.alpha*3;
+        if asum = 0 then
+          pdest^ := BGRAPixelTransparent
+        else if asum = 1020 then
+        begin
+          pdest^.alpha := 255;
+        if ADrawMode = dmXor then
+        begin
+          pdest^.alpha := (psrc^.alpha + (psrc+DeltaSrc)^.alpha*3 + 2) shr 2;
           pdest^.red := (psrc^.red + (psrc+DeltaSrc)^.red*3 + 2) shr 2;
           pdest^.green := (psrc^.green + (psrc+DeltaSrc)^.green*3 + 2) shr 2;
 …
         end else
         begin
+          pdest^.alpha := asum shr 2;
+          a1 := psrc^.alpha;
+          a2 := (psrc+DeltaSrc)^.alpha;
+          pdest^.red := (psrc^.red*a1 + (psrc+DeltaSrc)^.red*a2*3 + (asum shr 1)) div asum;
+          pdest^.green := (psrc^.green*a1 + (psrc+DeltaSrc)^.green*a2*3 + (asum shr 1)) div asum;
+          pdest^.blue := (psrc^.blue*a1 + (psrc+DeltaSrc)^.blue*a2*3 + (asum shr 1)) div asum;
+          asum := psrc^.alpha + (psrc+DeltaSrc)^.alpha*3;
+          if asum = 0 then
+            pdest^ := BGRAPixelTransparent
+          else if asum = 1020 then
+          begin
+            pdest^.alpha := 255;
+            pdest^.red := (psrc^.red + (psrc+DeltaSrc)^.red*3 + 2) shr 2;
+            pdest^.green := (psrc^.green + (psrc+DeltaSrc)^.green*3 + 2) shr 2;
+            pdest^.blue := (psrc^.blue + (psrc+DeltaSrc)^.blue*3 + 2) shr 2;
+          end else
+          begin
+            pdest^.alpha := asum shr 2;
+            a1 := psrc^.alpha;
+            a2 := (psrc+DeltaSrc)^.alpha;
+            pdest^.red := (psrc^.red*a1 + (psrc+DeltaSrc)^.red*a2*3 + (asum shr 1)) div asum;
+            pdest^.green := (psrc^.green*a1 + (psrc+DeltaSrc)^.green*a2*3 + (asum shr 1)) div asum;
+            pdest^.blue := (psrc^.blue*a1 + (psrc+DeltaSrc)^.blue*a2*3 + (asum shr 1)) div asum;
+          end;
         end;
       end else
       begin
         transition:= tsLeft;
+        asum := psrc^.alpha*3 + (psrc+DeltaSrc)^.alpha;
+        if asum = 0 then
+          pdest^ := BGRAPixelTransparent
+        else if asum = 1020 then
+        begin
+          pdest^.alpha := 255;
+        if ADrawMode = dmXor then
+        begin
+          pdest^.alpha := (psrc^.alpha*3 + (psrc+DeltaSrc)^.alpha + 2) shr 2;
           pdest^.red := (psrc^.red*3 + (psrc+DeltaSrc)^.red + 2) shr 2;
           pdest^.green := (psrc^.green*3 + (psrc+DeltaSrc)^.green + 2) shr 2;
 …
         end else
         begin
+          pdest^.alpha := asum shr 2;
+          a1 := psrc^.alpha;
+          a2 := (psrc+DeltaSrc)^.alpha;
+          pdest^.red := (psrc^.red*a1*3 + (psrc+DeltaSrc)^.red*a2 + (asum shr 1)) div asum;
+          pdest^.green := (psrc^.green*a1*3 + (psrc+DeltaSrc)^.green*a2 + (asum shr 1)) div asum;
+          pdest^.blue := (psrc^.blue*a1*3 + (psrc+DeltaSrc)^.blue*a2 + (asum shr 1)) div asum;
+          asum := psrc^.alpha*3 + (psrc+DeltaSrc)^.alpha;
+          if asum = 0 then
+            pdest^ := BGRAPixelTransparent
+          else if asum = 1020 then
+          begin
+            pdest^.alpha := 255;
+            pdest^.red := (psrc^.red*3 + (psrc+DeltaSrc)^.red + 2) shr 2;
+            pdest^.green := (psrc^.green*3 + (psrc+DeltaSrc)^.green + 2) shr 2;
+            pdest^.blue := (psrc^.blue*3 + (psrc+DeltaSrc)^.blue + 2) shr 2;
+          end else
+          begin
+            pdest^.alpha := asum shr 2;
+            a1 := psrc^.alpha;
+            a2 := (psrc+DeltaSrc)^.alpha;
+            pdest^.red := (psrc^.red*a1*3 + (psrc+DeltaSrc)^.red*a2 + (asum shr 1)) div asum;
+            pdest^.green := (psrc^.green*a1*3 + (psrc+DeltaSrc)^.green*a2 + (asum shr 1)) div asum;
+            pdest^.blue := (psrc^.blue*a1*3 + (psrc+DeltaSrc)^.blue*a2 + (asum shr 1)) div asum;
+          end;
         end;
       end;
 …
     ssRoundOutside: result := TSplineKernel.Create(0.75);
     ssVertexToSide: result := TSplineKernel.Create(1);
+    ssEasyBezier: raise Exception.Create('EasyBezier does not have an interpolator');
   else
     raise Exception.Create('Unknown spline style');

GraphicTest/Packages/bgrabitmap/bgrascene3d.pas

-              r494
+              r521
     FetchThrowsException: boolean;
     constructor Create;
     constructor Create(ASurface: TBGRACustomBitmap);
+    constructor Create; overload;
+    constructor Create(ASurface: TBGRACustomBitmap); overload;
     destructor Destroy; override;
     procedure Clear; virtual;
 …
     procedure LookUp(angleDeg: single);
     procedure LookDown(angleDeg: single);
     procedure Render; virtual;
     procedure Render(ARenderer: TCustomRenderer3D);
+    procedure Render;  overload; virtual;
+    procedure Render(ARenderer: TCustomRenderer3D); overload;
     function CreateObject: IBGRAObject3D; overload;
     function CreateObject(ATexture: IBGRAScanner): IBGRAObject3D; overload;
 …
     function CreateHalfSphere(ARadius: Single; AColor: TBGRAPixel; AHorizPrecision: integer = 6; AVerticalPrecision : integer = 6): IBGRAObject3D; overload;
     procedure RemoveObject(AObject: IBGRAObject3D);
     function AddDirectionalLight(ADirection: TPoint3D; ALightness: single = 1; AMinIntensity : single = 0): IBGRADirectionalLight3D;
     function AddDirectionalLight(ADirection: TPoint3D; AColor: TBGRAPixel; AMinIntensity: single = 0): IBGRADirectionalLight3D;
     function AddPointLight(AVertex: IBGRAVertex3D; AOptimalDistance: single; ALightness: single = 1; AMinIntensity : single = 0): IBGRAPointLight3D;
     function AddPointLight(AVertex: IBGRAVertex3D; AOptimalDistance: single; AColor: TBGRAPixel; AMinIntensity: single = 0): IBGRAPointLight3D;
+    function AddDirectionalLight(ADirection: TPoint3D; ALightness: single = 1; AMinIntensity : single = 0): IBGRADirectionalLight3D; overload;
+    function AddDirectionalLight(ADirection: TPoint3D; AColor: TBGRAPixel; AMinIntensity: single = 0): IBGRADirectionalLight3D; overload;
+    function AddPointLight(AVertex: IBGRAVertex3D; AOptimalDistance: single; ALightness: single = 1; AMinIntensity : single = 0): IBGRAPointLight3D; overload;
+    function AddPointLight(AVertex: IBGRAVertex3D; AOptimalDistance: single; AColor: TBGRAPixel; AMinIntensity: single = 0): IBGRAPointLight3D; overload;
     procedure RemoveLight(ALight: IBGRALight3D);
     procedure SetZoom(value: Single); overload;
     procedure SetZoom(value: TPointF); overload;
     function CreateMaterial: IBGRAMaterial3D;
     function CreateMaterial(ASpecularIndex: integer): IBGRAMaterial3D;
+    function CreateMaterial: IBGRAMaterial3D; overload;
+    function CreateMaterial(ASpecularIndex: integer): IBGRAMaterial3D; overload;
     function GetMaterialByName(AName: string): IBGRAMaterial3D;
     procedure UpdateMaterials; virtual;
 …
   function GetSingle: single;
   var code: integer;
   begin
     val(GetNextToken,result,code);
+  var {%H-}code: integer;
+  begin
+    val(GetNextToken,result,{%H-}code);
   end;
   function GetColorF: TColorF;
   var r,g,b: single;
     code: integer;
   begin
     val(GetNextToken,r,code);
     val(GetNextToken,g,code);
     val(GetNextToken,b,code);
+    {%H-}code: integer;
+  begin
+    val(GetNextToken,r,{%H-}code);
+    val(GetNextToken,g,{%H-}code);
+    val(GetNextToken,b,{%H-}code);
     result := ColorF(r,g,b,1);
   end;

GraphicTest/Packages/bgrabitmap/bgrascenetypes.pas

-              r494
+              r521
   IBGRAPart3D = interface
     procedure Clear(ARecursive: boolean);
     function Add(x,y,z: single): IBGRAVertex3D;
     function Add(pt: TPoint3D): IBGRAVertex3D;
     function Add(pt: TPoint3D; normal: TPoint3D): IBGRAVertex3D;
     function Add(pt: TPoint3D_128): IBGRAVertex3D;
     function Add(pt: TPoint3D_128; normal: TPoint3D_128): IBGRAVertex3D;
     function AddNormal(x,y,z: single): IBGRANormal3D;
     function AddNormal(pt: TPoint3D): IBGRANormal3D;
     function AddNormal(pt: TPoint3D_128): IBGRANormal3D;
     function Add(const coords: array of single): arrayOfIBGRAVertex3D;
     function Add(const pts: array of TPoint3D): arrayOfIBGRAVertex3D;
     function Add(const pts_128: array of TPoint3D_128): arrayOfIBGRAVertex3D;
     procedure Add(const pts: array of IBGRAVertex3D);
     procedure Add(AVertex: IBGRAVertex3D);
+    function Add(x,y,z: single): IBGRAVertex3D; overload;
+    function Add(pt: TPoint3D): IBGRAVertex3D; overload;
+    function Add(pt: TPoint3D; normal: TPoint3D): IBGRAVertex3D; overload;
+    function Add(pt: TPoint3D_128): IBGRAVertex3D; overload;
+    function Add(pt: TPoint3D_128; normal: TPoint3D_128): IBGRAVertex3D; overload;
+    function AddNormal(x,y,z: single): IBGRANormal3D; overload;
+    function AddNormal(pt: TPoint3D): IBGRANormal3D; overload;
+    function AddNormal(pt: TPoint3D_128): IBGRANormal3D; overload;
+    function Add(const coords: array of single): arrayOfIBGRAVertex3D; overload;
+    function Add(const pts: array of TPoint3D): arrayOfIBGRAVertex3D; overload;
+    function Add(const pts_128: array of TPoint3D_128): arrayOfIBGRAVertex3D; overload;
+    procedure Add(const pts: array of IBGRAVertex3D); overload;
+    procedure Add(AVertex: IBGRAVertex3D); overload;
     function GetTotalNormalCount: integer;
     function IndexOf(AVertex: IBGRAVertex3D): integer;
 …
     function GetContainer: IBGRAPart3D;
     procedure ResetTransform;
     procedure Scale(size: single; Before: boolean = true);
     procedure Scale(x,y,z: single; Before: boolean = true);
     procedure Scale(size: TPoint3D; Before: boolean = true);
+    procedure Scale(size: single; Before: boolean = true); overload;
+    procedure Scale(x,y,z: single; Before: boolean = true); overload;
+    procedure Scale(size: TPoint3D; Before: boolean = true); overload;
     procedure SetMatrix(const AValue: TMatrix3D);
     procedure SetNormal(AIndex: Integer; AValue: IBGRANormal3D);
     procedure SetVertex(AIndex: Integer; AValue: IBGRAVertex3D);
     procedure Translate(x,y,z: single; Before: boolean = true);
     procedure Translate(ofs: TPoint3D; Before: boolean = true);
+    procedure Translate(x,y,z: single; Before: boolean = true); overload;
+    procedure Translate(ofs: TPoint3D; Before: boolean = true); overload;
     procedure RotateXDeg(angle: single; Before: boolean = true);
     procedure RotateYDeg(angle: single; Before: boolean = true);
 …
     procedure ForEachFace(ACallback: TFace3DCallback);
     function AddFaceReversed(const AVertices: array of IBGRAVertex3D): IBGRAFace3D;
     function AddFace(const AVertices: array of IBGRAVertex3D): IBGRAFace3D;
     function AddFace(const AVertices: array of IBGRAVertex3D; ABiface: boolean): IBGRAFace3D;
     function AddFace(const AVertices: array of IBGRAVertex3D; ATexture: IBGRAScanner): IBGRAFace3D;
     function AddFace(const AVertices: array of IBGRAVertex3D; AColor: TBGRAPixel): IBGRAFace3D;
     function AddFace(const AVertices: array of IBGRAVertex3D; AColors: array of TBGRAPixel): IBGRAFace3D;
+    function AddFace(const AVertices: array of IBGRAVertex3D): IBGRAFace3D; overload;
+    function AddFace(const AVertices: array of IBGRAVertex3D; ABiface: boolean): IBGRAFace3D; overload;
+    function AddFace(const AVertices: array of IBGRAVertex3D; ATexture: IBGRAScanner): IBGRAFace3D; overload;
+    function AddFace(const AVertices: array of IBGRAVertex3D; AColor: TBGRAPixel): IBGRAFace3D; overload;
+    function AddFace(const AVertices: array of IBGRAVertex3D; AColors: array of TBGRAPixel): IBGRAFace3D; overload;
     procedure Update;
     procedure SetBiface(AValue : boolean);

GraphicTest/Packages/bgrabitmap/bgraslicescaling.pas

-              r494
+              r521
     // or as a local owned copy in other cases
     constructor Create(ABitmap: TBGRABitmap;
       AMarginTop, AMarginRight, AMarginBottom, AMarginLeft: integer; ABitmapOwner: boolean = false);
+      AMarginTop, AMarginRight, AMarginBottom, AMarginLeft: integer; ABitmapOwner: boolean = false); overload;
     constructor Create(ABitmap: TBitmap;
       AMarginTop, AMarginRight, AMarginBottom, AMarginLeft: integer);
+      AMarginTop, AMarginRight, AMarginBottom, AMarginLeft: integer); overload;
     constructor Create(AFilename: string;
       AMarginTop, AMarginRight, AMarginBottom, AMarginLeft: integer);
+      AMarginTop, AMarginRight, AMarginBottom, AMarginLeft: integer); overload;
     constructor Create(AFilename: string; AIsUtf8: boolean;
       AMarginTop, AMarginRight, AMarginBottom, AMarginLeft: integer);
+      AMarginTop, AMarginRight, AMarginBottom, AMarginLeft: integer); overload;
     constructor Create(AStream: TStream;
       AMarginTop, AMarginRight, AMarginBottom, AMarginLeft: integer);
     constructor Create(ABitmap: TBGRABitmap; ABitmapOwner: boolean = false);
     constructor Create(ABitmap: TBitmap);
     constructor Create(AFilename: string);
     constructor Create(AFilename: string; AIsUtf8: boolean);
     constructor Create(AStream: TStream);
     constructor Create;
     procedure SetMargins(AMarginTop, AMarginRight, AMarginBottom, AMarginLeft: integer);
     procedure SetMargins(AMargins: TMargins);
+      AMarginTop, AMarginRight, AMarginBottom, AMarginLeft: integer); overload;
+    constructor Create(ABitmap: TBGRABitmap; ABitmapOwner: boolean = false); overload;
+    constructor Create(ABitmap: TBitmap); overload;
+    constructor Create(AFilename: string); overload;
+    constructor Create(AFilename: string; AIsUtf8: boolean); overload;
+    constructor Create(AStream: TStream); overload;
+    constructor Create; overload;
+    procedure SetMargins(AMarginTop, AMarginRight, AMarginBottom, AMarginLeft: integer); overload;
+    procedure SetMargins(AMargins: TMargins); overload;
     destructor Destroy; override;
   public
 …
     //so new bitmaps should be used
     // Draw
     procedure Draw(ABitmap: TBGRABitmap; ARect: TRect; DrawGrid: boolean = False);
+    procedure Draw(ABitmap: TBGRABitmap; ARect: TRect; DrawGrid: boolean = False); overload;
     procedure Draw(ABitmap: TBGRABitmap; ALeft, ATop, AWidth, AHeight: integer;
       DrawGrid: boolean = False);
+      DrawGrid: boolean = False); overload;
     procedure AutodetectRepeat;
   public
 …
     constructor Create(ABitmap: TBGRABitmap;
       AMarginTop, AMarginRight, AMarginBottom, AMarginLeft, NumberOfItems: integer;
       Direction: TSliceScalingDirection; ABitmapOwner: boolean = false);
+      Direction: TSliceScalingDirection; ABitmapOwner: boolean = false); overload;
     constructor Create(ABitmap: TBitmap;
       AMarginTop, AMarginRight, AMarginBottom, AMarginLeft, NumberOfItems: integer;
       Direction: TSliceScalingDirection);
+      Direction: TSliceScalingDirection); overload;
     constructor Create(ABitmapFilename: string;
       AMarginTop, AMarginRight, AMarginBottom, AMarginLeft, NumberOfItems: integer;
       Direction: TSliceScalingDirection);
+      Direction: TSliceScalingDirection); overload;
     constructor Create(ABitmapFilename: string; AIsUtf8: boolean;
       AMarginTop, AMarginRight, AMarginBottom, AMarginLeft, NumberOfItems: integer;
       Direction: TSliceScalingDirection);
+      Direction: TSliceScalingDirection); overload;
     constructor Create(AStream: TStream;
       AMarginTop, AMarginRight, AMarginBottom, AMarginLeft, NumberOfItems: integer;
       Direction: TSliceScalingDirection);
+      Direction: TSliceScalingDirection); overload;
     destructor Destroy; override;
     constructor Create(AIniFilename, ASection: string; AIsUtf8Filename: boolean= false);
+    constructor Create(AIniFilename, ASection: string; AIsUtf8Filename: boolean= false); overload;
   public
     procedure Draw(ItemNumber: integer; ABitmap: TBGRABitmap;
       ARect: TRect; DrawGrid: boolean = False);
+      ARect: TRect; DrawGrid: boolean = False); overload;
     procedure Draw(ItemNumber: integer; ABitmap: TBGRABitmap;
       ALeft, ATop, AWidth, AHeight: integer; DrawGrid: boolean = False);
+      ALeft, ATop, AWidth, AHeight: integer; DrawGrid: boolean = False); overload;
   public
     property SliceScalingArray: TSliceScalingArray

GraphicTest/Packages/bgrabitmap/bgraspritegl.pas

-              r494
+              r521
     function GetLayer: Integer; virtual; abstract;
     function GetLocation: TPointF; virtual;
+    function GetVisible: Boolean; virtual;
     function GetW: Single; virtual; abstract;
     function GetX: Single; virtual; abstract;
 …
     procedure SetLocation(AValue: TPointF); virtual;
     procedure SetW(AValue: Single); virtual; abstract;
+    procedure SetVisible({%H-}AValue: boolean); virtual;
     procedure SetX(AValue: Single); virtual; abstract;
     procedure SetY(AValue: Single); virtual; abstract;
 …
     destructor Destroy; override;
     procedure OnDraw; virtual;
     procedure OnElapse(AElapsedMs: integer); virtual;
+    procedure OnElapse({%H-}AElapsedMs: integer); virtual;
     procedure OnTimer; virtual;
     procedure QueryDestroy; virtual; abstract;
 …
     property HorizontalAlign: TAlignment read GetHorizontalAlign write SetHorizontalAlign;
     property VerticalAlign: TTextLayout read GetVerticalAlign write SetVerticalAlign;
+    property Visible : Boolean read GetVisible write SetVisible;
     property Texture : IBGLTexture read GetTexture;
     property Handle  : Pointer read GetHandle;
 …
     FQueryDestroy: boolean;
     FLayer: integer;
+    FHidden: boolean;
     function GetHorizontalAlign: TAlignment; override;
     function GetVerticalAlign: TTextLayout; override;
 …
     function GetH: Single; override;
     function GetLayer: Integer; override;
+    function GetVisible: Boolean; override;
     function GetW: Single; override;
     function GetX: Single; override;
 …
     procedure SetH(AValue: Single); override;
     procedure SetLayer(AValue: Integer); override;
+    procedure SetVisible(AValue: boolean); override;
     procedure SetW(AValue: Single); override;
     procedure SetX(AValue: Single); override;
 …
 end;
+function TBGLDefaultSprite.GetVisible: Boolean;
+begin
+  Result:= not FHidden;
+end;
 function TBGLDefaultSprite.GetW: Single;
 begin
 …
 begin
   FLayer:= AValue;
+end;
+procedure TBGLDefaultSprite.SetVisible(AValue: boolean);
+begin
+  FHidden := not AValue;
 end;
 …
 end;
+function TBGLCustomSprite.GetVisible: Boolean;
+begin
+  result := true;
+end;
 procedure TBGLCustomSprite.SetLocation(AValue: TPointF);
 begin
   X := AValue.X;
   Y := AValue.Y;
+end;
+procedure TBGLCustomSprite.SetVisible(AValue: boolean);
+begin
+  raise ENotImplemented.Create('Not implemented in base class');
 end;
 …
 var NumFrame: integer;
 begin
   if Texture <> nil then
+  if Visible and (Texture <> nil) then
     begin
       NumFrame := Trunc(Frame+0.5);

GraphicTest/Packages/bgrabitmap/bgrastreamlayers.pas

-              r494
+              r521
 {$mode objfpc}{$H+}
+{$MODESWITCH ADVANCEDRECORDS}
 interface
 …
 function CheckStreamForLayers(AStream: TStream): boolean;
+function LoadLayersFromStream(AStream: TStream; out ASelectedLayerIndex: integer; ALoadLayerUniqueIds: boolean = false) : TBGRALayeredBitmap;
+function LoadLayersFromStream(AStream: TStream; out ASelectedLayerIndex: integer; ALoadLayerUniqueIds: boolean = false;
+         ADestination: TBGRALayeredBitmap = nil): TBGRALayeredBitmap;
 procedure SaveLayersToStream(AStream: TStream; ALayers: TBGRACustomLayeredBitmap; ASelectedLayerIndex: integer; ACompression: TLzpCompression = lzpZStream);
 procedure SaveLayerBitmapToStream(AStream: TStream; ABitmap: TBGRABitmap; ACaption: string; ACompression: TLzpCompression = lzpZStream);
 …
 uses BGRABitmapTypes, BGRACompressableBitmap, zstream, BGRAReadLzp, BGRAWriteLzp,
+     BGRAUTF8;
+     BGRAUTF8, Math;
+type
+  PLayerHeader = ^TLayerHeader;
+  { TLayerHeader }
+  TLayerHeader = packed record
+    LayerOption, BlendOp,
+    LayerOfsX, LayerOfsY,
+    LayerUniqueId, LayerOpacity: Longint;
+    LayerBitmapSize: int64;
+    OriginalGuid: TGuid;
+    OriginalMatrix: TAffineMatrix;
+    procedure FixEndian;
+  end;
+{ TLayerHeader }
+procedure TLayerHeader.FixEndian;
+begin
+  LayerOption := NtoLE(LayerOption);
+  BlendOp := NtoLE(BlendOp);
+  LayerOfsX := NtoLE(LayerOfsX);
+  LayerOfsY := NtoLE(LayerOfsY);
+  LayerUniqueId := NtoLE(LayerUniqueId);
+  LayerOpacity := NtoLE(LayerOpacity);
+  LayerBitmapSize := NtoLE(LayerBitmapSize);
+  OriginalGuid.D1 := NtoBE(OriginalGuid.D1);
+  OriginalGuid.D2 := NtoBE(OriginalGuid.D2);
+  OriginalGuid.D3 := NtoBE(OriginalGuid.D3);
+  DWord(OriginalMatrix[1,1]) := NtoLE(DWord(OriginalMatrix[1,1]));
+  DWord(OriginalMatrix[2,1]) := NtoLE(DWord(OriginalMatrix[2,1]));
+  DWord(OriginalMatrix[1,2]) := NtoLE(DWord(OriginalMatrix[1,2]));
+  DWord(OriginalMatrix[2,2]) := NtoLE(DWord(OriginalMatrix[2,2]));
+  DWord(OriginalMatrix[1,3]) := NtoLE(DWord(OriginalMatrix[1,3]));
+  DWord(OriginalMatrix[2,3]) := NtoLE(DWord(OriginalMatrix[2,3]));
+end;
 procedure SaveLayeredBitmapToStream(AStream: TStream; ALayers: TBGRACustomLayeredBitmap);
 …
 end;
 function LoadLayeredBitmapFromStream(AStream: TStream) : TBGRALayeredBitmap;
+procedure LoadLayeredBitmapFromStream(AStream: TStream; ALayers: TBGRACustomLayeredBitmap);
 var selectedIndex: integer;
 begin
   if not CheckStreamForLayers(AStream) then
+    result := nil
+  begin
+    if Assigned(ALayers) then ALayers.Clear;
+  end
   else
     result := LoadLayersFromStream(AStream,selectedIndex);
+    LoadLayersFromStream(AStream,selectedIndex,false,ALayers as TBGRALayeredBitmap);
 end;
 …
 end;
+function LoadLayersFromStream(AStream: TStream; out ASelectedLayerIndex: integer; ALoadLayerUniqueIds: boolean = false): TBGRALayeredBitmap;
+function LoadLayersFromStream(AStream: TStream; out ASelectedLayerIndex: integer; ALoadLayerUniqueIds: boolean = false;
+         ADestination: TBGRALayeredBitmap = nil): TBGRALayeredBitmap;
 var
   OldPosition: Int64;
   HeaderFound: string;
   NbLayers: LongInt;
+  NbLayers, canvasWidth, canvasHeight: LongInt;
   HeaderSize, LayerHeaderSize: LongInt;
+  LayerStackStartPosition, LayerHeaderPosition, LayerBitmapPosition, LayerEndPosition: Int64;
+  LayerOption,StackOption: LongInt;
+  LayerStackStartPosition, LayerHeaderPosition,
+  LayerBitmapPosition, LayerEndPosition, MemDirPos: Int64;
+  StackOption: LongInt;
   Layer: TBGRABitmap;
   i,LayerIndex: integer;
   LayerName: string;
-  LayerId: LongInt;
   Compression: TLzpCompression;
-  LayerVisible: boolean;
   LayerBlendOp: TBlendOperation;
-  LayerOffset: TPoint;
-  LayerOpacity: integer;
   LayerIdFound: boolean;
+  LayerBitmapSize: integer;
+begin
+  result := TBGRALayeredBitmap.Create;
+  h: TLayerHeader;
+begin
+  if Assigned(ADestination) then
+  begin
+    result := ADestination;
+    result.Clear;
+  end else
+    result := TBGRALayeredBitmap.Create;
   OldPosition:= AStream.Position;
   SetLength(HeaderFound, length(StreamHeader));
 …
     result.LinearBlend := (StackOption and 1) = 1;
     if (StackOption and 2) = 2 then Compression := lzpRLE else Compression:= lzpZStream;
+    if headerSize >= 20 then
+    begin
+      canvasWidth := LEReadLongint(AStream);
+      canvasHeight := LEReadLongint(AStream);
+      result.SetSize(canvasWidth,canvasHeight);
+    end;
+    if headerSize >= 28 then
+    begin
+      MemDirPos := LEReadInt64(AStream);
+    end else MemDirPos := 0;
     //end of header
+    if MemDirPos <> 0 then
+    begin
+      AStream.Position:= MemDirPos+OldPosition;
+      result.MemDirectory.LoadFromStream(AStream);
+    end else
+      result.MemDirectory.Clear;
     AStream.Position:= LayerStackStartPosition;
 …
     begin
       LayerHeaderSize:= LEReadLongint(AStream);
       LayerHeaderPosition := AStream.Position;
       LayerBitmapPosition := LayerHeaderPosition + LayerHeaderSize;
       LayerEndPosition := -1;
+      LayerVisible := true;
+      LayerBlendOp := result.DefaultBlendingOperation;
+      LayerOffset := Point(0,0);
+      LayerId := 0;
+      LayerIdFound := false;
+      LayerOpacity := 255;
+      if AStream.Position <= LayerBitmapPosition-4 then
+      begin
+        LayerOption := LEReadLongint(AStream);
+        LayerVisible := (LayerOption and 1) = 1;
+      end;
+      if AStream.Position <= LayerBitmapPosition-4 then
+        LayerBlendOp := TBlendOperation(LEReadLongint(AStream));
+      if AStream.Position <= LayerBitmapPosition-8 then
+      begin
+        LayerOffset := Point(LEReadLongint(AStream),LEReadLongint(AStream));
+        if AStream.Position <= LayerBitmapPosition-4 then
+        begin
+          LayerId := LEReadLongint(AStream);
+          LayerIdFound := true;
+        end;
+        if AStream.Position <= LayerBitmapPosition-4 then
+          LayerOpacity := LEReadLongint(AStream) shr 8;
+      end;
+      if AStream.Position <= LayerBitmapPosition-4 then
+      begin
+        LayerBitmapSize := LEReadLongint(AStream);
+        LayerEndPosition:= LayerBitmapPosition+LayerBitmapSize;
+      end;
+      fillchar({%H-}h, sizeof(h), 0);
+      h.LayerOption := 1; //visible
+      h.BlendOp:= integer(result.DefaultBlendingOperation);
+      h.LayerOpacity := 65535; //opaque
+      h.LayerUniqueId:= maxLongint;
+      h.FixEndian;
+      AStream.ReadBuffer(h, min(LayerHeaderSize, sizeof(h)));
+      h.FixEndian;
+      if h.BlendOp > ord(high(TBlendOperation)) then
+        LayerBlendOp := result.DefaultBlendingOperation
+      else
+        LayerBlendOp:= TBlendOperation(h.BlendOp);
+      LayerIdFound := h.LayerUniqueId <> maxLongint;
+      if h.LayerBitmapSize > 0 then
+        LayerEndPosition:= LayerBitmapPosition+h.LayerBitmapSize;
       AStream.Position:= LayerBitmapPosition;
 …
       result.LayerName[LayerIndex] := LayerName;
       result.LayerVisible[LayerIndex] := LayerVisible;
+      result.LayerVisible[LayerIndex] := (h.LayerOption and 1) = 1;
       result.BlendOperation[LayerIndex]:= LayerBlendOp;
       result.LayerOffset[LayerIndex] := LayerOffset;
+      result.LayerOffset[LayerIndex] := Point(h.LayerOfsX,h.LayerOfsY);
       if ALoadLayerUniqueIds and LayerIdFound then
+        result.LayerUniqueId[LayerIndex] := LayerId;
+      result.LayerOpacity[LayerIndex] := LayerOpacity;
+        result.LayerUniqueId[LayerIndex] := h.LayerUniqueId;
+      result.LayerOpacity[LayerIndex] := h.LayerOpacity shr 8;
+      result.LayerOriginalGuid[LayerIndex] := h.OriginalGuid;
+      result.LayerOriginalMatrix[LayerIndex] := h.OriginalMatrix;
+      result.LayerOriginalRenderStatus[layerIndex] := orsProof;
       if LayerEndPosition <> -1 then AStream.Position := LayerEndPosition;
     end;
+    result.NotifyLoaded;
   except
     on ex: Exception do
     begin
       AStream.Position := OldPosition;
+      if not Assigned(ADestination) then result.Free;
       raise ex;
     end;
 …
 procedure SaveLayersToStream(AStream: TStream; ALayers: TBGRACustomLayeredBitmap; ASelectedLayerIndex: integer; ACompression: TLzpCompression);
 var
   LayerOption,StackOption: longint;
+  StackOption: longint;
   i: integer;
   LayerHeaderSizePosition,LayerHeaderPosition: int64;
   LayerBitmapPosition,LayerBitmapSizePosition,BitmapSize: int64;
   LayerHeaderSize: integer;
+  DirectoryOffsetPos, EndPos: int64;
+  LayerHeaderPosition: int64;
+  LayerBitmapPosition,BitmapSize, startPos: int64;
   bitmap: TBGRABitmap;
+  h: TLayerHeader;
 begin
   if (ASelectedLayerIndex < -1) or (ASelectedLayerIndex >= ALayers.NbLayers) then
     raise exception.Create('Selected layer out of bounds');
+  ALayers.NotifySaving;
+  startPos := AStream.Position;
   AStream.Write(StreamHeader[1], length(StreamHeader));
   LEWriteLongint(AStream, 12); //header size
+  LEWriteLongint(AStream, 28); //header size
   LEWriteLongint(AStream, ALayers.NbLayers);
   LEWriteLongint(AStream, ASelectedLayerIndex);
 …
   if ACompression = lzpRLE then StackOption:= StackOption or 2;
   LEWriteLongint(AStream, StackOption);
+  LEWriteLongint(AStream, ALayers.Width);
+  LEWriteLongint(AStream, ALayers.Height);
+  DirectoryOffsetPos := AStream.Position;
+  LEWriteInt64(AStream, 0);
   //end of header
   for i := 0 to ALayers.NbLayers-1 do
   begin
+    LayerHeaderSizePosition:= AStream.Position;
+    LEWriteLongint(AStream, 0); //header size not computed yet
+    LEWriteLongint(AStream, sizeof(h));
     LayerHeaderPosition := AStream.Position;
+    LayerOption := 0;
+    if ALayers.LayerVisible[i] then LayerOption:= LayerOption or 1;
+    LEWriteLongint(AStream, LayerOption);
+    LEWriteLongint(AStream, Longint(ALayers.BlendOperation[i]));
+    LEWriteLongint(AStream, ALayers.LayerOffset[i].x);
+    LEWriteLongint(AStream, ALayers.LayerOffset[i].y);
+    LEWriteLongint(AStream, ALayers.LayerUniqueId[i]);
+    LEWriteLongint(AStream, integer(ALayers.LayerOpacity[i])*$101);
+    LayerBitmapSizePosition:=AStream.Position;
+    LEWriteLongint(AStream, 0);
+    bitmap := ALayers.GetLayerBitmapDirectly(i); //do it before to ensure update from original
+    h.LayerOption:= 0;
+    if ALayers.LayerVisible[i] then h.LayerOption:= h.LayerOption or 1;
+    h.BlendOp:= Longint(ALayers.BlendOperation[i]);
+    h.LayerOfsX:= ALayers.LayerOffset[i].x;
+    h.LayerOfsY:= ALayers.LayerOffset[i].y;
+    h.LayerUniqueId:= ALayers.LayerUniqueId[i];
+    h.LayerOpacity:= integer(ALayers.LayerOpacity[i])*$101;
+    h.LayerBitmapSize := 0;
+    h.OriginalGuid := ALayers.LayerOriginalGuid[i];
+    h.OriginalMatrix := ALayers.LayerOriginalMatrix[i];
+    h.FixEndian;
+    AStream.WriteBuffer(h, sizeof(h));
+    //end of layer header
     LayerBitmapPosition:=AStream.Position;
-    LayerHeaderSize := LayerBitmapPosition - LayerHeaderPosition;
-    AStream.Position:= LayerHeaderSizePosition;
-    LEWriteLongint(AStream, LayerHeaderSize);
-    //end of layer header
-    AStream.Position:= LayerBitmapPosition;
-    bitmap := ALayers.GetLayerBitmapDirectly(i);
     if bitmap <> nil then
       SaveLayerBitmapToStream(AStream, bitmap, ALayers.LayerName[i], ACompression)
 …
       bitmap.free;
     end;
     BitmapSize := AStream.Position - LayerBitmapPosition;
+    if BitmapSize > maxLongint then
+      raise exception.Create('Image too big');
+    AStream.Position:= LayerBitmapSizePosition;
+    LEWriteLongint(AStream, BitmapSize);
+    //store back the bitmap size
+    AStream.Position:= LayerHeaderPosition + (PByte(@PLayerHeader(nil)^.LayerBitmapSize)-PByte(nil));
+    LEWriteInt64(AStream, BitmapSize);
     AStream.Position:= LayerBitmapPosition+BitmapSize;
+  end;
+  EndPos:= AStream.Position;
+  if ALayers.HasMemFiles then
+  begin
+    AStream.Position := DirectoryOffsetPos;
+    LEWriteInt64(AStream,EndPos-startPos);
+    AStream.Position:= EndPos;
+    ALayers.MemDirectory.SaveToStream(AStream);
   end;
 end;
 …
   LayeredBitmapSaveToStreamProc := @SaveLayeredBitmapToStream;
   LayeredBitmapLoadFromStreamProc := @LoadLayeredBitmapFromStream;
+end;
+  LayeredBitmapCheckStreamProc := @CheckStreamForLayers;
+end;
+initialization
+  RegisterStreamLayers;
 end.

GraphicTest/Packages/bgrabitmap/bgrasvg.pas

-              r494
+              r521
 uses
   Classes, SysUtils, BGRABitmapTypes, laz2_DOM, BGRAUnits, BGRASVGShapes,
+  BGRACanvas2D;
+  BGRACanvas2D, BGRASVGType, FPimage;
+type
+  TCSSUnit = BGRAUnits.TCSSUnit;
+const
+  cuCustom = BGRAUnits.cuCustom;
+  cuPixel = BGRAUnits.cuPixel;
+  cuCentimeter = BGRAUnits.cuCentimeter;
+  cuMillimeter = BGRAUnits.cuMillimeter;
+  cuInch = BGRAUnits.cuInch;
+  cuPica = BGRAUnits.cuPica;
+  cuPoint = BGRAUnits.cuPoint;
+  cuFontEmHeight = BGRAUnits.cuFontEmHeight;
+  cuFontXHeight = BGRAUnits.cuFontXHeight;
+  cuPercent = BGRAUnits.cuPercent;
 type
 …
   TSVGUnits = class(TCSSUnitConverter)
   private
+    FOnRecompute: TSVGRecomputeEvent;
+    FViewOffset: TPointF;
     function GetCustomDpi: TPointF;
     procedure Recompute;
+    procedure SetOnRecompute(AValue: TSVGRecomputeEvent);
   protected
     FSvg: TDOMElement;
     FViewBox: TSVGViewBox;
+    FViewSize: TSVGSize;
+    FOriginalViewSize, FProportionalViewSize: TSVGSize;
     FDefaultUnitHeight, FDefaultUnitWidth: TFloatWithCSSUnit;
     FDefaultDpi: PSingle;
     FUseDefaultDPI: boolean;
     FDpiScaleX,FDpiScaleY: single;
+    FContainerHeight: TFloatWithCSSUnit;
+    FContainerWidth: TFloatWithCSSUnit;
+    procedure SetContainerHeight(AValue: TFloatWithCSSUnit);
+    procedure SetContainerWidth(AValue: TFloatWithCSSUnit);
     function GetDefaultUnitHeight: TFloatWithCSSUnit; override;
     function GetDefaultUnitWidth: TFloatWithCSSUnit; override;
 …
     procedure SetDefaultDpiAndOrigin;
     constructor Create(ASvg: TDOMElement; ADefaultDpi: PSingle);
+    function GetStretchRectF(AViewSize: TRectF; par: TSVGPreserveAspectRatio): TRectF;
     property ViewBox: TSVGViewBox read FViewBox write SetViewBox;
+    property OriginalViewSize: TSVGSize read FOriginalViewSize;
+    property ProportionalViewSize: TSVGSize read FProportionalViewSize;
+    property ViewOffset: TPointF read FViewOffset;
     property CustomOrigin: TPointF read GetCustomOrigin write SetCustomOrigin;
     property CustomDpiX: single read GetCustomDpiX;
     property CustomDpiY: single read GetCustomDpiY;
     property CustomDpi: TPointF read GetCustomDpi write SetCustomDpi;
+    property ContainerWidth: TFloatWithCSSUnit read FContainerWidth write SetContainerWidth;
+    property ContainerHeight: TFloatWithCSSUnit read FContainerHeight write SetContainerHeight;
+    property OnRecompute: TSVGRecomputeEvent read FOnRecompute write SetOnRecompute;
   end;
 …
   TBGRASVG = class
   private
+    function GetAttribute(AName: string): string;
+    function GetAttribute(AName: string): string; overload;
+    function GetAttribute(AName: string; ADefault: string): string; overload;
     function GetCustomDpi: TPointF;
     function GetHeight: TFloatWithCSSUnit;
     function GetHeightAsCm: single;
     function GetHeightAsInch: single;
+    function GetPreserveAspectRatio: string;
+    function GetViewBox: TSVGViewBox;
+    function GetViewBox(AUnit: TCSSUnit): TSVGViewBox;
+    function GetPreserveAspectRatio: TSVGPreserveAspectRatio;
+    function GetUTF8String: utf8string;
+    function GetViewBox: TSVGViewBox; overload;
+    function GetViewBox(AUnit: TCSSUnit): TSVGViewBox; overload;
     procedure GetViewBoxIndirect(AUnit: TCSSUnit; out AViewBox: TSVGViewBox);
+    function GetViewMin(AUnit: TCSSUnit): TPointF;
+    function GetViewSize(AUnit: TCSSUnit): TPointF;
     function GetWidth: TFloatWithCSSUnit;
     function GetWidthAsCm: single;
 …
     procedure SetHeightAsCm(AValue: single);
     procedure SetHeightAsInch(AValue: single);
+    procedure SetPreserveAspectRatio(AValue: string);
+    procedure SetPreserveAspectRatio(AValue: TSVGPreserveAspectRatio);
+    procedure SetUTF8String(AValue: utf8string);
     procedure SetViewBox(AValue: TSVGViewBox);
     procedure SetWidth(AValue: TFloatWithCSSUnit);
 …
     FDefaultDpi: single;
     FContent: TSVGContent;
+    FDataLink: TSVGDataLink;
     procedure Init(ACreateEmpty: boolean);
     function GetViewBoxAlignment(AHorizAlign: TAlignment; AVertAlign: TTextLayout): TPointF;
+    procedure UnitsRecompute(Sender: TObject);
   public
     constructor Create; overload;
 …
     constructor Create(AFilenameUTF8: string); overload;
     constructor Create(AStream: TStream); overload;
+    constructor CreateFromString(AUTF8String: string);
     destructor Destroy; override;
     procedure LoadFromFile(AFilenameUTF8: string);
     procedure LoadFromStream(AStream: TStream);
+    procedure LoadFromResource(AFilename: string);
     procedure SaveToFile(AFilenameUTF8: string);
     procedure SaveToStream(AStream: TStream);
 …
     procedure Draw(ACanvas2d: TBGRACanvas2D; x,y: single; destDpi: single); overload;
     procedure Draw(ACanvas2d: TBGRACanvas2D; x,y: single; destDpi: TPointF); overload;
+    procedure StretchDraw(ACanvas2d: TBGRACanvas2D; x,y,w,h: single); overload;
+    procedure StretchDraw(ACanvas2d: TBGRACanvas2D; x,y,w,h: single; useSvgAspectRatio: boolean = false); overload;
+    procedure StretchDraw(ACanvas2d: TBGRACanvas2D; r: TRectF; useSvgAspectRatio: boolean = false); overload;
     procedure StretchDraw(ACanvas2d: TBGRACanvas2D; AHorizAlign: TAlignment; AVertAlign: TTextLayout; x,y,w,h: single); overload;
+    function GetStretchRectF(AHorizAlign: TAlignment; AVertAlign: TTextLayout; x,y,w,h: single): TRectF;
+    property AsUTF8String: utf8string read GetUTF8String write SetUTF8String;
     property Units: TSVGUnits read FUnits;
     property Width: TFloatWithCSSUnit read GetWidth write SetWidth;
 …
     property ViewBox: TSVGViewBox read GetViewBox write SetViewBox;
     property ViewBoxInUnit[AUnit: TCSSUnit]: TSVGViewBox read GetViewBox;
+    property ViewMinInUnit[AUnit: TCSSUnit]: TPointF read GetViewMin;
+    property ViewSizeInUnit[AUnit: TCSSUnit]: TPointF read GetViewSize;
     property Attribute[AName: string]: string read GetAttribute write SetAttribute;
+    property AttributeDef[AName: string; ADefault: string]: string read GetAttribute;
     property DefaultDpi: single read FDefaultDpi write SetDefaultDpi; //this is not saved in the SVG file
     property CustomDpi: TPointF read GetCustomDpi write SetCustomDpi;
     property Content: TSVGContent read FContent;
+    property preserveAspectRatio: string read GetPreserveAspectRatio write SetPreserveAspectRatio;
+  end;
+    property DataLink: TSVGDataLink read FDataLink;//(for test or internal info)
+    property preserveAspectRatio: TSVGPreserveAspectRatio read GetPreserveAspectRatio write SetPreserveAspectRatio;
+  end;
+  { TFPReaderSVG }
+  TFPReaderSVG = class(TBGRAImageReader)
+    private
+      FRenderDpi: single;
+      FWidth,FHeight: integer;
+      FScale: single;
+    protected
+      function InternalCheck(Stream: TStream): boolean; override;
+      procedure InternalRead(Stream: TStream; Img: TFPCustomImage); override;
+    public
+      constructor Create; override;
+      function GetQuickInfo(AStream: TStream): TQuickImageInfo; override;
+      function GetBitmapDraft(AStream: TStream; AMaxWidth, AMaxHeight: integer; out AOriginalWidth,AOriginalHeight: integer): TBGRACustomBitmap; override;
+      property RenderDpi: single read FRenderDpi write FRenderDpi;
+      property Width: integer read FWidth;
+      property Height: integer read FHeight;
+      property Scale: single read FScale write FScale;
+  end;
+procedure RegisterSvgFormat;
 implementation
 uses laz2_XMLRead, laz2_XMLWrite, BGRAUTF8;
+uses laz2_XMLRead, laz2_XMLWrite, BGRAUTF8, math;
 const SvgNamespace = 'http://www.w3.org/2000/svg';
+{ TFPReaderSVG }
+function TFPReaderSVG.InternalCheck(Stream: TStream): boolean;
+var
+  magic: array[1..6] of char;
+  prevPos: int64;
+  count: LongInt;
+begin
+  prevPos := Stream.Position;
+  count := Stream.Read({%H-}magic, sizeof(magic));
+  Stream.Position:= prevPos;
+  result:= (count = sizeof(magic)) and (magic = '<?xml ');
+end;
+procedure TFPReaderSVG.InternalRead(Stream: TStream; Img: TFPCustomImage);
+var
+  svg: TBGRASVG;
+  vmin,vsize: TPointF;
+  bgra: TBGRACustomBitmap;
+  c2d: TBGRACanvas2D;
+  y, x: Integer;
+  p: PBGRAPixel;
+begin
+  svg := TBGRASVG.Create(Stream);
+  bgra := nil;
+  try
+    svg.DefaultDpi:= RenderDpi;
+    if Img is TBGRACustomBitmap then
+      bgra := TBGRACustomBitmap(Img)
+    else
+      bgra := BGRABitmapFactory.Create;
+    vsize := svg.GetViewSize(cuPixel);
+    bgra.SetSize(ceil(vsize.x*scale),ceil(vsize.y*scale));
+    bgra.FillTransparent;
+    vmin := svg.GetViewMin(cuPixel);
+    c2d := TBGRACanvas2D.Create(bgra);
+    c2d.scale(Scale);
+    c2d.translate(-vmin.x,-vmin.y);
+    svg.Draw(c2d,0,0);
+    c2d.Free;
+    if bgra<>Img then
+    begin
+      Img.SetSize(bgra.Width,bgra.Height);
+      for y := 0 to bgra.Height-1 do
+      begin
+        p := bgra.ScanLine[y];
+        for x := 0 to bgra.Width-1 do
+        begin
+          Img.Colors[x,y] := BGRAToFPColor(p^);
+          inc(p);
+        end;
+      end;
+    end;
+    FWidth:= bgra.Width;
+    FHeight:= bgra.Height;
+  finally
+    if bgra<>Img then bgra.Free;
+    svg.Free;
+  end;
+end;
+constructor TFPReaderSVG.Create;
+begin
+  inherited Create;
+  FRenderDpi:= 96;
+  FScale := 1;
+end;
+function TFPReaderSVG.GetQuickInfo(AStream: TStream): TQuickImageInfo;
+var
+  svg: TBGRASVG;
+  vsize: TPointF;
+begin
+  svg := TBGRASVG.Create(AStream);
+  svg.DefaultDpi:= RenderDpi;
+  vsize := svg.GetViewSize(cuPixel);
+  svg.Free;
+  result.Width:= ceil(vsize.x);
+  result.Height:= ceil(vsize.y);
+  result.AlphaDepth:= 8;
+  result.ColorDepth:= 24;
+end;
+function TFPReaderSVG.GetBitmapDraft(AStream: TStream; AMaxWidth,
+  AMaxHeight: integer; out AOriginalWidth, AOriginalHeight: integer): TBGRACustomBitmap;
+var
+  svg: TBGRASVG;
+  vmin,vsize: TPointF;
+  c2d: TBGRACanvas2D;
+  ratio: Single;
+begin
+  svg := TBGRASVG.Create(AStream);
+  result := nil;
+  try
+    svg.DefaultDpi:= RenderDpi;
+    vsize := svg.GetViewSize(cuPixel);
+    AOriginalWidth:= ceil(vsize.x);
+    AOriginalHeight:= ceil(vsize.y);
+    if (vsize.x = 0) or (vsize.y = 0) then exit;
+    ratio := min(AMaxWidth/vsize.x, AMaxHeight/vsize.y);
+    result := BGRABitmapFactory.Create(ceil(vsize.x*ratio),ceil(vsize.y*ratio));
+    if ratio <> 0 then
+    begin
+      vmin := svg.GetViewMin(cuPixel);
+      c2d := TBGRACanvas2D.Create(result);
+      c2d.scale(ratio);
+      c2d.translate(-vmin.x,-vmin.y);
+      svg.Draw(c2d,0,0);
+      c2d.Free;
+    end;
+  finally
+    svg.Free;
+  end;
+end;
+var AlreadyRegistered: boolean;
+procedure RegisterSvgFormat;
+begin
+  if AlreadyRegistered then exit;
+  ImageHandlers.RegisterImageReader ('Scalable Vector Graphic', 'svg', TFPReaderSVG);
+  AlreadyRegistered:= True;
+end;
 function TSVGUnits.GetCustomDpiX: single;
 var pixSize: single;
 begin
+  pixSize := Convert(FDefaultUnitWidth.value,FDefaultUnitWidth.CSSUnit,cuInch,FDefaultDpi^);
+  with GetDefaultUnitWidth do
+    pixSize := Convert(value,CSSUnit,cuInch,FDefaultDpi^);
   if pixSize = 0 then
     result := 0
 …
 var pixSize: single;
 begin
+  pixSize := Convert(FDefaultUnitHeight.value,FDefaultUnitHeight.CSSUnit,cuInch,FDefaultDpi^);
+  with GetDefaultUnitHeight do
+    pixSize := Convert(value,CSSUnit,cuInch,FDefaultDpi^);
   if pixSize = 0 then
     result := 0
 …
   FViewBox.size.y := parseNextFloat;
+  FViewSize.width := parseValue(FSvg.GetAttribute('width'), FloatWithCSSUnit(FViewBox.size.x, cuPixel));
+  if FViewSize.width.CSSUnit = cuCustom then FViewSize.width.CSSUnit := cuPixel;
+  FViewSize.height := parseValue(FSvg.GetAttribute('height'), FloatWithCSSUnit(FViewBox.size.y, cuPixel));
+  if FViewSize.height.CSSUnit = cuCustom then FViewSize.height.CSSUnit := cuPixel;
+  FOriginalViewSize.width := parseValue(FSvg.GetAttribute('width'), FloatWithCSSUnit(FViewBox.size.x, cuPixel));
+  if FOriginalViewSize.width.CSSUnit = cuCustom then FOriginalViewSize.width.CSSUnit := cuPixel;
+  if FOriginalViewSize.width.CSSUnit = cuPercent then
+  begin
+    FOriginalViewSize.width.value := FOriginalViewSize.width.value/100*FContainerWidth.value;
+    FOriginalViewSize.width.CSSUnit := FContainerWidth.CSSUnit;
+  end;
+  FOriginalViewSize.height := parseValue(FSvg.GetAttribute('height'), FloatWithCSSUnit(FViewBox.size.y, cuPixel));
+  if FOriginalViewSize.height.CSSUnit = cuCustom then FOriginalViewSize.height.CSSUnit := cuPixel;
+  if FOriginalViewSize.height.CSSUnit = cuPercent then
+  begin
+    FOriginalViewSize.height.value := FOriginalViewSize.height.value/100*FContainerHeight.value;
+    FOriginalViewSize.height.CSSUnit := FContainerHeight.CSSUnit;
+  end;
+  if FOriginalViewSize.height.CSSUnit <> FOriginalViewSize.width.CSSUnit then
+    FOriginalViewSize.height := ConvertHeight(FOriginalViewSize.height, FOriginalViewSize.width.CSSUnit);
+  FProportionalViewSize := FOriginalViewSize;
+  with GetStretchRectF(RectF(0,0,FOriginalViewSize.width.value,FOriginalViewSize.height.value), TSVGPreserveAspectRatio.DefaultValue) do
+  begin
+    FProportionalViewSize.width.value := Right-Left;
+    FProportionalViewSize.height.value := Bottom-Top;
+  end;
   if (FViewBox.size.x <= 0) and (FViewBox.size.y <= 0) then
 …
       FDpiScaleY := 1;
       FViewBox.min := PointF(0,0);
       FViewBox.size.x := ConvertWidth(FViewSize.width,cuCustom).value;
       FViewBox.size.y := ConvertHeight(FViewSize.height,cuCustom).value;
+      FViewBox.size.x := ConvertWidth(FProportionalViewSize.width,cuCustom).value;
+      FViewBox.size.y := ConvertHeight(FProportionalViewSize.height,cuCustom).value;
     end else
     begin
       FDefaultUnitWidth.value := FViewSize.width.value/FViewBox.size.x;
       FDefaultUnitWidth.CSSUnit := FViewSize.width.CSSUnit;
+      FDefaultUnitWidth.value := FProportionalViewSize.width.value/FViewBox.size.x;
+      FDefaultUnitWidth.CSSUnit := FProportionalViewSize.width.CSSUnit;
       if FDefaultUnitWidth.CSSUnit = cuCustom then
         begin
 …
           FDefaultUnitWidth.CSSUnit := cuInch;
         end;
       FDefaultUnitHeight.value := FViewSize.height.value/FViewBox.size.y;
       FDefaultUnitHeight.CSSUnit := FViewSize.height.CSSUnit;
+      FDefaultUnitHeight.value := FProportionalViewSize.height.value/FViewBox.size.y;
+      FDefaultUnitHeight.CSSUnit := FProportionalViewSize.height.CSSUnit;
       if FDefaultUnitHeight.CSSUnit = cuCustom then
         begin
 …
       FDpiScaleY := CustomDpiY/DpiY;
     end;
+  if Assigned(FOnRecompute) then FOnRecompute(self);
+end;
+procedure TSVGUnits.SetOnRecompute(AValue: TSVGRecomputeEvent);
+begin
+  if FOnRecompute=AValue then Exit;
+  FOnRecompute:=AValue;
+end;
+procedure TSVGUnits.SetContainerHeight(AValue: TFloatWithCSSUnit);
+begin
+  if CompareMem(@FContainerHeight,@AValue,sizeof(TFloatWithCSSUnit)) then Exit;
+  FContainerHeight:=AValue;
+  Recompute;
+end;
+procedure TSVGUnits.SetContainerWidth(AValue: TFloatWithCSSUnit);
+begin
+  if CompareMem(@FContainerWidth,@AValue,sizeof(TFloatWithCSSUnit)) then Exit;
+  FContainerWidth:=AValue;
+  Recompute;
 end;
 …
 begin
   vb := ViewBox;
   vs := FViewSize;
+  vs := FProportionalViewSize;
   if (vs.width.value > 0) and (vs.height.value > 0) then
     begin
 …
   FSvg := ASvg;
   FDefaultDpi := ADefaultDpi;
+  FContainerWidth := FloatWithCSSUnit(640,cuPixel);
+  FContainerHeight := FloatWithCSSUnit(480,cuPixel);
   Recompute;
 end;
+function TSVGUnits.GetStretchRectF(AViewSize: TRectF; par: TSVGPreserveAspectRatio): TRectF;
+var w0,h0,w,h: single;
+begin
+  result := AViewSize;
+  w0 := AViewSize.Right-AViewSize.Left;
+  h0 := AViewSize.Bottom-AViewSize.Top;
+  w := w0;
+  h := h0;
+  if par.Preserve and
+     (FViewBox.size.x > 0) and (FViewBox.size.y > 0) and
+     (w > 0) and (h > 0) then
+  begin
+    //viewBox wider than viewSize
+    if (FViewBox.size.x/FViewBox.size.y > w/h) xor par.Slice then
+      h := w * FViewBox.size.y / FViewBox.size.x
+    else
+      w := h * FViewBox.size.x / FViewBox.size.y;
+    case par.HorizAlign of
+      taCenter: result.Left += (w0-w)/2;
+      taRightJustify: result.Left += w0-w;
+    end;
+    case par.VertAlign of
+      tlCenter: result.Top += (h0-h)/2;
+      tlBottom: result.Top += h0-h;
+    end;
+  end;
+  result.Right := result.Left+w;
+  result.Bottom := result.Top+h;
+end;
 { TBGRASVG }
 function TBGRASVG.GetAttribute(AName: string): string;
 begin
+  result := FRoot.GetAttribute(AName);
+  result := Trim(FRoot.GetAttribute(AName));
+end;
+function TBGRASVG.GetAttribute(AName: string; ADefault: string): string;
+begin
+  result := GetAttribute(AName);
+  if result = '' then result := ADefault;
 end;
 …
 function TBGRASVG.GetHeight: TFloatWithCSSUnit;
 begin
   result := TCSSUnitConverter.parseValue(Attribute['height'],FloatWithCSSUnit(0,cuCustom));
+  result := TCSSUnitConverter.parseValue(Attribute['height'],FloatWithCSSUnit(FUnits.ViewBox.size.y,cuCustom));
 end;
 …
 end;
+function TBGRASVG.GetPreserveAspectRatio: string;
+begin
+  result := Attribute['preserveAspectRatio'];
+function TBGRASVG.GetPreserveAspectRatio: TSVGPreserveAspectRatio;
+begin
+  result := TSVGPreserveAspectRatio.Parse(Attribute['preserveAspectRatio','xMidYMid']);
+end;
+function TBGRASVG.GetUTF8String: utf8string;
+var str: TMemoryStream;
+begin
+  str := TMemoryStream.Create;
+  SaveToStream(str);
+  setlength(result, str.Size);
+  str.Position := 0;
+  str.Read(result[1], length(result));
+  str.Free;
 end;
 …
 end;
+function TBGRASVG.GetViewMin(AUnit: TCSSUnit): TPointF;
+var
+  vb: TSVGViewBox;
+begin
+  GetViewBoxIndirect(AUnit,vb);
+  result:= vb.min;
+end;
+function TBGRASVG.GetViewSize(AUnit: TCSSUnit): TPointF;
+var
+  vb: TSVGViewBox;
+begin
+  GetViewBoxIndirect(AUnit,vb);
+  result:= vb.size;
+end;
 function TBGRASVG.GetWidth: TFloatWithCSSUnit;
 begin
   result := TCSSUnitConverter.parseValue(Attribute['width'],FloatWithCSSUnit(0,cuCustom));
+  result := TCSSUnitConverter.parseValue(Attribute['width'],FloatWithCSSUnit(FUnits.ViewBox.size.x,cuCustom));
 end;
 …
 function TBGRASVG.GetZoomable: boolean;
 begin
   result := trim(Attribute['zoomAndPan'])<>'disable';
+  result := AttributeDef['zoomAndPan','magnify']<>'disable';
 end;
 …
   FUnits.CustomDpi := AValue;
   if AValue.x <> AValue.y then
     preserveAspectRatio := 'none';
+    preserveAspectRatio := TSVGPreserveAspectRatio.Parse('none');
 end;
 …
 end;
+procedure TBGRASVG.SetPreserveAspectRatio(AValue: string);
+begin
+  Attribute['preserveAspectRatio'] := AValue;
+procedure TBGRASVG.SetPreserveAspectRatio(AValue: TSVGPreserveAspectRatio);
+begin
+  Attribute['preserveAspectRatio'] := AValue.ToString;
+  Units.Recompute;
+end;
+procedure TBGRASVG.SetUTF8String(AValue: utf8string);
+var str: TMemoryStream;
+begin
+  str:= TMemoryStream.Create;
+  str.Write(AValue[1],length(AValue));
+  str.Position:= 0;
+  LoadFromStream(str);
+  str.Free;
 end;
 …
     FRoot := FXml.CreateElement('svg');
     FUnits := TSVGUnits.Create(FRoot,@FDefaultDpi);
+    FContent := TSVGContent.Create(FXml,FRoot,FUnits);
+    FUnits.OnRecompute:= @UnitsRecompute;
+    FDataLink := TSVGDataLink.Create;
+    FContent := TSVGContent.Create(FXml,FRoot,FUnits,FDataLink,nil);
     FXml.AppendChild(FRoot);
   end;
 …
 end;
+procedure TBGRASVG.UnitsRecompute(Sender: TObject);
+begin
+  FContent.Recompute;
+end;
 constructor TBGRASVG.Create;
 begin
 …
 end;
+constructor TBGRASVG.CreateFromString(AUTF8String: string);
+begin
+  Init(False);
+  AsUTF8String:= AUTF8String;
+end;
 destructor TBGRASVG.Destroy;
 begin
+  FreeAndNil(FDataLink);
   FreeAndNil(FContent);
   FreeAndNil(FUnits);
 …
     raise exception.Create('Root node not found');
   end;
+  FreeAndNil(FDataLink);
   FreeAndNil(FContent);
   FreeAndNil(FUnits);
 …
   FRoot := root as TDOMElement;
   FUnits := TSVGUnits.Create(FRoot,@FDefaultDpi);
+  FContent := TSVGContent.Create(FXml,FRoot,FUnits);
+  FUnits.OnRecompute:= @UnitsRecompute;
+  FDataLink := TSVGDataLink.Create;
+  FContent := TSVGContent.Create(FXml,FRoot,FUnits,FDataLink,nil);
+end;
+procedure TBGRASVG.LoadFromResource(AFilename: string);
+var
+  stream: TStream;
+begin
+  stream := BGRAResource.GetResourceStream(AFilename);
+  try
+    LoadFromStream(stream);
+  finally
+    stream.Free;
+  end;
 end;
 …
   ACanvas2d.translate(x,y);
   ACanvas2d.scale(destDpi.x/Units.DpiX,destDpi.y/Units.DpiY);
-  ACanvas2d.strokeResetTransform;
-  ACanvas2d.strokeScale(destDpi.x/Units.DpiX,destDpi.y/Units.DpiY);
   with GetViewBoxAlignment(AHorizAlign,AVertAlign) do ACanvas2d.translate(x,y);
   Draw(ACanvas2d, 0,0, cuPixel);
 …
   ACanvas2d.save;
   ACanvas2d.translate(x,y);
+  ACanvas2d.strokeMatrix := ACanvas2d.matrix;
   Content.Draw(ACanvas2d,AUnit);
   ACanvas2d.restore;
 …
   ACanvas2d.translate(x,y);
   ACanvas2d.scale(destDpi.x/Units.DpiX,destDpi.y/Units.DpiY);
-  ACanvas2d.strokeResetTransform;
-  ACanvas2d.strokeScale(destDpi.x/Units.DpiX,destDpi.y/Units.DpiY);
   Draw(ACanvas2d, 0,0, cuPixel);
   ACanvas2d.restore;
 end;
 procedure TBGRASVG.StretchDraw(ACanvas2d: TBGRACanvas2D; x, y, w, h: single);
+procedure TBGRASVG.StretchDraw(ACanvas2d: TBGRACanvas2D; x, y, w, h: single; useSvgAspectRatio: boolean);
 var vb: TSVGViewBox;
 begin
+  if useSvgAspectRatio then
+  begin
+    with preserveAspectRatio do
+      StretchDraw(ACanvas2d, HorizAlign, VertAlign, x,y,w,h);
+    exit;
+  end;
   ACanvas2d.save;
   ACanvas2d.translate(x,y);
 …
     ACanvas2d.translate(-min.x,-min.y);
     if size.x <> 0 then
-    begin
       ACanvas2d.scale(w/size.x,1);
-      ACanvas2d.strokeScale(w/size.x,1);
-    end;
     if size.y <> 0 then
-    begin
       ACanvas2d.scale(1,h/size.y);
-      ACanvas2d.strokeScale(1,h/size.y);
-    end;
   end;
   Draw(ACanvas2d, 0,0);
 …
 end;
+procedure TBGRASVG.StretchDraw(ACanvas2d: TBGRACanvas2D; r: TRectF; useSvgAspectRatio: boolean);
+begin
+  StretchDraw(ACanvas2d, r.Left,r.Top,r.Right-r.Left,r.Bottom-r.Top, useSvgAspectRatio);
+end;
 procedure TBGRASVG.StretchDraw(ACanvas2d: TBGRACanvas2D;
   AHorizAlign: TAlignment; AVertAlign: TTextLayout; x, y, w, h: single);
+var r: TRectF;
+begin
+  r := GetStretchRectF(AHorizAlign,AVertAlign, x, y, w, h);
+  StretchDraw(ACanvas2d, r.Left,r.Top,r.Right-r.Left,r.Bottom-r.Top);
+end;
+function TBGRASVG.GetStretchRectF(AHorizAlign: TAlignment;
+  AVertAlign: TTextLayout; x, y, w, h: single): TRectF;
 var ratio,stretchRatio,zoom: single;
-  vb: TSVGViewBox;
   sx,sy,sw,sh: single;
+begin
+  GetViewBoxIndirect(cuPixel,vb);
+  if (h = 0) or (w = 0) or (vb.size.x = 0) or (vb.size.y = 0) then exit;
+  ratio := vb.size.x/vb.size.y;
+  size: TSVGSize;
+begin
+  //determine global ratio according to viewSize
+  size := Units.OriginalViewSize;
+  size.width := Units.ConvertWidth(size.Width,cuPixel);
+  size.height := Units.ConvertHeight(size.height,cuPixel);
+  if (h = 0) or (w = 0) or (size.width.value = 0) or (size.height.value = 0) then
+  begin
+    result := RectF(x,y,w,h);
+    exit;
+  end;
+  ratio := size.width.value/size.height.value;
   stretchRatio := w/h;
   if ratio > stretchRatio then
     zoom := w / vb.size.x
+    zoom := w / size.width.value
   else
     zoom := h / vb.size.y;
+    zoom := h / size.height.value;
   sx := x;
   sy := y;
   sw := vb.size.x*zoom;
   sh := vb.size.y*zoom;
+  sw := size.width.value*zoom;
+  sh := size.height.value*zoom;
   case AHorizAlign of
 …
     tlBottom: sy += h - sh;
   end;
+  StretchDraw(ACanvas2d, sx,sy,sw,sh);
+end;
+  result := Units.GetStretchRectF(RectF(sx,sy,sx+sw,sy+sh), preserveAspectRatio);
+end;
+initialization
+  DefaultBGRAImageReader[ifSvg] := TFPReaderSVG;
 end.

GraphicTest/Packages/bgrabitmap/bgrasvgshapes.pas

-              r494
+              r521
 type
+  TSVGGradient = class;
+  { TSVGElementWithGradient }
+  TSVGElementWithGradient = class(TSVGElement)
+    private
+      FGradientElement: TSVGGradient;
+      FGradientElementDefined: boolean;
+      FCanvasGradient: IBGRACanvasGradient2D;
+      function EvaluatePercentage(fu: TFloatWithCSSUnit): single; { fu is a percentage of a number [0.0..1.0] }
+      function GetGradientElement: TSVGGradient;
+      procedure ResetGradient;
+      function FindGradientElement: boolean;
+    protected
+      procedure Initialize; override;
+      procedure AddStopElements(canvas: IBGRACanvasGradient2D);
+      procedure CreateCanvasLinearGradient(ACanvas2d: TBGRACanvas2D; ASVGGradient: TSVGGradient;
+        const origin: TPointF; const w,h: single; AUnit: TCSSUnit);
+      procedure CreateCanvasRadialGradient(ACanvas2d: TBGRACanvas2D; ASVGGradient: TSVGGradient;
+        const origin: TPointF; const w,h: single; AUnit: TCSSUnit);
+      procedure ApplyFillStyle(ACanvas2D: TBGRACanvas2D; AUnit: TCSSUnit); override;
+    public
+      procedure InitializeGradient(ACanvas2d: TBGRACanvas2D;
+                const origin: TPointF; const w,h: single; AUnit: TCSSUnit);
+      property GradientElement: TSVGGradient read GetGradientElement;
+  end;
   { TSVGLine }
 …
       procedure InternalDraw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit); override;
     public
       constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter); override;
+      constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); override;
       property x1: TFloatWithCSSUnit read GetX1 write SetX1;
       property y1: TFloatWithCSSUnit read GetY1 write SetY1;
 …
   { TSVGRectangle }
   TSVGRectangle = class(TSVGElement)
+  TSVGRectangle = class(TSVGElementWithGradient)
     private
       function GetX: TFloatWithCSSUnit;
 …
       procedure InternalDraw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit); override;
     public
       constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter); override;
+      constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); override;
       property x: TFloatWithCSSUnit read GetX write SetX;
       property y: TFloatWithCSSUnit read GetY write SetY;
 …
   { TSVGCircle }
   TSVGCircle = class(TSVGElement)
+  TSVGCircle = class(TSVGElementWithGradient)
     private
       function GetCX: TFloatWithCSSUnit;
 …
       procedure InternalDraw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit); override;
     public
       constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter); override;
+      constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); override;
       property cx: TFloatWithCSSUnit read GetCX write SetCX;
       property cy: TFloatWithCSSUnit read GetCY write SetCY;
 …
   { TSVGEllipse }
   TSVGEllipse = class(TSVGElement)
+  TSVGEllipse = class(TSVGElementWithGradient)
     private
       function GetCX: TFloatWithCSSUnit;
 …
       procedure InternalDraw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit); override;
     public
       constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter); override;
+      constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); override;
       property cx: TFloatWithCSSUnit read GetCX write SetCX;
       property cy: TFloatWithCSSUnit read GetCY write SetCY;
 …
   { TSVGPath }
   TSVGPath = class(TSVGElement)
+  TSVGPath = class(TSVGElementWithGradient)
     private
       FPath: TBGRAPath;
+      FBoundingBox: TRectF;
+      FBoundingBoxComputed: boolean;
+      function GetBoundingBoxF: TRectF;
       function GetPath: TBGRAPath;
       function GetPathLength: TFloatWithCSSUnit;
 …
       procedure InternalDraw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit); override;
     public
       constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter); override;
       constructor Create(ADocument: TXMLDocument; AElement: TDOMElement; AUnits: TCSSUnitConverter); override;
+      constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); override;
+      constructor Create(ADocument: TXMLDocument; AElement: TDOMElement; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); override;
       destructor Destroy; override;
       property d: string read GetData write SetData;
       property path: TBGRAPath read GetPath;
       property pathLength: TFloatWithCSSUnit read GetPathLength write SetPathLength;
+      property boundingBoxF: TRectF read GetBoundingBoxF;
   end;
   { TSVGPolypoints }
   TSVGPolypoints = class(TSVGElement)
+  TSVGPolypoints = class(TSVGElementWithGradient)
     private
+      FBoundingBox: TRectF;
+      FBoundingBoxComputed: boolean;
+      function GetBoundingBoxF: TRectF;
       function GetClosed: boolean;
       function GetPoints: string;
 …
       procedure SetPoints(AValue: string);
       procedure SetPointsF(AValue: ArrayOfTPointF);
+      procedure ComputeBoundingBox(APoints: ArrayOfTPointF);
     protected
       procedure InternalDraw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit); override;
     public
       constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; AClosed: boolean); overload;
+      constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; AClosed: boolean; ADataLink: TSVGDataLink); overload;
       destructor Destroy; override;
       property points: string read GetPoints write SetPoints;
       property pointsF: ArrayOfTPointF read GetPointsF write SetPointsF;
       property closed: boolean read GetClosed;
+      property boundingBoxF: TRectF read GetBoundingBoxF;
   end;
   { TSVGText }
   TSVGText = class(TSVGElement)
+  TSVGText = class(TSVGElementWithGradient)
     private
       function GetFontBold: boolean;
 …
       procedure InternalDraw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit); override;
     public
       constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter); override;
+      constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); override;
       property x: TFloatWithCSSUnit read GetX write SetX;
       property y: TFloatWithCSSUnit read GetY write SetY;
 …
   TSVGContent = class;
+  TConvMethod = (cmNone,cmHoriz,cmVertical,cmOrtho);
+  { TSVGGradient }
+  TSVGGradient = class(TSVGElement)
+    private
+      FContent: TSVGContent;
+      function GetGradientMatrix(AUnit: TCSSUnit): TAffineMatrix;
+      function GetGradientTransform: string;
+      function GetGradientUnits: string;
+      function GetHRef: string;
+      function GetUseObjectBoundingBox: boolean;
+      procedure SetGradientTransform(AValue: string);
+      procedure SetGradientUnits(AValue: string);
+      procedure SetHRef(AValue: string);
+      function HRefToGradientID(const AValue: string): string;
+      function FindGradientRef(const AGradientID: string): integer;
+    protected
+      InheritedGradients: TSVGElementList;//(for HRef)
+      procedure Initialize; override;
+      function GetInheritedAttribute(AValue: string;
+        AConvMethod: TConvMethod; ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
+    public
+      constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter;
+        ADataLink: TSVGDataLink); override;
+      constructor Create(ADocument: TXMLDocument; AElement: TDOMElement;
+        AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); override;
+      destructor Destroy; override;
+      procedure Recompute; override;
+      procedure ScanInheritedGradients(const forceScan: boolean = false);
+      property Content: TSVGContent read FContent;
+      property hRef: string read GetHRef write SetHRef;
+      property gradientUnits: string read GetGradientUnits write SetGradientUnits;
+      property gradientTransform: string read GetGradientTransform write SetGradientTransform;
+      property useObjectBoundingBox: boolean read GetUseObjectBoundingBox;
+      property gradientMatrix[AUnit: TCSSUnit]: TAffineMatrix read GetGradientMatrix;
+  end;
+  { TSVGGradientLinear }
+  TSVGLinearGradient = class(TSVGGradient)
+    private
+      function GetX1: TFloatWithCSSUnit;
+      function GetX2: TFloatWithCSSUnit;
+      function GetY1: TFloatWithCSSUnit;
+      function GetY2: TFloatWithCSSUnit;
+      procedure SetX1(AValue: TFloatWithCSSUnit);
+      procedure SetX2(AValue: TFloatWithCSSUnit);
+      procedure SetY1(AValue: TFloatWithCSSUnit);
+      procedure SetY2(AValue: TFloatWithCSSUnit);
+    public
+      constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter;
+        ADataLink: TSVGDataLink); override;
+      property x1: TFloatWithCSSUnit read GetX1 write SetX1;
+      property y1: TFloatWithCSSUnit read GetY1 write SetY1;
+      property x2: TFloatWithCSSUnit read GetX2 write SetX2;
+      property y2: TFloatWithCSSUnit read GetY2 write SetY2;
+  end;
+  { TSVGRadialGradient }
+  TSVGRadialGradient = class(TSVGGradient)
+    private
+      function GetCX: TFloatWithCSSUnit;
+      function GetCY: TFloatWithCSSUnit;
+      function GetR: TFloatWithCSSUnit;
+      function GetFX: TFloatWithCSSUnit;
+      function GetFY: TFloatWithCSSUnit;
+      function GetFR: TFloatWithCSSUnit;
+      procedure SetCX(AValue: TFloatWithCSSUnit);
+      procedure SetCY(AValue: TFloatWithCSSUnit);
+      procedure SetR(AValue: TFloatWithCSSUnit);
+      procedure SetFX(AValue: TFloatWithCSSUnit);
+      procedure SetFY(AValue: TFloatWithCSSUnit);
+      procedure SetFR(AValue: TFloatWithCSSUnit);
+    public
+      constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter;
+        ADataLink: TSVGDataLink); override;
+      property cx: TFloatWithCSSUnit read GetCX write SetCX;
+      property cy: TFloatWithCSSUnit read GetCY write SetCY;
+      property r: TFloatWithCSSUnit read GetR write SetR;
+      property fx: TFloatWithCSSUnit read GetFX write SetFX;
+      property fy: TFloatWithCSSUnit read GetFY write SetFY;
+      property fr: TFloatWithCSSUnit read GetFR write SetFR;
+  end;
+  { TSVGStopGradient }
+  TSVGStopGradient = class(TSVGElement)
+    private
+      function GetOffset: TFloatWithCSSUnit;
+      procedure SetOffset(AValue: TFloatWithCSSUnit);
+    public
+      constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter;
+        ADataLink: TSVGDataLink); override;
+      property Offset: TFloatWithCSSUnit read GetOffset write SetOffset;
+  end;
+  { TSVGDefine }
+  TSVGDefine = class(TSVGElement)
+  protected
+    FContent: TSVGContent;
+  public
+    constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter;
+      ADataLink: TSVGDataLink); override;
+    constructor Create(ADocument: TXMLDocument; AElement: TDOMElement;
+      AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); override;
+    destructor Destroy; override;
+    procedure Recompute; override;
+    property Content: TSVGContent read FContent;
+  end;
   { TSVGGroup }
 …
     procedure InternalDraw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit); override;
   public
     constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter); override;
+    constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); override;
     constructor Create(ADocument: TXMLDocument; AElement: TDOMElement;
       AUnits: TCSSUnitConverter); override;
+      AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); override;
     destructor Destroy; override;
+    procedure Recompute; override;
     property Content: TSVGContent read FContent;
   end;
+  { TSVGStyle }
+  TSVGStyleItem = record
+    name,
+    attribute: string;
+  end;
+  ArrayOfTSVGStyleItem = array of TSVGStyleItem;
+  TSVGStyle = class(TSVGElement)
+   private
+     FStyles: ArrayOfTSVGStyleItem;
+     procedure Parse(const s: String);
+     function IsValidID(const sid: integer): boolean;
+     function GetStyle(const sid: integer): TSVGStyleItem;
+     procedure SetStyle(const sid: integer; sr: TSVGStyleItem);
+     function Find(sr: TSVGStyleItem): integer; overload;
+   protected
+     procedure Initialize; override;
+   public
+     constructor Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); overload; override;
+     constructor Create(ADocument: TXMLDocument; AElement: TDOMElement;
+       AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); overload; override;
+     destructor Destroy; override;
+     function Count: Integer;
+     function Find(const AName: string): integer; overload;
+     function Add(sr: TSVGStyleItem): integer;
+     procedure Remove(sr: TSVGStyleItem);
+     procedure Clear;
+     procedure ReParse;
+     property Styles[sid: integer]: TSVGStyleItem read GetStyle write SetStyle;
+  end;
   { TSVGContent }
 …
   TSVGContent = class
     protected
+      FDataLink: TSVGDataLink;
       FDomElem: TDOMElement;
       FDoc: TXMLDocument;
       FElements: TList;
+      FElements: TFPList;
       FUnits: TCSSUnitConverter;
       procedure AppendElement(AElement: TSVGElement);
 …
       function GetUnits: TCSSUnitConverter;
     public
+      constructor Create(ADocument: TXMLDocument; AElement: TDOMElement; AUnits: TCSSUnitConverter);
+      constructor Create(ADocument: TXMLDocument; AElement: TDOMElement; AUnits: TCSSUnitConverter;
+        ADataLink: TSVGDataLink; ADataParent: TSVGElement);
       destructor Destroy; override;
+      procedure Recompute;
       procedure Draw(ACanvas2d: TBGRACanvas2D; x,y: single; AUnit: TCSSUnit); overload;
       procedure Draw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit); overload;
 …
 function GetSVGFactory(ATagName: string): TSVGFactory;
 function CreateSVGElementFromNode(ADocument: TXMLDocument;
   AElement: TDOMElement; AUnits: TCSSUnitConverter): TSVGElement;
+  AElement: TDOMElement; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink; ADataParent: TSVGElement): TSVGElement;
 implementation
 …
   if tag='text' then
     result := TSVGText else
+  if tag='lineargradient' then
+    result := TSVGLinearGradient else
+  if tag='radialgradient' then
+    result := TSVGRadialGradient else
+  if tag='stop' then
+    result := TSVGStopGradient else
+  if tag='defs' then
+    result := TSVGDefine else
   if tag='g' then
     result := TSVGGroup else
+  if tag='style' then
+    result := TSVGStyle else
     result := TSVGElement;
 end;
 function CreateSVGElementFromNode(ADocument: TXMLDocument;
   AElement: TDOMElement; AUnits: TCSSUnitConverter): TSVGElement;
+  AElement: TDOMElement; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink; ADataParent: TSVGElement): TSVGElement;
 var
   factory: TSVGFactory;
 begin
   factory := GetSVGFactory(AElement.TagName);
+  result := factory.Create(ADocument,AElement,AUnits);
+end;
+  result := factory.Create(ADocument,AElement,AUnits,ADataLink);
+  ADataLink.Link(result,ADataParent);
+end;
+{ TSVGElementWithGradient }
+procedure TSVGElementWithGradient.Initialize;
+begin
+  inherited Initialize;
+  ResetGradient;
+end;
+procedure TSVGElementWithGradient.ResetGradient;
+begin
+  FGradientElementDefined := false;
+  FGradientElement        := nil;
+  FCanvasGradient         := nil;
+end;
+function TSVGElementWithGradient.FindGradientElement: boolean;
+var
+  i: integer;
+  s: string;
+begin
+  Result:= false;
+  s:= fill;
+  if s <> '' then
+    if Pos('url(#',s) = 1 then
+    begin
+      s:= System.Copy(s,6,Length(s)-6);
+      with FDataLink do
+        for i:= GradientCount-1 downto 0 do
+          if (Gradients[i] as TSVGGradient).ID = s then
+          begin
+            FGradientElement:= TSVGGradient(Gradients[i]);
+            Result:= true;
+            Exit;
+          end;
+    end;
+end;
+function TSVGElementWithGradient.EvaluatePercentage(fu: TFloatWithCSSUnit): single;
+begin
+  Result:= fu.value;
+  if fu.CSSUnit <> cuPercent then
+  begin
+    if Result < 0 then
+      Result:= 0
+    else if Result > 1 then
+      Result:= 1;
+    Result:= Result * 100;
+  end;
+end;
+function TSVGElementWithGradient.GetGradientElement: TSVGGradient;
+begin
+  if not FGradientElementDefined then
+  begin
+    FindGradientElement;
+    FGradientElementDefined:= true;
+    if FGradientElement <> nil then
+      FGradientElement.ScanInheritedGradients;
+  end;
+  result := FGradientElement;
+end;
+procedure TSVGElementWithGradient.AddStopElements(canvas: IBGRACanvasGradient2D);
+  function AddStopElementFrom(el: TSVGElement): integer;
+  var
+    i: integer;
+    col: TBGRAPixel;
+  begin
+    result:= 0;
+    with el.DataChildList do
+      for i:= 0 to Count-1 do
+        if Items[i] is TSVGStopGradient then
+          with (Items[i] as TSVGStopGradient) do
+          begin
+            col:= StrToBGRA( AttributeOrStyleDef['stop-color','black'] );
+            col.alpha:= Round( Units.parseValue(AttributeOrStyleDef['stop-opacity','1'],1) * col.alpha );
+            canvas.addColorStop(EvaluatePercentage(offset)/100, col);
+            Inc(result);
+          end;
+  end;
+var
+  i: integer;
+begin
+  if not Assigned(GradientElement) then exit;
+  with GradientElement.InheritedGradients do
+    for i:= 0 to Count-1 do
+      AddStopElementFrom(Items[i]);
+end;
+procedure TSVGElementWithGradient.CreateCanvasLinearGradient(
+  ACanvas2d: TBGRACanvas2D; ASVGGradient: TSVGGradient;
+  const origin: TPointF; const w,h: single; AUnit: TCSSUnit);
+var p1,p2: TPointF;
+  g: TSVGLinearGradient;
+  m: TAffineMatrix;
+begin
+  g := ASVGGradient as TSVGLinearGradient;
+  if g.useObjectBoundingBox then
+  begin
+    p1.x:= EvaluatePercentage(g.x1)/100;
+    p1.y:= EvaluatePercentage(g.y1)/100;
+    p2.x:= EvaluatePercentage(g.x2)/100;
+    p2.y:= EvaluatePercentage(g.y2)/100;
+    m := ACanvas2d.matrix;
+    ACanvas2d.translate(origin.x,origin.y);
+    ACanvas2d.scale(w,h);
+    ACanvas2d.transform(g.gradientMatrix[cuCustom]);
+    FCanvasGradient:= ACanvas2d.createLinearGradient(p1,p2);
+    ACanvas2d.matrix := m;
+  end else
+  begin
+    p1.x:= Units.ConvertWidth(g.x1,AUnit,w).value;
+    p1.y:= Units.ConvertHeight(g.y1,AUnit,h).value;
+    p2.x:= Units.ConvertWidth(g.x1,AUnit,w).value;
+    p2.y:= Units.ConvertHeight(g.y1,AUnit,h).value;
+    m := ACanvas2d.matrix;
+    ACanvas2d.transform(g.gradientMatrix[AUnit]);
+    FCanvasGradient:= ACanvas2d.createLinearGradient(p1,p2);
+    ACanvas2d.matrix := m;
+  end;
+  AddStopElements(FCanvasGradient);
+end;
+procedure TSVGElementWithGradient.CreateCanvasRadialGradient(
+  ACanvas2d: TBGRACanvas2D; ASVGGradient: TSVGGradient; const origin: TPointF;
+  const w, h: single; AUnit: TCSSUnit);
+var c,f: TPointF;
+  r,fr: single;
+  g: TSVGRadialGradient;
+  m: TAffineMatrix;
+  procedure CheckFocalAndCreate(c: TPointF; r: single; f: TPointF; fr: single);
+  var u: TPointF;
+    d: single;
+  begin
+    u := f-c;
+    d := VectLen(u);
+    if d >= r then
+    begin
+      u *= (r/d)*0.99999;
+      f := c+u;
+    end;
+    FCanvasGradient:= ACanvas2d.createRadialGradient(c,r,f,fr,true);
+    AddStopElements(FCanvasGradient);
+  end;
+begin
+  g := ASVGGradient as TSVGRadialGradient;
+  if g.useObjectBoundingBox then
+  begin
+    c.x:= EvaluatePercentage(g.cx)/100;
+    c.y:= EvaluatePercentage(g.cy)/100;
+    r:= abs(EvaluatePercentage(g.r))/100;
+    f.x:= EvaluatePercentage(g.fx)/100;
+    f.y:= EvaluatePercentage(g.fy)/100;
+    fr:= abs(EvaluatePercentage(g.fr))/100;
+    m := ACanvas2d.matrix;
+    ACanvas2d.translate(origin.x,origin.y);
+    ACanvas2d.scale(w,h);
+    ACanvas2d.transform(g.gradientMatrix[cuCustom]);
+    CheckFocalAndCreate(c,r,f,fr);
+    ACanvas2d.matrix := m;
+  end else
+  begin
+    c.x:= Units.ConvertWidth(g.cx,AUnit,w).value;
+    c.y:= Units.ConvertHeight(g.cy,AUnit,h).value;
+    r:= abs(Units.ConvertWidth(g.r,AUnit,w).value);
+    f.x:= Units.ConvertWidth(g.fx,AUnit,w).value;
+    f.y:= Units.ConvertHeight(g.fy,AUnit,h).value;
+    fr:= abs(Units.ConvertWidth(g.fr,AUnit,w).value);
+    m := ACanvas2d.matrix;
+    ACanvas2d.transform(g.gradientMatrix[AUnit]);
+    CheckFocalAndCreate(c,r,f,fr);
+    ACanvas2d.matrix := m;
+  end;
+end;
+procedure TSVGElementWithGradient.InitializeGradient(ACanvas2d: TBGRACanvas2D;
+  const origin: TPointF; const w,h: single; AUnit: TCSSUnit);
+begin
+  if GradientElement <> nil then
+  begin
+    if GradientElement is TSVGLinearGradient then
+      CreateCanvasLinearGradient(ACanvas2d, GradientElement, origin, w,h, AUnit)
+    else
+    if GradientElement is TSVGRadialGradient then
+      CreateCanvasRadialGradient(ACanvas2d, GradientElement, origin, w,h, AUnit);
+  end;
+end;
+procedure TSVGElementWithGradient.ApplyFillStyle(ACanvas2D: TBGRACanvas2D; AUnit: TCSSUnit);
+begin
+  if FCanvasGradient = nil then
+    inherited ApplyFillStyle(ACanvas2D,AUnit)
+  else
+  begin
+    ACanvas2D.fillStyle(FCanvasGradient);
+    ACanvas2D.fillMode:= TFillMode(fillMode);
+  end;
+end;
 { TSVGText }
 …
 function TSVGText.GetFontFamily: string;
 begin
+  result := AttributeOrStyle['font-family'];
+  if result = '' then result := 'Arial';
+  result := AttributeOrStyleDef['font-family','Arial'];
 end;
 …
 function TSVGText.GetFontSize: TFloatWithCSSUnit;
 begin
+  if AttributeOrStyle['font-size']='' then
+    result := FloatWithCSSUnit(12,cuPoint)
+  else
+    result := VerticalAttributeOrStyleWithUnit['font-size'];
+  result:= VerticalAttributeOrStyleWithUnit['font-size',FloatWithCSSUnit(12,cuPoint)];
 end;
 function TSVGText.GetFontStyle: string;
 begin
+  result := AttributeOrStyle['font-style'];
+  if result = '' then result := 'normal';
+  result := AttributeOrStyleDef['font-style','normal'];
 end;
 function TSVGText.GetFontWeight: string;
 begin
+  result := AttributeOrStyle['font-weight'];
+  if result = '' then result := 'normal';
+  result := AttributeOrStyleDef['font-weight','normal'];
 end;
 …
 function TSVGText.GetTextDecoration: string;
 begin
+  result := AttributeOrStyle['text-decoration'];
+  if result='' then result := 'none';
+  result := AttributeOrStyleDef['text-decoration','none'];
 end;
 …
 procedure TSVGText.InternalDraw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit);
+var fs:TFontStyles;
+var
+  fs:TFontStyles;
+  vx,vy: single;
 begin
   ACanvas2d.beginPath;
   ACanvas2d.fontEmHeight := Units.ConvertWidth(fontSize,AUnit).value;
+  ACanvas2d.fontEmHeight := Units.ConvertHeight(fontSize,AUnit).value;
   ACanvas2d.fontName := fontFamily;
   fs := [];
 …
   if fontItalic then fs += [fsItalic];
   ACanvas2d.fontStyle := fs;
+  ACanvas2d.text(SimpleText,Units.ConvertWidth(x,AUnit).value,Units.ConvertWidth(y,AUnit).value);
+  vx:= Units.ConvertWidth(x,AUnit).value;
+  vy:= Units.ConvertHeight(y,AUnit).value;
+  ACanvas2d.text(SimpleText,vx,vy);
+  if Assigned(GradientElement) then
+    with ACanvas2d.measureText(SimpleText) do
+      InitializeGradient(ACanvas2d, PointF(vx,vy),width,height,AUnit);
   if not isFillNone then
   begin
     ACanvas2d.fillStyle(fillColor);
+    ApplyFillStyle(ACanvas2D,AUnit);
     ACanvas2d.fill;
   end;
 …
 end;
+constructor TSVGText.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter);
+begin
+constructor TSVGText.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
   Init(ADocument,'text',AUnits);
 end;
 …
 { TSVGGroup }
 constructor TSVGGroup.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter);
 begin
   inherited Create(ADocument, AUnits);
   FContent := TSVGContent.Create(ADocument,FDomElem,AUnits);
+constructor TSVGGroup.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
+  FContent := TSVGContent.Create(ADocument,FDomElem,AUnits,ADataLink,Self);
 end;
 constructor TSVGGroup.Create(ADocument: TXMLDocument; AElement: TDOMElement;
   AUnits: TCSSUnitConverter);
 begin
   inherited Create(ADocument, AElement, AUnits);
   FContent := TSVGContent.Create(ADocument,AElement,AUnits);
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AElement, AUnits, ADataLink);
+  FContent := TSVGContent.Create(ADocument,AElement,AUnits,ADataLink,Self);
 end;
 …
 end;
+procedure TSVGGroup.Recompute;
+begin
+  inherited Recompute;
+  FContent.Recompute;
+end;
+{ TSVGStyle }
+constructor TSVGStyle.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
+  Init(ADocument,'style',AUnits);
+end;
+constructor TSVGStyle.Create(ADocument: TXMLDocument; AElement: TDOMElement;
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AElement, AUnits, ADataLink);
+  Parse(AElement.TextContent);
+end;
+procedure TSVGStyle.Initialize;
+begin
+  inherited Initialize;
+  Clear;
+end;
+destructor TSVGStyle.Destroy;
+begin
+  Clear;
+  inherited Destroy;
+end;
+procedure TSVGStyle.Parse(const s: String);
+  function IsValidAttribute(const sa: string): boolean;
+  var
+    i: integer;
+  begin
+    //(for case example "{ ; ;}")
+    for i:= 1 to Length(sa) do
+     if not (sa[i] in [' ',';']) then
+      exit(true);
+    result:= false;
+  end;
+const
+  EmptyRec: TSVGStyleItem = (name: ''; attribute: '');
+var
+  i,l,pg: integer;
+  st: String;
+  rec: TSVGStyleItem;
+begin
+  (*
+    Example of internal style block
+    circle {..}
+    circle.type1 {..}
+    .pic1 {..}
+  *)
+  Clear;
+  l:= 0;
+  pg:= 0;
+  st:= '';
+  rec:= EmptyRec;
+  for i:= 1 to Length(s) do
+  begin
+    if s[i] = '{' then
+    begin
+      Inc(pg);
+      if (pg = 1) and (Length(st) <> 0) then
+      begin
+       rec.name:= Trim(st);
+       st:= '';
+      end;
+    end
+    else if s[i] = '}' then
+    begin
+      Dec(pg);
+      if (pg = 0) and (Length(st) <> 0) then
+      begin
+        if IsValidAttribute(st) then
+        begin
+          rec.attribute:= Trim(st);
+          Inc(l);
+          SetLength(FStyles,l);
+          FStyles[l-1]:= rec;
+          rec:= EmptyRec;
+        end;
+        st:= '';
+      end;
+    end
+    else
+      st:= st + s[i];
+  end;
+end;
+function TSVGStyle.IsValidID(const sid: integer): boolean;
+begin
+  result:= (sid >= 0) and (sid < Length(FStyles));
+end;
+function TSVGStyle.GetStyle(const sid: integer): TSVGStyleItem;
+begin
+  if IsValidID(sid) then
+    result:= FStyles[sid]
+  else
+    raise exception.Create(rsInvalidId);
+end;
+procedure TSVGStyle.SetStyle(const sid: integer; sr: TSVGStyleItem);
+begin
+  if IsValidID(sid) then
+    FStyles[sid]:= sr
+  else
+    raise exception.Create(rsInvalidId);
+end;
+function TSVGStyle.Count: Integer;
+begin
+  result:= Length(FStyles);
+end;
+function TSVGStyle.Find(sr: TSVGStyleItem): integer;
+var
+  i: integer;
+begin
+  for i:= 0 to Length(FStyles)-1 do
+    with FStyles[i] do
+      if (name = sr.name) and
+         (attribute = sr.attribute) then
+      begin
+        result:= i;
+        Exit;
+      end;
+  result:= -1;
+end;
+function TSVGStyle.Find(const AName: string): integer;
+var
+  i: integer;
+begin
+  for i:= 0 to Length(FStyles)-1 do
+    with FStyles[i] do
+      if name = AName then
+      begin
+        result:= i;
+        Exit;
+      end;
+  result:= -1;
+end;
+function TSVGStyle.Add(sr: TSVGStyleItem): integer;
+var
+  l: integer;
+begin
+  l:= Length(FStyles);
+  SetLength(FStyles,l+1);
+  FStyles[l]:= sr;
+  result:= l;
+end;
+procedure TSVGStyle.Remove(sr: TSVGStyleItem);
+var
+  l,p: integer;
+begin
+  p:= Find(sr);
+  l:= Length(FStyles);
+  if p <> -1 then
+  begin
+    Finalize(FStyles[p]);
+    System.Move(FStyles[p+1], FStyles[p], (l-p)*SizeOf(TSVGStyleItem));
+    SetLength(FStyles,l-1);
+  end;
+end;
+procedure TSVGStyle.Clear;
+begin
+  SetLength(FStyles,0);
+end;
+procedure TSVGStyle.ReParse;
+begin
+ Parse(FDomElem.TextContent);
+end;
 { TSVGRectangle }
 …
 constructor TSVGRectangle.Create(ADocument: TXMLDocument;
+  AUnits: TCSSUnitConverter);
+begin
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
   Init(ADocument,'rect',AUnits);
 end;
 procedure TSVGRectangle.InternalDraw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit);
+var
+  vx,vy,vw,vh: Single;
 begin
   if not isStrokeNone or not isFillNone then
   begin
+    vx:= Units.ConvertWidth(x,AUnit).value;
+    vy:= Units.ConvertHeight(y,AUnit).value;
+    vw:= Units.ConvertWidth(width,AUnit).value;
+    vh:= Units.ConvertHeight(height,AUnit).value;
     ACanvas2d.beginPath;
+    ACanvas2d.roundRect(Units.ConvertWidth(x,AUnit).value,Units.ConvertWidth(y,AUnit).value,
+       Units.ConvertWidth(width,AUnit).value,Units.ConvertWidth(height,AUnit).value,
+       Units.ConvertWidth(rx,AUnit).value,Units.ConvertWidth(ry,AUnit).value);
+    ACanvas2d.roundRect(vx,vy, vw,vh,
+       Units.ConvertWidth(rx,AUnit).value,Units.ConvertHeight(ry,AUnit).value);
+    if Assigned(GradientElement) then
+      InitializeGradient(ACanvas2d, PointF(vx,vy),vw,vh,AUnit);
     if not isFillNone then
     begin
       ACanvas2d.fillStyle(fillColor);
+      ApplyFillStyle(ACanvas2D,AUnit);
       ACanvas2d.fill;
     end;
 …
 begin
   result := FDomElem.TagName = 'polygon';
+end;
+function TSVGPolypoints.GetBoundingBoxF: TRectF;
+begin
+  if not FBoundingBoxComputed then
+    ComputeBoundingBox(pointsF);
+  result := FBoundingBox;
 end;
 …
     result[i].y := parser.ParseFloat;
   end;
+  parser.Free;
 end;
 …
   end;
   points := s;
+  ComputeBoundingBox(AValue);
+end;
+procedure TSVGPolypoints.ComputeBoundingBox(APoints: ArrayOfTPointF);
+var
+  i: Integer;
+begin
+  if length(APoints) > 1 then
+  begin
+    with APoints[0] do
+      FBoundingBox:= RectF(x,y,x,y);
+    for i:= 1 to high(APoints) do
+      with APoints[i] do
+      begin
+        if x < FBoundingBox.Left then
+         FBoundingBox.Left:= x
+        else if x > FBoundingBox.Right then
+         FBoundingBox.Right:= x;
+        if y < FBoundingBox.Top then
+         FBoundingBox.Top:= y
+        else if y > FBoundingBox.Bottom then
+         FBoundingBox.Bottom:= y;
+      end;
+    FBoundingBoxComputed := true;
+  end else
+  begin
+    FBoundingBox := RectF(0,0,0,0);
+    FBoundingBoxComputed := true;
+  end;
 end;
 constructor TSVGPolypoints.Create(ADocument: TXMLDocument;
+  AUnits: TCSSUnitConverter; AClosed: boolean);
+begin
+  AUnits: TCSSUnitConverter; AClosed: boolean; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
   if AClosed then
     Init(ADocument, 'polygon', AUnits)
 …
 var
   prevMatrix: TAffineMatrix;
+  pts: ArrayOfTPointF;
 begin
   if isFillNone and isStrokeNone then exit;
 …
   begin
     ACanvas2d.beginPath;
+    ACanvas2d.polylineTo(pointsF);
+    pts := pointsF;
+    ACanvas2d.polylineTo(pts);
     if closed then ACanvas2d.closePath;
+    with boundingBoxF do
+      InitializeGradient(ACanvas2d,
+        PointF(Left,Top),abs(Right-Left),abs(Bottom-Top),AUnit);
     if not isFillNone then
     begin
       ACanvas2d.fillStyle(fillColor);
+      ApplyFillStyle(ACanvas2D,AUnit);
       ACanvas2d.fill;
     end;
 …
 end;
+function TSVGPath.GetBoundingBoxF: TRectF;
+begin
+  if not FBoundingBoxComputed then
+  begin
+    FBoundingBox := path.GetBounds;
+    FBoundingBoxComputed := true;
+  end;
+  result := FBoundingBox;
+end;
 function TSVGPath.GetData: string;
 begin
 …
   else
     FPath.SvgString := AValue;
+  FBoundingBoxComputed := false;
 end;
 …
 end;
+constructor TSVGPath.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter);
+begin
+constructor TSVGPath.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
   Init(ADocument,'path',AUnits);
   FPath := nil;
+  FBoundingBoxComputed := false;
+  FBoundingBox := rectF(0,0,0,0);
 end;
 constructor TSVGPath.Create(ADocument: TXMLDocument; AElement: TDOMElement;
+  AUnits: TCSSUnitConverter);
+begin
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AElement, AUnits, ADataLink);
   Init(ADocument, AElement, AUnits);
   FPath := nil;
+  FBoundingBoxComputed := false;
+  FBoundingBox := rectF(0,0,0,0);
 end;
 …
   begin
     ACanvas2d.path(path);
+    if Assigned(GradientElement) then
+      with boundingBoxF do
+        InitializeGradient(ACanvas2d,
+          PointF(Left,Top),abs(Right-Left),abs(Bottom-Top),AUnit);
     if not isFillNone then
     begin
       ACanvas2d.fillStyle(fillColor);
+      ApplyFillStyle(ACanvas2D,AUnit);
       ACanvas2d.fill;
     end;
 …
 constructor TSVGEllipse.Create(ADocument: TXMLDocument;
+  AUnits: TCSSUnitConverter);
+begin
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
   Init(ADocument,'ellipse',AUnits);
 end;
 procedure TSVGEllipse.InternalDraw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit);
+var
+  vcx,vcy,vrx,vry: Single;
 begin
   if not isFillNone or not isStrokeNone then
   begin
+    vcx:= Units.ConvertWidth(cx,AUnit).value;
+    vcy:= Units.ConvertHeight(cy,AUnit).value;
+    vrx:= Units.ConvertWidth(rx,AUnit).value;
+    vry:= Units.ConvertHeight(ry,AUnit).value;
     ACanvas2d.beginPath;
+    ACanvas2d.ellipse(Units.ConvertWidth(cx,AUnit).value,Units.ConvertWidth(cy,AUnit).value,
+         Units.ConvertWidth(rx,AUnit).value,Units.ConvertWidth(ry,AUnit).value);
+    ACanvas2d.ellipse(vcx,vcy,vrx,vry);
+    if Assigned(GradientElement) then
+      InitializeGradient(ACanvas2d, PointF(vcx-vrx,vcy-vry),vrx*2,vry*2,AUnit);
     if not isFillNone then
     begin
       ACanvas2d.fillStyle(fillColor);
+      ApplyFillStyle(ACanvas2D,AUnit);
       ACanvas2d.fill;
     end;
 …
 end;
+constructor TSVGCircle.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter);
+begin
+constructor TSVGCircle.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
   Init(ADocument,'circle',AUnits);
 end;
 procedure TSVGCircle.InternalDraw(ACanvas2d: TBGRACanvas2D; AUnit: TCSSUnit);
+var
+  vcx,vcy,vr: Single;
 begin
   if not isFillNone or not isStrokeNone then
   begin
+    vcx:= Units.ConvertWidth(cx,AUnit).value;
+    vcy:= Units.ConvertHeight(cy,AUnit).value;
+    vr:= Units.ConvertWidth(r,AUnit).value;
     ACanvas2d.beginPath;
+    ACanvas2d.circle(Units.ConvertWidth(cx,AUnit).value,Units.ConvertWidth(cy,AUnit).value,
+         Units.ConvertWidth(r,AUnit).value);
+    ACanvas2d.circle(vcx,vcy,vr);
+    if Assigned(GradientElement) then
+      InitializeGradient(ACanvas2d, PointF(vcx-vr,vcy-vr),vr*2,vr*2,AUnit);
     if not isFillNone then
     begin
       ACanvas2d.fillStyle(fillColor);
+      ApplyFillStyle(ACanvas2D,AUnit);
       ACanvas2d.fill;
     end;
 …
 end;
+constructor TSVGLine.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter);
+begin
+constructor TSVGLine.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
   Init(ADocument,'line',AUnits);
 end;
 …
     ApplyStrokeStyle(ACanvas2D,AUnit);
     ACanvas2d.beginPath;
     ACanvas2d.moveTo(Units.ConvertWidth(x1,AUnit).value,Units.ConvertWidth(y1,AUnit).value);
     ACanvas2d.lineTo(Units.ConvertWidth(x2,AUnit).value,Units.ConvertWidth(y2,AUnit).value);
+    ACanvas2d.moveTo(Units.ConvertWidth(x1,AUnit).value,Units.ConvertHeight(y1,AUnit).value);
+    ACanvas2d.lineTo(Units.ConvertWidth(x2,AUnit).value,Units.ConvertHeight(y2,AUnit).value);
     ACanvas2d.stroke;
   end;
+end;
+{ TSVGGradient } //##
+function TSVGGradient.GetHRef: string;
+begin
+  result := Attribute['xlink:href'];
+  if result = '' then
+    result := Attribute['href'];//(Note: specific for svg 2)
+end;
+function TSVGGradient.GetUseObjectBoundingBox: boolean;
+begin
+  result := (gradientUnits = 'objectBoundingBox');
+end;
+procedure TSVGGradient.SetGradientTransform(AValue: string);
+begin
+  Attribute['gradientTransform'] := AValue;
+end;
+function TSVGGradient.GetGradientUnits: string;
+begin
+  result := AttributeDef['gradientUnits','objectBoundingBox'];
+end;
+function TSVGGradient.GetGradientTransform: string;
+begin
+  result := Attribute['gradientTransform'];
+end;
+function TSVGGradient.GetGradientMatrix(AUnit: TCSSUnit): TAffineMatrix;
+var parser: TSVGParser;
+  s: string;
+begin
+  s := gradientTransform;
+  if s = '' then
+  begin
+    result := AffineMatrixIdentity;
+    exit;
+  end;
+  parser := TSVGParser.Create(s);
+  result := parser.ParseTransform;
+  parser.Free;
+  result[1,3] := Units.ConvertWidth(result[1,3],cuCustom,AUnit);
+  result[2,3] := Units.ConvertHeight(result[2,3],cuCustom,AUnit);
+end;
+procedure TSVGGradient.SetGradientUnits(AValue: string);
+begin
+  Attribute['gradientUnits'] := AValue;
+end;
+procedure TSVGGradient.SetHRef(AValue: string);
+begin
+  Attribute['xlink:href'] := AValue;
+end;
+constructor TSVGGradient.Create(ADocument: TXMLDocument;
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
+  FContent := TSVGContent.Create(ADocument,FDomElem,AUnits,ADataLink,Self);
+end;
+function TSVGGradient.HRefToGradientID(const AValue: string): string;
+var
+  l: integer;
+begin
+  //(example input: "#gradient1")
+  l:= Length(AValue);
+  if l < 2 then
+    result:= ''
+  else
+    result:= System.Copy(AValue,2,l-1);
+end;
+function TSVGGradient.FindGradientRef(const AGradientID: string): integer;
+var
+  i: integer;
+begin
+  with FDataLink do
+    for i:= 0 to GradientCount-1 do
+      if (Gradients[i] as TSVGGradient).ID = AGradientID then
+      begin
+        result:= i;
+        exit;
+      end;
+  result:= -1;
+end;
+procedure TSVGGradient.Initialize;
+begin
+  inherited;
+  InheritedGradients:= TSVGElementList.Create;
+end;
+function TSVGGradient.GetInheritedAttribute(AValue: string;
+  AConvMethod: TConvMethod; ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
+var
+  i: integer;
+  el: TSVGGradient;
+  invalidDef: TFloatWithCSSUnit;
+begin
+  invalidDef:= FloatWithCSSUnit(EmptySingle,cuPercent);
+  //find valid inherited attribute (start from "self": item[0])
+  for i:= 0 to InheritedGradients.Count-1 do
+  begin
+    el:= TSVGGradient( InheritedGradients[i] );
+    with el do
+    begin
+      if AConvMethod = cmHoriz then
+        result:= HorizAttributeWithUnitDef[AValue,invalidDef]
+      else if AConvMethod = cmVertical then
+        result:= VerticalAttributeWithUnitDef[AValue,invalidDef]
+      else if AConvMethod = cmOrtho then
+        result:= OrthoAttributeWithUnitDef[AValue,invalidDef]
+      else
+        result:= AttributeWithUnitDef[AValue,invalidDef];
+      if (result.value <> invalidDef.value) or
+         (result.CSSUnit <> invalidDef.CSSUnit) then
+        exit;
+    end;
+  end;
+  result:= ADefault;
+end;
+constructor TSVGGradient.Create(ADocument: TXMLDocument; AElement: TDOMElement;
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AElement, AUnits, ADataLink);
+  FContent := TSVGContent.Create(ADocument,AElement,AUnits,ADataLink,Self);
+end;
+destructor TSVGGradient.Destroy;
+begin
+  FreeAndNil(FContent);
+  FreeAndNil(InheritedGradients);
+  inherited Destroy;
+end;
+procedure TSVGGradient.Recompute;
+begin
+  inherited Recompute;
+  FContent.Recompute;
+end;
+procedure TSVGGradient.ScanInheritedGradients(const forceScan: boolean = false);
+var
+  el: TSVGGradient;
+  pos: integer;
+  gradientID: string;
+begin
+  //(if list empty = not scan)
+  if (InheritedGradients.Count <> 0) and (not forceScan) then
+    exit;
+  InheritedGradients.Clear;
+  InheritedGradients.Add(Self);//(important)
+  el:= Self;
+  while el.hRef <> '' do
+  begin
+    gradientID:= HRefToGradientID(el.hRef);
+    pos:= FindGradientRef(gradientID);
+    if pos = -1 then
+      exit
+    else
+    begin
+      el:= TSVGGradient(FDataLink.Gradients[pos]);
+      InheritedGradients.Add(el);
+    end;
+  end;
+end;
+{ TSVGLinearGradient }
+function TSVGLinearGradient.GetX1: TFloatWithCSSUnit;
+begin
+  result := GetInheritedAttribute('x1',cmNone,FloatWithCSSUnit(0,cuPercent));
+end;
+function TSVGLinearGradient.GetX2: TFloatWithCSSUnit;
+begin
+  result := GetInheritedAttribute('x2',cmNone,FloatWithCSSUnit(100,cuPercent));
+end;
+function TSVGLinearGradient.GetY1: TFloatWithCSSUnit;
+begin
+  result := GetInheritedAttribute('y1',cmNone,FloatWithCSSUnit(0,cuPercent));
+end;
+function TSVGLinearGradient.GetY2: TFloatWithCSSUnit;
+begin
+  result := GetInheritedAttribute('y2',cmNone,FloatWithCSSUnit(0,cuPercent));
+end;
+procedure TSVGLinearGradient.SetX1(AValue: TFloatWithCSSUnit);
+begin
+  AttributeWithUnit['x1']:= AValue;
+end;
+procedure TSVGLinearGradient.SetX2(AValue: TFloatWithCSSUnit);
+begin
+  AttributeWithUnit['x2']:= AValue;
+end;
+procedure TSVGLinearGradient.SetY1(AValue: TFloatWithCSSUnit);
+begin
+  AttributeWithUnit['y1']:= AValue;
+end;
+procedure TSVGLinearGradient.SetY2(AValue: TFloatWithCSSUnit);
+begin
+  AttributeWithUnit['y2']:= AValue;
+end;
+constructor TSVGLinearGradient.Create(ADocument: TXMLDocument;
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
+  Init(ADocument,'linearGradient',AUnits);
+end;
+{ TSVGRadialGradient }
+function TSVGRadialGradient.GetCX: TFloatWithCSSUnit;
+begin
+  result := GetInheritedAttribute('cx',cmHoriz,FloatWithCSSUnit(50,cuPercent));
+end;
+function TSVGRadialGradient.GetCY: TFloatWithCSSUnit;
+begin
+  result := GetInheritedAttribute('cy',cmVertical,FloatWithCSSUnit(50,cuPercent));
+end;
+function TSVGRadialGradient.GetR: TFloatWithCSSUnit;
+begin
+  result := GetInheritedAttribute('r',cmOrtho,FloatWithCSSUnit(50,cuPercent));
+end;
+function TSVGRadialGradient.GetFX: TFloatWithCSSUnit;
+begin
+  result := GetInheritedAttribute('fx',cmHoriz,cx);
+end;
+function TSVGRadialGradient.GetFY: TFloatWithCSSUnit;
+begin
+  result := GetInheritedAttribute('fy',cmVertical,cy);
+end;
+function TSVGRadialGradient.GetFR: TFloatWithCSSUnit;
+begin
+  result := GetInheritedAttribute('fr',cmHoriz,FloatWithCSSUnit(0,cuPercent));
+end;
+procedure TSVGRadialGradient.SetCX(AValue: TFloatWithCSSUnit);
+begin
+  HorizAttributeWithUnit['cx'] := AValue;
+end;
+procedure TSVGRadialGradient.SetCY(AValue: TFloatWithCSSUnit);
+begin
+  VerticalAttributeWithUnit['cy'] := AValue;
+end;
+procedure TSVGRadialGradient.SetR(AValue: TFloatWithCSSUnit);
+begin
+  OrthoAttributeWithUnit['r'] := AValue;
+end;
+procedure TSVGRadialGradient.SetFX(AValue: TFloatWithCSSUnit);
+begin
+  HorizAttributeWithUnit['fx'] := AValue;
+end;
+procedure TSVGRadialGradient.SetFY(AValue: TFloatWithCSSUnit);
+begin
+  VerticalAttributeWithUnit['fy'] := AValue;
+end;
+procedure TSVGRadialGradient.SetFR(AValue: TFloatWithCSSUnit);
+begin
+  HorizAttributeWithUnit['fr'] := AValue;
+end;
+constructor TSVGRadialGradient.Create(ADocument: TXMLDocument;
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
+  Init(ADocument,'radialGradient',AUnits);
+end;
+{ TSVGStopGradient }
+function TSVGStopGradient.GetOffset: TFloatWithCSSUnit;
+begin
+  result := AttributeWithUnit['offset'];
+end;
+procedure TSVGStopGradient.SetOffset(AValue: TFloatWithCSSUnit);
+begin
+  AttributeWithUnit['offset'] := AValue;
+end;
+constructor TSVGStopGradient.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter;
+  ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
+  Init(ADocument,'stop',AUnits);
+end;
+{ TSVGDefine }
+constructor TSVGDefine.Create(ADocument: TXMLDocument; AUnits: TCSSUnitConverter;
+  ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AUnits, ADataLink);
+  FContent := TSVGContent.Create(ADocument,FDomElem,AUnits,ADataLink,Self);
+end;
+constructor TSVGDefine.Create(ADocument: TXMLDocument; AElement: TDOMElement;
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  inherited Create(ADocument, AElement, AUnits, ADataLink);
+  FContent := TSVGContent.Create(ADocument,AElement,AUnits,ADataLink,Self);
+end;
+destructor TSVGDefine.Destroy;
+begin
+  FreeAndNil(FContent);
+  inherited Destroy;
+end;
+procedure TSVGDefine.Recompute;
+begin
+  inherited Recompute;
+  FContent.Recompute;
 end;
 …
 constructor TSVGContent.Create(ADocument: TXMLDocument; AElement: TDOMElement;
   AUnits: TCSSUnitConverter);
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink; ADataParent: TSVGElement);
 var cur: TDOMNode;
 begin
   FDoc := ADocument;
   FDomElem := AElement;
+  FElements := TList.Create;
+  FDataLink := ADataLink;
+  FElements := TFPList.Create;
   FUnits := AUnits;
   cur := FDomElem.FirstChild;
 …
   begin
     if cur is TDOMElement then
+      FElements.Add(CreateSVGElementFromNode(ADocument,TDOMElement(cur),FUnits));
+      FElements.Add(CreateSVGElementFromNode(
+        ADocument,TDOMElement(cur),FUnits,ADataLink,ADataParent));
     cur := cur.NextSibling;
   end;
 …
   FreeAndNil(FElements);
   inherited Destroy;
+end;
+procedure TSVGContent.Recompute;
+var
+  i: Integer;
+begin
+  for i := 0 to ElementCount-1 do
+    Element[i].Recompute;
 end;
 …
   ): TSVGLine;
 begin
   result := TSVGLine.Create(FDoc,Units);
+  result := TSVGLine.Create(FDoc,Units,FDataLink);
   result.x1 := FloatWithCSSUnit(x1,AUnit);
   result.y1 := FloatWithCSSUnit(y1,AUnit);
 …
   if (AUnit <> cuCustom) and (Units.DpiScaleX <> Units.DpiScaleY) then
   begin
     result := TSVGCircle.Create(FDoc,Units);
+    result := TSVGCircle.Create(FDoc,Units,FDataLink);
     result.cx := FloatWithCSSUnit(Units.Convert(cx,AUnit,cuCustom,Units.DpiX),cuCustom);
     result.cy := FloatWithCSSUnit(Units.Convert(cy,AUnit,cuCustom,Units.DpiY),cuCustom);
 …
   end else
   begin
     result := TSVGCircle.Create(FDoc,Units);
+    result := TSVGCircle.Create(FDoc,Units,FDataLink);
     result.cx := FloatWithCSSUnit(cx,AUnit);
     result.cy := FloatWithCSSUnit(cy,AUnit);
 …
   ): TSVGEllipse;
 begin
   result := TSVGEllipse.Create(FDoc,Units);
+  result := TSVGEllipse.Create(FDoc,Units,FDataLink);
   result.cx := FloatWithCSSUnit(cx,AUnit);
   result.cy := FloatWithCSSUnit(cy,AUnit);
 …
   end else
   begin
     result := TSVGPath.Create(FDoc,Units);
+    result := TSVGPath.Create(FDoc,Units,FDataLink);
     result.d := data;
     AppendElement(result);
 …
   if (AUnit <> cuCustom) and (Units.DpiScaleX <> Units.DpiScaleY) then
   begin
     result := TSVGPath.Create(FDoc,Units);
+    result := TSVGPath.Create(FDoc,Units,FDataLink);
     result.path.scale(Units.Convert(1,AUnit,cuCustom,Units.DpiX));
     path.copyTo(result.path);
 …
   end else
   begin
     result := TSVGPath.Create(FDoc,Units);
+    result := TSVGPath.Create(FDoc,Units,FDataLink);
     result.path.scale(Units.ConvertWidth(1,AUnit,cuCustom));
     path.copyTo(result.path);
 …
   i: integer;
 begin
   result := TSVGPolypoints.Create(FDoc,FUnits,true);
+  result := TSVGPolypoints.Create(FDoc,FUnits,true,FDataLink);
   setlength(pts, length(points) div 2);
   for i := 0 to high(pts) do
 …
   i: integer;
 begin
   result := TSVGPolypoints.Create(FDoc,FUnits,true);
+  result := TSVGPolypoints.Create(FDoc,FUnits,true,FDataLink);
   setlength(pts, length(points));
   for i := 0 to high(pts) do
 …
   ): TSVGRectangle;
 begin
   result := TSVGRectangle.Create(FDoc,Units);
+  result := TSVGRectangle.Create(FDoc,Units,FDataLink);
   result.x := FloatWithCSSUnit(x,AUnit);
   result.y := FloatWithCSSUnit(y,AUnit);
 …
   ): TSVGText;
 begin
   result := TSVGText.Create(FDoc,Units);
+  result := TSVGText.Create(FDoc,Units,FDataLink);
   result.x := FloatWithCSSUnit(x,AUnit);
   result.y := FloatWithCSSUnit(y,AUnit);
 …
   AUnit: TCSSUnit): TSVGRectangle;
 begin
   result := TSVGRectangle.Create(FDoc,Units);
+  result := TSVGRectangle.Create(FDoc,Units,FDataLink);
   result.x := FloatWithCSSUnit(x,AUnit);
   result.y := FloatWithCSSUnit(y,AUnit);

GraphicTest/Packages/bgrabitmap/bgrasvgtype.pas

-              r494
+              r521
 {$mode objfpc}{$H+}
+{$MODESWITCH ADVANCEDRECORDS}
 interface
 …
 uses
   Classes, SysUtils, BGRATransform, BGRABitmapTypes, BGRAUnits,
   laz2_DOM, BGRACanvas2D;
+  laz2_DOM, BGRACanvas2D, fgl, BGRAGraphics;
 type
+  ArrayOfFloat = array of single;
   TSVGElement = class;
+  TSVGElementList = specialize TFPGList<TSVGElement>;
   TSVGFactory = class of TSVGElement;
+  TSVGFillMode = (
+     sfmEvenOdd = Ord(fmAlternate),
+     sfmNonZero = Ord(fmWinding)
+   );
+  TFindStyleState = (fssNotSearch,
+                     fssNotFind,
+                     fssFind);
+  TStyleAttribute = record
+     attr  : string;
+     pos   : integer;
+  end;
+  ArrayOfTStyleAttribute = array of TStyleAttribute;
+  { TSVGPreserveAspectRatio }
+  TSVGPreserveAspectRatio = record
+     Preserve, Slice: boolean;
+     HorizAlign: TAlignment;
+     VertAlign: TTextLayout;
+     function ToString: string;
+     class function Parse(AValue: string): TSVGPreserveAspectRatio; static;
+     class function DefaultValue: TSVGPreserveAspectRatio; static;
+  end;
+  TSVGRecomputeEvent = procedure(Sender: TObject) of object;
+  { TSVGDataLink }
+  TSVGDataLink = class
+   private
+     FElements,
+     FGradients,
+     FStyles,
+     FRootElements: TSVGElementList;
+     function IsValidID(const id: integer; list: TSVGElementList): boolean;
+     function GetElement(id: integer): TSVGElement;
+     function GetGradient(id: integer): TSVGElement;
+     function GetStyle(id: integer): TSVGElement;
+     function GetRootElement(id: integer): TSVGElement;
+     function FindElement(el: TSVGElement; list: TSVGElementList): integer;
+     function Find(el: TSVGElement): integer;//(find on FElements)
+     procedure InternalLink(const id: integer; parent: TSVGElement);
+     procedure InternalUnLink(const id: integer);
+     procedure InternalReLink(const id: integer; parent: TSVGElement);
+   public
+     constructor Create;
+     destructor Destroy; override;
+     function ElementCount: integer;
+     function GradientCount: integer;
+     function StyleCount: integer;
+     //contains the elements at the root of the link tree (having parent = nil)
+     function RootElementCount: integer;
+     function IsLink(el: TSVGElement): boolean;
+     //(Note: assumes that the valid parent is present in the list or added later)
+     function Link(el: TSVGElement; parent: TSVGElement = nil): integer;
+     //excludes el from the list (+ restores validity of links)
+     procedure Unlink(el: TSVGElement);
+     //(faster method than a "for.. Unlink()")
+     procedure UnlinkAll;
+     //Method needed to change the parent of an item without removing it
+     function ReLink(el: TSVGElement; parent: TSVGElement): boolean;
+     //(useful for testing support)
+     function GetInternalState: TStringList;
+     property Elements[ID: integer]: TSVGElement read GetElement;
+     property Gradients[ID: integer]: TSVGElement read GetGradient;
+     property Styles[ID: integer]: TSVGElement read GetStyle;
+     property RootElements[ID: integer]: TSVGElement read GetRootElement;
+  end;
   { TSVGElement }
 …
   TSVGElement = class
     private
+      function GetAttributeOrStyle(AName: string): string;
+      findStyleState: TFindStyleState;
+      styleAttributes: ArrayOfTStyleAttribute;
+      FDataParent: TSVGElement;
+      FDataChildList: TSVGElementList;
+      function GetAttributeOrStyle(AName,ADefault: string): string; overload;
+      function GetAttributeOrStyle(AName: string): string; overload;
       function GetFill: string;
       function GetFillColor: TBGRAPixel;
       function GetFillOpacity: single;
+      function GetHorizAttributeOrStyleWithUnit(AName: string
+        ): TFloatWithCSSUnit;
+      function GetFillRule: string;
+      function GetHorizAttributeOrStyleWithUnit(AName: string;
+        ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
       function GetIsFillNone: boolean;
       function GetIsStrokeNone: boolean;
       function GetMatrix(AUnit: TCSSUnit): TAffineMatrix;
       function GetOpacity: single;
       function GetOrthoAttributeOrStyleWithUnit(AName: string
         ): TFloatWithCSSUnit;
+      function GetOrthoAttributeOrStyleWithUnit(AName: string;
+        ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
       function GetStroke: string;
       function GetStrokeColor: TBGRAPixel;
 …
       function GetStrokeOpacity: single;
       function GetStrokeWidth: TFloatWithCSSUnit;
+      function GetStyle(const AName: string): string;
+      function GetStrokeDashArray: string;
+      function GetStrokeDashArrayF: ArrayOfFloat;
+      function GetStrokeDashOffset: TFloatWithCSSUnit;
+      function GetStyle(const AName,ADefault: string): string; overload;
+      function GetStyle(const AName: string): string; overload;
       function GetTransform: string;
       function GetUnits: TCSSUnitConverter;
+      function GetAttribute(AName: string): string;
+      function GetVerticalAttributeOrStyleWithUnit(AName: string
+        ): TFloatWithCSSUnit;
+      function GetAttribute(AName,ADefault: string; ACanInherit: boolean): string; overload;
+      function GetAttribute(AName,ADefault: string): string; overload;
+      function GetAttribute(AName: string): string; overload;
+      function GetVerticalAttributeOrStyleWithUnit(AName: string;
+        ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
       procedure SetAttribute(AName: string; AValue: string);
+      function GetAttributeWithUnit(AName: string): TFloatWithCSSUnit;
+      function GetAttributeOrStyleWithUnit(AName: string): TFloatWithCSSUnit;
+      function GetOrthoAttributeWithUnit(AName: string): TFloatWithCSSUnit;
+      function GetHorizAttributeWithUnit(AName: string): TFloatWithCSSUnit;
+      function GetVerticalAttributeWithUnit(AName: string): TFloatWithCSSUnit;
+      function GetAttributeWithUnit(AName: string; ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit; overload;
+      function GetAttributeWithUnit(AName: string): TFloatWithCSSUnit; overload;
+      function GetAttributeOrStyleWithUnit(AName: string;
+        ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit; overload;
+      function GetAttributeOrStyleWithUnit(AName: string): TFloatWithCSSUnit; overload;
+      function GetOrthoAttributeWithUnit(AName: string; ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit; overload;
+      function GetOrthoAttributeWithUnit(AName: string): TFloatWithCSSUnit; overload;
+      function GetHorizAttributeWithUnit(AName: string; ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit; overload;
+      function GetHorizAttributeWithUnit(AName: string): TFloatWithCSSUnit; overload;
+      function GetVerticalAttributeWithUnit(AName: string; ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit; overload;
+      function GetVerticalAttributeWithUnit(AName: string): TFloatWithCSSUnit; overload;
+      function GetID: string;
+      function GetClassAt: string;
       procedure SetAttributeWithUnit(AName: string; AValue: TFloatWithCSSUnit);
       procedure SetFill(AValue: string);
       procedure SetFillColor(AValue: TBGRAPixel);
       procedure SetFillOpacity(AValue: single);
+      procedure SetFillRule(AValue: string);
       procedure SetHorizAttributeWithUnit(AName: string; AValue: TFloatWithCSSUnit);
       procedure SetMatrix(AUnit: TCSSUnit; const AValue: TAffineMatrix);
 …
       procedure SetStrokeOpacity(AValue: single);
       procedure SetStrokeWidth(AValue: TFloatWithCSSUnit);
+      procedure SetStrokeDashArray(AValue: string);
+      procedure SetStrokeDashArrayF(AValue: ArrayOfFloat);
+      procedure SetStrokeDashOffset(AValue: TFloatWithCSSUnit);
       procedure SetStyle(AName: string; AValue: string);
       procedure SetTransform(AValue: string);
       procedure SetVerticalAttributeWithUnit(AName: string; AValue: TFloatWithCSSUnit);
       procedure SetOrthoAttributeWithUnit(AName: string; AValue: TFloatWithCSSUnit);
+      procedure SetID(AValue: string);
+      procedure SetClassAt(AValue: string);
+      function FindStyleElementInternal(const classStr: string;
+        out attributesStr: string): integer;
+      procedure FindStyleElement;
     protected
+      FDataLink: TSVGDataLink;
       FDomElem: TDOMElement;
       FUnits: TCSSUnitConverter;
 …
       procedure InternalDraw({%H-}ACanvas2d: TBGRACanvas2D; {%H-}AUnit: TCSSUnit); virtual;
       procedure LocateStyleDeclaration(AText: string; AProperty: string; out AStartPos,AColonPos,AValueLength: integer);
+      procedure ApplyFillStyle(ACanvas2D: TBGRACanvas2D; {%H-}AUnit: TCSSUnit); virtual;
       procedure ApplyStrokeStyle(ACanvas2D: TBGRACanvas2D; AUnit: TCSSUnit);
+      procedure Initialize; virtual;
     public
+      constructor Create({%H-}ADocument: TXMLDocument; AElement: TDOMElement; AUnits: TCSSUnitConverter); virtual;
+      constructor Create({%H-}ADocument: TXMLDocument; {%H-}AUnits: TCSSUnitConverter); virtual;
+      constructor Create({%H-}ADocument: TXMLDocument; AElement: TDOMElement; AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); overload; virtual;
+      constructor Create({%H-}ADocument: TXMLDocument; {%H-}AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink); overload; virtual;
+      destructor Destroy; override;
+      procedure Recompute; virtual;
       procedure Draw({%H-}ACanvas2d: TBGRACanvas2D; {%H-}AUnit: TCSSUnit);
       procedure fillNone;
 …
       procedure transformNone;
       procedure RemoveStyle(const AName: string);
+      function HasAttribute(AName: string): boolean;
+      function fillMode: TSVGFillMode;
+      function DataChildList: TSVGElementList;
+      property DataLink: TSVGDataLink read FDataLink write FDataLink;
+      property AttributeDef[AName,ADefault: string]: string read GetAttribute;
       property Attribute[AName: string]: string read GetAttribute write SetAttribute;
+      property AttributeOrStyleDef[AName,ADefault: string]: string read GetAttributeOrStyle;
       property AttributeOrStyle[AName: string]: string read GetAttributeOrStyle;
+      property StyleDef[AName,ADefault: string]: string read GetStyle;
       property Style[AName: string]: string read GetStyle write SetStyle;
+      property AttributeWithUnitDef[AName: string; ADefault: TFloatWithCSSUnit]: TFloatWithCSSUnit read GetAttributeWithUnit;
+      property AttributeWithUnit[AName: string]: TFloatWithCSSUnit read GetAttributeWithUnit write SetAttributeWithUnit;
+      property OrthoAttributeWithUnitDef[AName: string; ADefault: TFloatWithCSSUnit]: TFloatWithCSSUnit read GetOrthoAttributeWithUnit;
       property OrthoAttributeWithUnit[AName: string]: TFloatWithCSSUnit read GetOrthoAttributeWithUnit write SetOrthoAttributeWithUnit;
+      property HorizAttributeWithUnitDef[AName: string; ADefault: TFloatWithCSSUnit]: TFloatWithCSSUnit read GetHorizAttributeWithUnit;
       property HorizAttributeWithUnit[AName: string]: TFloatWithCSSUnit read GetHorizAttributeWithUnit write SetHorizAttributeWithUnit;
+      property VerticalAttributeWithUnitDef[AName: string; ADefault: TFloatWithCSSUnit]: TFloatWithCSSUnit read GetVerticalAttributeWithUnit;
       property VerticalAttributeWithUnit[AName: string]: TFloatWithCSSUnit read GetVerticalAttributeWithUnit write SetVerticalAttributeWithUnit;
       property OrthoAttributeOrStyleWithUnit[AName: string]: TFloatWithCSSUnit read GetOrthoAttributeOrStyleWithUnit;
       property HorizAttributeOrStyleWithUnit[AName: string]: TFloatWithCSSUnit read GetHorizAttributeOrStyleWithUnit;
       property VerticalAttributeOrStyleWithUnit[AName: string]: TFloatWithCSSUnit read GetVerticalAttributeOrStyleWithUnit;
+      property OrthoAttributeOrStyleWithUnit[AName: string; ADefault: TFloatWithCSSUnit]: TFloatWithCSSUnit read GetOrthoAttributeOrStyleWithUnit;
+      property HorizAttributeOrStyleWithUnit[AName: string; ADefault: TFloatWithCSSUnit]: TFloatWithCSSUnit read GetHorizAttributeOrStyleWithUnit;
+      property VerticalAttributeOrStyleWithUnit[AName: string; ADefault: TFloatWithCSSUnit]: TFloatWithCSSUnit read GetVerticalAttributeOrStyleWithUnit;
       property DOMElement: TDOMElement read GetDOMElement;
       property Units: TCSSUnitConverter read GetUnits;
 …
       property strokeLineJoin: string read GetStrokeLineJoin write SetStrokeLineJoin;
       property strokeLineCap: string read GetStrokeLineCap write SetStrokeLineCap;
+      property strokeDashArray: string read GetStrokeDashArray write SetStrokeDashArray;
+      property strokeDashArrayF: ArrayOfFloat read GetStrokeDashArrayF write SetStrokeDashArrayF;
+      property strokeDashOffset: TFloatWithCSSUnit read GetStrokeDashOffset write SetStrokeDashOffset;
       property fill: string read GetFill write SetFill;
       property fillColor: TBGRAPixel read GetFillColor write SetFillColor;
       property fillOpacity: single read GetFillOpacity write SetFillOpacity;
+      property fillRule: string read GetFillRule write SetFillRule;
       property opacity: single read GetOpacity write SetOpacity;
+      property ID: string read GetID write SetID;
+      property classAt: string read GetClassAt write SetClassAt;//Attribute "class"
+      property DataParent: TSVGElement read FDataParent write FDataParent;
   end;
 …
     function ParseId: string;
     function ParseSymbol: char;
+    function ParseTransform: TAffineMatrix;
     procedure SkipSymbol(ASymbol: char);
     procedure SkipUpToSymbol(ASymbol:char);
 …
     property Done: boolean read GetDone;
   end;
+  resourcestring
+    rsInvalidId = 'invalid id';
 implementation
+uses BGRASVGShapes;
+{ TSVGPreserveAspectRatio }
+function TSVGPreserveAspectRatio.ToString: string;
+begin
+  if not Preserve then result := 'none' else
+  begin
+    result := '';
+    case HorizAlign of
+    taCenter: result += 'xMid';
+    taRightJustify: result += 'xMax';
+    else result += 'xMin';
+    end;
+    case VertAlign of
+    tlCenter: result += 'YMid';
+    tlBottom: result += 'YMax';
+    else result += 'YMin';
+    end;
+    if Slice then result += ' slice' else result += ' meet';
+  end;
+end;
+class function TSVGPreserveAspectRatio.Parse(AValue: string
+  ): TSVGPreserveAspectRatio;
+var p: TSVGParser;
+  id: string;
+begin
+  p := TSVGParser.Create(AValue);
+  result := DefaultValue;
+  repeat
+    id := p.ParseId;
+    if id = 'none' then
+    begin
+      result.Preserve := false;
+      //set other parameters for intermediate value of ViewSize (before stretching non-proportionaly)
+      result.Slice := false;
+      result.HorizAlign := taCenter;
+      result.VertAlign := tlCenter;
+      exit;
+    end else
+    if id = 'slice' then result.Slice := true
+    else if (length(id)=8) and (id[1] = 'x') and (id[5] = 'Y') then
+    begin
+      case copy(id,2,3) of
+      'Min': result.HorizAlign := taLeftJustify;
+      'Mid': result.HorizAlign := taCenter;
+      'Max': result.HorizAlign := taRightJustify;
+      end;
+      case copy(id,6,3) of
+      'Min': result.VertAlign := tlTop;
+      'Mid': result.VertAlign := tlCenter;
+      'Max': result.VertAlign := tlBottom;
+      end;
+    end;
+  until id = '';
+  p.Free;
+end;
+class function TSVGPreserveAspectRatio.DefaultValue: TSVGPreserveAspectRatio;
+begin
+  result.Preserve := true;
+  result.Slice := false;
+  result.HorizAlign := taCenter;
+  result.VertAlign := tlCenter;
+end;
 { TSVGParser }
 …
 end;
+function TSVGParser.ParseTransform: TAffineMatrix;
+var
+  kind: String;
+  m : TAffineMatrix;
+  angle,tx,ty: single;
+begin
+  result := AffineMatrixIdentity;
+  while not Done do
+  begin
+    kind := ParseId;
+    if kind = '' then break;
+    if ParseSymbol <> '(' then break;
+    if compareText(kind,'matrix')=0 then
+    begin
+      m[1,1] := ParseFloat;
+      SkipSymbol(',');
+      m[2,1] := ParseFloat;
+      SkipSymbol(',');
+      m[1,2] := ParseFloat;
+      SkipSymbol(',');
+      m[2,2] := ParseFloat;
+      SkipSymbol(',');
+      m[1,3] := ParseFloat;
+      SkipSymbol(',');
+      m[2,3] := ParseFloat;
+      result *= m;
+    end else
+    if compareText(kind,'translate')=0 then
+    begin
+      tx := ParseFloat;
+      SkipSymbol(',');
+      ty := ParseFloat;
+      result *= AffineMatrixTranslation(tx,ty);
+    end else
+    if compareText(kind,'scale')=0 then
+    begin
+      tx := ParseFloat;
+      SkipSymbol(',');
+      ClearError;
+      ty := ParseFloat;
+      if NumberError then ty := tx;
+      result *= AffineMatrixScale(tx,ty);
+    end else
+    if compareText(kind,'rotate')=0 then
+    begin
+      angle := ParseFloat;
+      SkipSymbol(',');
+      tx := ParseFloat;
+      SkipSymbol(',');
+      ty := ParseFloat;
+      result *= AffineMatrixTranslation(tx,ty)*AffineMatrixRotationDeg(angle)*
+                AffineMatrixTranslation(-tx,-ty);
+    end else
+    if compareText(kind,'skewx')=0 then
+    begin
+      angle := ParseFloat;
+      result *= AffineMatrixSkewXDeg(angle);
+    end else
+    if compareText(kind,'skewy')=0 then
+    begin
+      angle := ParseFloat;
+      result *= AffineMatrixSkewYDeg(angle);
+    end;
+    SkipUpToSymbol(')');
+  end;
+end;
 procedure TSVGParser.SkipSymbol(ASymbol: char);
 begin
 …
 end;
+{ TSVGDataLink }
+constructor TSVGDataLink.Create;
+begin
+  FElements:= TSVGElementList.Create;
+  FGradients:= TSVGElementList.Create;
+  FStyles:= TSVGElementList.Create;
+  FRootElements:= TSVGElementList.Create;
+end;
+destructor TSVGDataLink.Destroy;
+begin
+  FreeAndNil(FRootElements);
+  FreeAndNil(FGradients);
+  FreeAndNil(FElements);
+  FreeAndNil(FStyles);
+  inherited Destroy;
+end;
+function TSVGDataLink.IsValidID(const id: integer; list: TSVGElementList): boolean;
+begin
+  result:= (id >= 0) and (id < list.Count);
+end;
+function TSVGDataLink.GetElement(id: integer): TSVGElement;
+begin
+  if not IsValidID(id,FElements) then
+   raise exception.Create(rsInvalidId);
+  result:= FElements[id];
+end;
+function TSVGDataLink.GetGradient(id: integer): TSVGElement;
+begin
+  if not IsValidID(id,FGradients) then
+   raise exception.Create(rsInvalidId);
+  result:= FGradients[id];
+end;
+function TSVGDataLink.GetStyle(id: integer): TSVGElement;
+begin
+  if not IsValidID(id,FStyles) then
+   raise exception.Create(rsInvalidId);
+  result:= FStyles[id];
+end;
+function TSVGDataLink.GetRootElement(id: integer): TSVGElement;
+begin
+  if not IsValidID(id,FRootElements) then
+   raise exception.Create(rsInvalidId);
+  result:= FRootElements[id];
+end;
+function TSVGDataLink.FindElement(el: TSVGElement; list: TSVGElementList): integer;
+var
+  i: integer;
+begin
+  for i:= 0 to list.Count-1 do
+    if list[i] = el then
+    begin
+      result:= i;
+      Exit;
+    end;
+  result:= -1;
+end;
+function TSVGDataLink.Find(el: TSVGElement): integer;
+begin
+  result:= FindElement(el,FElements);
+end;
+procedure TSVGDataLink.InternalLink(const id: integer; parent: TSVGElement);
+var
+  el: TSVGElement;
+begin
+  el:= FElements.Items[id];
+  with el do
+  begin
+    DataParent:= parent;
+    if parent = nil then
+     FRootElements.Add(el);
+    //Update DataChildList of "parent" before add it
+    //(not use el.DataChildList.Clear here!!)
+    if parent <> nil then
+      parent.DataChildList.Add(el);
+  end;
+end;
+procedure TSVGDataLink.InternalUnLink(const id: integer);
+var
+  i,pos_root: integer;
+  el: TSVGElement;
+begin
+  el:= FElements.Items[id];
+  with el do
+  begin
+    //se root need remove (use pos for add child as new root)
+    if DataParent = nil then
+     pos_root:= FRootElements.Remove(el)
+    else
+     pos_root:= FRootElements.Count;
+    //i have to assign a parent of a upper level
+    //and update child list of new parent (if not nil)
+    with DataChildList do
+    begin
+      for i:= 0 to Count-1 do
+      begin
+       Items[i].DataParent:= el.DataParent;
+       if el.DataParent = nil then
+        //with parent nil = new root
+        FRootElements.Insert(pos_root+i, Items[i])
+       else
+        el.DataParent.DataChildList.Add( Items[i] );
+      end;
+      Clear;
+    end;
+    //if he has a parent, I have to remove his reference as a child
+    if DataParent <> nil then
+    begin
+      DataParent.DataChildList.Remove(el);
+      DataParent:= nil;
+    end;
+  end;
+end;
+procedure TSVGDataLink.InternalReLink(const id: integer; parent: TSVGElement);
+begin
+  InternalUnLink(id);
+  InternalLink(id,parent);
+end;
+function TSVGDataLink.ElementCount: integer;
+begin
+  result:= FElements.Count;
+end;
+function TSVGDataLink.GradientCount: integer;
+begin
+  result:= FGradients.Count;
+end;
+function TSVGDataLink.StyleCount: integer;
+begin
+  result:= FStyles.Count;
+end;
+function TSVGDataLink.RootElementCount: integer;
+begin
+  result:= FRootElements.Count;
+end;
+function TSVGDataLink.IsLink(el: TSVGElement): boolean;
+begin
+  result:= Find(el) <> -1;
+end;
+function TSVGDataLink.Link(el: TSVGElement; parent: TSVGElement = nil): integer;
+begin
+  FElements.Add(el);
+  result:= FElements.Count-1;
+  InternalLink(result,parent);
+  if el is TSVGGradient then
+    FGradients.Add(el)
+  else if el is TSVGStyle then
+    FStyles.Add(el);
+end;
+procedure TSVGDataLink.Unlink(el: TSVGElement);
+var
+  id: integer;
+begin
+  id:= FindElement(el,FElements);
+  if id <> -1 then
+  begin
+    if el is TSVGGradient then
+      FGradients.Remove(el)
+    else if el is TSVGStyle then
+      FStyles.Remove(el);
+    InternalUnLink(id);
+    FElements.Delete(id);
+  end
+  else
+   raise exception.Create('element not find');
+end;
+procedure TSVGDataLink.UnlinkAll;
+var
+  i: integer;
+begin
+  FGradients.Clear;
+  FStyles.Clear;
+  for i:= 0 to FElements.Count-1 do
+    InternalUnLink(i);
+  FRootElements.Clear;
+  FElements.Clear;
+end;
+function TSVGDataLink.ReLink(el: TSVGElement; parent: TSVGElement): boolean;
+var
+  id: integer;
+begin
+  id:= FindElement(el,FElements);
+  if id <> -1 then
+  begin
+    result:= true;
+    if el.DataParent <> parent then
+      InternalReLink(id,parent);
+  end
+  else
+    result:= false;
+end;
+function TSVGDataLink.GetInternalState: TStringList;
+var
+  nid: integer;
+  sl: TStringList;
+  function SpaceStr(const level: integer): string;
+  var
+    i: integer;
+  begin
+    result:= '';
+    for i:= 1 to level do
+      result:= result + ' ';
+  end;
+  procedure AddStr(s: string; const level: integer);
+  begin
+    sl.Add( SpaceStr(level) + s );
+  end;
+  function ElementIdentity(el: TSVGElement): string;
+  begin
+   if el = nil then
+     result:= 'nil'
+   else
+   begin
+     result:= el.ID;
+     if Trim(Result) = '' then
+       result:= 'unknow';
+     result:= result + ' - ' + el.ClassName +
+       //(slow: for test ok)
+       ' | (pos: ' + IntToStr( Find(el) ) + ')';
+   end;
+  end;
+  procedure ElementToInfo(el: TSVGElement; const level: integer);
+  Var
+   i: integer;
+   sep: string;
+  begin
+   if el.DataParent = nil then
+    sep:= '###'
+   else
+    sep:= '***';
+   AddStr('{'+sep+' '+ElementIdentity(el)+' '+sep+'}', level);
+   AddStr('[Parent: ' + ElementIdentity(el.DataParent) + ']', level);
+   for i:= 0 to el.DataChildList.Count-1 do
+     AddStr('[Child: ' + ElementIdentity(el.DataChildList[i]) + ']', level);
+  end;
+  procedure BuildInfo(el: TSVGElement; const level: integer = 1);
+  const
+    kspace = 5;
+  var
+    i: Integer;
+  begin
+   ElementToInfo(el,level);
+   Inc(nid);
+   for i:= 0 to el.DataChildList.Count-1 do
+     BuildInfo(el.DataChildList[i],level+kspace);
+  end;
+var
+ i: integer;
+begin
+  nid:= 0;
+  sl:= TStringList.Create;
+  for i:= 0 to FRootElements.Count-1 do
+    BuildInfo( FRootElements[i] );
+  result:= sl;
+end;
 { TSVGElement }
+function TSVGElement.GetAttribute(AName,ADefault: string; ACanInherit: boolean): string;
+var
+  curNode: TDOMElement;
+begin
+  curNode := FDomElem;
+  repeat
+    result := Trim(curNode.GetAttribute(AName));
+    if (result = 'currentColor') and (AName <> 'color') then
+    begin
+      AName := 'color';
+      curNode := FDomElem; //get from the current element
+      ACanInherit:= true;
+      result := Trim(curNode.GetAttribute(AName));
+    end;
+    if ((result = '') or (result = 'inherit')) and ACanInherit and
+      (curNode.ParentNode is TDOMElement) then
+      curNode := curNode.ParentNode as TDOMElement
+    else
+      curNode := nil;
+  until curNode = nil;
+  if (result = '') or (result = 'inherit') then
+    result:= ADefault;
+end;
+function TSVGElement.GetAttribute(AName, ADefault: string): string;
+begin
+  result := GetAttribute(AName, ADefault, False);
+end;
 function TSVGElement.GetAttribute(AName: string): string;
 begin
   result := FDomElem.GetAttribute(AName);
 end;
 function TSVGElement.GetVerticalAttributeOrStyleWithUnit(AName: string
   ): TFloatWithCSSUnit;
 begin
   result := GetAttributeOrStyleWithUnit(AName);
+  result:= GetAttribute(AName,'');
+end;
+function TSVGElement.GetVerticalAttributeOrStyleWithUnit(AName: string;
+  ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
+begin
+  result := GetAttributeOrStyleWithUnit(AName,ADefault);
   if result.CSSUnit <> cuCustom then
     if units.DpiScaleY = 0 then
 …
 end;
+function TSVGElement.GetAttributeWithUnit(AName: string; ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
+begin
+  result := TCSSUnitConverter.parseValue(Attribute[AName],ADefault);
+end;
 function TSVGElement.GetAttributeWithUnit(AName: string): TFloatWithCSSUnit;
 begin
   result := TCSSUnitConverter.parseValue(Attribute[AName],FloatWithCSSUnit(0,cuCustom));
 end;
 function TSVGElement.GetAttributeOrStyleWithUnit(AName: string
+  ): TFloatWithCSSUnit;
 var valueText: string;
+  result := GetAttributeWithUnit(AName,FloatWithCSSUnit(0,cuCustom));
+end;
+function TSVGElement.GetAttributeOrStyleWithUnit(AName: string; ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
+var
+  valueText: string;
 begin
   valueText := Style[AName];
+  if valueText = '' then valueText := Attribute[AName];
+  result := TCSSUnitConverter.parseValue(valueText,FloatWithCSSUnit(0,cuCustom));
+end;
+function TSVGElement.GetOrthoAttributeWithUnit(AName: string
+  ): TFloatWithCSSUnit;
+begin
+  result := GetHorizAttributeWithUnit(AName);
+  if valueText = '' then
+    valueText := GetAttribute(AName,'',True);
+  result := TCSSUnitConverter.parseValue(valueText,ADefault);
+end;
+function TSVGElement.GetAttributeOrStyleWithUnit(AName: string): TFloatWithCSSUnit;
+begin
+  result := GetAttributeOrStyleWithUnit(AName,FloatWithCSSUnit(0,cuCustom));
+end;
+function TSVGElement.GetOrthoAttributeWithUnit(AName: string;
+  ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
+begin
+  result := GetHorizAttributeWithUnit(AName,ADefault);
   //value will be inconsistent if scaling is inconsistent
 end;
+function TSVGElement.GetHorizAttributeWithUnit(AName: string
+  ): TFloatWithCSSUnit;
+begin
+  result := GetAttributeWithUnit(AName);
+function TSVGElement.GetOrthoAttributeWithUnit(AName: string): TFloatWithCSSUnit;
+begin
+  result := GetOrthoAttributeWithUnit(AName,FloatWithCSSUnit(0,cuCustom));
+end;
+function TSVGElement.GetHorizAttributeWithUnit(AName: string;
+  ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
+begin
+  result := GetAttributeWithUnit(AName,ADefault);
+  if result.value <> EmptySingle then
+  begin
+    if result.CSSUnit <> cuCustom then
+      if units.DpiScaleX = 0 then
+        result.value := 0
+      else
+        result.value /= Units.DpiScaleX;
+  end;
+end;
+function TSVGElement.GetHorizAttributeWithUnit(AName: string): TFloatWithCSSUnit;
+begin
+  result := GetHorizAttributeWithUnit(AName,FloatWithCSSUnit(0,cuCustom));
+end;
+function TSVGElement.GetAttributeOrStyle(AName,ADefault: string): string;
+begin
+  result := GetStyle(AName,ADefault);
+  if result = '' then
+    result := GetAttribute(AName,ADefault,True);
+end;
+function TSVGElement.GetAttributeOrStyle(AName: string): string;
+begin
+  result:= GetAttributeOrStyle(AName,'');
+end;
+function TSVGElement.GetFill: string;
+begin
+  result := AttributeOrStyleDef['fill','black'];
+end;
+function TSVGElement.GetFillColor: TBGRAPixel;
+begin
+  result := StrToBGRA(fill,BGRABlack);
+  result.alpha := round(result.alpha*fillOpacity*opacity);
+  if result.alpha = 0 then result := BGRAPixelTransparent;
+end;
+function TSVGElement.GetFillOpacity: single;
+var errPos: integer;
+begin
+  val(AttributeOrStyleDef['fill-opacity','1'], result, errPos);
+  if errPos <> 0 then result := 1 else
+    if result < 0 then result := 0 else
+      if result > 1 then result := 1;
+end;
+function TSVGElement.GetFillRule: string;
+begin
+  result := AttributeOrStyleDef['fill-rule','nonzero'];
+end;
+function TSVGElement.GetHorizAttributeOrStyleWithUnit(AName: string;
+  ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
+begin
+  result := GetAttributeOrStyleWithUnit(AName,ADefault);
   if result.CSSUnit <> cuCustom then
     if units.DpiScaleX = 0 then
 …
 end;
+function TSVGElement.GetAttributeOrStyle(AName: string): string;
+begin
+  result := GetStyle(AName);
+  if result = '' then result := GetAttribute(AName);
+end;
+function TSVGElement.GetFill: string;
+begin
+  result := AttributeOrStyle['fill'];
+end;
+function TSVGElement.GetFillColor: TBGRAPixel;
+begin
+  result := StrToBGRA(fill,BGRABlack);
+  result.alpha := round(result.alpha*fillOpacity*opacity);
+  if result.alpha = 0 then result := BGRAPixelTransparent;
+end;
+function TSVGElement.GetFillOpacity: single;
+function TSVGElement.GetIsFillNone: boolean;
+begin
+  result := compareText(trim(fill),'none')=0;
+end;
+function TSVGElement.GetIsStrokeNone: boolean;
+var strokeStr: string;
+begin
+  strokeStr := stroke;
+  result := (trim(strokeStr)='') or (compareText(trim(strokeStr),'none')=0);
+end;
+function TSVGElement.GetMatrix(AUnit: TCSSUnit): TAffineMatrix;
+var parser: TSVGParser;
+    s: string;
+begin
+  s := transform;
+  if s='' then
+  begin
+    result := AffineMatrixIdentity;
+    exit;
+  end;
+  parser := TSVGParser.Create(s);
+  result := parser.ParseTransform;
+  result[1,3] := Units.ConvertWidth(result[1,3],cuCustom,AUnit);
+  result[2,3] := Units.ConvertHeight(result[2,3],cuCustom,AUnit);
+  parser.Free;
+end;
+function TSVGElement.GetOpacity: single;
 var errPos: integer;
 begin
   val(AttributeOrStyle['fill-opacity'], result, errPos);
+  val(AttributeOrStyleDef['opacity','1'], result, errPos);
   if errPos <> 0 then result := 1 else
     if result < 0 then result := 0 else
 …
 end;
+function TSVGElement.GetHorizAttributeOrStyleWithUnit(AName: string
+  ): TFloatWithCSSUnit;
+begin
+  result := GetAttributeOrStyleWithUnit(AName);
+  if result.CSSUnit <> cuCustom then
+    if units.DpiScaleX = 0 then
+      result.value := 0
+    else
+      result.value /= Units.DpiScaleX;
+end;
+function TSVGElement.GetIsFillNone: boolean;
+begin
+  result := compareText(trim(fill),'none')=0;
+end;
+function TSVGElement.GetIsStrokeNone: boolean;
+var strokeStr: string;
+begin
+  strokeStr := stroke;
+  result := (trim(strokeStr)='') or (compareText(trim(strokeStr),'none')=0);
+end;
+function TSVGElement.GetMatrix(AUnit: TCSSUnit): TAffineMatrix;
+var parser: TSVGParser;
+    s,kind: string;
+    m : TAffineMatrix;
+    angle,tx,ty: single;
+begin
+  result := AffineMatrixIdentity;
+  s := transform;
+  if s='' then exit;
+  parser := TSVGParser.Create(s);
+  while not parser.Done do
+  begin
+    kind := parser.ParseId;
+    if kind = '' then break;
+    if parser.ParseSymbol <> '(' then break;
+    if compareText(kind,'matrix')=0 then
+    begin
+      m[1,1] := parser.ParseFloat;
+      parser.SkipSymbol(',');
+      m[2,1] := parser.ParseFloat;
+      parser.SkipSymbol(',');
+      m[1,2] := parser.ParseFloat;
+      parser.SkipSymbol(',');
+      m[2,2] := parser.ParseFloat;
+      parser.SkipSymbol(',');
+      m[1,3] := parser.ParseFloat;
+      parser.SkipSymbol(',');
+      m[2,3] := parser.ParseFloat;
+      result *= m;
+    end else
+    if compareText(kind,'translate')=0 then
+    begin
+      tx := parser.ParseFloat;
+      parser.SkipSymbol(',');
+      ty := parser.ParseFloat;
+      result *= AffineMatrixTranslation(tx,ty);
+    end else
+    if compareText(kind,'scale')=0 then
+    begin
+      tx := parser.ParseFloat;
+      parser.SkipSymbol(',');
+      parser.ClearError;
+      ty := parser.ParseFloat;
+      if parser.NumberError then ty := tx;
+      result *= AffineMatrixScale(tx,ty);
+    end else
+    if compareText(kind,'rotate')=0 then
+    begin
+      angle := parser.ParseFloat;
+      parser.SkipSymbol(',');
+      tx := parser.ParseFloat;
+      parser.SkipSymbol(',');
+      ty := parser.ParseFloat;
+      result *= AffineMatrixTranslation(tx,ty)*AffineMatrixRotationDeg(angle)*
+                AffineMatrixTranslation(-tx,-ty);
+    end else
+    if compareText(kind,'skewx')=0 then
+    begin
+      angle := parser.ParseFloat;
+      result *= AffineMatrixSkewXDeg(angle);
+    end else
+    if compareText(kind,'skewy')=0 then
+    begin
+      angle := parser.ParseFloat;
+      result *= AffineMatrixSkewYDeg(angle);
+    end;
+    parser.SkipUpToSymbol(')');
+  end;
+  parser.free;
+  result[1,3] := Units.ConvertWidth(result[1,3],cuCustom,AUnit);
+  result[2,3] := Units.ConvertHeight(result[2,3],cuCustom,AUnit);
+end;
+function TSVGElement.GetOpacity: single;
+function TSVGElement.GetOrthoAttributeOrStyleWithUnit(AName: string;
+  ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
+begin
+  result := GetHorizAttributeOrStyleWithUnit(AName,ADefault);
+  //value will be inconsistent if scaling is inconsistent
+end;
+function TSVGElement.GetStroke: string;
+begin
+  result := AttributeOrStyleDef['stroke','none'];
+end;
+function TSVGElement.GetStrokeColor: TBGRAPixel;
+begin
+  result := StrToBGRA(stroke);
+  result.alpha := round(result.alpha*strokeOpacity*opacity);
+  if result.alpha = 0 then result := BGRAPixelTransparent;
+end;
+function TSVGElement.GetStrokeLineCap: string;
+begin
+  result := AttributeOrStyleDef['stroke-linecap','butt'];
+end;
+function TSVGElement.GetStrokeLineJoin: string;
+begin
+  result := AttributeOrStyleDef['stroke-linejoin','miter'];
+end;
+function TSVGElement.GetStrokeMiterLimit: single;
 var errPos: integer;
 begin
+  val(AttributeOrStyle['opacity'], result, errPos);
+  val(AttributeOrStyleDef['stroke-miterlimit','4'], result, errPos);
+  if errPos <> 0 then result := 4 else
+    if result < 1 then result := 1;
+end;
+function TSVGElement.GetStrokeOpacity: single;
+var errPos: integer;
+begin
+  val(AttributeOrStyleDef['stroke-opacity','1'], result, errPos);
   if errPos <> 0 then result := 1 else
     if result < 0 then result := 0 else
 …
 end;
-function TSVGElement.GetOrthoAttributeOrStyleWithUnit(AName: string
-  ): TFloatWithCSSUnit;
-begin
-  result := GetHorizAttributeOrStyleWithUnit(AName);
-  //value will be inconsistent if scaling is inconsistent
-end;
-function TSVGElement.GetStroke: string;
-begin
-  result := AttributeOrStyle['stroke'];
-end;
-function TSVGElement.GetStrokeColor: TBGRAPixel;
-begin
-  result := StrToBGRA(stroke);
-  result.alpha := round(result.alpha*strokeOpacity*opacity);
-  if result.alpha = 0 then result := BGRAPixelTransparent;
-end;
-function TSVGElement.GetStrokeLineCap: string;
-begin
-  result := AttributeOrStyle['stroke-linecap'];
-  if result = '' then result := 'butt';
-end;
-function TSVGElement.GetStrokeLineJoin: string;
-begin
-  result := AttributeOrStyle['stroke-linejoin'];
-  if result = '' then result := 'miter';
-end;
-function TSVGElement.GetStrokeMiterLimit: single;
-var errPos: integer;
-begin
-  val(AttributeOrStyle['stroke-miterlimit'], result, errPos);
-  if errPos <> 0 then result := 4 else
-    if result < 1 then result := 1;
-end;
-function TSVGElement.GetStrokeOpacity: single;
-var errPos: integer;
-begin
-  val(AttributeOrStyle['stroke-opacity'], result, errPos);
-  if errPos <> 0 then result := 1 else
-    if result < 0 then result := 0 else
-      if result > 1 then result := 1;
-end;
 function TSVGElement.GetStrokeWidth: TFloatWithCSSUnit;
 begin
+  result := OrthoAttributeOrStyleWithUnit['stroke-width'];
+end;
+  result := OrthoAttributeOrStyleWithUnit['stroke-width',FloatWithCSSUnit(1,cuCustom)];
+end;
+function TSVGElement.GetStrokeDashArray: string;
+begin
+  result := AttributeDef['stroke-dasharray','none'];
+end;
+function TSVGElement.GetStrokeDashArrayF: ArrayOfFloat;
+var
+  parser: TSVGParser;
+  nvalue,i: integer;
+  s_array: String;
+begin
+  s_array:= strokeDashArray;
+  if s_array = 'none' then
+  begin
+    setlength(Result,0);
+    exit;
+  end;
+  parser:=TSVGParser.Create(s_array);
+  nvalue := 0;
+  repeat
+    parser.ParseFloat;
+    if not parser.NumberError then
+      inc(nvalue);
+  until parser.NumberError or parser.Done;
+  parser.ClearError;
+  setlength(Result,nvalue);
+  parser.Position := 1;
+  for i := 0 to high(result) do
+    result[i] := parser.ParseFloat;
+  parser.Free;
+end;
+function TSVGElement.GetStrokeDashOffset: TFloatWithCSSUnit;
+begin
+  result := OrthoAttributeWithUnit['stroke-dashoffset'];
+end;
+function TSVGElement.GetStyle(const AName,ADefault: string): string;
+  function GetInternal(const ruleset: string): string;
+  var
+    startPos, colonPos, valueLength: integer;
+  begin
+    LocateStyleDeclaration(ruleset, AName, startPos,colonPos, valueLength);
+    if valueLength <> -1 then
+      result := trim(copy(ruleset, colonPos+1, valueLength))
+    else
+      result := '';
+  end;
+var
+  i: integer;
+begin
+  result:= '';
+  //Find on <style> block (priority!)
+  //if "not search"..search
+  if findStyleState = fssNotSearch then
+    FindStyleElement;
+  //if "find"..use
+  if findStyleState <> fssNotFind then
+    for i:= Length(styleAttributes)-1 downto 0 do
+    begin
+      result:= GetInternal(styleAttributes[i].attr);
+      if result <> '' then
+        Break;
+    end;
+  if result = '' then
+    result:= GetInternal( Attribute['style',ADefault] );
+end;
 function TSVGElement.GetStyle(const AName: string): string;
+var
+    startPos, colonPos, valueLength: integer;
+    ruleset: string;
+begin
+  ruleset := Attribute['style'];
+  LocateStyleDeclaration(ruleset, AName, startPos,colonPos, valueLength);
+  if valueLength <> -1 then
+  begin
+    result := trim(copy(ruleset, colonPos+1, valueLength));
+  end else
+    result := '';
+end;
+begin
+  result:= GetStyle(AName,'');
+end;
 function TSVGElement.GetTransform: string;
 …
 end;
+function TSVGElement.GetVerticalAttributeWithUnit(AName: string; ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
+begin
+  result := GetAttributeWithUnit(AName,ADefault);
+  if result.value <> EmptySingle then
+  begin
+    if result.CSSUnit <> cuCustom then
+      if units.DpiScaleY = 0 then
+        result.value := 0
+      else
+        result.value /= Units.DpiScaleY;
+  end;
+end;
 function TSVGElement.GetVerticalAttributeWithUnit(AName: string): TFloatWithCSSUnit;
 begin
+  result := GetAttributeWithUnit(AName);
+  if result.CSSUnit <> cuCustom then
+    if units.DpiScaleY = 0 then
+      result.value := 0
+    else
+      result.value /= Units.DpiScaleY;
+end;
+  result := GetVerticalAttributeWithUnit(AName,FloatWithCSSUnit(0,cuCustom));
+end;
 function TSVGElement.GetDOMElement: TDOMElement;
 …
   result := FDomElem;
 end;
+function TSVGElement.GetID: string;
+begin
+  result := Attribute['id'];
+end;
+function TSVGElement.GetClassAt: string;
+begin
+  result := Attribute['class'];
+end;
 procedure TSVGElement.SetAttribute(AName: string; AValue: string);
 …
   RemoveStyle('fill-opacity');
 end;
+procedure TSVGElement.SetFillRule(AValue: string);
+begin
+  Attribute['fill-rule'] := AValue;
+  RemoveStyle('fill-rule');
+end;
 procedure TSVGElement.SetHorizAttributeWithUnit(AName: string;
 …
 end;
+procedure TSVGElement.SetStrokeDashArray(AValue: string);
+begin
+  Attribute['stroke-dasharray'] := AValue;
+end;
+procedure TSVGElement.SetStrokeDashArrayF(AValue: ArrayOfFloat);
+var
+  s: string;
+  i: integer;
+begin
+  s:= '';
+  for i := 0 to high(AValue) do
+  begin
+    if s <> '' then s += ' ';
+    s += TCSSUnitConverter.formatValue(AValue[i])+' ';
+  end;
+  strokeDashArray := s;
+end;
+procedure TSVGElement.SetStrokeDashOffset(AValue: TFloatWithCSSUnit);
+begin
+  OrthoAttributeWithUnit['stroke-dashoffset'] := AValue;
+end;
 procedure TSVGElement.SetStyle(AName: string; AValue: string);
 var
 …
     SetHorizAttributeWithUnit(AName,AValue);
 end;
+procedure TSVGElement.SetID(AValue: string);
+begin
+  Attribute['id'] := AValue;
+end;
+procedure TSVGElement.SetClassAt(AValue: string);
+begin
+  Attribute['class'] := AValue;
+end;
 procedure TSVGElement.Init(ADocument: TXMLDocument; ATag: string;
 …
 end;
+procedure TSVGElement.ApplyFillStyle(ACanvas2D: TBGRACanvas2D; AUnit: TCSSUnit);
+begin
+  ACanvas2D.fillStyle(fillColor);
+  ACanvas2D.fillMode := TFillMode(fillMode);
+end;
 procedure TSVGElement.ApplyStrokeStyle(ACanvas2D: TBGRACanvas2D; AUnit: TCSSUnit);
+var
+  a: ArrayOfFloat;
+  lw: single;
+  i: Integer;
 begin
   ACanvas2d.strokeStyle(strokeColor);
+  ACanvas2d.lineWidth := Units.ConvertWidth(strokeWidth,AUnit).value;
+  lw := Units.ConvertWidth(strokeWidth,AUnit).value;
+  ACanvas2d.lineWidth := lw;
   ACanvas2d.lineCap := strokeLineCap;
   ACanvas2d.lineJoin := strokeLineJoin;
   ACanvas2d.miterLimit := strokeMiterLimit;
+  a:= strokeDashArrayF;
+  if (Length(a) <> 0) and (lw > 0) then
+  begin
+    for i := 0 to high(a) do
+      a[i] /= lw;
+    ACanvas2d.lineStyle(a);
+  end
+  else
+    ACanvas2d.lineStyle(psSolid);
+end;
+procedure TSVGElement.Initialize;
+begin
+  SetLength(styleAttributes,0);
+  findStyleState   := fssNotSearch;
+  FDataParent      := nil;
+  FDataChildList   := TSVGElementList.Create;
 end;
 constructor TSVGElement.Create(ADocument: TXMLDocument; AElement: TDOMElement;
+  AUnits: TCSSUnitConverter);
+begin
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  FDataLink:= ADataLink;
+  Initialize;
   Init(ADocument,AElement,AUnits);
 end;
 constructor TSVGElement.Create(ADocument: TXMLDocument;
+  AUnits: TCSSUnitConverter);
+begin
+  raise exception.Create('Cannot create a generic element');
+  AUnits: TCSSUnitConverter; ADataLink: TSVGDataLink);
+begin
+  FDataLink:= ADataLink;
+  Initialize;
+  //raise exception.Create('Cannot create a generic element');
+end;
+destructor TSVGElement.Destroy;
+begin
+  SetLength(styleAttributes,0);
+  FreeAndNil(FDataChildList);
+  inherited Destroy;
+end;
+procedure TSVGElement.Recompute;
+begin
 end;
 …
 end;
+function TSVGElement.HasAttribute(AName: string): boolean;
+begin
+  result := FDomElem.hasAttribute(AName);
+end;
+function TSVGElement.fillMode: TSVGFillMode;
+begin
+  if fillRule = 'evenodd' then
+    result := sfmEvenOdd
+  else
+    result := sfmNonZero;
+end;
+function TSVGElement.DataChildList: TSVGElementList;
+begin
+   result:= FDataChildList;
+end;
+function TSVGElement.FindStyleElementInternal(const classStr: string;
+  out attributesStr: string): integer;
+var
+  i: integer;
+begin
+  attributesStr:= '';
+  with FDataLink do
+    for i:= 0 to StyleCount-1 do
+    begin
+      result:= (Styles[i] as TSVGStyle).Find(classStr);
+      if result <> -1 then
+      begin
+        attributesStr:= (Styles[i] as TSVGStyle).Styles[result].attribute;
+        Exit;
+      end;
+    end;
+  result:= -1;
+end;
+procedure TSVGElement.FindStyleElement;
+  procedure AddStyle(const s: string; const id: integer);
+  var
+    l: integer;
+  begin
+    findStyleState:= fssFind;
+    l:= Length(styleAttributes);
+    SetLength(styleAttributes,l+1);
+    with styleAttributes[l] do
+    begin
+     attr:= s;
+     pos:= id;
+    end;
+  end;
+var
+  fid: integer;
+  tag,styleC,s: string;
+begin
+  findStyleState:= fssNotFind;
+  SetLength(styleAttributes,0);
+  tag:= FDomElem.TagName;
+  styleC:= classAt;
+  (*
+    if style element is:
+    <style>
+     circle.test{fill:red; fill-opacity: 0.8;}
+     circle{fill:blue; fill-opacity: 0.4;}
+     circle.style1{fill:yellow;}
+    </style>
+    and circle declare:
+    <circle class = "style1" cx="160" cy="160" r="35" stroke="black" />
+    styleAttributes[0] = 'fill:blue; fill-opacity: 0.4;'
+    styleAttributes[1] = 'fill:yellow;'
+    fill-opacity for "style1" = 0.4 not default 1!
+  *)
+  //Find as: "[tag]" example "circle"
+  fid:= FindStyleElementInternal(tag,s);
+  if fid <> -1 then
+    AddStyle(s,fid);
+  if styleC <> '' then
+  begin
+    //Find as: "[tag].[class]" example "circle.style1"
+    fid:= FindStyleElementInternal(tag+'.'+styleC,s);
+    if fid <> -1 then
+      AddStyle(s,fid)
+    else
+    begin
+      //Find as: ".[class]" example ".style1"
+      fid:= FindStyleElementInternal('.'+styleC,s);
+      if fid <> -1 then
+        AddStyle(s,fid);
+    end;
+  end;
+end;
 end.

GraphicTest/Packages/bgrabitmap/bgratext.pas

-              r494
+              r521
   {$DEFINE LCL_RENDERER_IS_FINE}
   {$DEFINE LCL_CLEARTYPE_RENDERER_IS_FINE}
+  {$DEFINE RENDER_TEXT_ON_TBITMAP}
 {$ENDIF}
 {$IFDEF FREEBSD}
 …
   {$DEFINE RENDER_TEXT_ON_TBITMAP}
 {$ENDIF}
+{$IFDEF WINDOWS}
+  {$IFNDEF LEGACY_FONT_VERTICAL_OFFSET}
+    {$DEFINE FIX_FONT_VERTICAL_OFFSET}
+  {$ENDIF}
+{$ENDIF}
+{
 …
 uses
+  Classes, Types, SysUtils, BGRAGraphics, BGRABitmapTypes, InterfaceBase, BGRAPen, BGRAGrayscaleMask;
+  Classes, Types, SysUtils, BGRAGraphics, BGRABitmapTypes, InterfaceBase, BGRAPen, BGRAGrayscaleMask,
+  LCLVersion;
 type
 …
     FWordBreakHandler: TWordBreakHandler;
     procedure UpdateFont; virtual;
+    function TextSizeNoUpdateFont(sUTF8: string): TSize;
+    procedure InternalTextWordBreak(ADest: TBGRACustomBitmap; ATextUTF8: string; x, y, AMaxWidth: integer; AColor: TBGRAPixel; ATexture: IBGRAScanner; AHorizAlign: TAlignment; AVertAlign: TTextLayout);
+    function InternalTextSize(sUTF8: string; AShowPrefix: boolean): TSize;
+    procedure InternalTextWordBreak(ADest: TBGRACustomBitmap; ATextUTF8: string;
+                                    x, y, AMaxWidth: integer; AColor: TBGRAPixel; ATexture: IBGRAScanner;
+                                    AHorizAlign: TAlignment; AVertAlign: TTextLayout; ARightToLeft: boolean);
     procedure InternalTextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; c: TBGRAPixel; ATexture: IBGRAScanner);
+    procedure InternalTextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; c: TBGRAPixel; texture: IBGRAScanner;
+                              align: TAlignment; AShowPrefix: boolean = false; ARightToLeft: boolean = false);
+    procedure InternalTextOutEllipse(ADest: TBGRACustomBitmap; x, y, availableWidth: single; sUTF8: string; c: TBGRAPixel; texture: IBGRAScanner;
+                              align: TAlignment; AShowPrefix: boolean = false; ARightToLeft: boolean = false);
+    procedure InternalSplitText(var ATextUTF8: string; AMaxWidth: integer; out ARemainsUTF8: string; out ALineEndingBreak: boolean;
+                                AWordBreak: TWordBreakHandler); overload;
+    procedure InternalSplitText(var ATextUTF8: string; AMaxWidth: integer; out ARemainsUTF8: string;
+                                AWordBreak: TWordBreakHandler); overload;
+    procedure DefaultWorkBreakHandler(var ABeforeUTF8, AAfterUTF8: string);
   public
     procedure SplitText(var ATextUTF8: string; AMaxWidth: integer; out ARemainsUTF8: string);
     function GetFontPixelMetric: TFontPixelMetric; override;
+    procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientationTenthDegCCW: integer; sUTF8: string; c: TBGRAPixel; align: TAlignment); override;
+    procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientationTenthDegCCW: integer; sUTF8: string; texture: IBGRAScanner; align: TAlignment); override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment); override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment); override;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; c: TBGRAPixel); override;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; texture: IBGRAScanner); override;
+    procedure TextWordBreak(ADest: TBGRACustomBitmap; AText: string; x, y, AMaxWidth: integer; AColor: TBGRAPixel; AHorizAlign: TAlignment; AVertAlign: TTextLayout);
+    procedure TextWordBreak(ADest: TBGRACustomBitmap; AText: string; x, y, AMaxWidth: integer; ATexture: IBGRAScanner; AHorizAlign: TAlignment; AVertAlign: TTextLayout);
+    procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientationTenthDegCCW: integer; sUTF8: string; c: TBGRAPixel; align: TAlignment); overload; override;
+    procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientationTenthDegCCW: integer; sUTF8: string; texture: IBGRAScanner; align: TAlignment); overload; override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment); overload; override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment); overload; override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment; ARightToLeft: boolean); overload; override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment; ARightToLeft: boolean); overload; override;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; c: TBGRAPixel); overload; override;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; texture: IBGRAScanner); overload; override;
+    procedure TextWordBreak(ADest: TBGRACustomBitmap; AText: string; x, y, AMaxWidth: integer; AColor: TBGRAPixel; AHorizAlign: TAlignment; AVertAlign: TTextLayout; ARightToLeft: boolean = false); overload;
+    procedure TextWordBreak(ADest: TBGRACustomBitmap; AText: string; x, y, AMaxWidth: integer; ATexture: IBGRAScanner; AHorizAlign: TAlignment; AVertAlign: TTextLayout; ARightToLeft: boolean = false); overload;
     function TextSize(sUTF8: string): TSize; override;
+    function TextSizeAngle(sUTF8: string; orientationTenthDegCCW: integer): TSize; override;
+    function TextSize(sUTF8: string; AMaxWidth: integer; {%H-}ARightToLeft: boolean): TSize; override;
+    function TextFitInfo(sUTF8: string; AMaxWidth: integer): integer; override;
     constructor Create;
     destructor Destroy; override;
 …
   TLCLFontRenderer = class(TCustomLCLFontRenderer)
+  protected
+    function TextSurfaceSmaller(sUTF8: string; ARect: TRect): boolean;
+  public
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; c: TBGRAPixel); override;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; sUTF8: string; style: TTextStyle; texture: IBGRAScanner); override;
   end;
 …
 procedure BGRATextOut(bmp: TBGRACustomBitmap; Font: TFont; Quality: TBGRAFontQuality; xf, yf: single; sUTF8: string;
+  c: TBGRAPixel; tex: IBGRAScanner; align: TAlignment; CustomAntialiasingLevel: Integer = 0);
+  c: TBGRAPixel; tex: IBGRAScanner; align: TAlignment; CustomAntialiasingLevel: Integer = 0;
+  ShowPrefix: boolean = false; RightToLeft: boolean = false);
 procedure BGRATextOutAngle(bmp: TBGRACustomBitmap; Font: TFont; Quality: TBGRAFontQuality; xf, yf: single; orientationTenthDegCCW: integer;
   sUTF8: string; c: TBGRAPixel; tex: IBGRAScanner; align: TAlignment; CustomAntialiasingLevel: Integer = 0);
 procedure BGRATextRect(bmp: TBGRACustomBitmap; Font: TFont; Quality: TBGRAFontQuality; ARect: TRect; x, y: integer;
+procedure BGRATextRect(bmp: TBGRACustomBitmap; Font: TFont; Quality: TBGRAFontQuality; ARect: TRect; xf, yf: single;
   sUTF8: string; style: TTextStyle; c: TBGRAPixel; tex: IBGRAScanner; CustomAntialiasingLevel: Integer = 0);
 function BGRATextSize(Font: TFont; Quality: TBGRAFontQuality; sUTF8: string; CustomAntialiasingLevel: Integer): TSize;
+function BGRATextFitInfo(Font: TFont; Quality: TBGRAFontQuality; sUTF8: string; CustomAntialiasingLevel: Integer; AMaxWidth: integer): integer;
 function BGRAOriginalTextSize(Font: TFont; Quality: TBGRAFontQuality; sUTF8: string; CustomAntialiasingLevel: integer): TSize;
+function BGRAOriginalTextSizeEx(Font: TFont; Quality: TBGRAFontQuality; sUTF8: string; CustomAntialiasingLevel: Integer; out actualAntialiasingLevel: integer): TSize;
+function BGRAOriginalTextSizeEx(Font: TFont; Quality: TBGRAFontQuality; sUTF8: string; CustomAntialiasingLevel: Integer;
+                                out actualAntialiasingLevel: integer; out extraVerticalMarginDueToRotation: integer): TSize;
 function BGRATextUnderline(ATopLeft: TPointF; AWidth: Single; AMetrics: TFontPixelMetric): ArrayOfTPointF; overload;
 …
 function LCLFontAvailable: boolean;
 function GetFineClearTypeAuto: TBGRAFontQuality;
+function FixLCLFontFullHeight({%H-}AFontName: string; AFontHeight: integer): integer;
 procedure BGRAFillClearTypeGrayscaleMask(dest: TBGRACustomBitmap; x,y: integer; xThird: integer; mask: TGrayscaleMask; color: TBGRAPixel; texture: IBGRAScanner = nil; RGBOrder: boolean=true);
 …
 implementation
+uses GraphType, Math, BGRABlend, BGRAUTF8;
+uses GraphType, Math, BGRABlend, BGRAUTF8, BGRAUnicode, BGRATextBidi
+     {$IF lcl_fullversion >= 1070000}, lclplatformdef{$ENDIF};
 const MaxPixelMetricCount = 100;
 …
 function GetLCLFontPixelMetric(AFont: TFont): TFontPixelMetric;
 var i,startPos,endPos: integer;
+begin
+  prevHeight,fixHeight: integer;
+begin
+  if (AFont.Height < -200) or (AFont.Height > 150) then
+  begin
+    prevHeight := AFont.Height;
+    if AFont.Height < 0 then
+      fixHeight := -200
+    else
+      fixHeight := 150;
+    AFont.Height := fixHeight;
+    result := GetLCLFontPixelMetric(AFont);
+    AFont.Height := prevHeight;
+    result.Baseline := round(result.Baseline/fixHeight*prevHeight);
+    result.CapLine := round(result.CapLine/fixHeight*prevHeight);
+    result.DescentLine := round(result.DescentLine/fixHeight*prevHeight);
+    result.Lineheight := round(result.Lineheight/fixHeight*prevHeight);
+    result.xLine := round(result.xLine/fixHeight*prevHeight);
+    exit;
+  end;
   FindPixelMetricPos(AFont,startPos,endPos);
   for i := startPos to endPos-1 do
 …
         end else
         if (green = 0) then break;
+        bgra.Free;
     lclBmp.Free;
   end;
 …
   fqFineClearTypeComputed:= true;
 end;
+{$IFNDEF WINDOWS}
+var LCLFontFullHeightRatio : array of record
+                          FontName: string;
+                          Ratio: single;
+                        end;
+{$ENDIF}
+function FixLCLFontFullHeight(AFontName: string; AFontHeight: integer): integer;
+{$IFNDEF WINDOWS}
+const TestHeight = 200;
+var
+  i: Integer;
+  ratio : single;
+  f: TFont;
+  h: LongInt;
+begin
+  if (AFontHeight = 0) or
+    (AFontHeight*FontEmHeightSign > 0) then
+      result := AFontHeight
+  else
+  begin
+    ratio := EmptySingle;
+    for i := 0 to high(LCLFontFullHeightRatio) do
+      if CompareText(AFontName, LCLFontFullHeightRatio[i].FontName)=0 then
+      begin
+        ratio := LCLFontFullHeightRatio[i].Ratio;
+        break;
+      end;
+    if ratio = EmptySingle then
+    begin
+      f := TFont.Create;
+      f.Quality := fqDefault;
+      f.Name := AFontName;
+      f.Height := FontFullHeightSign*TestHeight;
+      h := BGRATextSize(f, fqSystem, 'Hg', 1).cy;
+      if h = 0 then ratio := 1
+      else ratio := TestHeight/h;
+      setlength(LCLFontFullHeightRatio, length(LCLFontFullHeightRatio)+1);
+      LCLFontFullHeightRatio[high(LCLFontFullHeightRatio)].FontName:= AFontName;
+      LCLFontFullHeightRatio[high(LCLFontFullHeightRatio)].Ratio:= ratio;
+    end;
+    result := round(AFontHeight*ratio);
+  end;
+end;
+{$ELSE}
+begin
+  result := AFontHeight;
+end;
+{$ENDIF}
 function FontEmHeightSign: integer;
 …
 end;
+function BGRAOriginalTextSizeEx(Font: TFont; Quality: TBGRAFontQuality; sUTF8: string; CustomAntialiasingLevel: Integer; out actualAntialiasingLevel: integer): TSize;
+function BGRAOriginalTextSizeEx(Font: TFont; Quality: TBGRAFontQuality; sUTF8: string; CustomAntialiasingLevel: Integer;
+  out actualAntialiasingLevel: integer; out extraVerticalMarginDueToRotation: integer): TSize;
 begin
   actualAntialiasingLevel:= CustomAntialiasingLevel;
+  extraVerticalMarginDueToRotation := 0;
   if not LCLFontAvailable then
     result := Size(0,0)
 …
       Result.cy := 0;
       tempBmp.Canvas.Font.GetTextSize(sUTF8, Result.cx, Result.cy);
+      if Font.Orientation <> 0 then
+      begin
+        tempBmp.Canvas.Font.Orientation:= 0;
+        extraVerticalMarginDueToRotation := result.cy - tempBmp.Canvas.Font.GetTextHeight(sUTF8);
+      end;
     except
       on ex: exception do
 …
 end;
+function BGRATextFitInfo(Font: TFont; Quality: TBGRAFontQuality; sUTF8: string;
+  CustomAntialiasingLevel: Integer; AMaxWidth: integer): integer;
+var
+  actualAntialiasingLevel: Integer;
+begin
+  if AMaxWidth = 0 then exit(0);
+  actualAntialiasingLevel:= CustomAntialiasingLevel;
+  if not LCLFontAvailable then
+    result := 0
+  else
+  begin
+    try
+      if tempBmp = nil then tempBmp := TBitmap.Create;
+      tempBmp.Canvas.Font := Font;
+      if Quality in[fqFineClearTypeBGR,fqFineClearTypeRGB,fqFineAntialiasing] then
+      begin
+        tempBmp.Canvas.Font.Height := Font.Height*CustomAntialiasingLevel;
+      end else
+      begin
+        tempBmp.Canvas.Font.Height := Font.Height;
+        actualAntialiasingLevel:= 1;
+      end;
+      result := tempBmp.Canvas.TextFitInfo(sUTF8, AMaxWidth*actualAntialiasingLevel);
+    except
+      on ex: exception do
+      begin
+        result := 0;
+        LCLFontDisabledValue := True;
+      end;
+    end;
+  end;
+end;
 function BGRAOriginalTextSize(Font: TFont; Quality: TBGRAFontQuality; sUTF8: string; CustomAntialiasingLevel: Integer): TSize;
+var actualAntialiasingLevel: integer;
+begin
+  result := BGRAOriginalTextSizeEx(Font, Quality, sUTF8, CustomAntialiasingLevel, actualAntialiasingLevel);
+var actualAntialiasingLevel, extraMargin: integer;
+begin
+  result := BGRAOriginalTextSizeEx(Font, Quality, sUTF8, CustomAntialiasingLevel, actualAntialiasingLevel, extraMargin);
+  {$IFDEF FIX_FONT_VERTICAL_OFFSET}
+  if extraMargin > 0 then result.cy -= extraMargin;
+  {$ENDIF}
 end;
 …
     result.cy := ceil(Result.cy/CustomAntialiasingLevel);
   end;
+end;
+function RemovePrefix(sUTF8: string): string;
+var i,resLen: integer;
+begin
+  setlength(result, length(sUTF8));
+  resLen := 0;
+  i := 1;
+  while i <= length(sUTF8) do
+  begin
+    if sUTF8[i] = '&' then
+    begin // double ('&&') indicate single char '&'
+      if (i < length(sUTF8)) and (sUTF8[i+1] = '&') then
+      begin
+        inc(resLen);
+        result[resLen] := '&';
+        inc(i,2);
+      end else
+        // single indicate underline
+        inc(i);
+    end else
+    begin
+      inc(resLen);
+      result[resLen] := sUTF8[i];
+      inc(i);
+    end;
+  end;
+  setlength(result,resLen);
 end;
 …
       grayscaleMask := TGrayscaleMask.Create(temp, cGreen);
       FreeAndNil(temp);
+      {$IFNDEF LINUX}
       pb := grayscaleMask.Data;
       for n := grayscaleMask.NbPixels - 1 downto 0 do
 …
         Inc(pb);
       end;
+      {$ENDIF}
     end;
   end;
 …
 procedure BGRATextOut(bmp: TBGRACustomBitmap; Font: TFont; Quality: TBGRAFontQuality; xf, yf: single; sUTF8: string;
+  c: TBGRAPixel; tex: IBGRAScanner; align: TAlignment; CustomAntialiasingLevel: Integer = 0);
+  c: TBGRAPixel; tex: IBGRAScanner; align: TAlignment; CustomAntialiasingLevel: Integer = 0;
+  ShowPrefix: boolean = false; RightToLeft: boolean = false);
 var
   size: TSize;
+  temp: TBGRACustomBitmap;
+  {$IFDEF RENDER_TEXT_ON_TBITMAP}
+  tempLCL: TBitmap;
+  {$ENDIF}
+  xMargin,xThird: integer;
+  tempSize: TSize;
+  subX,subY: integer;
+  x,y :integer;
+  deltaX: single;
+  grayscale: TGrayscaleMask;
+  sizeFactor: integer;
+  sizeFactor, extraVerticalMargin: integer;
+  xMarginF: single;
+  style: TTextStyle;
+  noPrefix: string;
 begin
   if not LCLFontAvailable then exit;
 …
   {$ENDIF}
+  size := BGRAOriginalTextSizeEx(Font,Quality,sUTF8,CustomAntialiasingLevel,sizeFactor);
+  if ShowPrefix then
+    noPrefix := RemovePrefix(sUTF8)
+  else
+    noPrefix := sUTF8;
+  size := BGRAOriginalTextSizeEx(Font,Quality,noPrefix,CustomAntialiasingLevel,sizeFactor,extraVerticalMargin);
   if (size.cx = 0) or (size.cy = 0) then
     exit;
 …
   if (size.cy >= 144) and (Quality in[fqFineAntialiasing,fqFineClearTypeBGR,fqFineClearTypeRGB]) and (CustomAntialiasingLevel > 4) then
   begin
     BGRATextOut(bmp,Font,Quality,xf,yf,sUTF8,c,tex,align,4);
     exit;
+    CustomAntialiasingLevel:= 4;
+    size := BGRAOriginalTextSizeEx(Font,Quality,noPrefix,CustomAntialiasingLevel,sizeFactor,extraVerticalMargin);
   end;
 …
   end;
+  x := round(xf);
+  y := round(yf);
+  xThird := 0;
+  tempSize.cx := size.cx;
+  tempSize.cy := size.cy;
+  if sizeFactor <> 1 then
+  begin
+    tempSize.cx += sizeFactor-1;
+    tempSize.cx -= tempSize.cx mod sizeFactor;
+    tempSize.cy += sizeFactor-1;
+    tempSize.cy -= tempSize.cy mod sizeFactor;
+    deltaX := xf-floor(xf);
+    if Quality in [fqFineClearTypeBGR,fqFineClearTypeRGB] then
+    begin
+      xThird := floor(deltaX*3) mod 3;
+      deltaX -= xThird/3;
+    end;
+    subX := round(sizeFactor*deltaX);
+    x := round(floor(xf));
+    if subX <> 0 then inc(tempSize.cx, sizeFactor);
+    subY := round(sizeFactor*(yf-floor(yf)));
+    y := round(floor(yf));
+    if subY <> 0 then inc(tempSize.cy, sizeFactor);
+  end else
+  begin
+    subX := 0;
+    subY := 0;
+  end;
+  xMargin := size.cy div 2;
+  if sizeFactor <> 1 then
+  begin
+    xMargin += sizeFactor-1;
+    xMargin -= xMargin mod sizeFactor;
+  end;
+  tempSize.cx += xMargin*2;
+  {$IFDEF RENDER_TEXT_ON_TBITMAP}
+  tempLCL := TBitmap.Create;
+  tempLCL.Width := tempSize.cx;
+  tempLCL.Height := tempSize.cy;
+  tempLCL.Canvas.Brush.Color := clBlack;
+  tempLCL.Canvas.FillRect(0,0,tempLCL.Width,tempLCL.Height);
+  with tempLCL do begin
+  {$ELSE}
+  temp := bmp.NewBitmap(tempSize.cx, tempSize.cy, BGRABlack);
+  with temp do begin
+  {$ENDIF}
+    Canvas.Font := Font;
+    Canvas.Font.Height := Font.Height*sizeFactor;
+    Canvas.Font.Color := clWhite;
+    Canvas.Brush.Style := bsClear;
+    Canvas.TextOut(xMargin+subX, subY, sUTF8);
+  end;
+  {$IFDEF RENDER_TEXT_ON_TBITMAP}
+  temp := BGRABitmapFactory.create(tempLCL,False);
+  tempLCL.Free;
+  {$ENDIF}
+  FilterOriginalText(Quality,CustomAntialiasingLevel, temp, grayscale);
+  dec(x,round(xMargin/sizeFactor));
+  BGRAInternalRenderText(bmp, Quality, grayscale,temp, x,y,xThird, c,tex);
+  if temp <> nil then temp.Free;
+  if grayscale <> nil then grayscale.Free;
+  xMarginF := size.cy/sizeFactor;
+  fillchar({%H-}style,sizeof(style),0);
+  style.SingleLine := true;
+  style.Alignment := taLeftJustify;
+  style.Layout := tlTop;
+  style.RightToLeft := RightToLeft;
+  style.ShowPrefix := ShowPrefix;
+  BGRATextRect(bmp, Font, Quality,
+        rect(floor(xf-xMarginF), floor(yf), ceil(xf+size.cx/sizeFactor+xMarginF), ceil(yf+size.cy/sizeFactor)),
+        xf,yf, sUTF8, style, c, tex, sizeFactor);
 end;
 …
   size: TSize;
   temp: TBGRACustomBitmap;
   TopRight,BottomRight,BottomLeft: TPointF;
   Top: Single;
+  TopLeft,TopRight,BottomRight,BottomLeft: TPointF;
+  Top,dy: Single;
   Left: Single;
   cosA,sinA: single;
   rotBounds: TRect;
   sizeFactor: integer;
+  sizeFactor, extraVerticalMargin: integer;
   TempFont: TFont;
   oldOrientation: integer;
 …
   TempFont.Orientation := orientationTenthDegCCW;
   TempFont.Height := Font.Height;
   size := BGRAOriginalTextSizeEx(TempFont,Quality,sUTF8,CustomAntialiasingLevel,sizeFactor);
+  size := BGRAOriginalTextSizeEx(TempFont,Quality,sUTF8,CustomAntialiasingLevel,sizeFactor, extraVerticalMargin);
   if (size.cx = 0) or (size.cy = 0) then
   begin
 …
     exit;
   end;
+  {$IFDEF FIX_FONT_VERTICAL_OFFSET}
+  if extraVerticalMargin > 0 then
+    dy := -extraVerticalMargin*0.5 -1
+  else
+    dy := 0;
+  {$ELSE}
+  dy := 0;
+  {$ENDIF}
   tempFont.Free;
   cosA := cos(orientationTenthDegCCW*Pi/1800);
   sinA := sin(orientationTenthDegCCW*Pi/1800);
+  TopRight := PointF(cosA*size.cx,-sinA*size.cx);
+  BottomRight := PointF(cosA*size.cx+sinA*size.cy,cosA*size.cy-sinA*size.cx);
+  BottomLeft := PointF(sinA*size.cy,cosA*size.cy);
+  TopLeft := PointF(sinA*dy,cosA*dy);
+  xf += TopLeft.x/sizeFactor;
+  yf += TopLeft.y/sizeFactor;
+  TopRight := TopLeft + PointF(cosA*size.cx,-sinA*size.cx);
+  BottomRight := TopRight + PointF(sinA*size.cy,cosA*size.cy);
+  BottomLeft := TopLeft + PointF(sinA*size.cy,cosA*size.cy);
   rotBounds := rect(0,0,0,0);
   Top := 0;
 …
 end;
 procedure BGRATextRect(bmp: TBGRACustomBitmap; Font: TFont; Quality: TBGRAFontQuality; ARect: TRect; x, y: integer;
+procedure BGRATextRect(bmp: TBGRACustomBitmap; Font: TFont; Quality: TBGRAFontQuality; ARect: TRect; xf, yf: single;
   sUTF8: string; style: TTextStyle; c: TBGRAPixel; tex: IBGRAScanner; CustomAntialiasingLevel: Integer = 0);
 var
 …
     Canvas.Font.Color := clWhite;
     Canvas.Brush.Style := bsClear;
+    Canvas.TextRect(rect(lim.Left-ARect.Left, lim.Top-ARect.Top, (ARect.Right-ARect.Left)*sizeFactor, (ARect.Bottom-ARect.Top)*sizeFactor), (x - lim.Left)*sizeFactor, (y - lim.Top)*sizeFactor, sUTF8, style);
+    Canvas.TextRect(rect(lim.Left-ARect.Left, lim.Top-ARect.Top,
+                         (ARect.Right-ARect.Left)*sizeFactor, (ARect.Bottom-ARect.Top)*sizeFactor),
+                         round((xf - lim.Left)*sizeFactor), round((yf - lim.Top)*sizeFactor), sUTF8, style);
   end;
   {$IFDEF RENDER_TEXT_ON_TBITMAP}
 …
 end;
-{ TLCLFontRenderer }
-function TLCLFontRenderer.TextSurfaceSmaller(sUTF8: string; ARect: TRect): boolean;
-begin
-  with TextSize(sUTF8) do
-    result := cx*cy < (ARect.Right-ARect.Left)*(ARect.Bottom-ARect.Top);
-end;
-procedure TLCLFontRenderer.TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x,
-  y: integer; sUTF8: string; style: TTextStyle; c: TBGRAPixel);
-begin
-  if not style.Clipping or TextSurfaceSmaller(sUTF8,ARect) then
-  begin
-    InternalTextRect(ADest,ARect,x,y,sUTF8,style,c,nil);
-    exit;
-  end;
-  UpdateFont;
-  BGRAText.BGRATextRect(ADest,FFont,FontQuality,ARect,x,y,sUTF8,style,c,nil);
-end;
-procedure TLCLFontRenderer.TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x,
-  y: integer; sUTF8: string; style: TTextStyle; texture: IBGRAScanner);
-begin
-  if not style.Clipping or TextSurfaceSmaller(sUTF8,ARect) then
-  begin
-    InternalTextRect(ADest,ARect,x,y,sUTF8,style,BGRAPixelTransparent,texture);
-    exit;
-  end;
-  UpdateFont;
-  BGRAText.BGRATextRect(ADest,FFont,FontQuality,ARect,x,y,sUTF8,style,BGRAPixelTransparent,texture);
-end;
 { TCustomLCLFontRenderer }
 { Update font properties to internal TFont object }
 procedure TCustomLCLFontRenderer.UpdateFont;
+var fixedHeight: integer;
 begin
   if FFont.Name <> FontName then
 …
   if FFont.Style <> FontStyle then
     FFont.Style := FontStyle;
+  if FFont.Height <> FontEmHeight * FontEmHeightSign then
+    FFont.Height := FontEmHeight * FontEmHeightSign;
+  if FontEmHeight < 0 then
+    fixedHeight := FixLCLFontFullHeight(FontName, FontEmHeight * FontEmHeightSign)
+  else
+    fixedHeight := FontEmHeight * FontEmHeightSign;
+  if FFont.Height <> fixedHeight then
+    FFont.Height := fixedHeight;
   if FFont.Orientation <> FontOrientation then
     FFont.Orientation := FontOrientation;
 …
 end;
+function TCustomLCLFontRenderer.TextSizeNoUpdateFont(sUTF8: string): TSize;
+begin
+function TCustomLCLFontRenderer.InternalTextSize(sUTF8: string; AShowPrefix: boolean): TSize;
+begin
+  if AShowPrefix then sUTF8 := RemovePrefix(sUTF8);
   result := BGRAText.BGRATextSize(FFont,FontQuality,sUTF8,FontAntialiasingLevel);
   if (result.cy >= 24) and (FontQuality in[fqFineAntialiasing,fqFineClearTypeBGR,fqFineClearTypeRGB]) then
 …
 procedure TCustomLCLFontRenderer.SplitText(var ATextUTF8: string;
   AMaxWidth: integer; out ARemainsUTF8: string);
+var p,totalWidth: integer;
+begin
+  if ATextUTF8= '' then
+  begin
+    ARemainsUTF8 := '';
+    exit;
+  end;
+  if RemoveLineEnding(ATextUTF8,1) then
+  begin
+    ARemainsUTF8:= ATextUTF8;
+    ATextUTF8 := '';
+    exit;
+  end;
+var WordBreakHandler: TWordBreakHandler;
+begin
   UpdateFont;
+  p := 1;
+  inc(p, UTF8CharacterLength(@ATextUTF8[p])); //UTF8 chars may be more than 1 byte long
+  while p < length(ATextUTF8)+1 do
+  begin
+    if RemoveLineEnding(ATextUTF8,p) then
+    begin
+      ARemainsUTF8:= copy(ATextUTF8,p,length(ATextUTF8)-p+1);
+      ATextUTF8 := copy(ATextUTF8,1,p-1);
+      exit;
+    end;
+    totalWidth := TextSizeNoUpdateFont(copy(ATextUTF8,1,p+UTF8CharacterLength(@ATextUTF8[p])-1)).cx; //copy whole last UTF8 char
+    if totalWidth > AMaxWidth then
+    begin
+      ARemainsUTF8:= copy(ATextUTF8,p,length(ATextUTF8)-p+1);
+      ATextUTF8 := copy(ATextUTF8,1,p-1); //this includes the whole last UTF8 char
+      if Assigned(FWordBreakHandler) then
+        FWordBreakHandler(ATextUTF8,ARemainsUTF8) else
+          BGRADefaultWordBreakHandler(ATextUTF8,ARemainsUTF8);
+      exit;
+    end;
+    inc(p, UTF8CharacterLength(@ATextUTF8[p]));
+  end;
+  ARemainsUTF8 := '';
+  if Assigned(FWordBreakHandler) then
+    WordBreakHandler := FWordBreakHandler
+  else
+    WordBreakHandler := @DefaultWorkBreakHandler;
+  InternalSplitText(ATextUTF8, AMaxWidth, ARemainsUTF8, WordBreakHandler);
 end;
 …
 procedure TCustomLCLFontRenderer.TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string;
   texture: IBGRAScanner; align: TAlignment);
-var mode : TBGRATextOutImproveReadabilityMode;
 begin
   UpdateFont;
+  if Assigned(BGRATextOutImproveReadabilityProc) and (FontQuality in[fqFineAntialiasing,fqFineClearTypeBGR,fqFineClearTypeRGB]) and (FFont.Orientation mod 3600 = 0) then
+  begin
+    case FontQuality of
+      fqFineClearTypeBGR: mode := irClearTypeBGR;
+      fqFineClearTypeRGB: mode := irClearTypeRGB;
+    else
+      mode := irNormal;
+    end;
+    BGRATextOutImproveReadabilityProc(ADest,FFont,x,y,sUTF8,BGRAPixelTransparent,texture,align,mode);
+  end else
+    BGRAText.BGRATextOut(ADest,FFont,FontQuality,x,y,sUTF8,BGRAPixelTransparent,texture,align);
+  InternalTextOut(ADest, x,y, sUTF8, BGRAPixelTransparent,texture, align);
 end;
 procedure TCustomLCLFontRenderer.TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; c: TBGRAPixel;
   align: TAlignment);
-var mode : TBGRATextOutImproveReadabilityMode;
 begin
   UpdateFont;
+  if Assigned(BGRATextOutImproveReadabilityProc) and (FontQuality in[fqFineAntialiasing,fqFineClearTypeBGR,fqFineClearTypeRGB]) and (FFont.Orientation mod 3600 = 0) then
+  begin
+    case FontQuality of
+      fqFineClearTypeBGR: mode := irClearTypeBGR;
+      fqFineClearTypeRGB: mode := irClearTypeRGB;
+    else
+      mode := irNormal;
+    end;
+    BGRATextOutImproveReadabilityProc(ADest,FFont,x,y,sUTF8,c,nil,align,mode);
+  end else
+    BGRAText.BGRATextOut(ADest,FFont,FontQuality,x,y,sUTF8,c,nil,align);
+  InternalTextOut(ADest, x,y, sUTF8, c,nil, align);
+end;
+procedure TCustomLCLFontRenderer.TextOut(ADest: TBGRACustomBitmap; x,
+  y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment;
+  ARightToLeft: boolean);
+begin
+  UpdateFont;
+  InternalTextOut(ADest, x,y, sUTF8, BGRAPixelTransparent,texture, align,
+                False, ARightToLeft);
+end;
+procedure TCustomLCLFontRenderer.TextOut(ADest: TBGRACustomBitmap; x,
+  y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment;
+  ARightToLeft: boolean);
+begin
+  UpdateFont;
+  InternalTextOut(ADest, x,y, sUTF8, c,nil, align, false, ARightToLeft);
 end;
 …
   style: TTextStyle; c: TBGRAPixel);
 begin
+  UpdateFont;
   InternalTextRect(ADest,ARect,x,y,sUTF8,style,c,nil);
 end;
 …
   style: TTextStyle; texture: IBGRAScanner);
 begin
+  UpdateFont;
   InternalTextRect(ADest,ARect,x,y,sUTF8,style,BGRAPixelTransparent,texture);
 end;
 …
 procedure TCustomLCLFontRenderer.TextWordBreak(ADest: TBGRACustomBitmap;
   AText: string; x, y, AMaxWidth: integer; AColor: TBGRAPixel;
+  AHorizAlign: TAlignment; AVertAlign: TTextLayout);
+begin
+  InternalTextWordBreak(ADest,AText,x,y,AMaxWidth,AColor,nil,AHorizAlign,AVertAlign);
+  AHorizAlign: TAlignment; AVertAlign: TTextLayout; ARightToLeft: boolean);
+begin
+  UpdateFont;
+  InternalTextWordBreak(ADest,AText,x,y,AMaxWidth,AColor,nil,AHorizAlign,AVertAlign,ARightToLeft);
 end;
 procedure TCustomLCLFontRenderer.TextWordBreak(ADest: TBGRACustomBitmap;
   AText: string; x, y, AMaxWidth: integer; ATexture: IBGRAScanner;
+  AHorizAlign: TAlignment; AVertAlign: TTextLayout);
+begin
+  InternalTextWordBreak(ADest,AText,x,y,AMaxWidth,BGRAPixelTransparent,ATexture,AHorizAlign,AVertAlign);
+  AHorizAlign: TAlignment; AVertAlign: TTextLayout; ARightToLeft: boolean);
+begin
+  UpdateFont;
+  InternalTextWordBreak(ADest,AText,x,y,AMaxWidth,BGRAPixelTransparent,ATexture,AHorizAlign,AVertAlign,ARightToLeft);
 end;
 procedure TCustomLCLFontRenderer.InternalTextWordBreak(
   ADest: TBGRACustomBitmap; ATextUTF8: string; x, y, AMaxWidth: integer;
+  AColor: TBGRAPixel; ATexture: IBGRAScanner; AHorizAlign: TAlignment; AVertAlign: TTextLayout);
+var ARemains: string;
+  AColor: TBGRAPixel; ATexture: IBGRAScanner; AHorizAlign: TAlignment;
+  AVertAlign: TTextLayout; ARightToLeft: boolean);
+var remains, part, curText,nextText: string;
   stepX,stepY: integer;
   lines: TStringList;
   i: integer;
   lineShift: single;
+  WordBreakHandler: TWordBreakHandler;
+  lineEndingBreak: boolean;
+  bidiLayout: TBidiTextLayout;
+  bidiAlign: TBidiTextAlignment;
 begin
   if (ATextUTF8 = '') or (AMaxWidth <= 0) then exit;
+  if Assigned(FWordBreakHandler) then
+    WordBreakHandler := FWordBreakHandler
+  else
+    WordBreakHandler := @DefaultWorkBreakHandler;
+  if ContainsBidiIsolateOrFormattingUTF8(ATextUTF8) then
+  begin
+    bidiLayout := TBidiTextLayout.Create(self, ATextUTF8, ARightToLeft);
+    bidiLayout.WordBreakHandler:= WordBreakHandler;
+    bidiLayout.AvailableWidth := AMaxWidth;
+    case AHorizAlign of
+      taLeftJustify: bidiAlign:= btaLeftJustify;
+      taRightJustify: begin
+        bidiAlign:= btaRightJustify;
+        x -= AMaxWidth;
+      end
+      else
+      begin
+        bidiAlign:= btaCenter;
+        x -= AMaxWidth div 2;
+      end;
+    end;
+    for i := 0 to bidiLayout.ParagraphCount-1 do
+      bidiLayout.ParagraphAlignment[i] := bidiAlign;
+    case AVertAlign of
+      tlBottom: bidiLayout.TopLeft := PointF(x, y - bidiLayout.TotalTextHeight);
+      tlCenter: bidiLayout.TopLeft := PointF(x, y - bidiLayout.TotalTextHeight/2);
+    end;
+    if ATexture <> nil then bidiLayout.DrawText(ADest, ATexture)
+    else bidiLayout.DrawText(ADest, AColor);
+    bidiLayout.Free;
+    exit;
+  end;
   stepX := 0;
   stepY := TextSize('Hg').cy;
+  if AVertAlign = tlTop then
+  begin
+    repeat
+      SplitText(ATextUTF8, AMaxWidth, ARemains);
+      if ATexture <> nil then
+        TextOut(ADest,x,y,ATextUTF8,ATexture,AHorizAlign)
+      else
+        TextOut(ADest,x,y,ATextUTF8,AColor,AHorizAlign);
+      ATextUTF8 := ARemains;
+      X+= stepX;
+      Y+= stepY;
+    until ARemains = '';
+  end else
+  begin
+    lines := TStringList.Create;
+    repeat
+      SplitText(ATextUTF8, AMaxWidth, ARemains);
+      lines.Add(ATextUTF8);
+      ATextUTF8 := ARemains;
+    until ARemains = '';
+    if AVertAlign = tlCenter then lineShift := lines.Count/2
+    else if AVertAlign = tlBottom then lineShift := lines.Count
+    else lineShift := 0;
+    X -= round(stepX*lineShift);
+    Y -= round(stepY*lineShift);
+    for i := 0 to lines.Count-1 do
+    begin
+      if ATexture <> nil then
+        TextOut(ADest,x,y,lines[i],ATexture,AHorizAlign)
+      else
+        TextOut(ADest,x,y,lines[i],AColor,AHorizAlign);
+      X+= stepX;
+      Y+= stepY;
+    end;
+    lines.Free;
+  end;
+  lines := TStringList.Create;
+  curText := ATextUTF8;
+  repeat
+    InternalSplitText(curText, AMaxWidth, remains, lineEndingBreak, WordBreakHandler);
+    part := curText;
+    if not lineEndingBreak then
+      // append following direction to part
+      case GetFirstStrongBidiClassUTF8(remains) of
+        ubcLeftToRight: if ARightToLeft then part += UnicodeCharToUTF8($200E);
+        ubcRightToLeft,ubcArabicLetter: if not ARightToLeft then part += UnicodeCharToUTF8($200F);
+      end;
+    lines.Add(part);
+    // prefix next part with previous direction
+    nextText := remains;
+    if not lineEndingBreak then
+      case GetLastStrongBidiClassUTF8(curText) of
+        ubcLeftToRight: if ARightToLeft then nextText := UnicodeCharToUTF8($200E) + nextText;
+        ubcRightToLeft,ubcArabicLetter: if not ARightToLeft then nextText := UnicodeCharToUTF8($200F) + nextText;
+      end;
+    curText := nextText;
+  until remains = '';
+  if AVertAlign = tlCenter then lineShift := lines.Count/2
+  else if AVertAlign = tlBottom then lineShift := lines.Count
+  else lineShift := 0;
+  X -= round(stepX*lineShift);
+  Y -= round(stepY*lineShift);
+  for i := 0 to lines.Count-1 do
+  begin
+    InternalTextOut(ADest,x,y,lines[i],AColor,ATexture,AHorizAlign,false,ARightToLeft);
+    X+= stepX;
+    Y+= stepY;
+  end;
+  lines.Free;
 end;
 …
 var
   previousClip, intersected: TRect;
+  oldOrientation: integer;
+  lines: TStringList;
+  iStart,i,h: integer;
+  availableWidth: integer;
 begin
   previousClip := ADest.ClipRect;
 …
     ADest.ClipRect := intersected;
   end;
   oldOrientation:= FontOrientation;
   FontOrientation:= 0;
+  FFont.Orientation := 0;
+  if style.SystemFont then FFont.Name := 'default';
   if not (style.Alignment in[taCenter,taRightJustify]) then ARect.Left := x;
   if not (style.Layout in[tlCenter,tlBottom]) then ARect.top := y;
+  if ARect.Right <= ARect.Left then exit;
+  if (ARect.Right <= ARect.Left) and style.Clipping then
+  begin
+    ADest.ClipRect := previousClip;
+    exit;
+  end;
   if style.Layout = tlCenter then Y := (ARect.Top+ARect.Bottom) div 2 else
   if style.Layout = tlBottom then Y := ARect.Bottom else
 …
     X := ARect.Left;
   if style.Wordbreak then
+    InternalTextWordBreak(ADest,sUTF8,X,Y,ARect.Right-ARect.Left,c,ATexture,style.Alignment,style.Layout)
+  begin
+    if style.ShowPrefix then sUTF8 := RemovePrefix(sUTF8); //prefix not handled
+    InternalTextWordBreak(ADest,sUTF8,X,Y,ARect.Right-ARect.Left,c,ATexture,
+        style.Alignment,style.Layout,style.RightToLeft);
+  end
   else
   begin
+    if style.Layout = tlCenter then Y -= TextSize(sUTF8).cy div 2;
+    if style.Layout = tlBottom then Y -= TextSize(sUTF8).cy;
+    if ATexture <> nil then
+      TextOut(ADest,X,Y,sUTF8,ATexture,style.Alignment)
+    lines := nil;
+    iStart := 1;
+    if not style.SingleLine then
+    begin
+      i := iStart;
+      while i <= length(sUTF8) do
+      begin
+        if sUTF8[i] in[#13,#10] then
+        begin
+          if not assigned(lines) then lines := TStringList.Create;
+          lines.add(copy(sUTF8,iStart,i-iStart));
+          if (sUTF8[i]=#13) and (i < length(sUTF8)) and (sUTF8[i+1]=#10) then inc(i);
+          iStart := i+1
+        end;
+        inc(i);
+      end;
+    end;
+    if style.Alignment = taLeftJustify then
+      availableWidth := ARect.Right-X
     else
+      TextOut(ADest,X,Y,sUTF8,c,style.Alignment);
+  end;
+  FontOrientation:= oldOrientation;
+      availableWidth := ARect.Right-ARect.Left;
+    if availableWidth < 0 then availableWidth:= 0;
+    if lines = nil then //only one line
+    begin
+      if style.Layout = tlCenter then Y -= InternalTextSize(sUTF8,style.ShowPrefix).cy div 2;
+      if style.Layout = tlBottom then Y -= InternalTextSize(sUTF8,style.ShowPrefix).cy;
+      if style.EndEllipsis then
+        InternalTextOutEllipse(ADest,X,Y,availableWidth,sUTF8,c,ATexture,style.Alignment,
+                        style.ShowPrefix,style.RightToLeft)
+      else
+        InternalTextOut(ADest,X,Y,sUTF8,c,ATexture,style.Alignment,
+                        style.ShowPrefix,style.RightToLeft);
+    end else
+    begin    //multiple lines
+      lines.add(copy(sUTF8, iStart, length(sUTF8)-iStart+1));
+      h := InternalTextSize('Hg',False).cy;
+      if style.Layout = tlCenter then Y -= h*lines.Count div 2;
+      if style.Layout = tlBottom then Y -= h*lines.Count;
+      for i := 0 to lines.Count-1 do
+      begin
+        if style.EndEllipsis then
+          InternalTextOutEllipse(ADest,X,Y,availableWidth,lines[i],c,ATexture,style.Alignment,
+                          style.ShowPrefix,style.RightToLeft)
+        else
+          InternalTextOut(ADest,X,Y,lines[i],c,ATexture,style.Alignment,
+                          style.ShowPrefix,style.RightToLeft);
+        inc(Y,h);
+      end;
+      lines.Free;
+    end;
+  end;
   if style.Clipping then
     ADest.ClipRect := previousClip;
+end;
+procedure TCustomLCLFontRenderer.InternalTextOut(ADest: TBGRACustomBitmap; x,
+  y: single; sUTF8: string; c: TBGRAPixel; texture: IBGRAScanner;
+  align: TAlignment; AShowPrefix: boolean = false; ARightToLeft: boolean = false);
+var mode : TBGRATextOutImproveReadabilityMode;
+begin
+  {$IFDEF LINUX}
+  //help LCL detect the correct direction
+  case GetFirstStrongBidiClassUTF8(sUTF8) of
+    ubcRightToLeft, ubcArabicLetter: if not ARightToLeft then sUTF8 := UnicodeCharToUTF8($200E) + sUTF8;
+    else
+      begin //suppose left-to-right
+        if ARightToLeft then sUTF8 := UnicodeCharToUTF8($200F) + sUTF8;
+      end;
+  end;
+  {$ENDIF}
+  if Assigned(BGRATextOutImproveReadabilityProc) and (FontQuality in[fqFineAntialiasing,fqFineClearTypeBGR,fqFineClearTypeRGB]) and (FFont.Orientation mod 3600 = 0) then
+  begin
+    case FontQuality of
+      fqFineClearTypeBGR: mode := irClearTypeBGR;
+      fqFineClearTypeRGB: mode := irClearTypeRGB;
+    else
+      mode := irNormal;
+    end;
+    if AShowPrefix then sUTF8 := RemovePrefix(sUTF8); //prefix not handled
+    BGRATextOutImproveReadabilityProc(ADest,FFont,x,y,sUTF8,c,texture,align,mode);
+  end else
+    BGRAText.BGRATextOut(ADest,FFont,FontQuality,x,y,sUTF8,c,texture,align,
+,AShowPrefix,ARightToLeft);
+end;
+procedure TCustomLCLFontRenderer.InternalTextOutEllipse(
+  ADest: TBGRACustomBitmap; x, y, availableWidth: single; sUTF8: string;
+  c: TBGRAPixel; texture: IBGRAScanner; align: TAlignment;
+  AShowPrefix: boolean; ARightToLeft: boolean);
+var remain: string;
+begin
+  if InternalTextSize(sUTF8,AShowPrefix).cx > availableWidth then
+  begin
+    InternalSplitText(sUTF8, round(availableWidth - InternalTextSize('...',AShowPrefix).cx), remain, nil);
+    sUTF8 += '...';
+  end;
+  InternalTextOut(ADest,x,y,sUTF8,c,texture,align,AShowPrefix,ARightToLeft);
+end;
+procedure TCustomLCLFontRenderer.InternalSplitText(var ATextUTF8: string;
+  AMaxWidth: integer; out ARemainsUTF8: string; out ALineEndingBreak: boolean; AWordBreak: TWordBreakHandler);
+var p,skipCount, charLen: integer;
+  zeroWidth: boolean;
+  u: Cardinal;
+begin
+  ALineEndingBreak:= false;
+  if ATextUTF8= '' then
+  begin
+    ARemainsUTF8 := '';
+    exit;
+  end;
+  if RemoveLineEnding(ATextUTF8,1) then
+  begin
+    ARemainsUTF8:= ATextUTF8;
+    ATextUTF8 := '';
+    ALineEndingBreak:= true;
+    exit;
+  end;
+  if AMaxWidth <= 0 then
+    skipCount := 0
+  else
+    skipCount := BGRATextFitInfo(FFont, FontQuality, ATextUTF8, FontAntialiasingLevel, AMaxWidth);
+  if skipCount <= 0 then skipCount := 1;
+  p := 1;
+  zeroWidth := true;
+  repeat
+    charLen := UTF8CharacterLength(@ATextUTF8[p]);
+    u := UTF8CodepointToUnicode(@ATextUTF8[p], charLen);
+    if not IsZeroWidthUnicode(u) then
+      zeroWidth:= false;
+    inc(p, charLen); //UTF8 chars may be more than 1 byte long
+    dec(skipCount);
+    if RemoveLineEnding(ATextUTF8,p) then
+    begin
+      ARemainsUTF8:= copy(ATextUTF8,p,length(ATextUTF8)-p+1);
+      ATextUTF8 := copy(ATextUTF8,1,p-1);
+      ALineEndingBreak:= true;
+      exit;
+    end;
+  until ((skipCount <= 0) and not zeroWidth) or (p >= length(ATextUTF8)+1);
+  ARemainsUTF8:= copy(ATextUTF8,p,length(ATextUTF8)-p+1);
+  ATextUTF8 := copy(ATextUTF8,1,p-1); //this includes the whole last UTF8 char
+  if Assigned(AWordBreak) then AWordBreak(ATextUTF8,ARemainsUTF8);
+end;
+procedure TCustomLCLFontRenderer.InternalSplitText(var ATextUTF8: string;
+  AMaxWidth: integer; out ARemainsUTF8: string; AWordBreak: TWordBreakHandler);
+var lineEndingBreak: boolean;
+begin
+  InternalSplitText(ATextUTF8,AMaxWidth,ARemainsUTF8,lineEndingBreak,AWordBreak);
+end;
+procedure TCustomLCLFontRenderer.DefaultWorkBreakHandler(var ABeforeUTF8,
+  AAfterUTF8: string);
+begin
+  BGRADefaultWordBreakHandler(ABeforeUTF8,AAfterUTF8);
 end;
 …
   FontOrientation:= 0;
   UpdateFont;
   result := TextSizeNoUpdateFont(sUTF8);
+  result := InternalTextSize(sUTF8,False);
   FontOrientation:= oldOrientation;
+end;
+function TCustomLCLFontRenderer.TextSizeAngle(sUTF8: string;
+  orientationTenthDegCCW: integer): TSize;
+var oldOrientation: integer;
+begin
+  oldOrientation:= FontOrientation;
+  FontOrientation:= orientationTenthDegCCW;
+  UpdateFont;
+  result := InternalTextSize(sUTF8,False);
+  FontOrientation:= oldOrientation;
+end;
+function TCustomLCLFontRenderer.TextSize(sUTF8: string;
+  AMaxWidth: integer; ARightToLeft: boolean): TSize;
+var
+  remains: string;
+  h, i, w: integer;
+  WordBreakHandler: TWordBreakHandler;
+  layout: TBidiTextLayout;
+begin
+  UpdateFont;
+  if Assigned(FWordBreakHandler) then
+    WordBreakHandler := FWordBreakHandler
+  else
+    WordBreakHandler := @DefaultWorkBreakHandler;
+  if ContainsBidiIsolateOrFormattingUTF8(sUTF8) then
+  begin
+    layout := TBidiTextLayout.Create(self, sUTF8, ARightToLeft);
+    layout.WordBreakHandler:= WordBreakHandler;
+    layout.AvailableWidth := AMaxWidth;
+    for i := 0 to layout.ParagraphCount-1 do
+      layout.ParagraphAlignment[i] := btaLeftJustify;
+    result.cx := 0;
+    for i := 0 to layout.PartCount-1 do
+    begin
+      w := ceil(layout.PartRectF[i].Right);
+      if w > result.cx then result.cx := w;
+    end;
+    result.cy := ceil(layout.TotalTextHeight);
+    layout.Free;
+  end else
+  begin
+    result.cx := 0;
+    result.cy := 0;
+    h := InternalTextSize('Hg',False).cy;
+    repeat
+      InternalSplitText(sUTF8, AMaxWidth, remains, WordBreakHandler);
+      with InternalTextSize(sUTF8, false) do
+        if cx > result.cx then result.cx := cx;
+      result.cy += h;
+      sUTF8 := remains;
+    until remains = '';
+  end;
+end;
+function TCustomLCLFontRenderer.TextFitInfo(sUTF8: string; AMaxWidth: integer
+  ): integer;
+begin
+  UpdateFont;
+  result := BGRATextFitInfo(FFont, FontQuality, sUTF8, FontAntialiasingLevel, AMaxWidth);
 end;

GraphicTest/Packages/bgrabitmap/bgratextfx.pas

-              r494
+              r521
     OutlineVisible,OuterOutlineOnly: boolean;
     OutlineTexture: IBGRAScanner;
     constructor Create;
     constructor Create(AShader: TCustomPhongShading; AShaderOwner: boolean);
+    constructor Create; overload;
+    constructor Create(AShader: TCustomPhongShading; AShaderOwner: boolean); overload;
     destructor Destroy; override;
     procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientation: integer;
       s: string; texture: IBGRAScanner; align: TAlignment); override;
+      s: string; texture: IBGRAScanner; align: TAlignment); overload; override;
     procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientation: integer;
+      s: string; c: TBGRAPixel; align: TAlignment); override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; s: string;
+      texture: IBGRAScanner; align: TAlignment); override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; s: string; c: TBGRAPixel;
+      align: TAlignment); override;
+    function TextSize(sUTF8: string): TSize; override;
+      s: string; c: TBGRAPixel; align: TAlignment); overload; override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; s: string; texture: IBGRAScanner; align: TAlignment); overload; override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; s: string; c: TBGRAPixel; align: TAlignment); overload; override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment; {%H-}ARightToLeft: boolean); overload; override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment; {%H-}ARightToLeft: boolean); overload; override;
+    function TextSize(sUTF8: string): TSize; overload; override;
+    function TextSize(sUTF8: string; AMaxWidth: integer; {%H-}ARightToLeft: boolean): TSize; overload; override;
+    function TextFitInfo(sUTF8: string; AMaxWidth: integer): integer; override;
     property Shader: TCustomPhongShading read FShader;
     property ShaderLightPosition: TPoint read GetShaderLightPosition write SetShaderLightPosition;
 …
     procedure InitWithFontName(AText: string; AFontName: string; AFullHeight: integer; AStyle: TFontStyles; Antialiasing: boolean; SubOffsetX,SubOffsetY: single);
   public
     constructor Create(AText: string; Font: TFont; Antialiasing: boolean);
     constructor Create(AText: string; Font: TFont; Antialiasing: boolean; SubOffsetX,SubOffsetY: single);
     constructor Create(AText: string; Font: TFont; Antialiasing: boolean; SubOffsetX,SubOffsetY: single; GrainX, GrainY: Integer);
     constructor Create(AText: string; AFontName: string; AFullHeight: integer; Antialiasing: boolean);
     constructor Create(AText: string; AFontName: string; AFullHeight: integer; Antialiasing: boolean; SubOffsetX,SubOffsetY: single);
     constructor Create(AText: string; AFontName: string; AFullHeight: integer; AStyle: TFontStyles; Antialiasing: boolean);
     constructor Create(AText: string; AFontName: string; AFullHeight: integer; AStyle: TFontStyles; Antialiasing: boolean; SubOffsetX,SubOffsetY: single);
+    constructor Create(AText: string; Font: TFont; Antialiasing: boolean); overload;
+    constructor Create(AText: string; Font: TFont; Antialiasing: boolean; SubOffsetX,SubOffsetY: single); overload;
+    constructor Create(AText: string; Font: TFont; Antialiasing: boolean; SubOffsetX,SubOffsetY: single; GrainX, GrainY: Integer); overload;
+    constructor Create(AText: string; AFontName: string; AFullHeight: integer; Antialiasing: boolean); overload;
+    constructor Create(AText: string; AFontName: string; AFullHeight: integer; Antialiasing: boolean; SubOffsetX,SubOffsetY: single); overload;
+    constructor Create(AText: string; AFontName: string; AFullHeight: integer; AStyle: TFontStyles; Antialiasing: boolean); overload;
+    constructor Create(AText: string; AFontName: string; AFullHeight: integer; AStyle: TFontStyles; Antialiasing: boolean; SubOffsetX,SubOffsetY: single); overload;
   end;
 …
 end;
+procedure TBGRATextEffectFontRenderer.TextOut(ADest: TBGRACustomBitmap; x,
+  y: single; sUTF8: string; texture: IBGRAScanner; align: TAlignment;
+  ARightToLeft: boolean);
+begin
+  if VectorizedFontNeeded then
+    VectorizedFontRenderer.TextOut(ADest,x,y,sUTF8,texture,align,ARightToLeft)
+  else
+    InternalTextOut(ADest,x,y,sUTF8,BGRAPixelTransparent,texture,align);
+end;
+procedure TBGRATextEffectFontRenderer.TextOut(ADest: TBGRACustomBitmap; x,
+  y: single; sUTF8: string; c: TBGRAPixel; align: TAlignment;
+  ARightToLeft: boolean);
+begin
+  if VectorizedFontNeeded then
+    VectorizedFontRenderer.TextOut(ADest,x,y,sUTF8,c,align,ARightToLeft)
+  else
+    InternalTextOut(ADest,x,y,sUTF8,c,nil,align);
+end;
 function TBGRATextEffectFontRenderer.TextSize(sUTF8: string): TSize;
 begin
 …
     result := VectorizedFontRenderer.TextSize(sUTF8)
   else
-  begin
     result := inherited TextSize(sUTF8);
+  end;
+end;
+function TBGRATextEffectFontRenderer.TextSize(sUTF8: string;
+  AMaxWidth: integer; ARightToLeft: boolean): TSize;
+begin
+  if VectorizedFontNeeded then
+    result := VectorizedFontRenderer.TextSize(sUTF8, AMaxWidth, ARightToLeft)
+  else
+    result := inherited TextSize(sUTF8, AMaxWidth, ARightToLeft);
+end;
+function TBGRATextEffectFontRenderer.TextFitInfo(sUTF8: string;
+  AMaxWidth: integer): integer;
+begin
+  if VectorizedFontNeeded then
+    result := VectorizedFontRenderer.TextFitInfo(sUTF8, AMaxWidth)
+  else
+    result := inherited TextFitInfo(sUTF8, AMaxWidth)
 end;
 …
   overhang: integer;
 begin
+  FShadowQuality:= rbFast;
   if SubOffsetX < 0 then SubOffsetX := 0;
   if SubOffsetY < 0 then SubOffsetY := 0;

GraphicTest/Packages/bgrabitmap/bgrathumbnail.pas

-              r494
+              r521
   Classes, SysUtils, BGRABitmap, BGRABitmapTypes, FPimage;
+function GetBitmapThumbnail(ABitmap: TBGRABitmap; AWidth,AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap= nil; AVerticalShrink : single = 1): TBGRABitmap;
+function GetBitmapThumbnail(ABitmap: TBGRACustomBitmap; AWidth,AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap= nil; AVerticalShrink: single = 1; AHorizShrink: single = 1): TBGRABitmap; overload;
+function GetBitmapThumbnail(ABitmap: TBGRACustomBitmap; AFormat: TBGRAImageFormat; AWidth,AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap= nil; AVerticalShrink: single = 1; AHorizShrink: single = 1): TBGRABitmap; overload;
 function GetFileThumbnail(AFilenameUTF8: string; AWidth,AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap= nil): TBGRABitmap;
 function GetStreamThumbnail(AStream: TStream; AWidth,AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean; ASuggestedExtensionUTF8: string = ''; ADest: TBGRABitmap= nil): TBGRABitmap; overload;
 …
 function GetPaintDotNetThumbnail(AStream: TStream; AWidth, AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap= nil): TBGRABitmap;
 function GetBmpThumbnail(AStream: TStream; AWidth, AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap= nil): TBGRABitmap;
-{$IFDEF BGRABITMAP_USE_LCL}
 function GetIcoThumbnail(AStream: TStream; AWidth, AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap= nil): TBGRABitmap;
+{$ENDIF}
+function GetCurThumbnail(AStream: TStream; AWidth, AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap= nil): TBGRABitmap;
 function GetPcxThumbnail(AStream: TStream; AWidth, AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap= nil): TBGRABitmap;
 …
 function GetBmpMioMapThumbnail(AStream: TStream; AWidth, AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap= nil): TBGRABitmap;
+procedure DrawThumbnailCheckers(bmp: TBGRABitmap; ARect: TRect);
+procedure DrawThumbnailCheckers(bmp: TBGRABitmap; ARect: TRect; AIconCheckers: boolean = false);
+var
+  ImageCheckersColor1,ImageCheckersColor2  : TBGRAPixel;
+  IconCheckersColor1,IconCheckersColor2  : TBGRAPixel;
 implementation
 uses Types, base64, BGRAUTF8, {$IFDEF BGRABITMAP_USE_LCL}Graphics, GraphType,{$ENDIF}
+uses Types, base64, BGRAUTF8,
      DOM, XMLRead, BGRAReadJPEG, BGRAReadPng, BGRAReadGif, BGRAReadBMP,
      BGRAReadPSD, BGRAReadIco, UnzipperExt, BGRAReadLzp;
+procedure DrawThumbnailCheckers(bmp: TBGRABitmap; ARect: TRect);
+begin
+  bmp.DrawCheckers(ARect, BGRA(255,255,255), BGRA(220,220,220));
+end;
+function GetBitmapThumbnail(ABitmap: TBGRABitmap; AWidth, AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap; AVerticalShrink: single
+  ): TBGRABitmap;
+procedure DrawThumbnailCheckers(bmp: TBGRABitmap; ARect: TRect; AIconCheckers: boolean);
+begin
+  if AIconCheckers then
+    bmp.DrawCheckers(ARect, IconCheckersColor1, IconCheckersColor2)
+  else
+    bmp.DrawCheckers(ARect, ImageCheckersColor1, ImageCheckersColor2);
+end;
+function InternalGetBitmapThumbnail(ABitmap: TBGRACustomBitmap; AWidth, AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean;
+  ADest: TBGRABitmap; AVerticalShrink: single = 1; AHorizShrink: single = 1; AShowHotSpot: boolean = false; ADarkCheckers: boolean = false): TBGRABitmap;
 var
   factorX, factorY, factor: single;
   xIcon,yIcon,wIcon,hIcon: Integer;
+  hotspot: TPoint;
 begin
   result := nil;
 …
       end else
         result := TBGRABitmap.Create(AWidth,AHeight,ABackColor);
       factorX := result.Width/ABitmap.Width;
+      factorX := result.Width/(ABitmap.Width*AHorizShrink);
       factorY := result.Height/(ABitmap.Height*AVerticalShrink);
       if factorX < factorY then factor := factorX else factor := factorY;
+      wIcon := round(ABitmap.Width*factor);
+      wIcon := round(ABitmap.Width*AHorizShrink*factor);
+      if wIcon = 0 then wIcon := 1;
       hIcon := round(ABitmap.Height*AVerticalShrink*factor);
+      if hIcon = 0 then hIcon := 1;
       xIcon:= (result.Width-wIcon) div 2;
       yIcon:= (result.Height-hIcon) div 2;
+      if ACheckers then DrawThumbnailCheckers(result,Rect(xIcon,yIcon,xIcon+wIcon,yIcon+hIcon));
+      if ACheckers then DrawThumbnailCheckers(result,Rect(xIcon,yIcon,xIcon+wIcon,yIcon+hIcon),ADarkCheckers);
+      if AShowHotSpot and (wIcon > 0) and (hIcon > 0) then
+      begin
+        hotspot := Point(xIcon+ABitmap.HotSpot.X*wIcon div ABitmap.Width,yIcon+ABitmap.HotSpot.Y*hIcon div ABitmap.Height);
+        result.HorizLine(xIcon,hotspot.y-1,xIcon+wIcon-1,CSSLime,dmDrawWithTransparency);
+        result.HorizLine(xIcon,hotspot.y,xIcon+wIcon-1,CSSLime,dmDrawWithTransparency);
+        result.HorizLine(xIcon,hotspot.y+1,xIcon+wIcon-1,CSSLime,dmDrawWithTransparency);
+        result.VertLine(hotspot.x-1,yIcon,yIcon+hIcon-1,CSSLime,dmDrawWithTransparency);
+        result.VertLine(hotspot.x,yIcon,yIcon+hIcon-1,CSSLime,dmDrawWithTransparency);
+        result.VertLine(hotspot.x+1,yIcon,yIcon+hIcon-1,CSSLime,dmDrawWithTransparency);
+      end;
       if (ABackColor.alpha <> 0) or ACheckers then
         result.StretchPutImage(Rect(xIcon,yIcon,xIcon+wIcon,yIcon+hIcon),ABitmap,dmDrawWithTransparency) else
         result.StretchPutImage(Rect(xIcon,yIcon,xIcon+wIcon,yIcon+hIcon),ABitmap,dmSet);
+      if AShowHotSpot and (wIcon > 0) and (hIcon > 0) then
+      begin
+        result.HorizLine(xIcon,yIcon+ABitmap.HotSpot.Y*hIcon div ABitmap.Height,xIcon+wIcon-1,BGRA(255,0,255,96),dmDrawWithTransparency);
+        result.VertLine(xIcon+ABitmap.HotSpot.X*wIcon div ABitmap.Width,yIcon,yIcon+hIcon-1,BGRA(255,0,255,96),dmDrawWithTransparency);
+      end;
     end;
   except
   end;
+end;
+function GetBitmapThumbnail(ABitmap: TBGRACustomBitmap; AWidth, AHeight: integer;
+  ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap = nil;
+  AVerticalShrink: single = 1; AHorizShrink: single = 1): TBGRABitmap;
+begin
+  result := InternalGetBitmapThumbnail(ABitmap,AWidth,AHeight,ABackColor,ACheckers,ADest,AVerticalShrink,AHorizShrink,
+                                       false,false);
+end;
+function GetBitmapThumbnail(ABitmap: TBGRACustomBitmap; AFormat: TBGRAImageFormat; AWidth, AHeight: integer;
+  ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap = nil; AVerticalShrink: single = 1; AHorizShrink: single = 1): TBGRABitmap;
+begin
+  result := InternalGetBitmapThumbnail(ABitmap,AWidth,AHeight,ABackColor,ACheckers,ADest,AVerticalShrink,AHorizShrink,
+                                       AFormat = ifCur, AFormat in[ifCur,ifIco]);
 end;
 …
 var stream: TFileStreamUTF8;
 begin
+  result := nil;
   try
     stream := TFileStreamUTF8.Create(AFilenameUTF8,fmOpenRead or fmShareDenyWrite);
   except
-    result := nil;
     exit;
   end;
 …
   ABackColor: TBGRAPixel; ACheckers: boolean; ASuggestedExtensionUTF8: string;
   ADest: TBGRABitmap): TBGRABitmap;
+begin
+  case DetectFileFormat(AStream,ASuggestedExtensionUTF8) of
+var
+  ff: TBGRAImageFormat;
+  reader: TFPCustomImageReader;
+begin
+  ff := DetectFileFormat(AStream,ASuggestedExtensionUTF8);
+  case ff of
     ifJpeg: result := GetJpegThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
-    ifPng: result := GetPngThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
-    ifGif: result := GetGifThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
-    ifBmp: result := GetBmpThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
-    {$IFDEF BGRABITMAP_USE_LCL}
     ifIco: result := GetIcoThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
+    {$ENDIF}
+    ifPcx: result := GetPcxThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
+    ifCur: result := GetCurThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
     ifPaintDotNet: result := GetPaintDotNetThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
     ifLazPaint: result := GetLazPaintThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
 …
     ifPhoxo: result := GetPhoxoThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
     ifPsd: result := GetPsdThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
-    ifTarga: result := GetTargaThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
-    ifTiff: result := GetTiffThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
-    ifXwd: result := GetXwdThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
-    ifXPixMap: result := GetXPixMapThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
-    ifBmpMioMap: result := GetBmpMioMapThumbnail(AStream, AWidth,AHeight, ABackColor, ACheckers, ADest);
     else
+      result := nil;
+    begin
+      if (ff = ifUnknown) or (DefaultBGRAImageReader[ff] = nil) then
+        result := nil
+      else
+      begin
+        result := nil;
+        reader := nil;
+        try
+          reader := CreateBGRAImageReader(ff);
+          result := GetStreamThumbnail(AStream, reader, AWidth, AHeight, ABackColor, ACheckers, ADest);
+        finally
+          reader.Free;
+        end;
+      end;
+    end;
   end;
 end;
 …
   AWidth, AHeight: integer; ABackColor: TBGRAPixel; ACheckers: boolean;
   ADest: TBGRABitmap): TBGRABitmap;
+var bmp: TBGRABitmap;
+begin
+var
+  bmp: TBGRACustomBitmap;
+  AOriginalWidth, AOriginalHeight: integer;
+begin
+  if AReader is TBGRAImageReader then
+  begin
+    bmp := nil;
+    try
+      bmp := TBGRAImageReader(AReader).GetBitmapDraft(AStream, AWidth,AHeight, AOriginalWidth,AOriginalHeight);
+      if Assigned(bmp) and (bmp.Height <> 0) and (bmp.Width <> 0) then
+        result := GetBitmapThumbnail(bmp, AWidth, AHeight, ABackColor, ACheckers, ADest,
+                    AOriginalHeight/bmp.Height, AOriginalWidth/bmp.Width);
+    except
+      result := nil;
+    end;
+    bmp.free;
+    exit;
+  end;
   bmp := TBGRABitmap.Create;
   try
 …
   end;
 end;
 function GetOpenRasterThumbnail(AStream: TStream; AWidth, AHeight: integer;
 …
 end;
+function GetPngThumbnail(AStream: TStream; AWidth, AHeight: integer
+  ; ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap= nil): TBGRABitmap;
+var
+  png: TBGRAReaderPNG;
+  bmp: TBGRABitmap;
+begin
+  png:= TBGRAReaderPNG.Create;
+  bmp := TBGRABitmap.Create;
+  try
+    png.MinifyHeight := AHeight;
+    bmp.LoadFromStream(AStream, png);
+  except
+    FreeAndNil(bmp);
+  end;
+  if bmp = nil then
+    result := nil
+  else
+  begin
+    result := GetBitmapThumbnail(bmp, AWidth, AHeight, ABackColor, ACheckers, ADest, png.OriginalHeight/bmp.Height);
+    bmp.Free;
+  end;
+  png.Free;
+function GetPngThumbnail(AStream: TStream; AWidth, AHeight: integer;
+    ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap= nil): TBGRABitmap;
+var
+  pngFormat: TBGRAReaderPNG;
+begin
+  pngFormat:= TBGRAReaderPNG.Create;
+  result:= GetStreamThumbnail(AStream, pngFormat, AWidth,AHeight, ABackColor, ACheckers, ADest);
+  pngFormat.Free;
 end;
 …
         if Assigned(pngNode) then
         begin
           png64 := TStringStream.Create(pngNode.NodeValue);
+          png64 := TStringStream.Create(string(pngNode.NodeValue));
           try
             png64.Position := 0;
 …
 var
   bmpFormat: TBGRAReaderBMP;
-  bmp: TBGRABitmap;
 begin
   bmpFormat:= TBGRAReaderBMP.Create;
+  bmpFormat.MinifyHeight := AHeight*2;
+  bmp := TBGRABitmap.Create;
+  try
+    bmp.LoadFromStream(AStream, bmpFormat);
+  except
+    FreeAndNil(bmp);
+  end;
+  if bmp = nil then
+    result := nil
+  else
+  begin
+    if bmp.Height <= 0 then
+      result := nil
+    else
+      result := GetBitmapThumbnail(bmp, AWidth, AHeight, ABackColor, ACheckers, ADest, bmpFormat.OriginalHeight/bmp.Height);
+    bmp.Free;
+  end;
+  result:= GetStreamThumbnail(AStream, bmpFormat, AWidth,AHeight, ABackColor, ACheckers, ADest);
   bmpFormat.Free;
 end;
-{$IFDEF BGRABITMAP_USE_LCL}
 function GetIcoThumbnail(AStream: TStream; AWidth, AHeight: integer;
   ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap): TBGRABitmap;
+var ico: TIcon; i,bestIdx: integer;
+    height,width: word; format:TPixelFormat;
+    bestHeight,bestWidth: integer; maxFormat: TPixelFormat;
+    icoBmp: TBGRABitmap;
+var
+  reader: TBGRAReaderIco;
+  icoBmp: TBGRABitmap;
 begin
   result := nil;
+  ico := TIcon.Create;
+  try
+    ico.LoadFromStream(AStream);
+  except
+    ico.free;
+    exit;
+  end;
+  bestIdx := -1;
+  bestHeight := 0;
+  bestWidth := 0;
+  maxFormat := pfDevice;
+  try
+    for i := 0 to ico.Count-1 do
+    begin
+      ico.GetDescription(i,format,height,width);
+      if (bestIdx = -1) or (abs(height-AHeight)+abs(width-AWidth) < abs(bestHeight-AHeight)+abs(bestWidth-AWidth)) or
+      ((height = bestHeight) or (width = bestWidth) and (format > maxFormat)) then
+      begin
+        bestIdx := i;
+        bestHeight := height;
+        bestWidth := width;
+        maxFormat := format;
+      end;
+    end;
+    if (bestIdx = -1) or (bestWidth = 0) or (bestHeight = 0) then result := nil else
+    begin
+      ico.Current := bestIdx;
+      icoBmp := TBGRABitmap.Create(bestWidth,bestHeight);
+      icoBmp.Assign(ico);
+      result := GetBitmapThumbnail(icoBmp, AWidth, AHeight, ABackColor, ACheckers, ADest);
+      icoBmp.Free;
+    end;
+  except
+  end;
+  ico.Free;
+end;
+{$ENDIF}
+  reader := TBGRAReaderIco.Create;
+  reader.WantedWidth:= AWidth;
+  reader.WantedHeight:= AHeight;
+  icoBmp := TBGRABitmap.Create;
+  try
+    icoBmp.LoadFromStream(AStream, reader);
+    result := GetBitmapThumbnail(icoBmp, ifIco, AWidth, AHeight, ABackColor, ACheckers, ADest);
+  except
+  end;
+  icoBmp.Free;
+  reader.Free;
+end;
+function GetCurThumbnail(AStream: TStream; AWidth, AHeight: integer;
+  ABackColor: TBGRAPixel; ACheckers: boolean; ADest: TBGRABitmap): TBGRABitmap;
+var
+  reader: TBGRAReaderCur;
+  icoBmp: TBGRABitmap;
+begin
+  result := nil;
+  reader := TBGRAReaderCur.Create;
+  reader.WantedWidth:= AWidth;
+  reader.WantedHeight:= AHeight;
+  icoBmp := TBGRABitmap.Create;
+  try
+    icoBmp.LoadFromStream(AStream, reader);
+    result := GetBitmapThumbnail(icoBmp, ifCur, AWidth, AHeight, ABackColor, ACheckers, ADest);
+  except
+  end;
+  icoBmp.Free;
+  reader.Free;
+end;
 function GetPcxThumbnail(AStream: TStream; AWidth, AHeight: integer;
 …
 end;
+initialization
+  IconCheckersColor1 := BGRA(140,180,180);
+  IconCheckersColor2 := BGRA(80,140,140);
+  ImageCheckersColor1 := BGRA(255,255,255);
+  ImageCheckersColor2 := BGRA(220,220,220);
 end.

GraphicTest/Packages/bgrabitmap/bgratransform.pas

-              r494
+              r521
   { Contains an affine matrix, i.e. a matrix to transform linearly and translate TPointF coordinates }
   TAffineMatrix = BGRABitmapTypes.TAffineMatrix;
+  { TAffineBox }
+  TAffineBox = object
+  private
+    function GetAsPolygon: ArrayOfTPointF;
+    function GetBottomRight: TPointF;
+    function GetIsEmpty: boolean;
+  public
+    TopLeft, TopRight,
+    BottomLeft: TPointF;
+    class function EmptyBox: TAffineBox;
+    class function AffineBox(ATopLeft, ATopRight, ABottomLeft: TPointF): TAffineBox;
+    property BottomRight: TPointF read GetBottomRight;
+    property IsEmpty: boolean read GetIsEmpty;
+    property AsPolygon: ArrayOfTPointF read GetAsPolygon;
+  end;
+  { Contains an affine base and information on the resulting box }
+  TAffineBox = BGRABitmapTypes.TAffineBox;
   { TBGRAAffineScannerTransform allow to transform any scanner. To use it,
 …
     procedure Init(ABitmap: TBGRACustomBitmap; ARepeatImageX: Boolean= false; ARepeatImageY: Boolean= false; AResampleFilter: TResampleFilter = rfLinear; AIncludeEdges: boolean = false);
   public
     constructor Create(ABitmap: TBGRACustomBitmap; ARepeatImage: Boolean= false; AResampleFilter: TResampleFilter = rfLinear; AIncludeEdges: boolean = false);
     constructor Create(ABitmap: TBGRACustomBitmap; ARepeatImageX: Boolean; ARepeatImageY: Boolean; AResampleFilter: TResampleFilter = rfLinear; AIncludeEdges: boolean = false);
+    constructor Create(ABitmap: TBGRACustomBitmap; ARepeatImage: Boolean= false; AResampleFilter: TResampleFilter = rfLinear; AIncludeEdges: boolean = false); overload;
+    constructor Create(ABitmap: TBGRACustomBitmap; ARepeatImageX: Boolean; ARepeatImageY: Boolean; AResampleFilter: TResampleFilter = rfLinear; AIncludeEdges: boolean = false); overload;
     destructor Destroy; override;
     function InternalScanCurrentPixel: TBGRAPixel; override;
 …
     constructor Create(ASource: IBGRAScanner;
       ASourceMatrix: TAffineMatrix; const APoints: array of TPointF;
       ATextureInterpolation: boolean = true);
+      ATextureInterpolation: boolean = true); overload;
     constructor Create(ASource: IBGRAScanner;
       const ATexCoords: array of TPointF; const APoints: array of TPointF;
       ATextureInterpolation: boolean = true);
+      ATextureInterpolation: boolean = true); overload;
     destructor Destroy; override;
     property Culling: TFaceCulling read GetCulling write SetCulling;
 …
 {---------------------- Affine matrix functions -------------------}
 //fill a matrix
+function AffineMatrix(m11,m12,m13,m21,m22,m23: single): TAffineMatrix;
+function AffineMatrix(m11,m12,m13,m21,m22,m23: single): TAffineMatrix; overload;
+function AffineMatrix(AU,AV: TPointF; ATranslation: TPointF): TAffineMatrix; overload;
 //matrix multiplication
 …
 operator *(M: TAffineMatrix; V: TPointF): TPointF;
 operator *(M: TAffineMatrix; A: array of TPointF): ArrayOfTPointF;
+operator *(M: TAffineMatrix; ab: TAffineBox): TAffineBox;
 //check if matrix is inversible
 …
 //define a scaling matrix
 function AffineMatrixScale(sx,sy: single): TAffineMatrix;
+function AffineMatrixScaledRotation(ASourceVector, ATargetVector: TPointF): TAffineMatrix;
+function AffineMatrixScaledRotation(ASourcePoint, ATargetPoint, AOrigin: TPointF): TAffineMatrix;
 function AffineMatrixSkewXDeg(AngleCW: single): TAffineMatrix;
 …
 //define a linear matrix
+function AffineMatrixLinear(v1,v2: TPointF): TAffineMatrix;
+function AffineMatrixLinear(v1,v2: TPointF): TAffineMatrix; overload;
+function AffineMatrixLinear(const AMatrix: TAffineMatrix): TAffineMatrix; overload;
 //define a rotation matrix (positive radians are counter-clockwise)
 …
 function IsAffineMatrixOrthogonal(M: TAffineMatrix): boolean;
+function IsAffineMatrixScaledRotation(M: TAffineMatrix): boolean;
 type
 …
     procedure SetIncludeOppositePlane(AValue: boolean);
   public
     constructor Create(texture: IBGRAScanner; texCoord1,texCoord2: TPointF; const quad: array of TPointF);
     constructor Create(texture: IBGRAScanner; const texCoordsQuad: array of TPointF; const quad: array of TPointF);
+    constructor Create(texture: IBGRAScanner; texCoord1,texCoord2: TPointF; const quad: array of TPointF); overload;
+    constructor Create(texture: IBGRAScanner; const texCoordsQuad: array of TPointF; const quad: array of TPointF); overload;
     destructor Destroy; override;
     procedure ScanMoveTo(X, Y: Integer); override;
 …
   public
     constructor Create; overload;
     constructor Create(x1,y1,x2,y2: single; const quad: array of TPointF);
     constructor Create(const quad: array of TPointF; x1,y1,x2,y2: single);
     constructor Create(const srcQuad,destQuad: array of TPointF);
+    constructor Create(x1,y1,x2,y2: single; const quad: array of TPointF); overload;
+    constructor Create(const quad: array of TPointF; x1,y1,x2,y2: single); overload;
+    constructor Create(const srcQuad,destQuad: array of TPointF); overload;
     function MapQuadToQuad(const srcQuad,destQuad: array of TPointF): boolean;
     function MapRectToQuad(x1,y1,x2,y2: single; const quad: array of TPointF): boolean;
 …
 end;
+function AffineMatrix(AU, AV: TPointF; ATranslation: TPointF): TAffineMatrix;
+begin
+  result:= AffineMatrix(AU.x, AV.x, ATranslation.x,
+                        AU.y, AV.y, ATranslation.y);
+end;
 operator *(M, N: TAffineMatrix): TAffineMatrix;
 begin
 …
     for i := 0 to high(A) do
       result[i] := M*A[i];
+end;
+operator*(M: TAffineMatrix; ab: TAffineBox): TAffineBox;
+begin
+  result.TopLeft := M*ab.TopLeft;
+  result.TopRight := M*ab.TopRight;
+  result.BottomLeft := M*ab.BottomLeft;
 end;
 …
 end;
+function AffineMatrixScaledRotation(ASourceVector, ATargetVector: TPointF): TAffineMatrix;
+var
+  prevScale, newScale, scale: Single;
+  u1,v1,u2,v2,w: TPointF;
+begin
+  prevScale := VectLen(ASourceVector);
+  newScale := VectLen(ATargetVector);
+  if (prevScale = 0) or (newScale = 0) then
+    result := AffineMatrixIdentity
+  else
+  begin
+    scale := newScale/prevScale;
+    u1 := ASourceVector*(1/prevScale);
+    v1 := PointF(-u1.y,u1.x);
+    w := ATargetVector*(1/newScale);
+    u2 := PointF(w*u1, w*v1);
+    v2 := PointF(-u2.y,u2.x);
+    result := AffineMatrix(scale*u2,scale*v2,PointF(0,0));
+  end;
+end;
+function AffineMatrixScaledRotation(ASourcePoint, ATargetPoint, AOrigin: TPointF): TAffineMatrix;
+begin
+  result := AffineMatrixTranslation(AOrigin.x,AOrigin.y)*
+         AffineMatrixScaledRotation(ASourcePoint-AOrigin, ATargetPoint-AOrigin)*
+         AffineMatrixTranslation(-AOrigin.x,-AOrigin.y);
+end;
 function AffineMatrixSkewXDeg(AngleCW: single): TAffineMatrix;
 begin
 …
 end;
+function AffineMatrixLinear(const AMatrix: TAffineMatrix): TAffineMatrix;
+begin
+  result := AffineMatrix(AMatrix[1,1],AMatrix[1,2],0,
+                         AMatrix[2,1],AMatrix[2,2],0);
+end;
 function AffineMatrixRotationRad(AngleCCW: Single): TAffineMatrix;
 begin
 …
 begin
   result := PointF(M[1,1],M[2,1])*PointF(M[1,2],M[2,2]) = 0;
+end;
+function IsAffineMatrixScaledRotation(M: TAffineMatrix): boolean;
+begin
+  result := IsAffineMatrixOrthogonal(M) and
+           (VectLen(PointF(M[1,1],M[2,1]))=VectLen(PointF(M[1,2],M[2,2])));
 end;
 …
   if y > FBounds.Bottom-1 then y := FBounds.Bottom-1;
   result := FSource.ScanAt(X,Y);
-end;
-{ TAffineBox }
-function TAffineBox.GetAsPolygon: ArrayOfTPointF;
-begin
-  result := PointsF([TopLeft,TopRight,BottomRight,BottomLeft]);
-end;
-function TAffineBox.GetBottomRight: TPointF;
-begin
-  if IsEmpty then
-    result := EmptyPointF
-  else
-    result := TopRight + (BottomLeft-TopLeft);
-end;
-function TAffineBox.GetIsEmpty: boolean;
-begin
-  result := isEmptyPointF(TopRight) or isEmptyPointF(BottomLeft) or isEmptyPointF(TopLeft);
-end;
-class function TAffineBox.EmptyBox: TAffineBox;
-begin
-  result.TopLeft := EmptyPointF;
-  result.TopRight := EmptyPointF;
-  result.BottomLeft := EmptyPointF;
-end;
-class function TAffineBox.AffineBox(ATopLeft, ATopRight, ABottomLeft: TPointF): TAffineBox;
-begin
-  result.TopLeft := ATopLeft;
-  result.TopRight := ATopRight;
-  result.BottomLeft := ABottomLeft;
 end;

GraphicTest/Packages/bgrabitmap/bgratypewriter.pas

-              r494
+              r521
   end;
+  TGlyphPointCurveMode= (cmAuto, cmCurve, cmAngle);
+  TGlyphPointCurveMode= TEasyBezierCurveMode;
+const
+  cmAuto = TEasyBezierCurveMode.cmAuto;
+  cmCurve = TEasyBezierCurveMode.cmCurve;
+  cmAngle = TEasyBezierCurveMode.cmAngle;
+type
   { TBGRAPolygonalGlyph }
   TBGRAPolygonalGlyph = class(TBGRAGlyph)
   private
+    function GetClosed: boolean;
+    function GetMinimumDotProduct: single;
+    function GetPoint(AIndex: integer): TPointF;
+    function GetPointCount: integer;
+    procedure SetClosed(AValue: boolean);
+    procedure SetMinimumDotProduct(AValue: single);
+    procedure SetPoint(AIndex: integer; AValue: TPointF);
     procedure SetQuadraticCurves(AValue: boolean);
   protected
     FQuadraticCurves: boolean;
+    Points: array of TPointF;
+    CurveMode: array of TGlyphPointCurveMode;
+    Curves: array of record
+      isCurvedToNext,isCurvedToPrevious: boolean;
+      Center,ControlPoint,NextCenter: TPointF;
+    end;
+    function MaybeCurve(start1,end1,start2,end2: integer): boolean;
+    procedure ComputeQuadraticCurves;
+    FEasyBezier: TEasyBezierCurve;
     function ContentSize: integer; override;
     function HeaderName: string; override;
     procedure WriteContent(AStream: TStream); override;
     procedure ReadContent(AStream: TStream); override;
+    function PointTransformMatrix(APoint: PPointF; AData: pointer): TPointF;
     procedure Init;
   public
     Offset: TPointF;
-    Closed: boolean;
-    MinimumDotProduct: single;
     constructor Create(AIdentifier: string); override;
     constructor Create(AStream: TStream); override;
+    constructor Create(AStream: TStream; AQuadratic: boolean);
     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;
+    property Closed: boolean read GetClosed write SetClosed;
+    property MinimumDotProduct: single read GetMinimumDotProduct write SetMinimumDotProduct;
+    property Point[AIndex: integer]: TPointF read GetPoint write SetPoint;
+    property PointCount: integer read GetPointCount;
   end;
 …
 { TBGRAPolygonalGlyph }
+function TBGRAPolygonalGlyph.GetClosed: boolean;
+begin
+  result := FEasyBezier.Closed;
+end;
+function TBGRAPolygonalGlyph.GetMinimumDotProduct: single;
+begin
+  result := FEasyBezier.MinimumDotProduct;
+end;
+function TBGRAPolygonalGlyph.GetPoint(AIndex: integer): TPointF;
+begin
+  result := FEasyBezier.Point[AIndex];
+end;
+function TBGRAPolygonalGlyph.GetPointCount: integer;
+begin
+  result := FEasyBezier.PointCount;
+end;
+procedure TBGRAPolygonalGlyph.SetClosed(AValue: boolean);
+begin
+  FEasyBezier.Closed := AValue;
+end;
+procedure TBGRAPolygonalGlyph.SetMinimumDotProduct(AValue: single);
+begin
+  FEasyBezier.MinimumDotProduct := AValue;
+end;
+procedure TBGRAPolygonalGlyph.SetPoint(AIndex: integer; AValue: TPointF);
+begin
+  FEasyBezier.Point[AIndex] := AValue;
+end;
 procedure TBGRAPolygonalGlyph.SetQuadraticCurves(AValue: boolean);
 begin
   if FQuadraticCurves=AValue then Exit;
   FQuadraticCurves:=AValue;
-  Curves := nil;
-end;
-function TBGRAPolygonalGlyph.MaybeCurve(start1,end1,start2,end2: integer): boolean;
-var
-  u,v: TPointF;
-  lu,lv: single;
-begin
-  if (start1=-1) or (end1=-1) or (start2=-1) or (end2=-1) then
-  begin
-    result := false;
-    exit;
-  end;
-  u := pointF(points[end1].x - points[start1].x, points[end1].y - points[start1].y);
-  lu := sqrt(u*u);
-  if lu <> 0 then u *= 1/lu;
-  v := pointF(points[end2].x - points[start2].x, points[end2].y - points[start2].y);
-  lv := sqrt(v*v);
-  if lv <> 0 then v *= 1/lv;
-  result := u*v > MinimumDotProduct;
-end;
-procedure TBGRAPolygonalGlyph.ComputeQuadraticCurves;
-var
-  i,FirstPointIndex,NextPt,NextPt2: integer;
-begin
-  setlength(Curves, length(points));
-  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].Center := EmptyPointF;
-    Curves[i].ControlPoint := EmptyPointF;
-    Curves[i].NextCenter := EmptyPointF;
-    if IsEmptyPointF(Points[i]) then
-    begin
-      FirstPointIndex := i+1;
-    end else
-    begin
-      NextPt := i+1;
-      if (NextPt = length(points)) or isEmptyPointF(points[NextPt]) then NextPt := FirstPointIndex;
-      NextPt2 := NextPt+1;
-      if (NextPt2 = length(points)) or isEmptyPointF(points[NextPt2]) then NextPt2 := FirstPointIndex;
-      Curves[i].Center := (points[i]+points[NextPt])*0.5;
-      Curves[i].NextCenter := (points[NextPt]+points[NextPt2])*0.5;
-      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);
+  Result:= (inherited ContentSize) + sizeof(single)*2 + 4 + sizeof(single)*2*PointCount;
 end;
 function TBGRAPolygonalGlyph.HeaderName: string;
 begin
+  Result:='TBGRAPolygonalGlyph';
+  if FQuadraticCurves then
+    Result:='TBGRAEasyBezierGlyph'
+  else
+    Result:='TBGRAPolygonalGlyph'
 end;
 …
   inherited WriteContent(AStream);
   LEWritePointF(AStream, Offset);
+  LEWriteLongint(AStream,length(Points));
+  for i := 0 to high(Points) do
+    LEWritePointF(AStream, Points[i]);
+  LEWriteLongint(AStream,PointCount);
+  for i := 0 to PointCount-1 do
+    LEWritePointF(AStream, FEasyBezier.Point[i]);
+  if FQuadraticCurves then
+    for i := 0 to PointCount-1 do
+      LEWriteLongint(AStream, ord(FEasyBezier.CurveMode[i]));
 end;
 …
 var i: integer;
   tempPts: array of TPointF;
+  flags: LongInt;
 begin
   inherited ReadContent(AStream);
 …
     tempPts[i] := LEReadPointF(AStream);
   SetPoints(tempPts);
+  if FQuadraticCurves then
+  begin
+    for i := 0 to high(tempPts) do
+    begin
+      flags := LEReadLongint(AStream);
+      FEasyBezier.CurveMode[i] := TEasyBezierCurveMode(flags and 255);
+    end;
+  end;
+end;
+function TBGRAPolygonalGlyph.PointTransformMatrix(APoint: PPointF;
+  AData: pointer): TPointF;
+begin
+  result := TAffineMatrix(AData^) * APoint^;
 end;
 procedure TBGRAPolygonalGlyph.Init;
 begin
+  FEasyBezier.Init;
   Closed := True;
+  MinimumDotProduct := 0.707;
+  Offset := PointF(0,0);
+  FQuadraticCurves:= False;
 end;
 constructor TBGRAPolygonalGlyph.Create(AIdentifier: string);
 begin
+  Init;
   inherited Create(AIdentifier);
+  Offset := PointF(0,0);
+end;
+constructor TBGRAPolygonalGlyph.Create(AStream: TStream);
+begin
   Init;
-end;
-constructor TBGRAPolygonalGlyph.Create(AStream: TStream);
-begin
   inherited Create(AStream);
+end;
+constructor TBGRAPolygonalGlyph.Create(AStream: TStream; AQuadratic: boolean);
+begin
   Init;
+  FQuadraticCurves:= AQuadratic;
+  inherited Create(AStream);
 end;
 procedure TBGRAPolygonalGlyph.SetPoints(const APoints: array of TPointF);
+var i: integer;
+begin
+  SetLength(Points,length(APoints));
+  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;
+begin
+  FEasyBezier.SetPoints(APoints, cmAuto);
 end;
 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;
+  FEasyBezier.SetPoints(APoints, ACurveMode);
 end;
 …
 var i: integer;
   nextMove: boolean;
+  startCoord: TPointF;
+begin
+  if Points = nil then exit;
+  if (Curves = nil) and FQuadraticCurves then ComputeQuadraticCurves;
+  nextMove := true;
+begin
   AMatrix := AMatrix*AffineMatrixTranslation(Offset.X,Offset.Y);
+  for i := 0 to high(Points) do
+    if isEmptyPointF(Points[i]) then
+    begin
+      if not nextMove then ADest.closePath;
+      nextMove := true;
+    end else
+    if FQuadraticCurves then
+    begin
+      with Curves[i] do
+  if not FQuadraticCurves then
+  begin
+    nextMove := true;
+    for i := 0 to PointCount-1 do
+      if isEmptyPointF(Point[i]) then
+      begin
+        if not nextMove and Closed then ADest.closePath;
+        nextMove := true;
+      end else
       begin
         if nextMove then
         begin
+          if not isCurvedToPrevious then
+            startCoord := Points[i]
+          else
+            startCoord := Center;
+          ADest.moveTo(AMatrix*startCoord);
+          ADest.moveTo(AMatrix*Point[i]);
           nextMove := false;
         end else
+          if not isCurvedToPrevious then
+            ADest.lineTo(AMatrix*Points[i]);
+        if isCurvedToNext then
+        begin
+          if not isCurvedToPrevious then ADest.lineTo(AMatrix*Center);
+          ADest.quadraticCurveTo(AMatrix*ControlPoint,AMatrix*NextCenter);
+        end;
+          ADest.lineTo(AMatrix*Point[i]);
       end;
+    end else
+    begin
+      if nextMove then
+      begin
+        ADest.moveTo(AMatrix*Points[i]);
+        nextMove := false;
+      end else
+      begin
+        ADest.lineTo(AMatrix*Points[i]);
+      end;
+    end;
+  if not nextmove then
+    ADest.closePath;
+    if not nextmove and Closed then ADest.closePath;
+  end else
+    FEasyBezier.CopyToPath(ADest, @PointTransformMatrix, @AMatrix);
 end;
 …
   if lName = 'TBGRAPolygonalGlyph' then
     result := TBGRAPolygonalGlyph.Create(AStream)
+  else if lName = 'TBGRAEasyBezierGlyph' then
+    result := TBGRAPolygonalGlyph.Create(AStream, true)
   else if lName = 'TBGRAGlyph' then
     result := TBGRAGlyph.Create(AStream)

GraphicTest/Packages/bgrabitmap/bgraunits.pas

-              r494
+              r521
     property DefaultUnitHeight: TFloatWithCSSUnit read GetDefaultUnitHeight;
   public
+    function Convert(xy: single; sourceUnit, destUnit: TCSSUnit; dpi: single): single;
+    function ConvertWidth(x: single; sourceUnit, destUnit: TCSSUnit): single;
+    function ConvertHeight(y: single; sourceUnit, destUnit: TCSSUnit): single;
+    function ConvertWidth(AValue: TFloatWithCSSUnit; destUnit: TCSSUnit): TFloatWithCSSUnit;
+    function ConvertHeight(AValue: TFloatWithCSSUnit; destUnit: TCSSUnit): TFloatWithCSSUnit;
+    function ConvertCoord(pt: TPointF; sourceUnit, destUnit: TCSSUnit): TPointF; virtual;
+    class function parseValue(AValue: string; ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit;
+    class function formatValue(AValue: TFloatWithCSSUnit; APrecision: integer = 7): string;
+    class function formatValue(AValue: single; APrecision: integer = 7): string;
+    function Convert(xy: single; sourceUnit, destUnit: TCSSUnit; dpi: single; containerSize: single = 0): single;
+    function ConvertWidth(x: single; sourceUnit, destUnit: TCSSUnit; containerWidth: single = 0): single; overload;
+    function ConvertHeight(y: single; sourceUnit, destUnit: TCSSUnit; containerHeight: single = 0): single; overload;
+    function ConvertWidth(AValue: TFloatWithCSSUnit; destUnit: TCSSUnit; containerWidth: single = 0): TFloatWithCSSUnit; overload;
+    function ConvertHeight(AValue: TFloatWithCSSUnit; destUnit: TCSSUnit; containerHeight: single = 0): TFloatWithCSSUnit; overload;
+    function ConvertCoord(pt: TPointF; sourceUnit, destUnit: TCSSUnit; containerWidth: single = 0; containerHeight: single = 0): TPointF; virtual;
+    class function parseValue(AValue: string; ADefault: TFloatWithCSSUnit): TFloatWithCSSUnit; overload;
+    class function parseValue(AValue: string; ADefault: single): single; overload;
+    class function formatValue(AValue: TFloatWithCSSUnit; APrecision: integer = 7): string; overload;
+    class function formatValue(AValue: single; APrecision: integer = 7): string; overload;
     property DpiX: single read GetDpiX;
     property DpiY: single read GetDpiY;
 …
 function TCSSUnitConverter.Convert(xy: single; sourceUnit, destUnit: TCSSUnit;
   dpi: single): single;
+  dpi: single; containerSize: single): single;
 var sourceFactor, destFactor: integer;
 begin
 …
     result := xy
   else
+  if sourceUnit = cuPercent then
+  begin
+    result := xy/100*containerSize;
+  end else
   if sourceUnit = cuFontEmHeight then
   begin
 …
 function TCSSUnitConverter.ConvertWidth(x: single; sourceUnit,
   destUnit: TCSSUnit): single;
+  destUnit: TCSSUnit; containerWidth: single): single;
 begin
   if sourceUnit = destUnit then
 …
   with DefaultUnitWidth do
   begin
     result := x*ConvertWidth(value,CSSUnit, destUnit)
+    result := x*ConvertWidth(value,CSSUnit, destUnit, containerWidth)
   end
   else if destUnit = cuCustom then
 …
       result := x/value;
   end else
     result := Convert(x, sourceUnit, destUnit, DpiX);
+    result := Convert(x, sourceUnit, destUnit, DpiX, containerWidth);
 end;
 function TCSSUnitConverter.ConvertHeight(y: single; sourceUnit,
   destUnit: TCSSUnit): single;
+  destUnit: TCSSUnit; containerHeight: single): single;
 begin
   if sourceUnit = cuCustom then
   with DefaultUnitHeight do
   begin
     result := y*ConvertHeight(value,CSSUnit, destUnit)
+    result := y*ConvertHeight(value,CSSUnit, destUnit, containerHeight)
   end
   else if destUnit = cuCustom then
 …
       result := y/value;
   end else
     result := Convert(y, sourceUnit, destUnit, DpiY);
+    result := Convert(y, sourceUnit, destUnit, DpiY, containerHeight);
 end;
 function TCSSUnitConverter.ConvertWidth(AValue: TFloatWithCSSUnit;
   destUnit: TCSSUnit): TFloatWithCSSUnit;
+  destUnit: TCSSUnit; containerWidth: single): TFloatWithCSSUnit;
 begin
   result.CSSUnit := destUnit;
   result.value:= ConvertWidth(AValue.value,AValue.CSSUnit,destUnit);
+  result.value:= ConvertWidth(AValue.value,AValue.CSSUnit,destUnit,containerWidth);
 end;
 function TCSSUnitConverter.ConvertHeight(AValue: TFloatWithCSSUnit;
   destUnit: TCSSUnit): TFloatWithCSSUnit;
+  destUnit: TCSSUnit; containerHeight: single): TFloatWithCSSUnit;
 begin
   result.CSSUnit := destUnit;
   result.value:= ConvertHeight(AValue.value,AValue.CSSUnit,destUnit);
+  result.value:= ConvertHeight(AValue.value,AValue.CSSUnit,destUnit,containerHeight);
 end;
 function TCSSUnitConverter.ConvertCoord(pt: TPointF; sourceUnit,
   destUnit: TCSSUnit): TPointF;
 begin
   result.x := ConvertWidth(pt.x, sourceUnit, destUnit);
   result.y := ConvertHeight(pt.y, sourceUnit, destUnit);
+  destUnit: TCSSUnit; containerWidth: single; containerHeight: single): TPointF;
+begin
+  result.x := ConvertWidth(pt.x, sourceUnit, destUnit, containerWidth);
+  result.y := ConvertHeight(pt.y, sourceUnit, destUnit, containerHeight);
 end;
 …
 end;
+class function TCSSUnitConverter.parseValue(AValue: string; ADefault: single): single;
+var
+  errPos: integer;
+begin
+  AValue := trim(AValue);
+  val(AValue,result,errPos);
+  if errPos <> 0 then
+    result := ADefault;
+end;
 class function TCSSUnitConverter.formatValue(AValue: TFloatWithCSSUnit; APrecision: integer = 7): string;
 begin

GraphicTest/Packages/bgrabitmap/bgrautf8.pas

-              r494
+              r521
 uses
   Classes, SysUtils{$IFDEF BGRABITMAP_USE_LCL}, lazutf8classes{$ENDIF};
+  Classes, SysUtils, BGRAUnicode{$IFDEF BGRABITMAP_USE_LCL}, lazutf8classes{$ENDIF};
 {$IFDEF BGRABITMAP_USE_LCL}
 …
     FFileName: utf8string;
   public
     constructor Create(const AFileName: utf8string; Mode: Word);
     constructor Create(const AFileName: utf8string; Mode: Word; Rights: Cardinal);
+    constructor Create(const AFileName: utf8string; Mode: Word); overload;
+    constructor Create(const AFileName: utf8string; Mode: Word; Rights: Cardinal); overload;
     destructor Destroy; override;
     property FileName: utf8string Read FFilename;
 …
 function UTF8CharacterLength(p: PChar): integer;
 function UTF8Length(const s: string): PtrInt;
 function UTF8Length(p: PChar; ByteCount: PtrInt): PtrInt;
+function UTF8Length(const s: string): PtrInt; overload;
+function UTF8Length(p: PChar; ByteCount: PtrInt): PtrInt; overload;
 function UnicodeCharToUTF8(u: cardinal): string4;
+function UTF8ReverseString(const s: string): string;
+function UTF8CodepointToUnicode(p: PChar; ACodePointLen: integer): cardinal;
+type
+  TBidiUTF8Info = packed record
+    Offset: Integer;
+    BidiInfo: TUnicodeBidiInfo;
+  end;
+  TBidiUTF8Array = packed array of TBidiUTF8Info;
+  TUnicodeDisplayOrder = BGRAUnicode.TUnicodeDisplayOrder;
+function GetBidiClassUTF8(P: PChar): TUnicodeBidiClass;
+function GetFirstStrongBidiClassUTF8(const sUTF8: string): TUnicodeBidiClass;
+function GetLastStrongBidiClassUTF8(const sUTF8: string): TUnicodeBidiClass;
+function IsRightToLeftUTF8(const sUTF8: string): boolean;
+function IsZeroWidthUTF8(const sUTF8: string): boolean;
+function AddParagraphBidiUTF8(s: string; ARightToLeft: boolean): string;
+function AnalyzeBidiUTF8(const sUTF8: string; ARightToLeft: boolean): TBidiUTF8Array; overload;
+function AnalyzeBidiUTF8(const sUTF8: string): TBidiUTF8Array; overload;
+function GetUTF8DisplayOrder(const ABidi: TBidiUTF8Array): TUnicodeDisplayOrder;
+function ContainsBidiIsolateOrFormattingUTF8(const sUTF8: string): boolean;
+function UTF8OverrideDirection(const sUTF8: string; ARightToLeft: boolean): string;
+function UTF8EmbedDirection(const sUTF8: string; ARightToLeft: boolean): string;
 //little endian stream functions
+function LEReadInt64(Stream: TStream): int64;
+procedure LEWriteInt64(Stream: TStream; AValue: int64);
 function LEReadLongint(Stream: TStream): longint;
 procedure LEWriteLongint(Stream: TStream; AValue: LongInt);
 …
   result := LazUtf8.UnicodeToUTF8(u);
 end;
 {$ELSE}
 …
 {$ENDIF}
+function LEReadLongint(Stream: TStream): longint;
+begin
+  Result := 0;
+  stream.Read(Result, sizeof(Result));
+  Result := LEtoN(Result);
+end;
+procedure LEWriteLongint(Stream: TStream; AValue: LongInt);
+begin
+  AValue := NtoLE(AValue);
+  stream.Write(AValue, sizeof(AValue));
+end;
+function LEReadByte(Stream: TStream): byte;
+begin
+  Result := 0;
+  stream.Read(Result, sizeof(Result));
+end;
+procedure LEWriteByte(Stream: TStream; AValue: Byte);
+begin
+  stream.Write(AValue, sizeof(AValue));
+end;
+function LEReadSingle(Stream: TStream): single;
+var
+  ResultAsDWord : longword absolute result;
+begin
+  ResultAsDWord := 0;
+  stream.Read(ResultAsDWord, sizeof(Result));
+  ResultAsDWord := LEtoN(ResultAsDWord);
+end;
+procedure LEWriteSingle(Stream: TStream; AValue: single);
+var
+  ValueAsDWord : longword absolute AValue;
+begin
+  ValueAsDWord := NtoLE(ValueAsDWord);
+  stream.Write(ValueAsDWord, sizeof(AValue));
+function UTF8ReverseString(const s: string): string;
+var
+  pSrc,pDest,pEnd: PChar;
+  charLen: Integer;
+begin
+  if s = '' then
+  begin
+    result := '';
+    exit;
+  end;
+  setlength(result, length(s));
+  pDest := @result[1] + length(result);
+  pSrc := @s[1];
+  pEnd := pSrc+length(s);
+  while pSrc < pEnd do
+  begin
+    charLen := UTF8CharacterLength(pSrc);
+    if (charLen = 0) or (pSrc+charLen > pEnd) then break;
+    dec(pDest, charLen);
+    move(pSrc^, pDest^, charLen);
+    inc(pSrc, charLen);
+  end;
+end;
+function UTF8CodepointToUnicode(p: PChar; ACodePointLen: integer): cardinal;
+begin
+  case ACodePointLen of
+: result := 0;
+: result := ord(p^);
+: result := ((ord(p^) and %00011111) shl 6) or (ord(p[1]) and %00111111);
+: result := ((ord(p^) and %00011111) shl 12) or ((ord(p[1]) and %00111111) shl 6)
+                or (ord(p[2]) and %00111111);
+: result := ((ord(p^) and %00001111) shl 18) or ((ord(p[1]) and %00111111) shl 12)
+                or ((ord(p[2]) and %00111111) shl 6) or (ord(p[3]) and %00111111);
+    else
+      raise exception.Create('Invalid code point length');
+  end;
 end;
 …
 end;
+function GetBidiClassUTF8(P: PChar): TUnicodeBidiClass;
+begin
+  result := GetUnicodeBidiClass(UTF8CodepointToUnicode(P, UTF8CharacterLength(p)));
+end;
+function GetFirstStrongBidiClassUTF8(const sUTF8: string): TUnicodeBidiClass;
+var
+  p,pEnd: PChar;
+  charLen: Integer;
+  u: Cardinal;
+  curBidi: TUnicodeBidiClass;
+  isolateNesting: integer;
+begin
+  if sUTF8 = '' then exit(ubcUnknown);
+  p := @sUTF8[1];
+  pEnd := p + length(sUTF8);
+  isolateNesting:= 0;
+  while p < pEnd do
+  begin
+    charLen := UTF8CharacterLength(p);
+    if (charLen = 0) or (p+charLen > pEnd) then break;
+    u := UTF8CodepointToUnicode(p, charLen);
+    case u of
+      UNICODE_POP_DIRECTIONAL_ISOLATE: if isolateNesting > 0 then dec(isolateNesting);
+    end;
+    curBidi := GetUnicodeBidiClass(u);
+    if isolateNesting = 0 then
+    begin
+      if curBidi in[ubcLeftToRight,ubcRightToLeft,ubcArabicLetter] then
+        exit(curBidi);
+    end;
+    case u of
+      UNICODE_FIRST_STRONG_ISOLATE, UNICODE_LEFT_TO_RIGHT_ISOLATE, UNICODE_RIGHT_TO_LEFT_ISOLATE: inc(isolateNesting);
+    end;
+    if curBidi = ubcParagraphSeparator then isolateNesting:= 0;
+    inc(p,charLen);
+  end;
+  exit(ubcUnknown);
+end;
+function GetLastStrongBidiClassUTF8(const sUTF8: string): TUnicodeBidiClass;
+var
+  p,pEnd: PChar;
+  charLen: Integer;
+  u: Cardinal;
+  curBidi: TUnicodeBidiClass;
+  isolateNesting: integer;
+begin
+  if sUTF8 = '' then exit(ubcUnknown);
+  p := @sUTF8[1];
+  pEnd := p + length(sUTF8);
+  isolateNesting:= 0;
+  result := ubcUnknown;
+  while p < pEnd do
+  begin
+    charLen := UTF8CharacterLength(p);
+    if (charLen = 0) or (p+charLen > pEnd) then break;
+    u := UTF8CodepointToUnicode(p, charLen);
+    case u of
+      UNICODE_POP_DIRECTIONAL_ISOLATE: if isolateNesting > 0 then dec(isolateNesting);
+    end;
+    curBidi := GetUnicodeBidiClass(u);
+    if isolateNesting = 0 then
+    begin
+      if curBidi in[ubcLeftToRight,ubcRightToLeft,ubcArabicLetter] then
+        result := curBidi;
+    end;
+    case u of
+      UNICODE_FIRST_STRONG_ISOLATE, UNICODE_LEFT_TO_RIGHT_ISOLATE, UNICODE_RIGHT_TO_LEFT_ISOLATE: inc(isolateNesting);
+    end;
+    if curBidi = ubcParagraphSeparator then isolateNesting:= 0;
+    inc(p,charLen);
+  end;
+end;
+function IsRightToLeftUTF8(const sUTF8: string): boolean;
+begin
+  result := GetFirstStrongBidiClassUTF8(sUTF8) in[ubcRightToLeft,ubcArabicLetter];
+end;
+function IsZeroWidthUTF8(const sUTF8: string): boolean;
+var
+  p,pEnd: PChar;
+  charLen: Integer;
+  u: Cardinal;
+begin
+  if sUTF8 = '' then exit(true);
+  p := @sUTF8[1];
+  pEnd := p + length(sUTF8);
+  while p < pEnd do
+  begin
+    charLen := UTF8CharacterLength(p);
+    if (charLen = 0) or (p+charLen > pEnd) then break;
+    u := UTF8CodepointToUnicode(p, charLen);
+    if not IsZeroWidthUnicode(u) then exit(false);
+    inc(p,charLen);
+  end;
+  exit(true);
+end;
+function AddParagraphBidiUTF8(s: string; ARightToLeft: boolean): string;
+var
+  i,curParaStart: Integer;
+  procedure CheckParagraph;
+  var
+    para,newPara: string;
+    paraRTL: boolean;
+  begin
+    if i > curParaStart then
+    begin
+      para := copy(s,curParaStart,i-curParaStart);
+      paraRTL := GetFirstStrongBidiClassUTF8(para) in[ubcRightToLeft,ubcArabicLetter];
+      //detected paragraph does not match overall RTL option
+      if paraRTL <> ARightToLeft then
+      begin
+        if not paraRTL then
+          newPara := UnicodeCharToUTF8(UNICODE_LEFT_TO_RIGHT_MARK)+para+UnicodeCharToUTF8(UNICODE_LEFT_TO_RIGHT_MARK)
+        else
+          newPara := UnicodeCharToUTF8(UNICODE_RIGHT_TO_LEFT_MARK)+para+UnicodeCharToUTF8(UNICODE_RIGHT_TO_LEFT_MARK);
+        inc(i, length(newPara)-length(para));
+        delete(s, curParaStart, length(para));
+        insert(newPara, s, curParaStart);
+      end;
+    end;
+  end;
+var
+  charLen: integer;
+  u: Cardinal;
+begin
+  i := 1;
+  curParaStart := 1;
+  while i <= length(s) do
+  begin
+    charLen := UTF8CharacterLength(@s[i]);
+    u := UTF8CodepointToUnicode(@s[i], charLen);
+    if IsUnicodeParagraphSeparator(u) then
+    begin
+      CheckParagraph;
+      //skip end of line
+      inc(i);
+      //skip second CRLF
+      if ((u = 10) or (u = 13)) and (i <= length(s)) and (s[i] in[#13,#10]) and (s[i]<>s[i-1]) then inc(i);
+      curParaStart := i;
+    end else
+      inc(i);
+  end;
+  CheckParagraph;
+  result := s;
+end;
+type
+  TUnicodeArray = packed array of cardinal;
+  TIntegerArray = array of integer;
+procedure UTF8ToUnicode(const sUTF8: string; out u: TUnicodeArray; out ofs: TIntegerArray);
+var
+  index,len,charLen: integer;
+  p,pStart,pEnd: PChar;
+begin
+  if sUTF8 = '' then
+  begin
+    u := nil;
+    ofs := nil;
+  end
+  else
+  begin
+    pStart := @sUTF8[1];
+    pEnd := pStart + length(sUTF8);
+    p := pStart;
+    len := 0;
+    while p < pEnd do
+    begin
+      charLen := UTF8CharacterLength(p);
+      inc(len);
+      inc(p,charLen);
+    end;
+    setlength(u, len);
+    setlength(ofs, len);
+    p := pStart;
+    index := 0;
+    while p < pEnd do
+    begin
+      charLen := UTF8CharacterLength(p);
+      u[index] := UTF8CodepointToUnicode(p, charLen);
+      ofs[index] := p - pStart;
+      inc(index);
+      inc(p,charLen);
+    end;
+  end;
+end;
+function AnalyzeBidiUTF8(const sUTF8: string; ABaseDirection: cardinal): TBidiUTF8Array;
+var
+  u: TUnicodeArray;
+  ofs: TIntegerArray;
+  a: TUnicodeBidiArray;
+  i: Integer;
+begin
+  if sUTF8 = '' then
+    result := nil
+  else
+  begin
+    UTF8ToUnicode(sUTF8, u, ofs);
+    a := AnalyzeBidiUnicode(@u[0], length(u), ABaseDirection);
+    setlength(result, length(u));
+    for i := 0 to high(result) do
+    begin
+      result[i].Offset:= ofs[i];
+      result[i].BidiInfo := a[i];
+    end;
+  end;
+end;
+function AnalyzeBidiUTF8(const sUTF8: string; ARightToLeft: boolean): TBidiUTF8Array;
+begin
+  if ARightToLeft then
+    result := AnalyzeBidiUTF8(sUTF8, UNICODE_RIGHT_TO_LEFT_ISOLATE)
+  else
+    result := AnalyzeBidiUTF8(sUTF8, UNICODE_LEFT_TO_RIGHT_ISOLATE);
+end;
+function AnalyzeBidiUTF8(const sUTF8: string): TBidiUTF8Array;
+begin
+  result := AnalyzeBidiUTF8(sUTF8, UNICODE_FIRST_STRONG_ISOLATE)
+end;
+function GetUTF8DisplayOrder(const ABidi: TBidiUTF8Array): TUnicodeDisplayOrder;
+begin
+  if length(ABidi) = 0 then
+    result := nil
+  else
+    result := GetUnicodeDisplayOrder(@ABidi[0].BidiInfo, sizeof(TBidiUTF8Info), length(ABidi));
+end;
+function ContainsBidiIsolateOrFormattingUTF8(const sUTF8: string): boolean;
+var
+  p,pEnd: PChar;
+  charLen: Integer;
+  u: Cardinal;
+begin
+  if sUTF8 = '' then exit(false);
+  p := @sUTF8[1];
+  pEnd := p + length(sUTF8);
+  while p < pEnd do
+  begin
+    charLen := UTF8CharacterLength(p);
+    if (charLen = 0) or (p+charLen > pEnd) then break;
+    u := UTF8CodepointToUnicode(p, charLen);
+    case u of
+      UNICODE_LEFT_TO_RIGHT_ISOLATE, UNICODE_RIGHT_TO_LEFT_ISOLATE, UNICODE_FIRST_STRONG_ISOLATE,
+      UNICODE_LEFT_TO_RIGHT_EMBEDDING, UNICODE_RIGHT_TO_LEFT_EMBEDDING,
+      UNICODE_LEFT_TO_RIGHT_OVERRIDE, UNICODE_RIGHT_TO_LEFT_OVERRIDE: exit(true);
+    end;
+    inc(p,charLen);
+  end;
+  exit(false);
+end;
+function UTF8OverrideDirection(const sUTF8: string; ARightToLeft: boolean): string;
+begin
+  if ARightToLeft then
+    result := UnicodeCharToUTF8(UNICODE_RIGHT_TO_LEFT_OVERRIDE) + sUTF8 + UnicodeCharToUTF8(UNICODE_POP_DIRECTIONAL_FORMATTING)
+  else
+    result := UnicodeCharToUTF8(UNICODE_LEFT_TO_RIGHT_OVERRIDE) + sUTF8 + UnicodeCharToUTF8(UNICODE_POP_DIRECTIONAL_FORMATTING);
+end;
+function UTF8EmbedDirection(const sUTF8: string; ARightToLeft: boolean): string;
+begin
+  if ARightToLeft then
+    result := UnicodeCharToUTF8(UNICODE_RIGHT_TO_LEFT_EMBEDDING) + sUTF8 + UnicodeCharToUTF8(UNICODE_POP_DIRECTIONAL_FORMATTING)
+  else
+    result := UnicodeCharToUTF8(UNICODE_LEFT_TO_RIGHT_EMBEDDING) + sUTF8 + UnicodeCharToUTF8(UNICODE_POP_DIRECTIONAL_FORMATTING);
+end;
+//little endian stream functions
+function LEReadInt64(Stream: TStream): int64;
+begin
+  Result := 0;
+  stream.Read(Result, sizeof(Result));
+  Result := LEtoN(Result);
+end;
+procedure LEWriteInt64(Stream: TStream; AValue: int64);
+begin
+  AValue := NtoLE(AValue);
+  stream.Write(AValue, sizeof(AValue));
+end;
+function LEReadLongint(Stream: TStream): longint;
+begin
+  Result := 0;
+  stream.Read(Result, sizeof(Result));
+  Result := LEtoN(Result);
+end;
+procedure LEWriteLongint(Stream: TStream; AValue: LongInt);
+begin
+  AValue := NtoLE(AValue);
+  stream.Write(AValue, sizeof(AValue));
+end;
+function LEReadByte(Stream: TStream): byte;
+begin
+  Result := 0;
+  stream.Read(Result, sizeof(Result));
+end;
+procedure LEWriteByte(Stream: TStream; AValue: Byte);
+begin
+  stream.Write(AValue, sizeof(AValue));
+end;
+function LEReadSingle(Stream: TStream): single;
+var
+  ResultAsDWord : longword absolute result;
+begin
+  ResultAsDWord := 0;
+  stream.Read(ResultAsDWord, sizeof(Result));
+  ResultAsDWord := LEtoN(ResultAsDWord);
+end;
+procedure LEWriteSingle(Stream: TStream; AValue: single);
+var
+  ValueAsDWord : longword absolute AValue;
+begin
+  ValueAsDWord := NtoLE(ValueAsDWord);
+  stream.Write(ValueAsDWord, sizeof(AValue));
+end;
 end.

GraphicTest/Packages/bgrabitmap/bgravectorize.pas

-              r494
+              r521
     ShadowOffset: TPoint;
     constructor Create;
     constructor Create(ADirectoryUTF8: string);
+    constructor Create; overload;
+    constructor Create(ADirectoryUTF8: string); overload;
     function GetFontPixelMetric: TFontPixelMetric; override;
     procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientation: integer; s: string; c: TBGRAPixel; align: TAlignment); override;
     procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientation: integer; s: string; texture: IBGRAScanner; align: TAlignment); override;
     procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; s: string; texture: IBGRAScanner; align: TAlignment); override;
     procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; s: string; c: TBGRAPixel; align: TAlignment); override;
     procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; s: string; style: TTextStyle; c: TBGRAPixel); override;
     procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; s: string; style: TTextStyle; texture: IBGRAScanner); override;
+    procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientation: integer; s: string; c: TBGRAPixel; align: TAlignment); overload; override;
+    procedure TextOutAngle(ADest: TBGRACustomBitmap; x, y: single; orientation: integer; s: string; texture: IBGRAScanner; align: TAlignment); overload; override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; s: string; texture: IBGRAScanner; align: TAlignment); overload; override;
+    procedure TextOut(ADest: TBGRACustomBitmap; x, y: single; s: string; c: TBGRAPixel; align: TAlignment); overload; override;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; s: string; style: TTextStyle; c: TBGRAPixel); overload; override;
+    procedure TextRect(ADest: TBGRACustomBitmap; ARect: TRect; x, y: integer; s: string; style: TTextStyle; texture: IBGRAScanner); overload; override;
     procedure CopyTextPathTo(ADest: IBGRAPath; x, y: single; s: string; align: TAlignment); override;
+    function HandlesTextPath: boolean; override;
     function TextSize(s: string): TSize; override;
+    function TextSize(sUTF8: string; AMaxWidth: integer; {%H-}ARightToLeft: boolean): TSize; override;
+    function TextFitInfo(sUTF8: string; AMaxWidth: integer): integer; override;
     destructor Destroy; override;
   end;
 …
   public
     UnderlineDecoration,StrikeOutDecoration: boolean;
     constructor Create;
     constructor Create(AVectorizeLCL: boolean);
+    constructor Create; overload;
+    constructor Create(AVectorizeLCL: boolean); overload;
     destructor Destroy; override;
     function GetGlyphSize(AIdentifier:string): TPointF;
 …
       AAlign: TBGRATypeWriterAlignment=twaTopLeft); override;
     procedure DrawTextWordBreak(ADest: TBGRACanvas2D; ATextUTF8: string; X, Y, MaxWidth: Single; AAlign: TBGRATypeWriterAlignment=twaTopLeft);
     procedure DrawTextRect(ADest: TBGRACanvas2D; ATextUTF8: string; X1,Y1,X2,Y2: Single; AAlign: TBGRATypeWriterAlignment=twaTopLeft);
     procedure DrawTextRect(ADest: TBGRACanvas2D; ATextUTF8: string; ATopLeft,ABottomRight: TPointF; AAlign: TBGRATypeWriterAlignment=twaTopLeft);
+    procedure DrawTextRect(ADest: TBGRACanvas2D; ATextUTF8: string; X1,Y1,X2,Y2: Single; AAlign: TBGRATypeWriterAlignment=twaTopLeft); overload;
+    procedure DrawTextRect(ADest: TBGRACanvas2D; ATextUTF8: string; ATopLeft,ABottomRight: TPointF; AAlign: TBGRATypeWriterAlignment=twaTopLeft); overload;
     function GetTextWordBreakGlyphBoxes(ATextUTF8: string; X,Y, MaxWidth: Single; AAlign: TBGRATypeWriterAlignment = twaTopLeft): TGlyphBoxes;
     function GetTextRectGlyphBoxes(ATextUTF8: string; X1,Y1,X2,Y2: Single; AAlign: TBGRATypeWriterAlignment=twaTopLeft): TGlyphBoxes;
     function GetTextRectGlyphBoxes(ATextUTF8: string; ATopLeft,ABottomRight: TPointF; AAlign: TBGRATypeWriterAlignment=twaTopLeft): TGlyphBoxes;
+    function GetTextRectGlyphBoxes(ATextUTF8: string; X1,Y1,X2,Y2: Single; AAlign: TBGRATypeWriterAlignment=twaTopLeft): TGlyphBoxes; overload;
+    function GetTextRectGlyphBoxes(ATextUTF8: string; ATopLeft,ABottomRight: TPointF; AAlign: TBGRATypeWriterAlignment=twaTopLeft): TGlyphBoxes; overload;
     procedure UpdateDirectory;
     function LoadGlyphsInfo(AFilenameUTF8: string): TBGRAGlyphsInfo;
 …
 implementation
 uses BGRAUTF8;
+uses BGRAUTF8, math;
 function VectorizeMonochrome(ASource: TBGRACustomBitmap; zoom: single; PixelCenteredCoordinates: boolean): ArrayOfTPointF;
 …
     inc(nbpoints);
   end;
   procedure AddLine(x1,y1,x2,y2: integer);
+  procedure AddLine(x1,y1,x2,y2: integer); overload;
   var i,j,k: integer;
   begin
 …
     points[k].next := addpoint(x2,y2,k,-1);
   end;
   procedure AddLine(x1,y1,x2,y2,x3,y3: integer);
+  procedure AddLine(x1,y1,x2,y2,x3,y3: integer); overload;
   begin
     AddLine(x1,y1,x2,y2);
     AddLine(x2,y2,x3,y3);
   end;
   procedure AddLine(x1,y1,x2,y2,x3,y3,x4,y4: integer);
+  procedure AddLine(x1,y1,x2,y2,x3,y3,x4,y4: integer); overload;
   begin
     AddLine(x1,y1,x2,y2);
 …
     AddLine(x3,y3,x4,y4);
   end;
   procedure AddLine(x1,y1,x2,y2,x3,y3,x4,y4,x5,y5: integer);
+  procedure AddLine(x1,y1,x2,y2,x3,y3,x4,y4,x5,y5: integer); overload;
   begin
     AddLine(x1,y1,x2,y2);
 …
 end;
+function TBGRAVectorizedFontRenderer.HandlesTextPath: boolean;
+begin
+  Result:= true;
+end;
 function TBGRAVectorizedFontRenderer.TextSize(s: string): TSize;
 var sizeF: TPointF;
 …
   result.cx := round(sizeF.x);
   result.cy := round(sizeF.y);
+end;
+function TBGRAVectorizedFontRenderer.TextSize(sUTF8: string;
+  AMaxWidth: integer; ARightToLeft: boolean): TSize;
+var
+  remains: string;
+  w,h,totalH: single;
+begin
+  UpdateFont;
+  result.cx := 0;
+  totalH := 0;
+  h := FVectorizedFont.FullHeight;
+  repeat
+    FVectorizedFont.SplitText(sUTF8, AMaxWidth, remains);
+    w := FVectorizedFont.GetTextSize(sUTF8).x;
+    if round(w)>result.cx then result.cx := round(w);
+    totalH += h;
+    sUTF8 := remains;
+  until remains = '';
+  result.cy := ceil(totalH);
+end;
+function TBGRAVectorizedFontRenderer.TextFitInfo(sUTF8: string;
+  AMaxWidth: integer): integer;
+var
+  remains: string;
+begin
+  UpdateFont;
+  FVectorizedFont.SplitText(sUTF8, AMaxWidth, remains);
+  result := length(sUTF8);
 end;
 …
       FFont.Height := FontEmHeightSign * 100;
       lEmHeight := BGRATextSize(FFont, fqSystem, 'Hg', 1).cy;
       FFont.Height := FontFullHeightSign * 100;
+      FFont.Height := FixLCLFontFullHeight(FFont.Name, FontFullHeightSign * 100);
       lFullHeight := BGRATextSize(FFont, fqSystem, 'Hg', 1).cy;
       if lEmHeight = 0 then
 …
     FFont.Name := FName;
     FFont.Style := FStyle;
+    FFont.Height := FontFullHeightSign * FResolution;
+    FFont.Height := FixLCLFontFullHeight(FFont.Name, FontFullHeightSign * FResolution);
+    FFont.Quality := fqNonAntialiased;
     FFontEmHeightRatio := 1;
     FFontEmHeightRatioComputed := false;
 …
     FBuffer.Fill(BGRAWhite);
     FBuffer.Canvas.Font := FFont;
-    FBuffer.Canvas.Font.Quality := fqNonAntialiased;
     FBuffer.Canvas.Font.Color := clBlack;
     FBuffer.Canvas.TextOut(size.cy div 2,0,AIdentifier);

GraphicTest/Packages/bgrabitmap/bgrawinbitmap.pas

-              r494
+              r521
   public
     procedure LoadFromBitmapIfNeeded; override;
     procedure Draw(ACanvas: TCanvas; x, y: integer; Opaque: boolean=True); override;
     procedure Draw(ACanvas: TCanvas; Rect: TRect; Opaque: boolean = True); override;
     procedure DataDrawOpaque(ACanvas: TCanvas; Rect: TRect; AData: Pointer;
+    procedure Draw(ACanvas: TCanvas; x, y: integer; Opaque: boolean=True); overload; override;
+    procedure Draw(ACanvas: TCanvas; Rect: TRect; Opaque: boolean = True); overload; override;
+    procedure DataDrawOpaque(ACanvas: TCanvas; ARect: TRect; AData: Pointer;
       ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer); override;
     procedure GetImageFromCanvas(CanvasSource: TCanvas; x, y: integer); override;
 …
 end;
 procedure TBGRAWinBitmap.DataDrawOpaque(ACanvas: TCanvas; Rect: TRect;
+procedure TBGRAWinBitmap.DataDrawOpaque(ACanvas: TCanvas; ARect: TRect;
   AData: Pointer; ALineOrder: TRawImageLineOrder; AWidth, AHeight: integer);
 var
 …
   info := DIBitmapInfo(AWidth, AHeight);
   StretchDIBits(ACanvas.Handle, Rect.Left, Rect.Top, Rect.Right -
     Rect.Left, Rect.Bottom - Rect.Top,
+  StretchDIBits(ACanvas.Handle, ARect.Left, ARect.Top, ARect.Right -
+    ARect.Left, ARect.Bottom - ARect.Top,
 , 0, AWidth, AHeight, AData, info, DIB_RGB_COLORS, SRCCOPY);

GraphicTest/Packages/bgrabitmap/bgrawinresource.pas

-              r494
+              r521
 uses
   Classes, SysUtils, BGRAMultiFileType, BGRABitmapTypes;
+  Classes, SysUtils, BGRAMultiFileType, BGRABitmapTypes, BGRAReadBMP;
 const
 …
   RT_HTML = 23;
   RT_MANIFEST = 24;
+  ICON_OR_CURSOR_FILE_ICON_TYPE = 1;
+  ICON_OR_CURSOR_FILE_CURSOR_TYPE = 2;
 type
 …
     constructor Create(AContainer: TMultiFileContainer; ATypeNameOrId: TNameOrId; AEntryNameOrId: TNameOrId; const AResourceInfo: TResourceInfo; ADataStream: TStream);
     destructor Destroy; override;
     function CopyTo(ADestination: TStream): integer; override;
+    function CopyTo(ADestination: TStream): int64; override;
   end;
 …
   public
     constructor Create(AContainer: TMultiFileContainer; AEntryNameOrId: TNameOrId; const AResourceInfo: TResourceInfo; ADataStream: TStream);
     function CopyTo(ADestination: TStream): integer; override;
+    function CopyTo(ADestination: TStream): int64; override;
     procedure CopyFrom(ASource: TStream);
   end;
 …
     constructor Create(AContainer: TMultiFileContainer; ATypeNameOrId: TNameOrId; AEntryNameOrId: TNameOrId; const AResourceInfo: TResourceInfo);
     procedure Clear;
     function CopyTo(ADestination: TStream): integer; override;
+    function CopyTo(ADestination: TStream): int64; override;
     procedure CopyFrom(ASource: TStream);
     property NbIcons: integer read GetNbIcons;
 …
 implementation
 uses Math, BMPcomn, BGRAUTF8;
+uses Math, BGRAUTF8;
 operator =(const ANameOrId1, ANameOrId2: TNameOrId): boolean;
 …
 end;
 function NameOrId(AName: string): TNameOrId;
+function NameOrId(AName: string): TNameOrId; overload;
 begin
   result.Id := -1;
 …
 end;
 function NameOrId(AId: integer): TNameOrId;
+function NameOrId(AId: integer): TNameOrId; overload;
 begin
   result.Id := AId;
 …
 function TGroupCursorEntry.ExpectedResourceType: word;
 begin
   result := 2;
+  result := ICON_OR_CURSOR_FILE_CURSOR_TYPE;
 end;
 …
 function TGroupIconEntry.ExpectedResourceType: word;
 begin
   result := 1;
+  result := ICON_OR_CURSOR_FILE_ICON_TYPE;
 end;
 …
 end;
 function TGroupIconOrCursorEntry.CopyTo(ADestination: TStream): integer;
+function TGroupIconOrCursorEntry.CopyTo(ADestination: TStream): int64;
 var
   fileDir: packed array of TIconFileDirEntry;
 …
 end;
+function TBitmapResourceEntry.CopyTo(ADestination: TStream): integer;
+var header: PBitMapInfoHeader;
+  fileHeader: TBitMapFileHeader;
+  headerSize: integer;
+  extraSize: integer;
+function TBitmapResourceEntry.CopyTo(ADestination: TStream): int64;
+var fileHeader: TBitMapFileHeader;
 begin
   result := 0;
   FDataStream.Position := 0;
+  headerSize := LEtoN(FDataStream.ReadDWord);
+  if (headerSize < 16) or (headerSize > FDataStream.Size) then
+    raise exception.Create('Invalid header size');
+  getmem(header, headerSize);
+  try
+    fillchar(header^, headerSize,0);
+    header^.Size := NtoLE(headerSize);
+    FDataStream.ReadBuffer((PByte(header)+4)^, headerSize-4);
+    if LEtoN(header^.Compression) = BI_BITFIELDS then
+      extraSize := 4*3
+    else if LEtoN(header^.BitCount) in [1,4,8] then
+    begin
+      if header^.ClrUsed > 0 then
+        extraSize := 4*header^.ClrUsed
+      else
+        extraSize := 4*(1 shl header^.BitCount);
+    end else
+      extraSize := 0;
+    fileHeader.bfType:= Word('BM');
+    fileHeader.bfSize := NtoLE(Integer(sizeof(TBitMapFileHeader) + FDataStream.Size));
+    fileHeader.bfReserved:= 0;
+    fileHeader.bfOffset := NtoLE(Integer(sizeof(TBitMapFileHeader) + headerSize + extraSize));
+    ADestination.WriteBuffer(fileHeader, sizeof(fileHeader));
+    result += sizeof(fileHeader);
+    ADestination.WriteBuffer(header^, headerSize);
+    result += headerSize;
+    if FDataStream.Size - headerSize > 0 then
+      result += ADestination.CopyFrom(FDataStream, FDataStream.Size - headerSize);
+  finally
+    freemem(header);
+  end;
+  fileHeader := MakeBitmapFileHeader(FDataStream);
+  ADestination.WriteBuffer(fileHeader, sizeof(fileHeader));
+  result += sizeof(fileHeader);
+  FDataStream.Position := 0;
+  result += ADestination.CopyFrom(FDataStream, FDataStream.Size);
 end;
 …
 end;
 function TUnformattedResourceEntry.CopyTo(ADestination: TStream): integer;
+function TUnformattedResourceEntry.CopyTo(ADestination: TStream): int64;
 begin
   if FDataStream.Size > 0 then
 …
   'ico': begin
            result := TGroupIconEntry.Create(self, entryName, resourceInfo);
+           AContent.Position:= 0;
            TGroupIconEntry(result).CopyFrom(AContent);
+           AContent.Free;
          end;
   'cur': begin
            result := TGroupCursorEntry.Create(self, entryName, resourceInfo);
+           AContent.Position:= 0;
            TGroupCursorEntry(result).CopyFrom(AContent);
+           AContent.Free;
          end;
   'bmp': begin
            result := TBitmapResourceEntry.Create(self, entryName, resourceInfo, AContent);
+           AContent.Position:= 0;
            TBitmapResourceEntry(result).CopyFrom(AContent);
+           AContent.Free;
          end;
   'dat': result := TUnformattedResourceEntry.Create(self, NameOrId(RT_RCDATA), entryName, resourceInfo, AContent);

GraphicTest/Packages/bgrabitmap/bgrawritelzp.pas

-              r494
+              r521
     begin
       IncludeThumbnail := false;
       header.compressionMode:= CompressionMode;
+      header.compressionMode:= CompressionMode; //update field for thumbnail
     end;
   header.previewOffset:= Str.Position - startPos;
   if Compression = lzpRLE then
     WriteRLEImage(Str, Img)
+    WriteRLEImage(Str, Img, Caption)
   else
   begin
     compBmp := TBGRACompressableBitmap.Create(Img as TBGRABitmap);
+    compBmp.Caption := Caption;
     compBmp.WriteToStream(Str);
     compBmp.Free;

GraphicTest/Packages/bgrabitmap/bgrawritepng.pas

-              r494
+              r521
       function  DoFilter (LineFilter:byte;index:longword; b:byte) : byte; virtual;
       procedure SetChunkLength (aValue : longword);
       procedure SetChunkType (ct : TChunkTypes);
       procedure SetChunkType (ct : TChunkCode);
+      procedure SetChunkType (ct : TChunkTypes); overload;
+      procedure SetChunkType (ct : TChunkCode); overload;
       function DecideGetPixel : TGetPixelFunc; virtual;
       procedure DetermineHeader (var AHeader : THeaderChunk); virtual;

GraphicTest/Packages/bgrabitmap/csscolorconst.inc

-              r494
+              r521
     constructor Create;
     {** Add a color to the list }
     procedure Add(Name: string; const Color: TBGRAPixel);
+    procedure Add(Name: string; const Color: TBGRAPixel); overload;
     {** Ends the color list and prevents further modifications }
     procedure Finished;
 …
 {* Converts a fully defined string into a ''TBGRAPixel'' value. Color names from ''VGAColors'' and ''CSSColors''
    are used if there is an exact match }
 function StrToBGRA(str: string): TBGRAPixel;
+function StrToBGRA(str: string): TBGRAPixel; overload;
 {* Converts a string into a ''TBGRAPixel'' value. If the value is not fully defined or that
    there is an error, ''DefaultColor'' is returned.
    Color names from ''VGAColors'' and ''CSSColors'' are used if there is an exact match. }
 function StrToBGRA(str: string; const DefaultColor: TBGRAPixel): TBGRAPixel;
+function StrToBGRA(str: string; const DefaultColor: TBGRAPixel): TBGRAPixel; overload;
 {* Converts a string into a ''TBGRAPixel'' value. If the value is not fully defined, missing channels (expressed with '?')
    are filled with fallbackValues. You can check if there was an error with the provided boolean.
 …
 function ParseColorValue(str: string; var flagError: boolean): byte;
 var pourcent,unclipped,{%H-}errPos: integer;
+  pourcentF: single;
+  pourcentStr: string;
 begin
   if str = '' then result := 0 else
 …
     if str[length(str)]='%' then
     begin
+      val(copy(str,1,length(str)-1),pourcent,errPos);
+      if errPos <> 0 then flagError := true;
+      if pourcent < 0 then result := 0 else
+      if pourcent > 100 then result := 255 else
+        result := pourcent*255 div 100;
+      pourcentStr := copy(str,1,length(str)-1);
+      val(pourcentStr,pourcent,errPos);
+      if errPos <> 0 then
+      begin
+        val(pourcentStr,pourcentF,errPos);
+        if errPos <> 0 then
+        begin
+          flagError := true;
+          result := 0;
+        end
+        else
+        begin
+          if pourcentF < 0 then result := 0 else
+          if pourcentF > 100 then result := 255 else
+           result := round(pourcentF*255 / 100);
+        end;
+      end else
+      begin
+         if pourcent < 0 then result := 0 else
+         if pourcent > 100 then result := 255 else
+           result := pourcent*255 div 100;
+      end;
     end else
     begin

GraphicTest/Packages/bgrabitmap/geometrytypes.inc

-              r494
+              r521
   {$endif}
+  {* Contains an array of points with single-precision floating point coordinates }
+  ArrayOfTPointF = array of TPointF;
+  {* An affine matrix contains three 2D vectors: the image of x, the image of y and the translation }
   TAffineMatrix = array[1..2,1..3] of single;
 …
   TRectF = Types.TRectF;
   {$else}
+  {$define BGRA_DEFINE_TRECTF}
+  { TRectF }
   TRectF =
   {$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
 …
   {$endif FPC_REQUIRES_PROPER_ALIGNMENT}
   record
+  private
+    function GetHeight: single;
+    function GetWidth: Single;
+  public
+    property Width: Single read GetWidth;
+    property Height: single read GetHeight;
+    procedure Offset (const dx,dy : Single);
     case Integer of
 : (Left, Top, Right, Bottom: Single);
 : (TopLeft, BottomRight: TPointF);
   end;
+  { TRectHelper }
+  TRectHelper = record helper for TRect
+  private
+    function GetHeight: integer;
+    function GetIsEmpty: boolean;
+    function GetWidth: integer;
+    procedure SetHeight(AValue: integer);
+    procedure SetWidth(AValue: integer);
+  public
+    constructor Create(Origin: TPoint; AWidth, AHeight: Longint); overload;
+    constructor Create(ALeft, ATop, ARight, ABottom: Longint); overload;
+    procedure Intersect(const ARect: TRect);
+    procedure Offset(DX, DY: Longint);
+    procedure Inflate(DX, DY: Longint);
+    function Contains(const APoint: TPoint): boolean; overload;
+    function Contains(const ARect: TRect): boolean; overload;
+    property Width: integer read GetWidth write SetWidth;
+    property Height: integer read GetHeight write SetHeight;
+    property IsEmpty: boolean read GetIsEmpty;
+  end;
+operator=(const ARect1,ARect2: TRect): boolean;
+type
+  { TSizeHelper }
+  TSizeHelper = record helper for TSize
+  private
+    function GetHeight: integer;
+    function GetWidth: integer;
+  public
+    property Width: integer read GetWidth;
+    property Height: integer read GetHeight;
+  end;
   {$endif}
+const
+  EmptyPoint : TPoint = (X: -2147483648; Y: -2147483648);
+function IsEmptyPoint(const APoint: TPoint): boolean;
+type
+  TPointFHelper = record helper for TPointF
+    function Ceiling: TPoint;
+    function Truncate: TPoint;
+    function Floor: TPoint;
+    function Round: TPoint;
+    function Length: Single;
+  end;
+type
+  PRectF = ^TRectF;
+  { TRectFHelper }
+  TRectFHelper = record helper for TRectF
+    class function Intersect(const R1: TRectF; const R2: TRectF): TRectF; overload; static;
+    class function Union(const R1: TRectF; const R2: TRectF): TRectF; overload; static;
+    class function Union(const R1: TRectF; const R2: TRectF; ADiscardEmpty: boolean): TRectF; overload; static;
+    function Union(const r: TRectF):TRectF;
+    function Union(const r: TRectF; ADiscardEmpty: boolean):TRectF;
+    function IntersectsWith(const r: TRectF): boolean;
+    function IsEmpty: boolean;
+  end;
+const
+  {* A value for an empty rectangle }
+  EmptyRectF : TRectF = (left:0; top:0; right:0; bottom: 0);
   function RectF(Left, Top, Right, Bottom: Single): TRectF;
+  function RectF(const ATopLeft,ABottomRight: TPointF): TRectF;
+  function RectWithSizeF(left,top,width,height: Single): TRectF;
+  function IsEmptyRectF(const ARect:TRectF): boolean;
+type
+  { TAffineBox }
+  TAffineBox = object
+  private
+    function GetAsPolygon: ArrayOfTPointF;
+    function GetBottomRight: TPointF;
+    function GetHeight: single;
+    function GetIsEmpty: boolean;
+    function GetRectBounds: TRect;
+    function GetRectBoundsF: TRectF;
+    function GetSurface: single;
+    function GetWidth: single;
+  public
+    TopLeft, TopRight,
+    BottomLeft: TPointF;
+    class function EmptyBox: TAffineBox; static;
+    class function AffineBox(ATopLeft, ATopRight, ABottomLeft: TPointF): TAffineBox; static; overload;
+    class function AffineBox(ARectF: TRectF): TAffineBox; static; overload;
+    function Contains(APoint: TPointF): boolean;
+    property RectBounds: TRect read GetRectBounds;
+    property RectBoundsF: TRectF read GetRectBoundsF;
+    property BottomRight: TPointF read GetBottomRight;
+    property IsEmpty: boolean read GetIsEmpty;
+    property AsPolygon: ArrayOfTPointF read GetAsPolygon;
+    property Width: single read GetWidth;
+    property Height: single read GetHeight;
+    property Surface: single read GetSurface;
+  end;
   const
 …
   {----------------- Operators for TPointF --------------------}
   {** Creates a new structure with values ''x'' and ''y'' }
+  function PointF(x, y: single): TPointF;
+  function PointF(x, y: single): TPointF; overload;
+  function PointF(pt: TPoint): TPointF; overload;
   {** Checks if the structure is empty (equal to ''EmptyPointF'') }
   function isEmptyPointF(const pt: TPointF): boolean;
 …
 type
   TFaceCulling = (fcNone, fcKeepCW, fcKeepCCW);
-  {* Contains an array of points with single-precision floating point coordinates }
-  ArrayOfTPointF = array of TPointF;
   {** Creates an array of ''TPointF'' }
 …
     ssRoundOutside,
     {** The curve is outside the polygonal envelope and there is a tangeant at vertices (starting and ending points are reached) }
+    ssVertexToSide);
+  { TCubicBezierCurve }
+  {* Definition of a Bézier curve of order 3. It has two control points ''c1'' and ''c2''. Those are not reached by the curve }
+  TCubicBezierCurve = object
+  private
+    function SimpleComputePoints(AAcceptedDeviation: single = 0.1; AIncludeFirstPoint: boolean = true): ArrayOfTPointF;
+  public
+    {** Starting point (reached) }
+    p1: TPointF;
+    {** First control point (not reached by the curve) }
+    c1: TPointF;
+    {** Second control point (not reached by the curve) }
+    c2: TPointF;
+    {** Ending point (reached) }
+    p2: TPointF;
+    {** Computes the point at time ''t'', varying from 0 to 1 }
+    function ComputePointAt(t: single): TPointF;
+    {** Split the curve in two such that ''ALeft.p2'' = ''ARight.p1'' }
+    procedure Split(out ALeft, ARight: TCubicBezierCurve);
+    {** Compute an approximation of the length of the curve. ''AAcceptedDeviation'' indicates the
+       maximum orthogonal distance that is ignored and approximated by a straight line. }
+    function ComputeLength(AAcceptedDeviation: single = 0.1): single;
+    {** Computes a polygonal approximation of the curve. ''AAcceptedDeviation'' indicates the
+       maximum orthogonal distance that is ignored and approximated by a straight line.
+       ''AIncludeFirstPoint'' indicates if the first point must be included in the array }
+    function ToPoints(AAcceptedDeviation: single = 0.1; AIncludeFirstPoint: boolean = true): ArrayOfTPointF;
+    function GetBounds: TRectF;
+  end;
+  {** Creates a structure for a cubic Bézier curve }
+  function BezierCurve(origin, control1, control2, destination: TPointF) : TCubicBezierCurve; overload;
+type
+  { TQuadraticBezierCurve }
+  {* Definition of a Bézier curve of order 2. It has one control point }
+  TQuadraticBezierCurve = object
+  private
+    function SimpleComputePoints(AAcceptedDeviation: single = 0.1; AIncludeFirstPoint: boolean = true): ArrayOfTPointF;
+    function ComputeExtremumPositionOutsideSegment: single;
+  public
+    {** Starting point (reached) }
+    p1: TPointF;
+    {** Control point (not reached by the curve) }
+    c: TPointF;
+    {** Ending point (reached) }
+    p2: TPointF;
+    {** Computes the point at time ''t'', varying from 0 to 1 }
+    function ComputePointAt(t: single): TPointF;
+    {** Split the curve in two such that ''ALeft.p2'' = ''ARight.p1'' }
+    procedure Split(out ALeft, ARight: TQuadraticBezierCurve);
+    {** Compute the '''exact''' length of the curve }
+    function ComputeLength: single;
+    {** Computes a polygonal approximation of the curve. ''AAcceptedDeviation'' indicates the
+       maximum orthogonal distance that is ignored and approximated by a straight line.
+       ''AIncludeFirstPoint'' indicates if the first point must be included in the array }
+    function ToPoints(AAcceptedDeviation: single = 0.1; AIncludeFirstPoint: boolean = true): ArrayOfTPointF;
+    function GetBounds: TRectF;
+  end;
+  {** Creates a structure for a quadratic Bézier curve }
+  function BezierCurve(origin, control, destination: TPointF) : TQuadraticBezierCurve; overload;
+  {** Creates a structure for a quadratic Bézier curve without curvature }
+  function BezierCurve(origin, destination: TPointF) : TQuadraticBezierCurve; overload;
+    ssVertexToSide,
+    {** The curve is rounded using Bezier curves when the angle is less than or equal to 45° }
+    ssEasyBezier);
 type
 …
       procedure SetStrokeMatrix(const AValue: TAffineMatrix); virtual; abstract;
   public
       function ComputePolyline(const APoints: array of TPointF; AWidth: single; AClosedCap: boolean = true): ArrayOfTPointF; virtual; abstract;
       function ComputePolyline(const APoints: array of TPointF; AWidth: single; APenColor: TBGRAPixel; AClosedCap: boolean = true): ArrayOfTPointF; virtual; abstract;
+      function ComputePolyline(const APoints: array of TPointF; AWidth: single; AClosedCap: boolean = true): ArrayOfTPointF; overload; virtual; abstract;
+      function ComputePolyline(const APoints: array of TPointF; AWidth: single; APenColor: TBGRAPixel; AClosedCap: boolean = true): ArrayOfTPointF; overload; virtual; abstract;
       function ComputePolylineAutoCycle(const APoints: array of TPointF; AWidth: single): ArrayOfTPointF; virtual; abstract;
       function ComputePolygon(const APoints: array of TPointF; AWidth: single): ArrayOfTPointF; virtual; abstract;
 …
   {** Computes the intersection of two lines. If they are parallel, returns
       the middle of the segment between the two origins }
   function IntersectLine(line1, line2: TLineDef): TPointF;
+  function IntersectLine(line1, line2: TLineDef): TPointF; overload;
   {** Computes the intersection of two lines. If they are parallel, returns
       the middle of the segment between the two origins. The value ''parallel''
       is set to indicate if the lines were parallel }
   function IntersectLine(line1, line2: TLineDef; out parallel: boolean): TPointF;
+  function IntersectLine(line1, line2: TLineDef; out parallel: boolean): TPointF; overload;
   {** Checks if the polygon formed by the given points is convex. ''IgnoreAlign''
       specifies that if the points are aligned, it should still be considered as convex }
 …
     procedure closePath;
     {** Moves to a location, disconnected from previous points }
     procedure moveTo(const pt: TPointF);
+    procedure moveTo(constref pt: TPointF);
     {** Adds a line from the current point }
     procedure lineTo(const pt: TPointF);
+    procedure lineTo(constref pt: TPointF);
     {** Adds a polyline from the current point }
     procedure polylineTo(const pts: array of TPointF);
     {** Adds a quadratic Bézier curve from the current point }
     procedure quadraticCurveTo(const cp,pt: TPointF);
+    procedure quadraticCurveTo(constref cp,pt: TPointF);
     {** Adds a cubic Bézier curve from the current point }
     procedure bezierCurveTo(const cp1,cp2,pt: TPointF);
+    procedure bezierCurveTo(constref cp1,cp2,pt: TPointF);
     {** Adds an arc. If there is a current point, it is connected to the beginning of the arc }
     procedure arc(const arcDef: TArcDef);
+    procedure arc(constref arcDef: TArcDef);
     {** Adds an opened spline. If there is a current point, it is connected to the beginning of the spline }
     procedure openedSpline(const pts: array of TPointF; style: TSplineStyle);
 …
     procedure copyTo(dest: IBGRAPath);
     {** Returns the content of the path as an array of points }
     function getPoints: ArrayOfTPointF;
+    function getPoints: ArrayOfTPointF; overload;
     {** Returns the content of the path as an array of points with the transformation specified by ''AMatrix'' }
     function getPoints(AMatrix: TAffineMatrix): ArrayOfTPointF;
+    function getPoints(AMatrix: TAffineMatrix): ArrayOfTPointF; overload;
     {** Returns a cursor to go through the path. The cursor must be freed by calling ''Free''. }
     function getCursor: TBGRACustomPathCursor;
   end;
+  { TBGRACustomPath }
+  TBGRACustomPath = class(IBGRAPath)
+    constructor Create; virtual; abstract;
+    procedure beginPath; virtual; abstract;
+    procedure closePath; virtual; abstract;
+    procedure moveTo(constref pt: TPointF); virtual; abstract;
+    procedure lineTo(constref pt: TPointF); virtual; abstract;
+    procedure polylineTo(const pts: array of TPointF); virtual; abstract;
+    procedure quadraticCurveTo(constref cp,pt: TPointF); virtual; abstract;
+    procedure bezierCurveTo(constref cp1,cp2,pt: TPointF); virtual; abstract;
+    procedure arc(constref arcDef: TArcDef); virtual; abstract;
+    procedure openedSpline(const pts: array of TPointF; style: TSplineStyle); virtual; abstract;
+    procedure closedSpline(const pts: array of TPointF; style: TSplineStyle); virtual; abstract;
+    procedure copyTo(dest: IBGRAPath); virtual; abstract;
+  protected
+    function getPoints: ArrayOfTPointF; virtual; abstract;
+    function getPoints(AMatrix: TAffineMatrix): ArrayOfTPointF; virtual; abstract;
+    function getLength: single; virtual; abstract;
+    function getCursor: TBGRACustomPathCursor; virtual; abstract;
+  protected
+    function QueryInterface({$IFDEF FPC_HAS_CONSTREF}constref{$ELSE}const{$ENDIF} IID: TGUID; out Obj): HResult; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
+    function _AddRef: Integer; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
+    function _Release: Integer; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
+  end;
+  TBGRAPathAny = class of TBGRACustomPath;
   { TBGRACustomPathCursor }
 …
   end;
+var
+  BGRAPathFactory: TBGRAPathAny;
 const
   {* A value for an empty rectangle }
 …
 {* Creates a rectangle with the specified ''width'' and ''height'' }
 function RectWithSize(left,top,width,height: integer): TRect;
+{$DEFINE INCLUDE_INTERFACE}
+{$I bezier.inc}
 type
 …
     gtDiamond,
     {** The color changes in a radial way from a given center }
+    gtRadial);
+    gtRadial,
+    {** The color changes according to the angle relative to a given center }
+    gtAngular);
 const
   {** List of string to represent gradient types }
   GradientTypeStr : array[TGradientType] of string
   = ('Linear','Reflected','Diamond','Radial');
+  = ('Linear','Reflected','Diamond','Radial','Angular');
   {** Returns the gradient type represented by the given string }
   function StrToGradientType(str: string): TGradientType;
 …
 {$UNDEF INCLUDE_IMPLEMENTATION}
+{$IFDEF BGRA_DEFINE_TRECTF}
+{ TRectF }
+function TRectF.GetHeight: single;
+begin
+  result := Bottom-Top;
+end;
+function TRectF.GetWidth: Single;
+begin
+  result := Right-Left;
+end;
+procedure TRectF.Offset(const dx, dy: Single);
+begin
+  left:=left+dx; right:=right+dx;
+  bottom:=bottom+dy; top:=top+dy;
+end;
+{ TRectHelper }
+function TRectHelper.GetHeight: integer;
+begin
+  result := Bottom-Top;
+end;
+function TRectHelper.GetIsEmpty: boolean;
+begin
+  result := (Width = 0) and (Height = 0)
+end;
+function TRectHelper.GetWidth: integer;
+begin
+  result := Right-Left;
+end;
+procedure TRectHelper.SetHeight(AValue: integer);
+begin
+  Bottom := Top+AValue;
+end;
+procedure TRectHelper.SetWidth(AValue: integer);
+begin
+  Right := Left+AValue;
+end;
+constructor TRectHelper.Create(Origin: TPoint; AWidth, AHeight: Longint);
+begin
+  self.Left := Origin.X;
+  self.Top := Origin.Y;
+  self.Right := Origin.X+AWidth;
+  self.Bottom := Origin.Y+AHeight;
+end;
+constructor TRectHelper.Create(ALeft, ATop, ARight, ABottom: Longint);
+begin
+  self.Left := ALeft;
+  self.Top := ATop;
+  self.Right := ARight;
+  self.Bottom := ABottom;
+end;
+procedure TRectHelper.Intersect(const ARect: TRect);
+begin
+  IntersectRect(self, self, ARect);
+end;
+procedure TRectHelper.Offset(DX, DY: Longint);
+begin
+  OffsetRect(self, DX,DY);
+end;
+procedure TRectHelper.Inflate(DX, DY: Longint);
+begin
+  InflateRect(self, DX,DY);
+end;
+function TRectHelper.Contains(const APoint: TPoint): boolean;
+begin
+  result := (APoint.X >= Left) and (APoint.X <= Right) and
+    (APoint.Y >= Top) and (APoint.Y <= Bottom);
+end;
+function TRectHelper.Contains(const ARect: TRect): boolean;
+begin
+  Result := (Left <= ARect.Left) and (ARect.Right <= Right) and (Top <= ARect.Top) and (ARect.Bottom <= Bottom);
+end;
+operator =(const ARect1, ARect2: TRect): boolean;
+begin
+  result:= (ARect1.Left = ARect2.Left) and (ARect1.Top = ARect2.Top) and
+           (ARect1.Right = ARect2.Right) and (ARect1.Bottom = ARect2.Bottom);
+end;
+{ TSizeHelper }
+function TSizeHelper.GetHeight: integer;
+begin
+  result := cy;
+end;
+function TSizeHelper.GetWidth: integer;
+begin
+  result := cx;
+end;
+{$ENDIF}
+function IsEmptyPoint(const APoint: TPoint): boolean;
+begin
+  result := (APoint.x = -2147483648) or (APoint.y = -2147483648);
+end;
+function TPointFHelper.Ceiling: TPoint;
+begin
+  if isEmptyPointF(self) then
+    result := EmptyPoint
+  else
+  begin
+    result.x:=ceil(x);
+    result.y:=ceil(y);
+  end;
+end;
+function TPointFHelper.Truncate: TPoint;
+begin
+  if isEmptyPointF(self) then
+    result := EmptyPoint
+  else
+  begin
+    result.x:=trunc(x);
+    result.y:=trunc(y);
+  end;
+end;
+function TPointFHelper.Floor: TPoint;
+begin
+  if isEmptyPointF(self) then
+    result := EmptyPoint
+  else
+  begin
+    result.x:=Math.floor(x);
+    result.y:=Math.floor(y);
+  end;
+end;
+function TPointFHelper.Round: TPoint;
+begin
+  if isEmptyPointF(self) then
+    result := EmptyPoint
+  else
+  begin
+    result.x:=System.round(x);
+    result.y:=System.round(y);
+  end;
+end;
+function TPointFHelper.Length: Single;
+begin
+  result:= VectLen(self);
+end;
+class function TRectFHelper.Intersect(const R1: TRectF; const R2: TRectF): TRectF;
+begin
+  result.left:=max(R1.left,R2.left);
+  result.top:=max(R1.top,R2.top);
+  result.right:=min(R1.right,R2.right);
+  result.bottom:=min(R1.bottom,R2.bottom);
+  if (result.left >= result.right) or (result.top >= result.bottom) then
+    result := EmptyRectF;
+end;
+class function TRectFHelper.Union(const R1: TRectF; const R2: TRectF): TRectF;
+begin
+  result.left:=min(R1.left,R2.left);
+  result.top:=min(R1.top,R2.top);
+  result.right:=max(R1.right,R2.right);
+  result.bottom:=max(R1.bottom,R2.bottom);
+end;
+class function TRectFHelper.Union(const R1: TRectF; const R2: TRectF; ADiscardEmpty: boolean): TRectF;
+begin
+  if ADiscardEmpty and IsEmptyRectF(R1) then result:= R2 else
+  if ADiscardEmpty and IsEmptyRectF(R2) then result:= R1 else
+    result := Union(R1,R2);
+end;
+function TRectFHelper.Union(const r: TRectF): TRectF;
+begin
+  result := TRectF.Union(self, r);
+end;
+function TRectFHelper.Union(const r: TRectF; ADiscardEmpty: boolean): TRectF;
+begin
+  result := TRectF.Union(self, r, ADiscardEmpty);
+end;
+function TRectFHelper.IntersectsWith(const r: TRectF): boolean;
+begin
+  result:= not TRectF.Intersect(self, r).IsEmpty;
+end;
+function TRectFHelper.IsEmpty: boolean;
+begin
+  result:= IsEmptyRectF(self);
+end;
+{ TAffineBox }
+function TAffineBox.GetAsPolygon: ArrayOfTPointF;
+begin
+  result := PointsF([TopLeft,TopRight,BottomRight,BottomLeft]);
+end;
+function TAffineBox.GetBottomRight: TPointF;
+begin
+  if IsEmpty then
+    result := EmptyPointF
+  else
+    result := TopRight + (BottomLeft-TopLeft);
+end;
+function TAffineBox.GetHeight: single;
+begin
+  if isEmptyPointF(TopLeft) or isEmptyPointF(BottomLeft) then
+    result := 0
+  else
+    result := VectLen(BottomLeft-TopLeft);
+end;
+function TAffineBox.GetIsEmpty: boolean;
+begin
+  result := isEmptyPointF(TopRight) or isEmptyPointF(BottomLeft) or isEmptyPointF(TopLeft);
+end;
+function TAffineBox.GetRectBounds: TRect;
+begin
+  with GetRectBoundsF do
+    result := Rect(floor(Left),floor(Top),ceil(Right),ceil(Bottom));
+end;
+function TAffineBox.GetRectBoundsF: TRectF;
+var
+  x1,y1,x2,y2: single;
+begin
+  x1 := TopLeft.x; x2 := x1;
+  y1 := TopLeft.y; y2 := y1;
+  if TopRight.x > x2 then x2 := TopRight.x;
+  if TopRight.x < x1 then x1 := TopRight.x;
+  if TopRight.y > y2 then y2 := TopRight.y;
+  if TopRight.y < y1 then y1 := TopRight.y;
+  if BottomLeft.x > x2 then x2 := BottomLeft.x;
+  if BottomLeft.x < x1 then x1 := BottomLeft.x;
+  if BottomLeft.y > y2 then y2 := BottomLeft.y;
+  if BottomLeft.y < y1 then y1 := BottomLeft.y;
+  if BottomRight.x > x2 then x2 := BottomRight.x;
+  if BottomRight.x < x1 then x1 := BottomRight.x;
+  if BottomRight.y > y2 then y2 := BottomRight.y;
+  if BottomRight.y < y1 then y1 := BottomRight.y;
+  result := RectF(x1,y1,x2,y2);
+end;
+function TAffineBox.GetSurface: single;
+var
+  u, v: TPointF;
+  lenU, lenH: Single;
+begin
+  u := TopRight-TopLeft;
+  lenU := VectLen(u);
+  if lenU = 0 then exit(0);
+  u *= 1/lenU;
+  v := BottomLeft-TopLeft;
+  lenH := PointF(-u.y,u.x)*v;
+  result := abs(lenU*lenH);
+end;
+function TAffineBox.GetWidth: single;
+begin
+  if isEmptyPointF(TopLeft) or isEmptyPointF(TopRight) then
+    result := 0
+  else
+    result := VectLen(TopRight-TopLeft);
+end;
+class function TAffineBox.EmptyBox: TAffineBox;
+begin
+  result.TopLeft := EmptyPointF;
+  result.TopRight := EmptyPointF;
+  result.BottomLeft := EmptyPointF;
+end;
+class function TAffineBox.AffineBox(ATopLeft, ATopRight, ABottomLeft: TPointF): TAffineBox;
+begin
+  result.TopLeft := ATopLeft;
+  result.TopRight := ATopRight;
+  result.BottomLeft := ABottomLeft;
+end;
+class function TAffineBox.AffineBox(ARectF: TRectF): TAffineBox;
+begin
+  result.TopLeft := ARectF.TopLeft;
+  result.TopRight := PointF(ARectF.Right, ARectF.Top);
+  result.BottomLeft := PointF(ARectF.Left, ARectF.Bottom);
+end;
+function TAffineBox.Contains(APoint: TPointF): boolean;
+var
+  u,v,perpU,perpV: TPointF;
+  posV1, posV2, posU1, posU2: single;
+begin
+  if IsEmpty then exit(false);
+  u := TopRight-TopLeft;
+  perpU := PointF(-u.y,u.x);
+  v := BottomLeft-TopLeft;
+  perpV := PointF(v.y,-v.x);
+  //reverse normal if not in the same direction as other side
+  if perpU*v < 0 then
+  begin
+    perpU := -perpU;
+    perpV := -perpV;
+  end;
+  //determine position along normals
+  posU1 := (APoint-TopLeft)*perpU;
+  posU2 := (APoint-BottomLeft)*perpU;
+  posV1 := (APoint-TopLeft)*perpV;
+  posV2 := (APoint-TopRight)*perpV;
+  result := (posU1 >= 0) and (posU2 < 0) and (posV1 >= 0) and (posV2 < 0);
+end;
 function StrToGradientType(str: string): TGradientType;
 var gt: TGradientType;
 …
 end;
+//-------------- Bézier curves definitions ----------------
+// See : http://en.wikipedia.org/wiki/B%C3%A9zier_curve
+// Define a Bézier curve with two control points.
+function BezierCurve(origin, control1, control2, destination: TPointF): TCubicBezierCurve;
+begin
+  result.p1 := origin;
+  result.c1 := control1;
+  result.c2 := control2;
+  result.p2 := destination;
+end;
+// Define a Bézier curve with one control point.
+function BezierCurve(origin, control, destination: TPointF
+  ): TQuadraticBezierCurve;
+begin
+  result.p1 := origin;
+  result.c := control;
+  result.p2 := destination;
+end;
+//straight line
+function BezierCurve(origin, destination: TPointF): TQuadraticBezierCurve;
+begin
+  result.p1 := origin;
+  result.c := (origin+destination)*0.5;
+  result.p2 := destination;
+{ TBGRACustomPath }
+function TBGRACustomPath.QueryInterface({$IFDEF FPC_HAS_CONSTREF}constref{$ELSE}const{$ENDIF} IID: TGUID; out Obj): HResult; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
+begin
+  if GetInterface(iid, obj) then
+    Result := S_OK
+  else
+    Result := longint(E_NOINTERFACE);
+end;
+{ There is no automatic reference counting, but it is compulsory to define these functions }
+function TBGRACustomPath._AddRef: Integer; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
+begin
+  result := 0;
+end;
+function TBGRACustomPath._Release: Integer; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
+begin
+  result := 0;
 end;
 …
 end;
+function RectF(const ATopLeft, ABottomRight: TPointF): TRectF;
+begin
+  result.TopLeft:= ATopLeft;
+  result.BottomRight:= ABottomRight;
+end;
+function RectWithSizeF(left, top, width, height: Single): TRectF;
+begin
+  result.Left:= Left;
+  result.Top:= Top;
+  result.Right:= left+width;
+  result.Bottom:= top+height;
+end;
+function IsEmptyRectF(const ARect: TRectF): boolean;
+begin
+  result:= (ARect.Width = 0) and (ARect.Height = 0);
+end;
 function PointF(x, y: single): TPointF;
 begin
   Result.x := x;
   Result.y := y;
+end;
+function PointF(pt: TPoint): TPointF;
+begin
+  if IsEmptyPoint(pt) then
+    result:= EmptyPointF
+  else
+  begin
+    Result.x := pt.x;
+    Result.y := pt.y;
+  end;
 end;
 …
 function VectLen(v: TPointF): single;
 begin
+  result := sqrt(v*v);
+  if isEmptyPointF(v) then
+    result := EmptySingle
+  else
+    result := sqrt(v*v);
 end;
 …
 end;
+{------------------ Bezier curves ------------------------}
+function ComputeBezierCurvePrecision(pt1, pt2, pt3, pt4: TPointF; AAcceptedDeviation: single = 0.1): integer;
+var
+  len: single;
+begin
+  len    := sqr(pt1.x - pt2.x) + sqr(pt1.y - pt2.y);
+  len    := max(len, sqr(pt3.x - pt2.x) + sqr(pt3.y - pt2.y));
+  len    := max(len, sqr(pt3.x - pt4.x) + sqr(pt3.y - pt4.y));
+  Result := round(sqrt(sqrt(len)/ AAcceptedDeviation) * 1);
+  if Result<=0 then Result:=1;
+end;
+{ TCubicBezierCurve }
+function TCubicBezierCurve.SimpleComputePoints(AAcceptedDeviation: single;
+  AIncludeFirstPoint: boolean = true): ArrayOfTPointF;
+var
+  t,step: single;
+  i,nb: Integer;
+begin
+  nb := ComputeBezierCurvePrecision(p1,c1,c2,p2, AAcceptedDeviation/2);
+  if nb <= 1 then nb := 2;
+  if AIncludeFirstPoint then
+  begin
+    setlength(result,nb);
+    result[0] := p1;
+    result[nb-1] := p2;
+    step := 1/(nb-1);
+    t := 0;
+    for i := 1 to nb-2 do
+    begin
+      t += step;
+      result[i] := ComputePointAt(t);
+    end;
+  end else
+  begin
+    setlength(result,nb-1);
+    result[nb-2] := p2;
+    step := 1/(nb-1);
+    t := 0;
+    for i := 0 to nb-3 do
+    begin
+      t += step;
+      result[i] := ComputePointAt(t);
+    end;
+  end;
+end;
+function TCubicBezierCurve.ComputePointAt(t: single): TPointF;
+var
+  f1,f2,f3,f4: single;
+begin
+  f1 := (1-t);
+  f2 := f1*f1;
+  f1 *= f2;
+  f2 *= t*3;
+  f4 := t*t;
+  f3 := f4*(1-t)*3;
+  f4 *= t;
+  result.x := f1*p1.x + f2*c1.x +
+              f3*c2.x + f4*p2.x;
+  result.y := f1*p1.y + f2*c1.y +
+              f3*c2.y + f4*p2.y;
+end;
+procedure TCubicBezierCurve.Split(out ALeft, ARight: TCubicBezierCurve);
+var midc: TPointF;
+begin
+  ALeft.p1 := p1;
+  ALeft.c1 := 0.5*(p1+c1);
+  ARight.p2 := p2;
+  ARight.c2 := 0.5*(p2+c2);
+  midc := 0.5*(c1+c2);
+  ALeft.c2 := 0.5*(ALeft.c1+midc);
+  ARight.c1 := 0.5*(ARight.c2+midc);
+  ALeft.p2 := 0.5*(ALeft.c2+ARight.c1);
+  ARight.p1 := ALeft.p2;
+end;
+function TCubicBezierCurve.ComputeLength(AAcceptedDeviation: single): single;
+var
+  t,step: single;
+  i,nb: Integer;
+  curCoord,nextCoord: TPointF;
+begin
+  nb := ComputeBezierCurvePrecision(p1,c1,c2,p2, AAcceptedDeviation);
+  if nb <= 1 then nb := 2;
+  result := 0;
+  curCoord := p1;
+  step := 1/(nb-1);
+  t := 0;
+  for i := 1 to nb-2 do
+  begin
+    t += step;
+    nextCoord := ComputePointAt(t);
+    result += VectLen(nextCoord-curCoord);
+    curCoord := nextCoord;
+  end;
+  result += VectLen(p2-curCoord);
+end;
+function TCubicBezierCurve.ToPoints(AAcceptedDeviation: single;
+  AIncludeFirstPoint: boolean = true): ArrayOfTPointF;
+begin
+  result := SimpleComputePoints(AAcceptedDeviation, AIncludeFirstPoint);
+end;
+{//The following function computes by splitting the curve. It is slower than the simple function.
+function TCubicBezierCurve.ToPoints(AAcceptedDeviation: single;
+  ARelativeDeviation: boolean): ArrayOfTPointF;
+  function ToPointsRec(const ACurve: TCubicBezierCurve): ArrayOfTPointF;
+  var simpleLen2: single;
+    v: TPointF;
+    left,right: TCubicBezierCurve;
+    subLeft,subRight: ArrayOfTPointF;
+    maxDev,dev1,dev2: single;
+    subLeftLen: integer;
+    procedure ComputeExtremum;
+    begin
+      raise Exception.Create('Not implemented');
+      result := nil;
+    end;
+  begin
+    v := ACurve.p2-ACurve.p1;
+    simpleLen2 := v*v;
+    if simpleLen2 = 0 then
+    begin
+      if (ACurve.c1.x = ACurve.p1.x) and (ACurve.c1.y = ACurve.p1.y) and
+         (ACurve.c2.x = ACurve.p2.x) and (ACurve.c2.y = ACurve.p2.y) then
+      begin
+        result := nil;
+        exit;
+      end;
+      ACurve.Split(left,right);
+    end else
+    begin
+      ACurve.Split(left,right);
+      if not ARelativeDeviation then simpleLen2:= sqrt(simpleLen2);
+      maxDev := AAcceptedDeviation*simpleLen2;
+      if abs(PointF(v.y,-v.x) * (left.p2-ACurve.p1)) <= maxDev then
+      begin
+        dev1 := PointF(v.y,-v.x) * (ACurve.c1-ACurve.p1);
+        dev2 := PointF(v.y,-v.x) * (ACurve.c2-ACurve.p2);
+        if not ((Sign(dev1)<>Sign(dev2)) and ((abs(dev1) > maxDev) or (abs(dev2) > maxDev))) then
+        begin
+          result := nil;
+          if ((ACurve.c1-ACurve.p1)*v < -maxDev) or
+             ((ACurve.c1-ACurve.p2)*v > maxDev) or
+             ((ACurve.c2-ACurve.p1)*v < -maxDev) or
+             ((ACurve.c2-ACurve.p2)*v > maxDev) then
+            ComputeExtremum;
+          exit;
+        end;
+      end;
+    end;
+    subRight := ToPointsRec(right);
+    subLeft := ToPointsRec(left);
+    subLeftLen := length(subLeft);
+    //avoid leaving a gap in memory
+    result := subLeft;
+    subLeft := nil;
+    setlength(result, subLeftLen+1+length(subRight));
+    result[subLeftLen] := left.p2;
+    move(subRight[0], result[subLeftLen+1], length(subRight)*sizeof(TPointF));
+  end;
+var
+  subLen: integer;
+begin
+  if (c1.x = p1.x) and (c1.y = p1.y) and
+     (c1.x = c2.x) and (c1.y = c2.y) and
+     (c1.x = p2.x) and (c1.y = p2.y) then
+  begin
+    setlength(result,1);
+    result[0] := c1;
+    exit;
+  end else
+  begin
+    result := ToPointsRec(self);
+    subLen := length(result);
+    setlength(result, length(result)+2);
+    move(result[0], result[1], subLen*sizeof(TPointF));
+    result[0] := p1;
+    result[high(result)] := p2;
+  end;
+end;}
+function TCubicBezierCurve.GetBounds: TRectF;
+const precision = 1e-5;
+  procedure Include(pt: TPointF);
+  begin
+    if pt.x < result.Left then result.Left := pt.x
+    else if pt.x > result.Right then result.Right := pt.x;
+    if pt.y < result.Top then result.Top := pt.y
+    else if pt.y > result.Bottom then result.Bottom := pt.y;
+  end;
+  procedure IncludeT(t: single);
+  begin
+    if (t > 0) and (t < 1) then
+      Include(ComputePointAt(t));
+  end;
+  procedure IncludeABC(a,b,c: single);
+  var b2ac, sqrtb2ac: single;
+  begin
+    if abs(a) < precision then
+    begin
+      if abs(b) < precision then exit;
+      IncludeT(-c/b);
+    end else
+    begin
+      b2ac := sqr(b) - 4 * a * c;
+      if b2ac >= 0 then
+      begin
+        sqrtb2ac := sqrt(b2ac);
+        IncludeT((-b + sqrtb2ac) / (2 * a));
+        IncludeT((-b - sqrtb2ac) / (2 * a));
+      end;
+    end;
+  end;
+var
+  va, vb, vc: TPointF;
+begin
+  result.TopLeft := p1;
+  result.BottomRight := p1;
+  Include(p2);
+  vb := 6 * p1 - 12 * c1 + 6 * c2;
+  va := -3 * p1 + 9 * c1 - 9 * c2 + 3 * p2;
+  vc := 3 * c1 - 3 * p1;
+  IncludeABC(va.x,vb.x,vc.x);
+  IncludeABC(va.y,vb.y,vc.y);
+end;
+{ TQuadraticBezierCurve }
+function TQuadraticBezierCurve.SimpleComputePoints(AAcceptedDeviation: single;
+  AIncludeFirstPoint: boolean = true): ArrayOfTPointF;
+var
+  t,step: single;
+  i,nb: Integer;
+begin
+  nb := ComputeBezierCurvePrecision(p1,c,c,p2, AAcceptedDeviation);
+  if nb <= 1 then nb := 2;
+  if AIncludeFirstPoint then
+  begin
+    setlength(result,nb);
+    result[0] := p1;
+    result[nb-1] := p2;
+    step := 1/(nb-1);
+    t := 0;
+    for i := 1 to nb-2 do
+    begin
+      t += step;
+      result[i] := ComputePointAt(t);
+    end;
+  end else
+  begin
+    setlength(result,nb-1);
+    result[nb-2] := p2;
+    step := 1/(nb-1);
+    t := 0;
+    for i := 0 to nb-3 do
+    begin
+      t += step;
+      result[i] := ComputePointAt(t);
+    end;
+  end;
+end;
+function TQuadraticBezierCurve.ComputeExtremumPositionOutsideSegment: single;
+var a,b: single;
+  v: TPointF;
+begin
+  v := self.p2-self.p1;
+  a := (self.p1-2*self.c+self.p2)*v;
+  if a = 0 then //no solution
+  begin
+    result := -1;
+    exit;
+  end;
+  b := (self.c-self.p1)*v;
+  result := -b/a;
+end;
+function TQuadraticBezierCurve.ComputePointAt(t: single): TPointF;
+var
+  rev_t,f2,t2: single;
+begin
+  rev_t := (1-t);
+  f2 := rev_t*t*2;
+  rev_t *= rev_t;
+  t2 := t*t;
+  result.x := rev_t*p1.x + f2*c.x + t2*p2.x;
+  result.y := rev_t*p1.y + f2*c.y + t2*p2.y;
+end;
+procedure TQuadraticBezierCurve.Split(out ALeft, ARight: TQuadraticBezierCurve);
+begin
+  ALeft.p1 := p1;
+  ALeft.c := 0.5*(p1+c);
+  ARight.p2 := p2;
+  ARight.c := 0.5*(p2+c);
+  ALeft.p2 := 0.5*(ALeft.c+ARight.c);
+  ARight.p1 := ALeft.p2;
+end;
+function TQuadraticBezierCurve.ComputeLength: single;
+var a,b: TPointF;
+  A_,AB_,B_,Sabc,A_2,A_32,B_2,BA,
+  divisor: single;
+  extremumPos: single;
+  extremum: TPointF;
+begin
+  a := p1 - 2*c + p2;
+  b := 2*(c - p1);
+  A_ := 4*(a*a);
+  B_ := b*b;
+  if (A_ = 0) or (B_ = 0) then
+  begin
+    result := VectLen(p2-p1);
+    exit;
+  end;
+  AB_ := 4*(a*b);
+  A_2 := sqrt(A_);
+  B_2 := 2*sqrt(B_);
+  BA := AB_/A_2;
+  divisor := BA+B_2;
+  if divisor <= 0 then
+  begin
+    extremumPos:= ComputeExtremumPositionOutsideSegment;
+    if (extremumPos <= 0) or (extremumPos >= 1) then
+      result := VectLen(p2-p1)
+    else
+    begin
+      extremum := ComputePointAt(extremumPos);
+      result := VectLen(extremum-p1)+VectLen(p2-extremum);
+    end;
+    exit;
+  end;
+  Sabc := 2*sqrt(A_+AB_+B_);
+  A_32 := 2*A_*A_2;
+  result := ( A_32*Sabc +
+              A_2*AB_*(Sabc-B_2) +
+              (4*B_*A_-AB_*AB_)*ln( (2*A_2+BA+Sabc)/divisor )
+            )/(4*A_32);
+end;
+function TQuadraticBezierCurve.ToPoints(AAcceptedDeviation: single;
+  AIncludeFirstPoint: boolean = true): ArrayOfTPointF;
+begin
+  result := SimpleComputePoints(AAcceptedDeviation, AIncludeFirstPoint);
+end;
+function TQuadraticBezierCurve.GetBounds: TRectF;
+const precision = 1e-5;
+  procedure Include(pt: TPointF);
+  begin
+    if pt.x < result.Left then result.Left := pt.x
+    else if pt.x > result.Right then result.Right := pt.x;
+    if pt.y < result.Top then result.Top := pt.y
+    else if pt.y > result.Bottom then result.Bottom := pt.y;
+  end;
+  procedure IncludeT(t: single);
+  begin
+    if (t > 0) and (t < 1) then
+      Include(ComputePointAt(t));
+  end;
+  procedure IncludeABC(a,b,c: single);
+  var denom: single;
+  begin
+    denom := a-2*b+c;
+    if abs(denom) < precision then exit;
+    IncludeT((a-b)/denom);
+  end;
+begin
+  result.TopLeft := p1;
+  result.BottomRight := p1;
+  Include(p2);
+  IncludeABC(p1.x,c.x,p2.x);
+  IncludeABC(p1.y,c.y,p2.y);
+end;
+{//The following function computes by splitting the curve. It is slower than the simple function
+function TQuadraticBezierCurve.ToPoints(AAcceptedDeviation: single; ARelativeDeviation: boolean): ArrayOfTPointF;
+  function ToPointsRec(const ACurve: TQuadraticBezierCurve): ArrayOfTPointF;
+  var simpleLen2: single;
+    v: TPointF;
+    left,right: TQuadraticBezierCurve;
+    subLeft,subRight: ArrayOfTPointF;
+    subLeftLen: Integer;
+    procedure ComputeExtremum;
+    var
+      t: single;
+    begin
+      t := ACurve.ComputeExtremumPositionOutsideSegment;
+      if (t <= 0) or (t >= 1) then
+        result := nil
+      else
+      begin
+        setlength(result,1);
+        result[0] := ACurve.ComputePointAt(t);
+      end;
+    end;
+  begin
+    v := ACurve.p2-ACurve.p1;
+    simpleLen2 := v*v;
+    if simpleLen2 = 0 then
+    begin
+      if (ACurve.c.x = ACurve.p1.x) and (ACurve.c.y = ACurve.p1.y) then
+      begin
+        result := nil;
+        exit;
+      end;
+      ACurve.Split(left,right);
+    end else
+    begin
+      ACurve.Split(left,right);
+      if not ARelativeDeviation then simpleLen2:= sqrt(simpleLen2);
+      if abs(PointF(v.y,-v.x) * (left.p2-ACurve.p1))
+          <= AAcceptedDeviation*simpleLen2 then
+      begin
+        result := nil;
+        if ((ACurve.c-ACurve.p1)*v < -AAcceptedDeviation*simpleLen2) or
+           ((ACurve.c-ACurve.p2)*v > AAcceptedDeviation*simpleLen2) then
+          ComputeExtremum;
+        exit;
+      end;
+    end;
+    subRight := ToPointsRec(right);
+    subLeft := ToPointsRec(left);
+    subLeftLen := length(subLeft);
+    //avoid leaving a gap in memory
+    result := subLeft;
+    subLeft := nil;
+    setlength(result, subLeftLen+1+length(subRight));
+    result[subLeftLen] := left.p2;
+    move(subRight[0], result[subLeftLen+1], length(subRight)*sizeof(TPointF));
+  end;
+var
+  subLen: integer;
+begin
+  if (c.x = p1.x) and (c.y = p1.y) and
+     (c.x = p2.x) and (c.y = p2.y) then
+  begin
+    setlength(result,1);
+    result[0] := c;
+    exit;
+  end else
+  begin
+    result := ToPointsRec(self);
+    subLen := length(result);
+    setlength(result, length(result)+2);
+    move(result[0], result[1], subLen*sizeof(TPointF));
+    result[0] := p1;
+    result[high(result)] := p2;
+  end;
+end;}
+{$DEFINE INCLUDE_IMPLEMENTATION}
+{$I bezier.inc}
 {$ENDIF}

GraphicTest/Packages/bgrabitmap/lineartexscan.inc

-              r494
+              r521
     procedure NextLight; inline;
     begin
       inc(light,lightStep);
+      light := (light+lightStep) and 65535;
       inc(lightAcc,lightDiff);
       if lightAcc >= lightMod then
       begin
         dec(lightAcc,lightMod);
         inc(light);
+        light := (light + 1) and 65535;
       end;
     end;
 …
       light := info1.lightness;
       lightLen := info2.lightness-info1.lightness;
+      lightStep := lightLen div (ix2-ix1);
+      lightMod := ix2-ix1;
+      lightDiff := lightLen - lightStep*(ix2-ix1);
+      if lightLen >= 0 then
+      begin
+        lightStep := lightLen div (ix2-ix1);
+        lightMod := ix2-ix1;
+        lightDiff := lightLen - lightStep*(ix2-ix1);
+      end else
+      begin
+        lightStep := (-lightLen+(ix2-ix1-1)) div (ix2-ix1);
+        lightMod := ix2-ix1;
+        lightDiff := lightLen + lightStep*(ix2-ix1);
+        lightStep := 65536 - lightStep;
+      end;
     end;
     lightAcc := lightDiff div 2;

GraphicTest/Packages/bgrabitmap/multishapeline.inc

-              r494
+              r521
         for k := 0 to NbShapeRows-1 do
         with shapeRow[shapeRowsList[k]],shapes[shapeRowsList[k]] do
+        if densMinx <= densMaxx then
         begin
+          if densMinx < minx then densMinx := minx;
+          if densMaxx > maxx then densMaxx := maxx;
           if texture <> nil then
           begin
 …
             with sums[xb-minx] do
             begin
+              j := pdens^; inc(pdens);
+              if j <> 0 then
+              if pdens^ <> 0 then
               begin
                 ec := GammaExpansion(ScanNextFunc());
                 {$ifdef PARAM_ANTIALIASINGFACTOR}
                   w := DivByAntialiasPrecision65536(j*ec.alpha);
+                  w := DivByAntialiasPrecision65536(pdens^ * ec.alpha);
                 {$else}
                   w := (j*ec.alpha) shr 16;
+                  w := (pdens^ * ec.alpha) shr 16;
                 {$endif}
                 if w <> 0 then
 …
               end else
                 ScanNextFunc();
+              inc(pdens);
             end;
           end else
 …
              with sums[xb-minx] do
              begin
+               j := pdens^; inc(pdens);
+               if j <> 0 then
+               if pdens^ <> 0 then
                begin
                  {$ifdef PARAM_ANTIALIASINGFACTOR}
                    w := DivByAntialiasPrecision65536(j*ec.alpha);
+                   w := DivByAntialiasPrecision65536(pdens^ * ec.alpha);
                  {$else}
                    w := (j*ec.alpha) shr 16;
+                   w := (pdens^ * ec.alpha) shr 16;
                  {$endif}
                  if w <> 0 then
 …
                  end;
                end;
+               inc(pdens);
              end;
           end;

GraphicTest/Packages/bgrabitmap/paletteformats.inc

-              r494
+              r521
     AStream.WriteBuffer(AValue,sizeof(AValue));
   end;
   procedure WriteBlock(ABlockType: Int16; AContentLength: Int32);
+  procedure WriteBlock(ABlockType: Int16; AContentLength: Int32); overload;
   begin
     WriteInt16(ABlockType);
 …
   end;
   procedure WriteBlock(ABlockType: Int16; AName: string; AExtraContentLength: Int32);
+  procedure WriteBlock(ABlockType: Int16; AName: string; AExtraContentLength: Int32); overload;
   var contentLength: Int32;
     wideName: UnicodeString;

GraphicTest/Packages/bgrabitmap/part3d.inc

-              r494
+              r521
     destructor Destroy; override;
     procedure Clear(ARecursive: boolean);
     function Add(x,y,z: single): IBGRAVertex3D;
     function Add(pt: TPoint3D): IBGRAVertex3D;
     function Add(pt: TPoint3D; normal: TPoint3D): IBGRAVertex3D;
     function Add(pt: TPoint3D_128): IBGRAVertex3D;
     function Add(pt: TPoint3D_128; normal: TPoint3D_128): IBGRAVertex3D;
     function Add(const coords: array of single): arrayOfIBGRAVertex3D;
     function Add(const pts: array of TPoint3D): arrayOfIBGRAVertex3D;
     function Add(const pts: array of TPoint3D_128): arrayOfIBGRAVertex3D;
     procedure Add(const pts: array of IBGRAVertex3D);
     procedure Add(AVertex: IBGRAVertex3D);
     function AddNormal(x,y,z: single): IBGRANormal3D;
     function AddNormal(pt: TPoint3D): IBGRANormal3D;
     function AddNormal(pt: TPoint3D_128): IBGRANormal3D;
     procedure AddNormal(ANormal: IBGRANormal3D);
+    function Add(x,y,z: single): IBGRAVertex3D; overload;
+    function Add(pt: TPoint3D): IBGRAVertex3D; overload;
+    function Add(pt: TPoint3D; normal: TPoint3D): IBGRAVertex3D; overload;
+    function Add(pt: TPoint3D_128): IBGRAVertex3D; overload;
+    function Add(pt: TPoint3D_128; normal: TPoint3D_128): IBGRAVertex3D; overload;
+    function Add(const coords: array of single): arrayOfIBGRAVertex3D; overload;
+    function Add(const pts: array of TPoint3D): arrayOfIBGRAVertex3D; overload;
+    function Add(const pts: array of TPoint3D_128): arrayOfIBGRAVertex3D; overload;
+    procedure Add(const pts: array of IBGRAVertex3D); overload;
+    procedure Add(AVertex: IBGRAVertex3D); overload;
+    function AddNormal(x,y,z: single): IBGRANormal3D; overload;
+    function AddNormal(pt: TPoint3D): IBGRANormal3D; overload;
+    function AddNormal(pt: TPoint3D_128): IBGRANormal3D; overload;
+    procedure AddNormal(ANormal: IBGRANormal3D); overload;
     procedure RemoveVertex(Index: integer);
     procedure RemoveNormal(Index: integer);
 …
     procedure SetNormal(AIndex: Integer; AValue: IBGRANormal3D);
     procedure ResetTransform;
     procedure Translate(x,y,z: single; Before: boolean = true);
     procedure Translate(ofs: TPoint3D; Before: boolean = true);
     procedure Scale(size: single; Before: boolean = true);
     procedure Scale(x,y,z: single; Before: boolean = true);
     procedure Scale(size: TPoint3D; Before: boolean = true);
+    procedure Translate(x,y,z: single; Before: boolean = true); overload;
+    procedure Translate(ofs: TPoint3D; Before: boolean = true); overload;
+    procedure Scale(size: single; Before: boolean = true); overload;
+    procedure Scale(x,y,z: single; Before: boolean = true); overload;
+    procedure Scale(size: TPoint3D; Before: boolean = true); overload;
     procedure RotateXDeg(angle: single; Before: boolean = true);
     procedure RotateYDeg(angle: single; Before: boolean = true);

GraphicTest/Packages/bgrabitmap/perspectivescan.inc

-              r494
+              r521
     procedure NextLight; inline;
     begin
       inc(light,lightStep);
+      light := (light+lightStep) and 65535;
       inc(lightAcc,lightDiff);
       if lightAcc >= lightMod then
       begin
         dec(lightAcc,lightMod);
         inc(light);
+        light := (light + 1) and 65535;
       end;
     end;
 …
       light := info1.lightness;
       lightLen := info2.lightness-info1.lightness;
+      lightStep := lightLen div (ix2-ix1);
+      lightMod := ix2-ix1;
+      lightDiff := lightLen - lightStep*(ix2-ix1);
+      if lightLen >= 0 then
+      begin
+        lightStep := lightLen div (ix2-ix1);
+        lightMod := ix2-ix1;
+        lightDiff := lightLen - lightStep*(ix2-ix1);
+      end else
+      begin
+        lightStep := (-lightLen+(ix2-ix1-1)) div (ix2-ix1);
+        lightMod := ix2-ix1;
+        lightDiff := lightLen + lightStep*(ix2-ix1);
+        lightStep := 65536 - lightStep;
+      end;
     end;
     lightAcc := lightDiff div 2;

GraphicTest/Packages/bgrabitmap/vertex3d.inc

-              r494
+              r521
     FFaceColorsInvalidated,
     FMaterialInvalidated: boolean;
     procedure AddFace(AFace: IBGRAFace3D);
+    procedure AddFace(AFace: IBGRAFace3D); overload;
   public
     constructor Create(AScene: TBGRAScene3D);
 …
     procedure InvalidateColor;
     procedure InvalidateMaterial;
     function AddFace(const AVertices: array of IBGRAVertex3D): IBGRAFace3D;
     function AddFace(const AVertices: array of IBGRAVertex3D; ABiface: boolean): IBGRAFace3D;
     function AddFace(const AVertices: array of IBGRAVertex3D; ATexture: IBGRAScanner): IBGRAFace3D;
     function AddFace(const AVertices: array of IBGRAVertex3D; AColor: TBGRAPixel): IBGRAFace3D;
     function AddFace(const AVertices: array of IBGRAVertex3D; AColors: array of TBGRAPixel): IBGRAFace3D;
+    function AddFace(const AVertices: array of IBGRAVertex3D): IBGRAFace3D; overload;
+    function AddFace(const AVertices: array of IBGRAVertex3D; ABiface: boolean): IBGRAFace3D; overload;
+    function AddFace(const AVertices: array of IBGRAVertex3D; ATexture: IBGRAScanner): IBGRAFace3D; overload;
+    function AddFace(const AVertices: array of IBGRAVertex3D; AColor: TBGRAPixel): IBGRAFace3D; overload;
+    function AddFace(const AVertices: array of IBGRAVertex3D; AColors: array of TBGRAPixel): IBGRAFace3D; overload;
     function AddFaceReversed(const AVertices: array of IBGRAVertex3D): IBGRAFace3D;
     procedure ComputeWithMatrix(constref AMatrix: TMatrix3D; constref AProjection: TProjection3D);

GraphicTest/UMainForm.pas

-              r472
+              r521
 uses
   Classes, SysUtils, FileUtil, SynHighlighterPas, SynMemo, Forms, Controls,
+  Classes, SysUtils, LazFileUtils, SynHighlighterPas, SynMemo, Forms, Controls,
   Graphics, Dialogs, ComCtrls, ExtCtrls, StdCtrls, DateUtils, UPlatform,
   LCLType, IntfGraphics, fpImage, Math, GraphType, Contnrs, LclIntf, Spin,
 …
     Copy(TDrawMethod(DrawMethods[ListViewMethods.Selected.Index]).ClassName, 2, High(Integer)) + '.pas';
     if FileExistsUTF8(FileName) then
+    if FileExists(FileName) then
       SynMemo1.Lines.LoadFromFile(FileName)
       else SynMemo1.Lines.Clear;

Context Navigation

Legend:

Download in other formats: