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

Timestamp:

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

Author:

chronos

Message:

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

File:

• GraphicTest/Packages/bgrabitmap/bgracanvas2d.pas (modified) (65 diffs)

GraphicTest/Packages/bgrabitmap/bgracanvas2d.pas

@@ -3 +3 @@
 { To do :
 
+  draw text with a different precision if the matrix is scaled
+  drawImage(in image, in double sx, in double sy, in double sw, in double sh, in double dx, in double dy, in double dw, in double dh)
+  -> using FillPoly with texture coordinates
   linear gradient any transformation
   clearPath clipping
   createRadialGradient
-  text functions
   globalCompositeOperation
-  drawImage(in image, in double sx, in double sy, in double sw, in double sh, in double dx, in double dy, in double dw, in double dh)
   image data functions
 }
@@ -17 +18 @@
 
 uses
-  Classes, SysUtils, Graphics, BGRABitmapTypes, BGRATransform, BGRAGradientScanner;
+  Classes, SysUtils, Graphics, BGRABitmapTypes, BGRATransform, BGRAGradientScanner, BGRAPath;
 
 type
@@ -47 +48 @@
     globalAlpha: byte;
 
+    fontName: string;
+    fontStyle: TFontStyles;
+    fontEmHeight: single;
+    textAlign: TAlignment;
+    textBaseline: string;
+
     lineWidth: single;
     lineCap: TPenEndCap;
@@ -55 +62 @@
     shadowOffsetX,shadowOffsetY,shadowBlur: single;
     shadowColor: TBGRAPixel;
+    shadowFastest: boolean;
 
     matrix: TAffineMatrix;
@@ -63 +71 @@
   end;
 
+  TCanvas2dTextSize = record
+    width,height: single;
+  end;
+
   { TBGRACanvas2D }
 
-  TBGRACanvas2D = class
+  TBGRACanvas2D = class(IBGRAPath)
   private
     FSurface: TBGRACustomBitmap;
@@ -74 +86 @@
     FPathPoints: array of TPointF;
     FPathPointCount: integer;
+    FFontRenderer: TBGRACustomFontRenderer;
+    FLastCoord, FStartCoord: TPointF;
+    function GetCurrentPath: ArrayOfTPointF;
+    function GetFontName: string;
+    function GetFontRenderer: TBGRACustomFontRenderer;
+    function GetFontEmHeight: single;
+    function GetFontString: string;
+    function GetFontStyle: TFontStyles;
     function GetGlobalAlpha: single;
     function GetHasShadow: boolean;
     function GetHeight: Integer;
     function GetLineCap: string;
+    function GetLineCapLCL: TPenEndCap;
     function GetlineJoin: string;
+    function GetlineJoinLCL: TPenJoinStyle;
     function GetLineWidth: single;
+    function GetMatrix: TAffineMatrix;
     function GetMiterLimit: single;
     function GetPixelCenteredCoordinates: boolean;
     function GetShadowBlur: single;
+    function GetShadowFastest: boolean;
     function GetShadowOffset: TPointF;
     function GetShadowOffsetX: single;
     function GetShadowOffsetY: single;
+    function GetTextAlign: string;
+    function GetTextAlignLCL: TAlignment;
+    function GetTextBaseline: string;
     function GetWidth: Integer;
+    procedure SetFontName(AValue: string);
+    procedure SetFontRenderer(AValue: TBGRACustomFontRenderer);
+    procedure SetFontEmHeight(AValue: single);
+    procedure SetFontString(AValue: string);
+    procedure SetFontStyle(AValue: TFontStyles);
     procedure SetGlobalAlpha(const AValue: single);
     procedure SetLineCap(const AValue: string);
+    procedure SetLineCapLCL(AValue: TPenEndCap);
     procedure SetLineJoin(const AValue: string);
     procedure FillPoly(const points: array of TPointF);
     procedure FillStrokePoly(const points: array of TPointF; fillOver: boolean);
+    procedure SetLineJoinLCL(AValue: TPenJoinStyle);
     procedure SetLineWidth(const AValue: single);
+    procedure SetMatrix(AValue: TAffineMatrix);
     procedure SetMiterLimit(const AValue: single);
     procedure SetPixelCenteredCoordinates(const AValue: boolean);
     procedure SetShadowBlur(const AValue: single);
+    procedure SetShadowFastest(AValue: boolean);
     procedure SetShadowOffset(const AValue: TPointF);
     procedure SetShadowOffsetX(const AValue: single);
     procedure SetShadowOffsetY(const AValue: single);
+    procedure SetTextAlign(AValue: string);
+    procedure SetTextAlignLCL(AValue: TAlignment);
+    procedure SetTextBaseine(AValue: string);
     procedure StrokePoly(const points: array of TPointF);
     procedure DrawShadow(const points, points2: array of TPointF);
@@ -105 +144 @@
     function ApplyTransform(const points: array of TPointF): ArrayOfTPointF; overload;
     function ApplyTransform(point: TPointF): TPointF; overload;
-    function GetPenPos: TPointF;
+    function GetPenPos(defaultX, defaultY: single): TPointF;
+    function GetPenPos(defaultPt: TPointF): TPointF;
     procedure AddPoint(point: TPointF);
     procedure AddPoints(const points: array of TPointF);
     procedure AddPointsRev(const points: array of TPointF);
     function ApplyGlobalAlpha(color: TBGRAPixel): TBGRAPixel;
+    function GetDrawMode: TDrawMode;
+    procedure copyTo({%H-}dest: IBGRAPath); //IBGRAPath
   public
+    antialiasing, linearBlend: boolean;
     constructor Create(ASurface: TBGRACustomBitmap);
     destructor Destroy; override;
@@ -118 +161 @@
     procedure save;
     procedure restore;
-    procedure scale(x,y: single);
-    procedure rotate(angleRad: single);
+    procedure scale(x,y: single); overload;
+    procedure scale(factor: single); overload;
+    procedure rotate(angleRadCW: single);
     procedure translate(x,y: single);
-    procedure transform(a,b,c,d,e,f: single);
+    procedure transform(a,b,c,d,e,f: single); overload;
+    procedure transform(AMatrix: TAffineMatrix); overload;
     procedure setTransform(a,b,c,d,e,f: single);
     procedure resetTransform;
@@ -137 +182 @@
     procedure shadowColor(color: TColor); overload;
     procedure shadowColor(color: string); overload;
+    procedure shadowNone;
     function getShadowColor: TBGRAPixel;
     function createLinearGradient(x0,y0,x1,y1: single): IBGRACanvasGradient2D; overload;
@@ -149 +195 @@
     procedure clearRect(x,y,w,h: single);
 
