Changeset 521 for GraphicTest/Packages/bgrabitmap/bgrasvg.pas

Timestamp:

Apr 17, 2019, 12:58:41 AM (5 years ago)

Author:

chronos

Message:

• Modified: Propagate project build mode options to used packages.
• Added: Check memory leaks using heaptrc.
• Modified: Update BGRABitmap package.

Location:

GraphicTest

Files:

• . (modified) (1 prop)
• Packages/bgrabitmap/bgrasvg.pas (modified) (33 diffs)

GraphicTest

@@ -8 +8 @@
 GraphicTest.lps
 GraphicTest.dbg
+heaptrclog.trc

@@ -8 +8 @@
 GraphicTest.lps
 GraphicTest.dbg
+heaptrclog.trc

GraphicTest/Packages/bgrabitmap/bgrasvg.pas

@@ -7 +7 @@
 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
@@ -21 +36 @@
   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;
@@ -47 +70 @@
     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;
 
@@ -58 +88 @@
   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;
@@ -77 +111 @@
     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);
@@ -89 +124 @@
     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;
@@ -97 +134 @@
     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);
@@ -108 +147 @@
     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;
@@ -120 +162 @@
     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
@@ -146 +339 @@
 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
@@ -194 +388 @@
   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
@@ -209 +422 @@
       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
@@ -220 +433 @@
           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
@@ -231 +444 @@
       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;
 
@@ -238 +473 @@
 begin
   vb := ViewBox;
-  vs := FViewSize;
+  vs := FProportionalViewSize;
   if (vs.width.value > 0) and (vs.height.value > 0) then
     begin
@@ -303 +538 @@
   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;
 
@@ -320 +594 @@
 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;
 
@@ -333 +607 @@
 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;
 
@@ -357 +642 @@
 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;
 
@@ -374 +675 @@
 function TBGRASVG.GetZoomable: boolean;
 begin
-  result := trim(Attribute['zoomAndPan'])<>'disable';
+  result := AttributeDef['zoomAndPan','magnify']<>'disable';
 end;
 
@@ -392 +693 @@
   FUnits.CustomDpi := AValue;
   if AValue.x <> AValue.y then
-    preserveAspectRatio := 'none';
+    preserveAspectRatio := TSVGPreserveAspectRatio.Parse('none');
 end;
 
@@ -417 +718 @@
 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;
 
@@ -460 +772 @@
     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;
@@ -487 +801 @@
 end;
 
+procedure TBGRASVG.UnitsRecompute(Sender: TObject);
+begin
+  FContent.Recompute;
+end;
+
 constructor TBGRASVG.Create;
 begin
@@ -523 +842 @@
 end;
 
+constructor TBGRASVG.CreateFromString(AUTF8String: string);
+begin
+  Init(False);
+  AsUTF8String:= AUTF8String;
+end;
+
 destructor TBGRASVG.Destroy;
 begin
+  FreeAndNil(FDataLink);
   FreeAndNil(FContent);
   FreeAndNil(FUnits);
@@ -565 +891 @@
     raise exception.Create('Root node not found');
   end;
+  FreeAndNil(FDataLink);
   FreeAndNil(FContent);
   FreeAndNil(FUnits);
@@ -571 +898 @@
   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;
 
@@ -614 +955 @@
   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);
@@ -628 +967 @@
   ACanvas2d.save;
   ACanvas2d.translate(x,y);
+  ACanvas2d.strokeMatrix := ACanvas2d.matrix;
   Content.Draw(ACanvas2d,AUnit);
   ACanvas2d.restore;
@@ -643 +983 @@
   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);
@@ -660 +1004 @@
     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);
@@ -674 +1012 @@
 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
@@ -702 +1060 @@
     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.

@@ -8 +8 @@
 GraphicTest.lps
 GraphicTest.dbg
+heaptrclog.trc