+    procedure addPath(APath: IBGRAPath); overload;
+    procedure addPath(ASvgPath: string); overload;
+    procedure path(APath: IBGRAPath); overload;
+    procedure path(ASvgPath: string); overload;
     procedure beginPath;
     procedure closePath;
@@ -154 +204 @@
     procedure moveTo(x,y: single); overload;
     procedure lineTo(x,y: single); overload;
-    procedure moveTo(pt: TPointF); overload;
-    procedure lineTo(pt: TPointF); overload;
+    procedure moveTo(const pt: TPointF); overload;
+    procedure lineTo(const pt: TPointF); overload;
     procedure polylineTo(const pts: array of TPointF);
     procedure quadraticCurveTo(cpx,cpy,x,y: single); overload;
-    procedure quadraticCurveTo(cp,pt: TPointF); overload;
+    procedure quadraticCurveTo(const cp,pt: TPointF); overload;
     procedure bezierCurveTo(cp1x,cp1y,cp2x,cp2y,x,y: single); overload;
-    procedure bezierCurveTo(cp1,cp2,pt: TPointF); overload;
+    procedure bezierCurveTo(const cp1,cp2,pt: TPointF); overload;
     procedure rect(x,y,w,h: single);
-    procedure roundRect(x,y,w,h,radius: single);
+    procedure roundRect(x,y,w,h,radius: single); overload;
+    procedure roundRect(x,y,w,h,rx,ry: single); overload;
     procedure spline(const pts: array of TPointF; style: TSplineStyle= ssOutside);
     procedure splineTo(const pts: array of TPointF; style: TSplineStyle= ssOutside);
-    procedure arc(x, y, radius, startAngle, endAngle: single; anticlockwise: boolean); overload;
-    procedure arc(x, y, radius, startAngle, endAngle: single); overload;
+    procedure arc(x, y, radius, startAngleRadCW, endAngleRadCW: single; anticlockwise: boolean); overload;
+    procedure arc(x, y, radius, startAngleRadCW, endAngleRadCW: 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 arcTo(x1, y1, x2, y2, radius: single); overload;
     procedure arcTo(p1,p2: TPointF; radius: single); overload;
+    procedure arcTo(rx, ry, xAngleRadCW: single; largeArc,anticlockwise: boolean; x, y: single);
+    procedure circle(x,y,r: single);
+    procedure ellipse(x,y,rx,ry: single);
+    procedure text(AText: string; x,y: single);
+    procedure fillText(AText: string; x,y: single);
+    procedure strokeText(AText: string; x,y: single);
+    function measureText(AText: string): TCanvas2dTextSize;
+
     procedure fill;
     procedure stroke;
@@ -183 +245 @@
 
     function getLineStyle: TBGRAPenStyle;
-    procedure lineStyle(const AValue: array of single);
+    procedure lineStyle(const AValue: array of single); overload;
+    procedure lineStyle(AStyle: TPenStyle); overload;
 
     property surface: TBGRACustomBitmap read FSurface;
@@ -190 +253 @@
     property pixelCenteredCoordinates: boolean read GetPixelCenteredCoordinates write SetPixelCenteredCoordinates;
     property globalAlpha: single read GetGlobalAlpha write SetGlobalAlpha;
+    property matrix: TAffineMatrix read GetMatrix write SetMatrix;
 
     property lineWidth: single read GetLineWidth write SetLineWidth;
     property lineCap: string read GetLineCap write SetLineCap;
+    property lineCapLCL: TPenEndCap read GetLineCapLCL write SetLineCapLCL;
     property lineJoin: string read GetlineJoin write SetLineJoin;
+    property lineJoinLCL: TPenJoinStyle read GetlineJoinLCL write SetLineJoinLCL;
     property miterLimit: single read GetMiterLimit write SetMiterLimit;
 
@@ -200 +266 @@
     property shadowOffset: TPointF read GetShadowOffset write SetShadowOffset;
     property shadowBlur: single read GetShadowBlur write SetShadowBlur;
+    property shadowFastest: boolean read GetShadowFastest write SetShadowFastest;
     property hasShadow: boolean read GetHasShadow;
+
+    property fontName: string read GetFontName write SetFontName;
+    property fontEmHeight: single read GetFontEmHeight write SetFontEmHeight;
+    property fontStyle: TFontStyles read GetFontStyle write SetFontStyle;
+    property font: string read GetFontString write SetFontString;
+    property textAlignLCL: TAlignment read GetTextAlignLCL write SetTextAlignLCL;
+    property textAlign: string read GetTextAlign write SetTextAlign;
+    property textBaseline: string read GetTextBaseline write SetTextBaseine;
+
+    property currentPath: ArrayOfTPointF read GetCurrentPath;
+    property fontRenderer: TBGRACustomFontRenderer read GetFontRenderer write SetFontRenderer;
+
+  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;
 
 implementation
 
-uses Math, BGRAPen, BGRAFillInfo, BGRAPolygon, BGRABlend, FPWriteJPEG, FPWriteBMP, base64;
+uses Types, Math, BGRAPen, BGRAFillInfo, BGRAPolygon, BGRABlend, FPWriteJPEG, FPWriteBMP, base64;
 
 type
@@ -446 +529 @@
   globalAlpha := 255;
 
+  fontName := 'Arial';
+  fontEmHeight := 10;
+  fontStyle := [];
+  textAlign:= taLeftJustify;
+  textBaseline := 'alphabetic';
+
   lineWidth := 1;
   lineCap := pecFlat;
@@ -456 +545 @@
   shadowBlur := 0;
   shadowColor := BGRAPixelTransparent;
+  shadowFastest:= false;
 
   matrix := AMatrix;
@@ -473 +563 @@
   result.globalAlpha := globalAlpha;
 
+  result.fontName:= fontName;
+  result.fontEmHeight := fontEmHeight;
+  result.fontStyle := fontStyle;
+
   result.lineWidth := lineWidth;
   result.lineCap := lineCap;
@@ -483 +577 @@
   result.shadowBlur := shadowBlur;
   result.shadowColor := shadowColor;
+  result.shadowFastest := shadowFastest;
 end;
 
@@ -495 +590 @@
 function TBGRACanvas2D.GetHeight: Integer;
 begin
-  result := Surface.Height;
+  if Assigned(surface) then
+    result := Surface.Height
+  else
+    result := 0;
 end;
 
@@ -507 +605 @@
 end;
 
+function TBGRACanvas2D.GetLineCapLCL: TPenEndCap;
+begin
+  result := currentState.lineCap;
+end;
+
 function TBGRACanvas2D.GetlineJoin: string;
 begin
@@ -516 +619 @@
 end;
 
+function TBGRACanvas2D.GetlineJoinLCL: TPenJoinStyle;
+begin
+  result := currentState.lineJoin;
+end;
+
 function TBGRACanvas2D.getLineStyle: TBGRAPenStyle;
 begin
@@ -526 +634 @@
 end;
 
+function TBGRACanvas2D.GetMatrix: TAffineMatrix;
+begin
+  result := currentState.matrix;
+end;
+
 function TBGRACanvas2D.GetMiterLimit: single;
 begin
@@ -541 +654 @@
 end;
 
+function TBGRACanvas2D.GetShadowFastest: boolean;
+begin
+  result := currentState.shadowFastest;
+end;
+
 function TBGRACanvas2D.GetShadowOffset: TPointF;
 begin
@@ -556 +674 @@
 end;
 
+function TBGRACanvas2D.GetTextAlign: string;
+begin
+  case currentState.textAlign of
+    taRightJustify: result := 'right';
+    taCenter: result := 'center';
+  else
+    result := 'left';
+  end;
+end;
+
+function TBGRACanvas2D.GetTextAlignLCL: TAlignment;
+begin
+  result := currentState.textAlign;
+end;
+
+function TBGRACanvas2D.GetTextBaseline: string;
+begin
+  result := currentState.textBaseline;
+end;
+
 function TBGRACanvas2D.GetGlobalAlpha: single;
 begin
   result := currentState.globalAlpha/255;
+end;
+
+function TBGRACanvas2D.GetCurrentPath: ArrayOfTPointF;
+var i: integer;
+begin
+  setlength(result, FPathPointCount);
+  for i := 0 to high(result) do
+    result[i] := FPathPoints[i];
+end;
+
+function TBGRACanvas2D.GetFontName: string;
+begin
+  result := currentState.fontName;
+end;
+
+function TBGRACanvas2D.GetFontRenderer: TBGRACustomFontRenderer;
+var zoom1,zoom2,zoom: single;
+begin
+  if FFontRenderer = nil then
+  begin
+    if FSurface <> nil then
+      result := FSurface.FontRenderer
+    else
+      result := nil;
+  end else
+    result := FFontRenderer;
+  if Assigned(result) then
+  begin
+    result.FontName := currentState.fontName;
+    result.FontStyle := currentState.fontStyle;
+    if antialiasing then
+      result.FontQuality:= fqFineAntialiasing
+    else
+      result.FontQuality := fqSystem;
+    result.FontOrientation := 0;
+    zoom1 := VectLen(currentState.matrix[1,1],currentState.matrix[2,1]);
+    zoom2 := VectLen(currentState.matrix[1,2],currentState.matrix[2,2]);
+    if zoom1>zoom2 then zoom := zoom1 else zoom := zoom2;
+    result.FontEmHeight := round(currentState.fontEmHeight*zoom);
+  end;
+end;
+
+function TBGRACanvas2D.GetFontEmHeight: single;
+begin
+  result := currentState.fontEmHeight;
+end;
+
+function TBGRACanvas2D.GetFontString: string;
+var formats: TFormatSettings;
+begin
+  formats := DefaultFormatSettings;
+  formats.DecimalSeparator := '.';
+
+  result := '';
+  if fsItalic in currentState.fontStyle then
+    result := result+'italic ';
+  if fsBold in currentState.fontStyle then
+    result += 'bold ';
+  result += FloatToStrF(currentState.fontEmHeight,ffGeneral,6,0,formats)+'px ';
+  result += currentState.fontName;
+  result := trim(result);
+end;
+
+function TBGRACanvas2D.GetFontStyle: TFontStyles;
+begin
+  result := currentState.fontStyle;
 end;
 
@@ -570 +774 @@
 function TBGRACanvas2D.GetWidth: Integer;
 begin
-  result := Surface.Width;
+  if Assigned(Surface) then
+    result := Surface.Width
+  else
+    result := 0;
+end;
+
+procedure TBGRACanvas2D.SetFontName(AValue: string);
+begin
+  currentState.fontName := AValue;
+end;
+
+procedure TBGRACanvas2D.SetFontRenderer(AValue: TBGRACustomFontRenderer);
+begin
+  if AValue = FFontRenderer then exit;
+  FreeAndNil(FFontRenderer);
+  FFontRenderer := AValue;
+end;
+
+procedure TBGRACanvas2D.SetFontEmHeight(AValue: single);
+begin
+  currentState.fontEmHeight := AValue;
+end;
+
+procedure TBGRACanvas2D.SetFontString(AValue: string);
+var idxSpace,errPos: integer;
+  attrib,u: string;
+  value: single;
+begin
+  currentState.fontStyle := [];
+  currentState.fontEmHeight := 10;
+  currentState.fontName := 'Arial';
+  AValue := trim(AValue);
+  while AValue <> '' do
+  begin
+    while (AValue <> '') and (AValue[1]in [#0..#32]) do delete(AValue,1,1);
+    idxSpace := pos(' ',AValue);
+    if idxSpace = 0 then
+      attrib := AValue
+    else
+      attrib := copy(AValue,1,idxSpace-1);
+    attrib := lowerCase(attrib);
+    if attrib = '' then break;
+    if (attrib = 'normal') or (attrib = 'small-caps') or (attrib = 'lighter') then
+    begin
+      //nothing
+    end else
+    if (attrib = 'italic') or (attrib = 'oblique') then
+    begin
+      currentState.fontStyle += [fsItalic];
+    end else
+    if (attrib = 'bold') or (attrib = 'bolder') then
+    begin
+      currentState.fontStyle += [fsBold];
+    end else
+    if (attrib[1] in ['.','0'..'9']) then
+    begin
+      u := '';
+      while (length(attrib)>0) and (attrib[length(attrib)] in['a'..'z']) do
+      begin
+        u := attrib[length(attrib)]+u;
+        delete(attrib,length(attrib),1);
+      end;
+      val(attrib,value,errPos);
+      if errPos = 0 then
+      begin
+        if u = '' then //weight
+        begin
+          if value >= 600 then currentState.fontStyle += [fsBold];
+        end else
+        if u = 'px' then currentState.fontEmHeight := value else
+        if u = 'pt' then currentState.fontEmHeight:= value/72*96 else
+        if u = 'in' then currentState.fontEmHeight:= value*96 else
+        if u = 'mm' then currentState.fontEmHeight:= value/25.4*96 else
+        if u = 'cm' then currentState.fontEmHeight:= value/2.54*96;
+      end;
+    end else
+      break;
+    delete(AValue,1,length(attrib)+1);
+  end;
+  AValue := trim(AValue);
+  if AValue <> '' then currentState.fontName := AValue;
+end;
+
+procedure TBGRACanvas2D.SetFontStyle(AValue: TFontStyles);
+begin
+  currentState.fontStyle:= AValue;
 end;
 
@@ -590 +879 @@
 end;
 
+procedure TBGRACanvas2D.SetLineCapLCL(AValue: TPenEndCap);
+begin
+  currentState.lineCap := AValue;
+end;
+
 procedure TBGRACanvas2D.SetLineJoin(const AValue: string);
 begin
@@ -604 +898 @@
   tempScan: TBGRACustomScanner;
 begin
-  if length(points) = 0 then exit;
+  if (length(points) = 0) or (surface = nil) then exit;
   If hasShadow then DrawShadow(points,[]);
   if currentState.clipMask <> nil then
@@ -612 +906 @@
     else
       tempScan := TBGRASolidColorMaskScanner.Create(currentState.clipMask,Point(0,0),ApplyGlobalAlpha(currentState.fillColor));
-    BGRAPolygon.FillPolyAntialiasWithTexture(surface, points, tempScan, true);
+    if self.antialiasing then
+      BGRAPolygon.FillPolyAntialiasWithTexture(surface, points, tempScan, true, linearBlend)
+    else
+      BGRAPolygon.FillPolyAliasedWithTexture(surface, points, tempScan, true, GetDrawMode);
     tempScan.free;
   end else
@@ -621 +918 @@
       begin
         tempScan := TBGRAOpacityScanner.Create(currentState.fillTextureProvider.texture, currentState.globalAlpha);
-        BGRAPolygon.FillPolyAntialiasWithTexture(surface, points, tempScan, true);
+        if self.antialiasing then
+          BGRAPolygon.FillPolyAntialiasWithTexture(surface, points, tempScan, true, linearBlend)
+        else
+          BGRAPolygon.FillPolyAliasedWithTexture(surface, points, tempScan, true, GetDrawMode);
         tempScan.Free;
       end else
-        BGRAPolygon.FillPolyAntialiasWithTexture(surface, points, currentState.fillTextureProvider.texture, true)
+      begin
+        if self.antialiasing then
+          BGRAPolygon.FillPolyAntialiasWithTexture(surface, points, currentState.fillTextureProvider.texture, true, linearBlend)
+        else
+          BGRAPolygon.FillPolyAliasedWithTexture(surface, points, currentState.fillTextureProvider.texture, true, GetDrawMode);
+      end
     end
     else
-      BGRAPolygon.FillPolyAntialias(surface, points, ApplyGlobalAlpha(currentState.fillColor), false, true);
+    begin
+      if self.antialiasing then
+        BGRAPolygon.FillPolyAntialias(surface, points, ApplyGlobalAlpha(currentState.fillColor), false, true, linearBlend)
+      else
+        BGRAPolygon.FillPolyAliased(surface, points, ApplyGlobalAlpha(currentState.fillColor), false, true, GetDrawMode)
+    end
   end;
 end;
@@ -639 +949 @@
   texture: IBGRAScanner;
 begin
-  if length(points) = 0 then exit;
+  if (length(points) = 0) or (surface = nil) then exit;
   tempScan := nil;
   tempScan2 := nil;
@@ -693 +1003 @@
 
   if fillOver then multi.PolygonOrder := poFirstOnTop else multi.PolygonOrder:= poLastOnTop;
+  multi.Antialiasing := self.antialiasing;
   multi.Draw(surface);
   tempScan.free;
@@ -699 +1010 @@
 end;
 
+procedure TBGRACanvas2D.SetLineJoinLCL(AValue: TPenJoinStyle);
+begin
+  currentState.lineJoin := AValue;
+end;
+
 procedure TBGRACanvas2D.lineStyle(const AValue: array of single);
 begin
@@ -704 +1020 @@
 end;
 
+procedure TBGRACanvas2D.lineStyle(AStyle: TPenStyle);
+begin
+  case AStyle of
+    psSolid: lineStyle(SolidPenStyle);
+    psDash: lineStyle(DashPenStyle);
+    psDot: lineStyle(DotPenStyle);
+    psDashDot: lineStyle(DashDotPenStyle);
+    psDashDotDot: lineStyle(DashDotDotPenStyle);
+    psClear: lineStyle(ClearPenStyle);
+  end;
+end;
+
+function TBGRACanvas2D.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 TBGRACanvas2D._AddRef: Integer; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
+begin
+  result := 0;
+end;
+
+function TBGRACanvas2D._Release: Integer; {$IF (not defined(WINDOWS)) AND (FPC_FULLVERSION>=20501)}cdecl{$ELSE}stdcall{$IFEND};
+begin
+  result := 0;
+end;
+
 procedure TBGRACanvas2D.SetLineWidth(const AValue: single);
 begin
   currentState.lineWidth := AValue;
+end;
+
+procedure TBGRACanvas2D.SetMatrix(AValue: TAffineMatrix);
+begin
+  currentState.matrix := AValue;
 end;
 
@@ -728 +1080 @@
 end;
 
+procedure TBGRACanvas2D.SetShadowFastest(AValue: boolean);
+begin
+  currentState.shadowFastest := AValue;
+end;
+
 procedure TBGRACanvas2D.SetShadowOffset(const AValue: TPointF);
 begin
@@ -742 +1099 @@
 begin
   currentState.shadowOffsetY := AValue;
+end;
+
+procedure TBGRACanvas2D.SetTextAlign(AValue: string);
+begin
+  AValue := trim(LowerCase(AValue));
+  if (AValue = 'left') or (AValue = 'start') then
+    textAlignLCL := taLeftJustify else
+  if (AValue = 'right') or (AValue = 'end') then
+    textAlignLCL := taRightJustify else
+  if AValue = 'center' then
+    textAlignLCL := taCenter;
+end;
+
+procedure TBGRACanvas2D.SetTextAlignLCL(AValue: TAlignment);
+begin
+  currentState.textAlign := AValue;
+end;
+
+procedure TBGRACanvas2D.SetTextBaseine(AValue: string);
+begin
+  currentState.textBaseline := trim(lowercase(AValue));
 end;
 
@@ -750 +1128 @@
   contour: array of TPointF;
 begin
-  if (length(points)= 0) or (currentState.lineWidth = 0) then exit;
+  if (length(points)= 0) or (currentState.lineWidth = 0) or (surface = nil) then exit;
   contour := ComputeWidePolylinePoints(points,currentState.lineWidth,BGRAPixelTransparent,
       currentState.lineCap,currentState.lineJoin,currentState.lineStyle,[plAutoCycle],miterLimit);
@@ -761 +1139 @@
     else
       tempScan := TBGRASolidColorMaskScanner.Create(currentState.clipMask,Point(0,0),ApplyGlobalAlpha(currentState.strokeColor));
-    BGRAPolygon.FillPolyAntialiasWithTexture(Surface,contour,tempScan,True);
+    if self.antialiasing then
+      BGRAPolygon.FillPolyAntialiasWithTexture(Surface,contour,tempScan,True, linearBlend)
+    else
+      BGRAPolygon.FillPolyAliasedWithTexture(Surface,contour,tempScan,True,GetDrawMode);
     tempScan.free;
   end else
@@ -769 +1150 @@
       texture := nil;
     if texture = nil then
-      BGRAPolygon.FillPolyAntialias(Surface,contour,ApplyGlobalAlpha(currentState.strokeColor),false,True)
+    begin
+      if self.antialiasing then
+        BGRAPolygon.FillPolyAntialias(Surface,contour,ApplyGlobalAlpha(currentState.strokeColor),false,True, linearBlend)
+      else
+        BGRAPolygon.FillPolyAliased(Surface,contour,ApplyGlobalAlpha(currentState.strokeColor),false,True,GetDrawMode)
+    end
     else
-      BGRAPolygon.FillPolyAntialiasWithTexture(Surface,contour,texture,True);
+    begin
+      if self.antialiasing then
+        BGRAPolygon.FillPolyAntialiasWithTexture(Surface,contour,texture,True, linearBlend)
+      else
+        BGRAPolygon.FillPolyAliasedWithTexture(Surface,contour,texture,True,GetDrawMode)
+    end;
   end;
 end;
 
 procedure TBGRACanvas2D.DrawShadow(const points, points2: array of TPointF);
+const invSqrt2 = 1/sqrt(2);
 var ofsPts,ofsPts2: array of TPointF;
     offset: TPointF;
     i: Integer;
     tempBmp,blurred: TBGRACustomBitmap;
-begin
-  if not hasShadow then exit;
+    maxRect: TRect;
+    foundRect: TRect;
+    firstFound: boolean;
+
+    procedure AddPt(const coord: TPointF);
+    var pixRect: TRect;
+    begin
+      if isEmptyPointF(coord) then exit;
+      pixRect := Types.Rect(round(floor(coord.x)),round(floor(coord.y)),round(ceil(coord.x+0.999))+1,round(ceil(coord.y+0.999))+1);
+      if firstFound then
+      begin
+        foundRect := pixRect;
+        firstFound := false
+      end
+      else
+      begin
+        if pixRect.left < foundRect.left then foundRect.left := pixRect.Left;
+        if pixRect.top < foundRect.top then foundRect.top := pixRect.top;
+        if pixRect.right > foundRect.right then foundRect.right := pixRect.right;
+        if pixRect.bottom > foundRect.bottom then foundRect.bottom := pixRect.bottom;
+      end;
+    end;
+
+begin
+  if not hasShadow or (surface = nil) then exit;
   offset := PointF(shadowOffsetX,shadowOffsetY);
   setlength(ofsPts, length(points));
@@ -789 +1204 @@
   for i := 0 to high(ofsPts2) do
     ofsPts2[i] := points2[i]+offset;
-  tempBmp := surface.NewBitmap(width,height,BGRAPixelTransparent);
+
+  maxRect := Types.Rect(0,0,width,height);
+  if currentState.clipMask <> nil then
+    foundRect := maxRect
+  else
+  begin
+    firstFound := true;
+    for i := 0 to high(ofsPts) do
+      AddPt(ofsPts[i]);
+    for i := 0 to high(ofsPts2) do
+      AddPt(ofsPts2[i]);
+    if firstFound then exit;
+    InflateRect(foundRect, ceil(shadowBlur),ceil(shadowBlur));
+    if not IntersectRect(foundRect, foundRect,maxRect) then exit;
+    offset := PointF(-foundRect.Left,-foundRect.Top);
+    for i := 0 to high(ofsPts) do
+      ofsPts[i] += offset;
+    for i := 0 to high(ofsPts2) do
+      ofsPts2[i] += offset;
+  end;
+
+  tempBmp := surface.NewBitmap(foundRect.Right-foundRect.Left,foundRect.Bottom-foundRect.Top,BGRAPixelTransparent);
   tempBmp.FillMode := fmWinding;
   tempBmp.FillPolyAntialias(ofsPts, getShadowColor);
@@ -795 +1231 @@
   if shadowBlur > 0 then
   begin
-    if (shadowBlur < 5) and (abs(shadowBlur-round(shadowBlur)) > 1e-6) then
-      blurred := tempBmp.FilterBlurRadial(round(shadowBlur*10),rbPrecise)
+    if shadowFastest then
+    begin
+      if shadowBlur*invSqrt2 >= 0.5 then
+      begin
+        blurred := tempBmp.FilterBlurRadial(round(shadowBlur*invSqrt2),rbBox);
+        tempBmp.Free;
+        tempBmp := blurred;
+      end;
+    end
     else
-      blurred := tempBmp.FilterBlurRadial(round(shadowBlur),rbFast);
-    tempBmp.Free;
-    tempBmp := blurred;
+    begin
+      if (shadowBlur < 5) and (abs(shadowBlur-round(shadowBlur)) > 1e-6) then
+        blurred := tempBmp.FilterBlurRadial(round(shadowBlur*10),rbPrecise)
+      else
+        blurred := tempBmp.FilterBlurRadial(round(shadowBlur),rbFast);
+      tempBmp.Free;
+      tempBmp := blurred;
+    end;
   end;
   if currentState.clipMask <> nil then
     tempBmp.ApplyMask(currentState.clipMask);
-  surface.PutImage(0,0,tempBmp,dmDrawWithTransparency,currentState.globalAlpha);
+  surface.PutImage(foundRect.Left,foundRect.Top,tempBmp,GetDrawMode,currentState.globalAlpha);
   tempBmp.Free;
 end;
@@ -810 +1258 @@
 procedure TBGRACanvas2D.ClearPoly(const points: array of TPointF);
 begin
-  BGRAPolygon.FillPolyAntialias(surface, points, BGRA(0,0,0,255), true, true)
+  if surface = nil then exit;
+  if self.antialiasing then
+    BGRAPolygon.FillPolyAntialias(surface, points, BGRA(0,0,0,255), true, true, linearBlend)
+  else
+    BGRAPolygon.FillPolyAliased(surface, points, BGRA(0,0,0,255), true, true, dmSet);
 end;
 
@@ -844 +1296 @@
 end;
 
-function TBGRACanvas2D.GetPenPos: TPointF;
-begin
-  if FPathPointCount = 0 then
-    result := PointF(0,0)
+function TBGRACanvas2D.GetPenPos(defaultX,defaultY: single): TPointF;
+begin
+  if isEmptyPointF(FLastCoord) then
+    result := PointF(defaultX,defaultY)
   else
-    result := FPathPoints[FPathPointCount-1];
+    result := FLastCoord;
+end;
+
+function TBGRACanvas2D.GetPenPos(defaultPt: TPointF): TPointF;
+begin
+  result := GetPenPos(defaultPt.x,defaultPt.y);
 end;
 
@@ -889 +1346 @@
 end;
 
+function TBGRACanvas2D.GetDrawMode: TDrawMode;
+begin
+  if linearBlend then result := dmLinearBlend else result := dmDrawWithTransparency;
+end;
+
+procedure TBGRACanvas2D.copyTo(dest: IBGRAPath);
+begin
+  //nothing
+end;
+
 constructor TBGRACanvas2D.Create(ASurface: TBGRACustomBitmap);
 begin
@@ -894 +1361 @@
   StateStack := TList.Create;
   FPathPointCount := 0;
+  FLastCoord := EmptyPointF;
+  FStartCoord := EmptyPointF;
   currentState := TBGRACanvasState2D.Create(AffineMatrixIdentity,nil);
   pixelCenteredCoordinates := false;
+  antialiasing := true;
 end;
 
@@ -906 +1376 @@
   StateStack.Free;
   currentState.Free;
+  FreeAndNil(FFontRenderer);
   inherited Destroy;
 end;
@@ -917 +1388 @@
   encode64: TBase64EncodingStream;
 begin
+  if surface = nil then exit;
   stream := TMemoryStream.Create;
   if mimeType='image/jpeg' then
@@ -967 +1439 @@
 end;
 
-procedure TBGRACanvas2D.rotate(angleRad: single);
-begin
-  currentState.matrix *= AffineMatrixRotationRad(-angleRad);
+procedure TBGRACanvas2D.scale(factor: single);
+begin
+  currentState.matrix *= AffineMatrixScale(factor,factor);
+end;
+
+procedure TBGRACanvas2D.rotate(angleRadCW: single);
+begin
+  currentState.matrix *= AffineMatrixRotationRad(-angleRadCW);
 end;
 
@@ -980 +1457 @@
 begin
   currentState.matrix *= AffineMatrix(a,c,e,b,d,f);
+end;
+
+procedure TBGRACanvas2D.transform(AMatrix: TAffineMatrix);
+begin
+  currentState.matrix *= AMatrix;
 end;
 
@@ -1063 +1545 @@
 begin
   shadowColor(StrToBGRA(color));
+end;
+
+procedure TBGRACanvas2D.shadowNone;
+begin
+  shadowColor(BGRAPixelTransparent);
 end;
 
@@ -1145 +1632 @@
 end;
 
+procedure TBGRACanvas2D.addPath(APath: IBGRAPath);
+begin
+  if (FPathPointCount <> 0) and not isEmptyPointF(FPathPoints[FPathPointCount-1]) then
+  begin
+    AddPoint(EmptyPointF);
+    FLastCoord := EmptyPointF;
+    FStartCoord := EmptyPointF;
+  end;
+  APath.copyTo(self);
+end;
+
+procedure TBGRACanvas2D.addPath(ASvgPath: string);
+var p: TBGRAPath;
+begin
+  p := TBGRAPath.Create(ASvgPath);
+  addPath(p);
+  p.Free;
+end;
+
+procedure TBGRACanvas2D.path(APath: IBGRAPath);
+begin
+  beginPath;
+  addPath(APath);
+end;
+
+procedure TBGRACanvas2D.path(ASvgPath: string);
+begin
+  beginPath;
+  addPath(ASvgPath);
+end;
+
 procedure TBGRACanvas2D.beginPath;
 begin
   FPathPointCount := 0;
+  FLastCoord := EmptyPointF;
+  FStartCoord := EmptyPointF;
 end;
 
@@ -1158 +1678 @@
     while (i > 0) and not isEmptyPointF(FPathPoints[i-1]) do dec(i);
     AddPoint(FPathPoints[i]);
+    FLastCoord := FStartCoord;
   end;
 end;
@@ -1175 +1696 @@
       pts[j] := FPathPoints[i+j];
     if closed then
-      splinePts := surface.ComputeClosedSpline(pts,style)
+      splinePts := BGRAPath.ComputeClosedSpline(pts,style)
     else
-      splinePts := surface.ComputeOpenedSpline(pts,style);
+      splinePts := BGRAPath.ComputeOpenedSpline(pts,style);
     dec(FPathPointCount,nb);
     AddPoints(splinePts);
@@ -1193 +1714 @@
 end;
 
-procedure TBGRACanvas2D.moveTo(pt: TPointF);
-begin
-  if FPathPointCount <> 0 then
+procedure TBGRACanvas2D.moveTo(const pt: TPointF);
+begin
+  if (FPathPointCount <> 0) and not isEmptyPointF(FPathPoints[FPathPointCount-1]) then
     AddPoint(EmptyPointF);
   AddPoint(ApplyTransform(pt));
-end;
-
-procedure TBGRACanvas2D.lineTo(pt: TPointF);
+  FStartCoord := pt;
+  FLastCoord := pt;
+end;
+
+procedure TBGRACanvas2D.lineTo(const pt: TPointF);
 begin
   AddPoint(ApplyTransform(pt));
+  FLastCoord := pt;
 end;
 
 procedure TBGRACanvas2D.polylineTo(const pts: array of TPointF);
 begin
-  AddPoints(ApplyTransform(pts));
+  if length(pts)> 0 then
+  begin
+    AddPoints(ApplyTransform(pts));
+    FLastCoord := pts[high(pts)];
+  end;
 end;
 
@@ -1215 +1743 @@
   pts : array of TPointF;
 begin
-  curve := BezierCurve(GetPenPos,ApplyTransform(PointF(cpx,cpy)),ApplyTransform(PointF(x,y)));
-  pts := Surface.ComputeBezierCurve(curve);
+  curve := BezierCurve(ApplyTransform(GetPenPos(cpx,cpy)),ApplyTransform(PointF(cpx,cpy)),ApplyTransform(PointF(x,y)));
+  pts := BGRAPath.ComputeBezierCurve(curve);
   AddPoints(pts);
-end;
-
-procedure TBGRACanvas2D.quadraticCurveTo(cp, pt: TPointF);
+  FLastCoord := PointF(x,y);
+end;
+
+procedure TBGRACanvas2D.quadraticCurveTo(const cp, pt: TPointF);
 begin
   quadraticCurveTo(cp.x,cp.y,pt.x,pt.y);
@@ -1230 +1759 @@
   pts : array of TPointF;
 begin
-  curve := BezierCurve(GetPenPos,ApplyTransform(PointF(cp1x,cp1y)),
+  curve := BezierCurve(ApplyTransform(GetPenPos(cp1x,cp1y)),ApplyTransform(PointF(cp1x,cp1y)),
     ApplyTransform(PointF(cp2x,cp2y)),ApplyTransform(PointF(x,y)));
-  pts := Surface.ComputeBezierCurve(curve);
+  pts := BGRAPath.ComputeBezierCurve(curve);
   AddPoints(pts);
-end;
-
-procedure TBGRACanvas2D.bezierCurveTo(cp1, cp2, pt: TPointF);
+  FLastCoord := PointF(x,y);
+end;
+
+procedure TBGRACanvas2D.bezierCurveTo(const cp1, cp2, pt: TPointF);
 begin
   bezierCurveTo(cp1.x,cp1.y,cp2.x,cp2.y,pt.x,pt.y);
@@ -1247 +1777 @@
   LineTo(x+w,y+h);
   LineTo(x,y+h);
-  LineTo(x,y);
+  closePath;
 end;
 
@@ -1265 +1795 @@
   arcTo(PointF(x,y+h),PointF(x,y), radius);
   arcTo(PointF(x,y),PointF(x+w,y), radius);
+  closePath;
+end;
+
+procedure TBGRACanvas2D.roundRect(x, y, w, h, rx, ry: single);
+begin
+  if (w <= 0) or (h <= 0) then exit;
+  if rx < 0 then rx := 0;
+  if ry < 0 then ry := 0;
+  if (rx = 0) and (ry = 0) then
+  begin
+    rect(x,y,w,h);
+    exit;
+  end;
+  if rx*2 > w then rx := w/2;
+  if ry*2 > h then ry := h/2;
+  moveTo(x+rx,y);
+  lineTo(x+w-rx,y);
+  arcTo(rx,ry,0,false,false,x+w,y+ry);
+  lineTo(x+w,y+h-ry);
+  arcTo(rx,ry,0,false,false,x+w-rx,y+h);
+  lineTo(x+rx,y+h);
+  arcTo(rx,ry,0,false,false,x,y+h-ry);
+  lineTo(x,y+ry);
+  arcTo(rx,ry,0,false,false,x+rx,y);
+  closePath;
 end;
 
@@ -1273 +1828 @@
   transf := ApplyTransform(pts);
   if (pts[0] = pts[high(pts)]) and (length(pts) > 1) then
-    transf := surface.ComputeClosedSpline(slice(transf, length(transf)-1),style)
+    transf := BGRAPath.ComputeClosedSpline(slice(transf, length(transf)-1),style)
   else
-    transf := surface.ComputeOpenedSpline(transf,style);
+    transf := BGRAPath.ComputeOpenedSpline(transf,style);
   AddPoints(transf);
+  FLastCoord := pts[high(pts)];
 end;
 
@@ -1284 +1840 @@
   i: Integer;
 begin
+  if length(pts) = 0 then exit;
   transf := ApplyTransform(pts);
   if FPathPointCount <> 0 then
@@ -1290 +1847 @@
     for i := high(transf) downto 1 do
       transf[i]:= transf[i-1];
-    transf[0] := GetPenPos;
-  end;
-  transf := surface.ComputeOpenedSpline(transf,style);
+    transf[0] := ApplyTransform(GetPenPos(pts[0].x,pts[0].y));
+  end;
+  transf := BGRAPath.ComputeOpenedSpline(transf,style);
   AddPoints(transf);
-end;
-
-procedure TBGRACanvas2D.arc(x, y, radius, startAngle, endAngle: single;
+  FLastCoord := pts[high(pts)];
+end;
+
+procedure TBGRACanvas2D.arc(x, y, radius, startAngleRadCW, endAngleRadCW: single;
   anticlockwise: boolean);
 var pts: array of TPointF;
@@ -1305 +1863 @@
   unitAffine: TAffineMatrix;
   v1orig,v2orig,v1ortho,v2ortho: TPointF;
+  startRadCCW,endRadCCW: single;
 begin
   v1orig := PointF(currentState.matrix[1,1],currentState.matrix[2,1]);
@@ -1317 +1876 @@
   unitAffine := AffineMatrix(v1ortho.x, v2ortho.x, pt.x,
                              v1ortho.y, v2ortho.y, pt.y);
-  startAngle := -startAngle;
-  endAngle := -endAngle;
+  startRadCCW := -startAngleRadCW;
+  endRadCCW := -endAngleRadCW;
   if not anticlockwise then
   begin
-    temp := startAngle;
-    startAngle := endAngle;
-    endAngle := temp;
-    pts := surface.ComputeArcRad(0,0,rx,ry,startAngle,endAngle);
+    temp := startRadCCW;
+    startRadCCW := endRadCCW;
+    endRadCCW:= temp;
+    pts := BGRAPath.ComputeArcRad(0,0,rx,ry,startRadCCW,endRadCCW);
     pts := ApplyTransform(pts,unitAffine);
     AddPointsRev(pts);
   end else
   begin
-    pts := surface.ComputeArcRad(0,0,rx,ry,startAngle,endAngle);
+    pts := BGRAPath.ComputeArcRad(0,0,rx,ry,startRadCCW,endRadCCW);
     pts := ApplyTransform(pts,unitAffine);
     AddPoints(pts);
   end;
-end;
-
-procedure TBGRACanvas2D.arc(x, y, radius, startAngle, endAngle: single);
-begin
-  arc(x,y,radius,startAngle,endAngle,false);
+  FLastCoord := ArcEndPoint(ArcDef(x,y,radius,radius,0,startAngleRadCW,endAngleRadCW,anticlockwise));
+end;
+
+procedure TBGRACanvas2D.arc(x, y, radius, startAngleRadCW, endAngleRadCW: single);
+begin
+  arc(x,y,radius,startAngleRadCW,endAngleRadCW,false);
+end;
+
+procedure TBGRACanvas2D.arc(cx, cy, rx, ry, xAngleRadCW, startAngleRadCW, endAngleRadCW: single;
+  anticlockwise: boolean);
+begin
+  arc(ArcDef(cx,cy,rx,ry,xAngleRadCW,startAngleRadCW,endAngleRadCW,anticlockwise))
+end;
+
+procedure TBGRACanvas2D.arc(cx, cy, rx, ry, xAngleRadCW, startAngleRadCW, endAngleRadCW: single);
+begin
+  arc(ArcDef(cx,cy,rx,ry,xAngleRadCW,startAngleRadCW,endAngleRadCW,false))
+end;
+
+procedure TBGRACanvas2D.arc(const arcDef: TArcDef);
+var previousMatrix: TAffineMatrix;
+begin
+  if (arcDef.radius.x = 0) and (arcDef.radius.y = 0) then
+    lineTo(arcDef.center) else
+  begin
+    previousMatrix := currentState.matrix;
+    translate(arcDef.center.x,arcDef.center.y);
+    rotate(arcDef.xAngleRadCW);
+    scale(arcDef.radius.x,arcDef.radius.y);
+    arc(0,0,1,arcDef.startAngleRadCW,arcDef.endAngleRadCW,arcDef.anticlockwise);
+    currentState.matrix := previousMatrix;
+    FLastCoord := ArcEndPoint(arcDef);
+  end;
 end;
 
 procedure TBGRACanvas2D.arcTo(x1, y1, x2, y2, radius: single);
-var p0,p1,p2,p3,p4,an,bn,cn,c: TPointF;
-    dir, a2, b2, c2, cosx, sinx, d,
-    angle0, angle1: single;
-    anticlockwise: boolean;
-begin
-  if FPathPointCount = 0 then
-    moveTo(x1,y1);
-  radius := abs(radius);
-  p0 := GetPenPos;
-  p1 := PointF(x1,y1);
-  p2 := PointF(x2,y2);
-
-  if (p0 = p1) or (p1 = p2) or (radius = 0) then
-  begin
-    lineto(x1,y1);
-    exit;
-  end;
-
-  dir := (x2-x1)*(p0.y-y1) + (y2-y1)*(x1-p0.x);
-  if dir = 0 then
-  begin
-    lineto(x1,y1);
-    exit;
-  end;
-
-  a2 := (p0.x-x1)*(p0.x-x1) + (p0.y-y1)*(p0.y-y1);
-  b2 := (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2);
-  c2 := (p0.x-x2)*(p0.x-x2) + (p0.y-y2)*(p0.y-y2);
-  cosx := (a2+b2-c2)/(2*sqrt(a2*b2));
-
-  sinx := sqrt(1 - cosx*cosx);
-  if (sinx = 0) or (cosx = 1) then
-  begin
-    lineto(x1,y1);
-    exit;
-  end;
-  d := radius / ((1 - cosx) / sinx);
-
-  an := (p1-p0)*(1/sqrt(a2));
-  bn := (p1-p2)*(1/sqrt(b2));
-  p3 := p1 - an*d;
-  p4 := p1 - bn*d;
-  anticlockwise := (dir < 0);
-
-  cn := PointF(an.y,-an.x)*radius;
-  if not anticlockwise then cn := -cn;
-  c := p3 + cn;
-  angle0 := arctan2((p3.y-c.y), (p3.x-c.x));
-  angle1 := arctan2((p4.y-c.y), (p4.x-c.x));
-
-  lineTo(p3.x,p3.y);
-  arc(c.x,c.y, radius, angle0, angle1, anticlockwise);
+var p0: TPointF;
+begin
+  p0 := GetPenPos(x1,y1);
+  arc(Html5ArcTo(p0,PointF(x1,y1),PointF(x2,y2),radius));
 end;
 
@@ -1398 +1937 @@
 begin
   arcTo(p1.x,p1.y,p2.x,p2.y,radius);
+end;
+
+procedure TBGRACanvas2D.arcTo(rx, ry, xAngleRadCW: single; largeArc,
+  anticlockwise: boolean; x, y: single);
+begin
+  arc(SvgArcTo(GetPenPos(x,y), rx,ry, xAngleRadCW, largeArc, anticlockwise, PointF(x,y)));
+  FLastCoord := PointF(x,y);
+end;
+
+procedure TBGRACanvas2D.circle(x, y, r: single);
+begin
+  arc(x,y,r,0,0);
+end;
+
+procedure TBGRACanvas2D.ellipse(x, y, rx, ry: single);
+begin
+  arc(x,y,rx,ry,0,0,0);
+end;
+
+procedure TBGRACanvas2D.text(AText: string; x, y: single);
+var renderer : TBGRACustomFontRenderer;
+  previousMatrix: TAffineMatrix;
+begin
+  renderer := fontRenderer;
+  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;
+  FLastCoord := EmptyPointF;
+  FStartCoord := EmptyPointF;
+end;
+
+procedure TBGRACanvas2D.fillText(AText: string; x, y: single);
+begin
+  beginPath;
+  text(AText,x,y);
+  fill;
+  beginPath;
+end;
+
+procedure TBGRACanvas2D.strokeText(AText: string; x, y: single);
+begin
+  beginPath;
+  text(AText,x,y);
+  stroke;
+  beginPath;
+end;
+
+function TBGRACanvas2D.measureText(AText: string): TCanvas2dTextSize;
+var renderer: TBGRACustomFontRenderer;
+begin
+  renderer := fontRenderer;
+  if renderer <> nil then
+  begin
+    with renderer.TextSize(AText) do
+    begin
+      result.width := cx;
+      result.height:= cy;
+    end;
+  end
+  else
+  begin
+    result.width := 0;
+    result.height := 0;
+  end;
 end;
 
@@ -1442 +2062 @@
     currentState.clipMask := surface.NewBitmap(width,height,BGRAWhite);
   tempBmp := surface.NewBitmap(width,height,BGRABlack);
-  tempBmp.FillPolyAntialias(slice(FPathPoints,FPathPointCount),BGRAWhite);
+  if antialiasing then
+    tempBmp.FillPolyAntialias(slice(FPathPoints,FPathPointCount),BGRAWhite)
+  else
+    tempBmp.FillPoly(slice(FPathPoints,FPathPointCount),BGRAWhite,dmSet);
   currentState.clipMask.BlendImage(0,0,tempBmp,boDarken);
   tempBmp.Free;
@@ -1451 +2074 @@
   if FPathPointCount = 0 then exit;
   if currentState.clipMask = nil then exit;
-  currentState.clipMask.FillPolyAntialias(slice(FPathPoints,FPathPointCount),BGRAWhite);
+  if antialiasing then
+    currentState.clipMask.FillPolyAntialias(slice(FPathPoints,FPathPointCount),BGRAWhite)
+  else
+    currentState.clipMask.FillPoly(slice(FPathPoints,FPathPointCount),BGRAWhite,dmSet);
   if currentState.clipMask.Equals(BGRAWhite) then
     FreeAndNil(currentState.clipMask);