mirror of
https://github.com/doublecmd/doublecmd.git
synced 2026-06-21 09:58:13 +00:00
4723 lines
144 KiB
ObjectPascal
4723 lines
144 KiB
ObjectPascal
unit Img32.SVG.Reader;
|
|
|
|
(*******************************************************************************
|
|
* Author : Angus Johnson *
|
|
* Version : 4.3 *
|
|
* Date : 27 September 2022 *
|
|
* Website : http://www.angusj.com *
|
|
* Copyright : Angus Johnson 2019-2022 *
|
|
* *
|
|
* Purpose : Read SVG 2.0 files *
|
|
* *
|
|
* License : Use, modification & distribution is subject to *
|
|
* Boost Software License Ver 1 *
|
|
* http://www.boost.org/LICENSE_1_0.txt *
|
|
*******************************************************************************)
|
|
|
|
interface
|
|
|
|
{$I Img32.inc}
|
|
|
|
uses
|
|
SysUtils, Classes, Types, Math, StrUtils,
|
|
{$IFDEF XPLAT_GENERICS} Generics.Collections, Generics.Defaults,{$ENDIF}
|
|
Img32, Img32.SVG.Core, Img32.SVG.Path, Img32.Vector,
|
|
Img32.Draw, Img32.Text, Img32.Transform;
|
|
|
|
{$IFDEF ZEROBASEDSTR}
|
|
{$ZEROBASEDSTRINGS OFF}
|
|
{$ENDIF}
|
|
|
|
type
|
|
TSvgElement = class;
|
|
|
|
TDrawData = record
|
|
currentColor : TColor32;
|
|
fillColor : TColor32;
|
|
fillOpacity : double;
|
|
fillRule : TFillRule;
|
|
fillEl : UTF8String;
|
|
strokeColor : TColor32;
|
|
strokeOpacity : double;
|
|
strokeWidth : TValue;
|
|
strokeCap : TEndStyle;
|
|
strokeJoin : TJoinStyle;
|
|
strokeMitLim : double;
|
|
strokeEl : UTF8String;
|
|
dashArray : TArrayOfDouble;
|
|
dashOffset : double;
|
|
fontInfo : TSVGFontInfo;
|
|
markerStart : UTF8String;
|
|
markerMiddle : UTF8String;
|
|
markerEnd : UTF8String;
|
|
filterElRef : UTF8String;
|
|
maskElRef : UTF8String;
|
|
clipElRef : UTF8String;
|
|
opacity : integer;
|
|
matrix : TMatrixD;
|
|
visible : Boolean;
|
|
useEl : TSvgElement; //to check for and prevent <USE> recursion
|
|
bounds : TRectD;
|
|
end;
|
|
|
|
TSvgReader = class;
|
|
TElementClass = class of TSvgElement;
|
|
|
|
TSvgElement = class
|
|
private
|
|
fParent : TSvgElement;
|
|
fParserEl : TSvgTreeEl;
|
|
fReader : TSvgReader;
|
|
{$IFDEF XPLAT_GENERICS}
|
|
fChilds : TList<TSvgElement>;
|
|
{$ELSE}
|
|
fChilds : TList;
|
|
{$ENDIF}
|
|
fId : UTF8String;
|
|
fDrawData : TDrawData; //currently both static and dynamic vars
|
|
function FindRefElement(refname: UTF8String): TSvgElement;
|
|
function GetChildCount: integer;
|
|
function GetChild(index: integer): TSvgElement;
|
|
function FindChild(const idName: UTF8String): TSvgElement;
|
|
protected
|
|
elRectWH : TValueRecWH; //multifunction variable
|
|
function IsFirstChild: Boolean;
|
|
procedure LoadAttributes;
|
|
procedure LoadAttribute(attrib: PSvgAttrib);
|
|
function LoadContent: Boolean; virtual;
|
|
//GetRelFracLimit: ie when to assume untyped vals are relative vals
|
|
function GetRelFracLimit: double; virtual;
|
|
procedure Draw(image: TImage32; drawDat: TDrawData); virtual;
|
|
procedure DrawChildren(image: TImage32; drawDat: TDrawData); virtual;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); virtual;
|
|
destructor Destroy; override;
|
|
property Child[index: integer]: TSvgElement read GetChild; default;
|
|
property ChildCount: integer read GetChildCount;
|
|
property DrawData: TDrawData read fDrawData write fDrawData;
|
|
property Id: UTF8String read fId;
|
|
end;
|
|
|
|
TSvgRootElement = class(TSvgElement)
|
|
protected
|
|
viewboxWH : TRectWH;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TSvgReader = class
|
|
private
|
|
fSvgParser : TSvgParser;
|
|
fBkgndColor : TColor32;
|
|
fBackgndImage : TImage32;
|
|
fTempImage : TImage32;
|
|
fBlurQuality : integer;
|
|
fIdList : TStringList;
|
|
fClassStyles : TClassStylesList;
|
|
fLinGradRenderer : TLinearGradientRenderer;
|
|
fRadGradRenderer : TSvgRadialGradientRenderer;
|
|
fImgRenderer : TImageRenderer;
|
|
fRootElement : TSvgRootElement;
|
|
fFontCache : TFontCache;
|
|
fUsePropScale : Boolean;
|
|
function LoadInternal: Boolean;
|
|
function GetIsEmpty: Boolean;
|
|
procedure SetBlurQuality(quality: integer);
|
|
protected
|
|
userSpaceBounds : TRectD;
|
|
currentColor : TColor32;
|
|
procedure GetBestFontForFontCache(const svgFontInfo: TSVGFontInfo);
|
|
property RadGradRenderer: TSvgRadialGradientRenderer read fRadGradRenderer;
|
|
property LinGradRenderer: TLinearGradientRenderer read fLinGradRenderer;
|
|
property ImageRenderer : TImageRenderer read fImgRenderer;
|
|
property BackgndImage : TImage32 read fBackgndImage;
|
|
property TempImage : TImage32 read fTempImage;
|
|
public
|
|
constructor Create;
|
|
destructor Destroy; override;
|
|
procedure Clear;
|
|
function GetViewbox(containerWidth, containerHeight: integer): TRectWH;
|
|
procedure DrawImage(img: TImage32; scaleToImage: Boolean);
|
|
function LoadFromStream(stream: TStream): Boolean;
|
|
function LoadFromFile(const filename: string): Boolean;
|
|
function LoadFromString(const str: string): Boolean;
|
|
|
|
//The following two methods are deprecated and intended only for ...
|
|
//https://github.com/EtheaDev/SVGIconImageList
|
|
procedure SetOverrideFillColor(color: TColor32); //deprecated;
|
|
procedure SetOverrideStrokeColor(color: TColor32); //deprecated;
|
|
|
|
function FindElement(const idName: UTF8String): TSvgElement;
|
|
property BackgroundColor : TColor32 read fBkgndColor write fBkgndColor;
|
|
property BlurQuality : integer read fBlurQuality write SetBlurQuality;
|
|
property IsEmpty : Boolean read GetIsEmpty;
|
|
//KeepAspectRatio: this property has also been added for the convenience of
|
|
//the third-party SVGIconImageList. (IMHO it should always = true)
|
|
property KeepAspectRatio: Boolean
|
|
read fUsePropScale write fUsePropScale;
|
|
property RootElement : TSvgRootElement read fRootElement;
|
|
end;
|
|
|
|
implementation
|
|
|
|
uses
|
|
Img32.Extra;
|
|
|
|
type
|
|
TFourDoubles = array [0..3] of double;
|
|
|
|
TDefsElement = class(TSvgElement)
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
//-------------------------------------
|
|
|
|
TShapeElement = class(TSvgElement)
|
|
protected
|
|
hasPaths : Boolean;
|
|
drawPathsO : TPathsD; //open only
|
|
drawPathsC : TPathsD; //closed only
|
|
drawPathsF : TPathsD; //both open and closed (for filling)
|
|
function GetBounds: TRectD; virtual;
|
|
function HasMarkers: Boolean;
|
|
procedure GetPaths(const drawDat: TDrawData); virtual;
|
|
//GetSimplePath: required only for markers
|
|
function GetSimplePath(const drawDat: TDrawData): TPathsD; virtual;
|
|
procedure DrawFilled(img: TImage32; drawDat: TDrawData);
|
|
procedure DrawStroke(img: TImage32; drawDat: TDrawData; isClosed: Boolean);
|
|
procedure DrawMarkers(img: TImage32; drawDat: TDrawData);
|
|
procedure Draw(image: TImage32; drawDat: TDrawData); override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TGroupElement = class(TShapeElement)
|
|
protected
|
|
procedure Draw(image: TImage32; drawDat: TDrawData); override;
|
|
end;
|
|
|
|
TSwitchElement = class(TShapeElement)
|
|
protected
|
|
procedure Draw(image: TImage32; drawDat: TDrawData); override;
|
|
end;
|
|
|
|
TUseElement = class(TShapeElement)
|
|
private
|
|
callerUse: TSvgElement;
|
|
function ValidateNonRecursion(el: TSvgElement): Boolean;
|
|
protected
|
|
refEl: UTF8String;
|
|
procedure GetPaths(const drawDat: TDrawData); override;
|
|
procedure Draw(img: TImage32; drawDat: TDrawData); override;
|
|
end;
|
|
|
|
TMaskElement = class(TShapeElement)
|
|
protected
|
|
maskRec: TRect;
|
|
procedure GetPaths(const drawDat: TDrawData); override;
|
|
procedure ApplyMask(img: TImage32; const drawDat: TDrawData);
|
|
end;
|
|
|
|
TSymbolElement = class(TShapeElement)
|
|
protected
|
|
viewboxWH: TRectWH;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
//-------------------------------------
|
|
|
|
TPathElement = class(TShapeElement)
|
|
private
|
|
fSvgPaths : TSvgPath;
|
|
procedure Flatten(index: integer; scalePending: double;
|
|
out path: TPathD; out isClosed: Boolean);
|
|
protected
|
|
function GetBounds: TRectD; override;
|
|
procedure ParseDAttrib(const value: UTF8String);
|
|
procedure GetPaths(const drawDat: TDrawData); override;
|
|
function GetSimplePath(const drawDat: TDrawData): TPathsD; override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
destructor Destroy; override;
|
|
end;
|
|
|
|
TPolyElement = class(TShapeElement) //polyline or polygon
|
|
protected
|
|
path : TPathD;
|
|
function GetBounds: TRectD; override;
|
|
procedure ParsePoints(const value: UTF8String);
|
|
procedure GetPaths(const drawDat: TDrawData); override;
|
|
function GetSimplePath(const drawDat: TDrawData): TPathsD; override;
|
|
end;
|
|
|
|
TLineElement = class(TShapeElement)
|
|
protected
|
|
path : TPathD;
|
|
function GetBounds: TRectD; override;
|
|
procedure GetPaths(const drawDat: TDrawData); override;
|
|
function GetSimplePath(const drawDat: TDrawData): TPathsD; override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TCircleElement = class(TShapeElement)
|
|
protected
|
|
centerPt : TValuePt;
|
|
radius : TValue;
|
|
function GetBounds: TRectD; override;
|
|
procedure GetPaths(const drawDat: TDrawData); override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TEllipseElement = class(TShapeElement)
|
|
protected
|
|
centerPt : TValuePt;
|
|
radius : TValuePt;
|
|
function GetBounds: TRectD; override;
|
|
procedure GetPaths(const drawDat: TDrawData); override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TRectElement = class(TShapeElement)
|
|
protected
|
|
radius : TValuePt;
|
|
function GetBounds: TRectD; override;
|
|
procedure GetPaths(const drawDat: TDrawData); override;
|
|
function GetSimplePath(const drawDat: TDrawData): TPathsD; override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
//TTextElement: although this is a TShapeElement descendant, it's really
|
|
//only a container for 'tspan' and 'subtext' elements. (See Draw method.)
|
|
TTextElement = class(TShapeElement)
|
|
protected
|
|
offset : TValuePt;
|
|
startX : double;
|
|
currentPt : TPointD;
|
|
function GetTopTextElement: TTextElement;
|
|
procedure DoOffsetX(dx: double);
|
|
procedure ResetTmpPt;
|
|
procedure GetPaths(const drawDat: TDrawData); override;
|
|
function LoadContent: Boolean; override;
|
|
procedure Draw(img: TImage32; drawDat: TDrawData); override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TTSpanElement = class(TTextElement)
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TSubtextElement = class(TShapeElement)
|
|
protected
|
|
text : UTF8String;
|
|
procedure GetPaths(const drawDat: TDrawData); override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
//-------------------------------------
|
|
|
|
TTextPathElement = class(TSubtextElement)
|
|
protected
|
|
pathEl: UTF8String; //name (id) of path element
|
|
procedure GetPaths(const drawDat: TDrawData); override;
|
|
end;
|
|
|
|
TMarkerElement = class(TShapeElement)
|
|
private
|
|
fPoints : TPathD;
|
|
protected
|
|
refPt : TValuePt;
|
|
angle : double;
|
|
angle2 : double;
|
|
markerBoxWH : TRectWH;
|
|
autoStartReverse : Boolean;
|
|
procedure SetEndPoint(const pt: TPointD; angle: double);
|
|
function SetMiddlePoints(const points: TPathD): Boolean;
|
|
procedure Draw(img: TImage32; drawDat: TDrawData); override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TSvgColorStop = record
|
|
offset : double;
|
|
color : TColor32;
|
|
end;
|
|
TSvgColorStops = array of TSvgColorStop;
|
|
|
|
TFillElement = class(TSvgElement)
|
|
protected
|
|
refEl : UTF8String;
|
|
units : Cardinal;
|
|
function GetRelFracLimit: double; override;
|
|
end;
|
|
|
|
TPatternElement = class(TFillElement)
|
|
protected
|
|
pattBoxWH : TRectWH;
|
|
function PrepareRenderer(renderer: TImageRenderer;
|
|
drawDat: TDrawData): Boolean; virtual;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
//nb: gradients with objectBoundingBox should not be applied to
|
|
//elements without width and height.
|
|
TGradientElement = class(TFillElement)
|
|
protected
|
|
stops : TSvgColorStops;
|
|
spreadMethod : TGradientFillStyle;
|
|
function LoadContent: Boolean; override;
|
|
procedure AddStop(color: TColor32; offset: double);
|
|
procedure AssignTo(other: TSvgElement); virtual;
|
|
function PrepareRenderer(renderer: TCustomGradientRenderer;
|
|
drawDat: TDrawData): Boolean; virtual;
|
|
end;
|
|
|
|
TRadGradElement = class(TGradientElement)
|
|
protected
|
|
radius: TValuePt;
|
|
F, C: TValuePt;
|
|
procedure AssignTo(other: TSvgElement); override;
|
|
function PrepareRenderer(renderer: TCustomGradientRenderer;
|
|
drawDat: TDrawData): Boolean; override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TLinGradElement = class(TGradientElement)
|
|
protected
|
|
startPt, endPt: TValuePt;
|
|
procedure AssignTo(other: TSvgElement); override;
|
|
function PrepareRenderer(renderer: TCustomGradientRenderer;
|
|
drawDat: TDrawData): Boolean; override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TGradStopElement = class(TSvgElement)
|
|
protected
|
|
offset: double;
|
|
color: TColor32;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TFilterElement = class(TSvgElement)
|
|
private
|
|
fSrcImg : TImage32;
|
|
fLastImg : TImage32;
|
|
fScale : double;
|
|
fFilterBounds : TRect;
|
|
fObjectBounds : TRect;
|
|
fImages : array of TImage32;
|
|
fNames : array of UTF8String;
|
|
protected
|
|
procedure Clear;
|
|
function GetRelFracLimit: double; override;
|
|
function GetAdjustedBounds(const bounds: TRectD): TRectD;
|
|
function FindNamedImage(const name: UTF8String): TImage32;
|
|
function AddNamedImage(const name: UTF8String): TImage32;
|
|
function GetNamedImage(const name: UTF8String): TImage32;
|
|
procedure Apply(img: TImage32;
|
|
const filterBounds: TRect; const matrix: TMatrixD);
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
destructor Destroy; override;
|
|
end;
|
|
|
|
TFeBaseElement = class(TSvgElement)
|
|
private
|
|
function GetParentAsFilterEl: TFilterElement;
|
|
protected
|
|
in1: UTF8String;
|
|
in2: UTF8String;
|
|
res: UTF8String;
|
|
srcImg, dstImg: TImage32;
|
|
srcRec, dstRec: TRect;
|
|
function GetSrcAndDst: Boolean;
|
|
function GetBounds(img: TImage32): TRect;
|
|
procedure Apply; virtual; abstract;
|
|
property ParentFilterEl: TFilterElement read GetParentAsFilterEl;
|
|
end;
|
|
|
|
TFeBlendElement = class(TFeBaseElement)
|
|
protected
|
|
procedure Apply; override;
|
|
end;
|
|
|
|
TCompositeOp = (coOver, coIn, coOut, coAtop, coXOR, coArithmetic);
|
|
|
|
TFeCompositeElement = class(TFeBaseElement)
|
|
protected
|
|
fourKs: TFourDoubles; //arithmetic constants
|
|
compositeOp: TCompositeOp;
|
|
procedure Apply; override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TFeColorMatrixElement = class(TFeBaseElement)
|
|
protected
|
|
values: TArrayOfDouble;
|
|
procedure Apply; override;
|
|
end;
|
|
|
|
TFeDefuseLightElement = class(TFeBaseElement)
|
|
protected
|
|
color : TColor32;
|
|
surfaceScale : double;
|
|
diffuseConst : double;
|
|
kernelSize : integer;
|
|
procedure Apply; override;
|
|
end;
|
|
|
|
TFeDropShadowElement = class(TFeBaseElement)
|
|
protected
|
|
stdDev : double;
|
|
offset : TValuePt;
|
|
floodColor : TColor32;
|
|
procedure Apply; override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TFeFloodElement = class(TFeBaseElement)
|
|
protected
|
|
floodColor : TColor32;
|
|
procedure Apply; override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TFeGaussElement = class(TFeBaseElement)
|
|
protected
|
|
stdDev: double;
|
|
procedure Apply; override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
|
|
TFeMergeElement = class(TFeBaseElement)
|
|
protected
|
|
procedure Apply; override;
|
|
end;
|
|
|
|
TFeMergeNodeElement = class(TFeBaseElement)
|
|
protected
|
|
procedure Apply; override;
|
|
end;
|
|
|
|
TFeOffsetElement = class(TFeBaseElement)
|
|
protected
|
|
offset : TValuePt;
|
|
procedure Apply; override;
|
|
end;
|
|
|
|
TFePointLightElement = class(TFeBaseElement)
|
|
protected
|
|
z : double;
|
|
end;
|
|
|
|
TFeSpecLightElement = class(TFeBaseElement)
|
|
protected
|
|
exponent : double;
|
|
color : TColor32;
|
|
procedure Apply; override;
|
|
end;
|
|
|
|
TClipPathElement = class(TShapeElement)
|
|
protected
|
|
units: Cardinal;
|
|
procedure GetPaths(const drawDat: TDrawData); override;
|
|
public
|
|
constructor Create(parent: TSvgElement; svgEl: TSvgTreeEl); override;
|
|
end;
|
|
//-------------------------------------
|
|
|
|
|
|
const
|
|
buffSize = 32;
|
|
clAlphaSet = $00010101;
|
|
SourceImage : UTF8String = 'SourceGraphic';
|
|
//SourceAlpha : UTF8String = 'SourceAlpha';
|
|
tmpFilterImg : UTF8String = 'tmp';
|
|
|
|
//https://www.w3.org/TR/css-fonts-3/#font-family-prop
|
|
emptyDrawInfo: TDrawData =
|
|
(currentColor: clInvalid;
|
|
fillColor: clInvalid; fillOpacity: InvalidD;
|
|
fillRule: frNonZero; fillEl: '';
|
|
strokeColor: clInvalid; strokeOpacity: InvalidD;
|
|
strokeWidth: (rawVal: InvalidD; unitType: utNumber);
|
|
strokeCap: esPolygon; strokeJoin: jsAuto; strokeMitLim: 0.0; strokeEl : '';
|
|
dashArray: nil; dashOffset: 0;
|
|
fontInfo: (family: ttfUnknown; size: 0; spacing: 0.0;
|
|
textLength: 0; italic: sfsUndefined; weight: -1; align: staUndefined;
|
|
decoration: fdUndefined; baseShift: (rawVal: InvalidD; unitType: utNumber));
|
|
markerStart: ''; markerMiddle: ''; markerEnd: '';
|
|
filterElRef: ''; maskElRef: ''; clipElRef: ''; opacity: MaxInt;
|
|
matrix: ((1, 0, 0),(0, 1, 0),(0, 0, 1)); visible: true;
|
|
useEl: nil; bounds: (Left:0; Top:0; Right:0; Bottom:0));
|
|
|
|
var
|
|
//defaultFontHeight: this size will be used to retrieve all glyph contours
|
|
//(and later scaled as necessary). This relatively large default ensures
|
|
//that contours will have adequate detail.
|
|
defaultFontHeight: double = 20.0;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Miscellaneous functions ...
|
|
//------------------------------------------------------------------------------
|
|
|
|
function HashToElementClass(hash: Cardinal): TElementClass;
|
|
begin
|
|
case hash of
|
|
hClippath : Result := TClipPathElement;
|
|
hCircle : Result := TCircleElement;
|
|
hDefs : Result := TDefsElement;
|
|
hEllipse : Result := TEllipseElement;
|
|
hFilter : Result := TFilterElement;
|
|
hfeBlend : Result := TFeBlendElement;
|
|
hfeColorMatrix : Result := TFeColorMatrixElement;
|
|
hfeComposite : Result := TFeCompositeElement;
|
|
hfeDefuseLighting : Result := TFeDefuseLightElement;
|
|
hfeDropShadow : Result := TFeDropShadowElement;
|
|
hfeFlood : Result := TFeFloodElement;
|
|
hFeGaussianBlur : Result := TFeGaussElement;
|
|
hfeMerge : Result := TFeMergeElement;
|
|
hfeMergeNode : Result := TFeMergeNodeElement;
|
|
hfeOffset : Result := TFeOffsetElement;
|
|
hfePointLight : Result := TFePointLightElement;
|
|
hfeSpecularLighting : Result := TFeSpecLightElement;
|
|
hG : Result := TGroupElement;
|
|
hLine : Result := TLineElement;
|
|
hLineargradient : Result := TLinGradElement;
|
|
hMarker : Result := TMarkerElement;
|
|
hMask : Result := TMaskElement;
|
|
hPath : Result := TPathElement;
|
|
hPattern : Result := TPatternElement;
|
|
hPolyline : Result := TPolyElement;
|
|
hPolygon : Result := TPolyElement;
|
|
hRadialgradient : Result := TRadGradElement;
|
|
hRect : Result := TRectElement;
|
|
hStop : Result := TGradStopElement;
|
|
hSvg : Result := TSvgRootElement;
|
|
hSwitch : Result := TSwitchElement;
|
|
hSymbol : Result := TSymbolElement;
|
|
hText : Result := TTextElement;
|
|
hTextPath : Result := TTextPathElement;
|
|
hTSpan : Result := TTSpanElement;
|
|
hUse : Result := TUseElement;
|
|
else Result := TSvgElement; //use generic class
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure UpdateDrawInfo(var drawDat: TDrawData; thisElement: TSvgElement);
|
|
begin
|
|
with thisElement.fDrawData do
|
|
begin
|
|
if currentColor <> clInvalid then
|
|
thisElement.fReader.currentColor := currentColor;
|
|
drawDat.fillRule := fillRule;
|
|
if (fillColor = clCurrent) then
|
|
drawDat.fillColor := thisElement.fReader.currentColor
|
|
else if (fillColor <> clInvalid) then
|
|
drawDat.fillColor := fillColor;
|
|
if fillOpacity <> InvalidD then
|
|
drawDat.fillOpacity := fillOpacity;
|
|
if (fillEl <> '') then
|
|
drawDat.fillEl := fillEl;
|
|
if (strokeColor = clCurrent) then
|
|
drawDat.strokeColor := thisElement.fReader.currentColor
|
|
else if strokeColor <> clInvalid then
|
|
drawDat.strokeColor := strokeColor;
|
|
if strokeOpacity <> InvalidD then
|
|
drawDat.strokeOpacity := strokeOpacity;
|
|
if strokeWidth.IsValid then
|
|
drawDat.strokeWidth := strokeWidth;
|
|
if strokeCap = esPolygon then
|
|
drawDat.strokeCap := strokeCap;
|
|
if strokeJoin = jsAuto then
|
|
drawDat.strokeJoin := strokeJoin;
|
|
if strokeMitLim > 0 then
|
|
drawDat.strokeMitLim := strokeMitLim;
|
|
if Assigned(dashArray) then
|
|
drawDat.dashArray := Copy(dashArray, 0, Length(dashArray));
|
|
if dashOffset <> 0 then
|
|
drawDat.dashOffset := dashOffset;
|
|
if (strokeEl <> '') then
|
|
drawDat.strokeEl := strokeEl;
|
|
if opacity < MaxInt then
|
|
drawDat.opacity := opacity;
|
|
|
|
if (clipElRef <> '') then
|
|
drawDat.clipElRef := clipElRef;
|
|
if (maskElRef <> '') then
|
|
drawDat.maskElRef := maskElRef;
|
|
if (filterElRef <> '') then
|
|
drawDat.filterElRef := filterElRef;
|
|
|
|
if fontInfo.family <> ttfUnknown then
|
|
drawDat.fontInfo.family := fontInfo.family;
|
|
if fontInfo.size > 0 then
|
|
drawDat.fontInfo.size := fontInfo.size;
|
|
if fontInfo.spacing <> 0 then
|
|
drawDat.fontInfo.spacing := fontInfo.spacing;
|
|
if fontInfo.textLength > 0 then
|
|
drawDat.fontInfo.textLength := fontInfo.textLength;
|
|
|
|
if (fontInfo.italic <> sfsUndefined) then
|
|
drawDat.fontInfo.italic := fontInfo.italic;
|
|
if (fontInfo.weight <> -1) then
|
|
drawDat.fontInfo.weight := fontInfo.weight;
|
|
|
|
if fontInfo.align <> staUndefined then
|
|
drawDat.fontInfo.align := fontInfo.align;
|
|
|
|
if (thisElement is TTextElement) or
|
|
(fontInfo.decoration <> fdUndefined) then
|
|
drawDat.fontInfo.decoration := fontInfo.decoration;
|
|
if fontInfo.baseShift.IsValid then
|
|
drawDat.fontInfo.baseShift := fontInfo.baseShift;
|
|
|
|
if not IsIdentityMatrix(matrix) then
|
|
drawDat.matrix := MatrixMultiply(drawDat.matrix, matrix);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function IsFilled(const drawDat: TDrawData): Boolean;
|
|
begin
|
|
with drawDat do
|
|
Result := (fillOpacity <> 0) and
|
|
((fillColor <> clNone32) or (fillEl <> ''));
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function IsStroked(const drawDat: TDrawData): Boolean;
|
|
begin
|
|
with drawDat do
|
|
if (strokeOpacity = 0) then
|
|
Result := false
|
|
else if (strokeEl <> '') then
|
|
Result := ((strokeWidth.rawVal = InvalidD) or (strokeWidth.rawVal > 0))
|
|
else if (strokeColor = clNone32) or
|
|
((strokeColor = clInvalid) and (strokeWidth.rawVal = InvalidD)) then
|
|
Result := false
|
|
else
|
|
Result := ((strokeWidth.rawVal = InvalidD) or (strokeWidth.rawVal > 0));
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function MergeColorAndOpacity(color: TColor32; opacity: double): TColor32;
|
|
begin
|
|
if (opacity < 0) or (opacity >= 1.0) then Result := color
|
|
else if opacity = 0 then Result := clNone32
|
|
else Result := (color and $FFFFFF) + Round(opacity * 255) shl 24;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function UTF8StringToFloat(const ansiValue: UTF8String;
|
|
out value: double): Boolean;
|
|
var
|
|
c: PUTF8Char;
|
|
begin
|
|
c := PUTF8Char(ansiValue);
|
|
Result := ParseNextNum(c, c + Length(ansiValue), false, value);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function UTF8StringToFloatEx(const ansiValue: UTF8String;
|
|
var value: double; out measureUnit: TUnitType): Boolean;
|
|
var
|
|
c: PUTF8Char;
|
|
begin
|
|
c := PUTF8Char(ansiValue);
|
|
Result := ParseNextNumEx(c, c + Length(ansiValue), false, value, measureUnit);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure UTF8StringToOpacity(const ansiValue: UTF8String; var color: TColor32);
|
|
var
|
|
opacity: double;
|
|
begin
|
|
if color = clNone32 then
|
|
begin
|
|
color := clAlphaSet;
|
|
Exit;
|
|
end;
|
|
|
|
if color = clInvalid then color := clNone32;
|
|
if not UTF8StringToFloat(ansiValue, opacity) then Exit;
|
|
with TARGB(color) do
|
|
if (opacity <= 0) then
|
|
begin
|
|
if Color = clNone32 then Color := clAlphaSet
|
|
else A := 0;
|
|
end
|
|
else if (opacity >= 1) then A := 255
|
|
else A := Round(255 * opacity);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function MatrixApply(const paths: TPathsD; const matrix: TMatrixD): TPathsD; overload;
|
|
var
|
|
i,j,len,len2: integer;
|
|
pp,rr: PPointD;
|
|
begin
|
|
if not Assigned(paths) then
|
|
Result := nil
|
|
else if IsIdentityMatrix(matrix) then
|
|
Result := CopyPaths(paths)
|
|
else
|
|
begin
|
|
len := Length(paths);
|
|
SetLength(Result, len);
|
|
for i := 0 to len -1 do
|
|
begin
|
|
len2 := Length(paths[i]);
|
|
SetLength(Result[i], len2);
|
|
if len2 = 0 then Continue;
|
|
pp := @paths[i][0];
|
|
rr := @Result[i][0];
|
|
for j := 0 to High(paths[i]) do
|
|
begin
|
|
rr.X := pp.X * matrix[0, 0] + pp.Y * matrix[1, 0] + matrix[2, 0];
|
|
rr.Y := pp.X * matrix[0, 1] + pp.Y * matrix[1, 1] + matrix[2, 1];
|
|
inc(pp); inc(rr);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TDefsElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TDefsElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
fDrawData.visible := false;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TGroupElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TGroupElement.Draw(image: TImage32; drawDat: TDrawData);
|
|
var
|
|
clipEl : TSvgElement;
|
|
maskEl : TSvgElement;
|
|
tmpImg : TImage32;
|
|
clipPaths : TPathsD;
|
|
clipRec : TRect;
|
|
begin
|
|
if fChilds.Count = 0 then Exit;
|
|
|
|
UpdateDrawInfo(drawDat, self);
|
|
|
|
maskEl := FindRefElement(drawDat.maskElRef);
|
|
clipEl := FindRefElement(drawDat.clipElRef);
|
|
if Assigned(clipEl) then
|
|
begin
|
|
with TClipPathElement(clipEl) do
|
|
begin
|
|
drawDat.clipElRef := '';
|
|
GetPaths(drawDat);
|
|
clipPaths := CopyPaths(drawPathsF);
|
|
|
|
MatrixApply(drawDat.matrix, clipPaths);
|
|
clipRec := Img32.Vector.GetBounds(clipPaths);
|
|
end;
|
|
if IsEmptyRect(clipRec) then Exit;
|
|
|
|
//nb: it's not safe to use fReader.TempImage when calling DrawChildren
|
|
tmpImg := TImage32.Create(Image.Width, Image.Height);
|
|
try
|
|
DrawChildren(tmpImg, drawDat);
|
|
with TClipPathElement(clipEl) do
|
|
EraseOutsidePaths(tmpImg, clipPaths, fDrawData.fillRule, clipRec);
|
|
image.CopyBlend(tmpImg, clipRec, clipRec, BlendToAlpha);
|
|
finally
|
|
tmpImg.Free;
|
|
end;
|
|
|
|
end
|
|
else if Assigned(maskEl) then
|
|
begin
|
|
drawDat.maskElRef := '';
|
|
with TMaskElement(maskEl) do
|
|
begin
|
|
GetPaths(drawDat);
|
|
clipRec := maskRec;
|
|
end;
|
|
tmpImg := TImage32.Create(image.Width, image.Height);
|
|
try
|
|
DrawChildren(tmpImg, drawDat);
|
|
TMaskElement(maskEl).ApplyMask(tmpImg, drawDat);
|
|
image.CopyBlend(tmpImg, clipRec, clipRec, BlendToAlpha);
|
|
finally
|
|
tmpImg.Free;
|
|
end;
|
|
end else
|
|
DrawChildren(image, drawDat);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TSwitchElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TSwitchElement.Draw(image: TImage32; drawDat: TDrawData);
|
|
var
|
|
i: integer;
|
|
begin
|
|
for i := 0 to fChilds.Count -1 do
|
|
if TSvgElement(fChilds[i]) is TShapeElement then
|
|
with TShapeElement(fChilds[i]) do
|
|
if fDrawData.visible then
|
|
begin
|
|
Draw(image, drawDat);
|
|
break; //break after the first successful drawing
|
|
end;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TUseElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TUseElement.GetPaths(const drawDat: TDrawData);
|
|
var
|
|
el: TSvgElement;
|
|
dx, dy: double;
|
|
begin
|
|
if Assigned(drawPathsF) or (refEl = '') then Exit;
|
|
|
|
el := FindRefElement(refEl);
|
|
if not Assigned(el) or not (el is TShapeElement) then Exit;
|
|
with TShapeElement(el) do
|
|
begin
|
|
GetPaths(drawDat);
|
|
self.drawPathsC := CopyPaths(drawPathsC);
|
|
self.drawPathsO := CopyPaths(drawPathsO);
|
|
end;
|
|
|
|
if elRectWH.left.IsValid then
|
|
dx := elRectWH.left.rawVal else
|
|
dx := 0;
|
|
if elRectWH.top.IsValid then
|
|
dy := elRectWH.top.rawVal else
|
|
dy := 0;
|
|
|
|
if (dx <> 0) or (dy <> 0) then
|
|
begin
|
|
drawPathsC := OffsetPath(drawPathsC, dx, dy);
|
|
drawPathsO := OffsetPath(drawPathsO, dx, dy);
|
|
end;
|
|
|
|
drawPathsF := CopyPaths(drawPathsC);
|
|
AppendPath(drawPathsF, drawPathsO);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TUseElement.ValidateNonRecursion(el: TSvgElement): Boolean;
|
|
begin
|
|
Result := false;
|
|
while assigned(el) do
|
|
begin
|
|
if (el = Self) then Exit;
|
|
if not (el is TUseElement) then break; //shouldn't happen
|
|
el := TUseElement(el).callerUse;
|
|
end;
|
|
Result := true;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TUseElement.Draw(img: TImage32; drawDat: TDrawData);
|
|
var
|
|
el: TSvgElement;
|
|
s, dx, dy: double;
|
|
scale, scale2: TSizeD;
|
|
mat: TMatrixD;
|
|
begin
|
|
|
|
//make sure there's not recursion, either directly or indirectly
|
|
if not ValidateNonRecursion(drawDat.useEl) then Exit;
|
|
|
|
callerUse := drawDat.useEl;
|
|
drawDat.useEl := self;
|
|
|
|
el := FindRefElement(refEl);
|
|
if not Assigned(el) then Exit;
|
|
|
|
UpdateDrawInfo(drawDat, self); //nb: <use> attribs override el's.
|
|
scale := ExtractScaleFromMatrix(drawDat.matrix);
|
|
|
|
if elRectWH.left.IsValid then dx := elRectWH.left.rawVal else dx := 0;
|
|
if elRectWH.top.IsValid then dy := elRectWH.top.rawVal else dy := 0;
|
|
|
|
if (dx <> 0) or (dy <> 0) then
|
|
begin
|
|
mat := IdentityMatrix;
|
|
MatrixTranslate(mat, dx, dy);
|
|
drawDat.matrix := MatrixMultiply(drawDat.matrix, mat);
|
|
end;
|
|
|
|
if el is TSymbolElement then
|
|
begin
|
|
with TSymbolElement(el) do
|
|
begin
|
|
if not viewboxWH.IsEmpty then
|
|
begin
|
|
//scale the symbol according to its width and height attributes
|
|
if elRectWH.width.IsValid and elRectWH.height.IsValid then
|
|
begin
|
|
scale2.cx := elRectWH.width.rawVal / viewboxWH.Width;
|
|
scale2.cy := elRectWH.height.rawVal / viewboxWH.Height;
|
|
if scale2.cy < scale2.cx then s := scale2.cy else s := scale2.cx;
|
|
//the following 3 lines will scale without translating
|
|
mat := IdentityMatrix;
|
|
MatrixScale(mat, s, s);
|
|
drawDat.matrix := MatrixMultiply(drawDat.matrix, mat);
|
|
drawDat.bounds := RectD(0,0,viewboxWH.Width, viewboxWH.Height);
|
|
end;
|
|
|
|
if self.elRectWH.width.IsValid and
|
|
self.elRectWH.height.IsValid then
|
|
begin
|
|
with viewboxWH do
|
|
begin
|
|
dx := -Left/Width * self.elRectWH.width.rawVal;
|
|
dy := -Top/Height * self.elRectWH.height.rawVal;
|
|
|
|
//scale <symbol> proportionally to fill the <use> element
|
|
scale2.cx := self.elRectWH.width.rawVal / Width;
|
|
scale2.cy := self.elRectWH.height.rawVal / Height;
|
|
if scale2.cy < scale2.cx then s := scale2.cy else s := scale2.cx;
|
|
end;
|
|
|
|
mat := IdentityMatrix;
|
|
MatrixScale(mat, s, s);
|
|
MatrixTranslate(mat, dx, dy);
|
|
drawDat.matrix := MatrixMultiply(drawDat.matrix, mat);
|
|
|
|
//now center after scaling
|
|
if scale2.cx > scale2.cy then
|
|
begin
|
|
if scale2.cx > 1 then
|
|
begin
|
|
s := (self.elRectWH.width.rawVal - viewboxWH.Width) * 0.5;
|
|
MatrixTranslate(drawDat.matrix, s * scale.cx, 0);
|
|
end;
|
|
end else if scale2.cy > 1 then
|
|
begin
|
|
s := (self.elRectWH.height.rawVal - viewboxWH.Height) * 0.5;
|
|
MatrixTranslate(drawDat.matrix, 0, s * scale.cy);
|
|
end;
|
|
|
|
end;
|
|
end;
|
|
DrawChildren(img, drawDat);
|
|
end;
|
|
end
|
|
else if el is TShapeElement then
|
|
el.Draw(img, drawDat);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TMaskElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TMaskElement.GetPaths(const drawDat: TDrawData);
|
|
var
|
|
i : integer;
|
|
el : TShapeElement;
|
|
begin
|
|
maskRec := NullRect;
|
|
for i := 0 to fChilds.Count -1 do
|
|
if TSvgElement(fChilds[i]) is TShapeElement then
|
|
begin
|
|
el := TShapeElement(fChilds[i]);
|
|
el.GetPaths(drawDat);
|
|
maskRec :=
|
|
Img32.Vector.UnionRect(maskRec, Img32.Vector.GetBounds(el.drawPathsF));
|
|
end;
|
|
MatrixApply(drawDat.matrix, maskRec);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TMaskElement.ApplyMask(img: TImage32; const drawDat: TDrawData);
|
|
var
|
|
tmpImg: TImage32;
|
|
begin
|
|
tmpImg := TImage32.Create(img.Width, img.Height);
|
|
try
|
|
DrawChildren(tmpImg, drawDat);
|
|
img.CopyBlend(tmpImg, maskRec, maskRec, BlendBlueChannel);
|
|
finally
|
|
tmpImg.Free;
|
|
end;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TSymbolElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TSymbolElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
fDrawData.visible := false;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TGradElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TGradientElement.LoadContent: Boolean;
|
|
var
|
|
i: integer;
|
|
begin
|
|
Result := inherited LoadContent;
|
|
for i := 0 to fChilds.Count -1 do
|
|
if TSvgElement(fChilds[i]) is TGradStopElement then
|
|
with TGradStopElement(fChilds[i]) do
|
|
AddStop(color, offset);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TGradientElement.AddStop(color: TColor32; offset: double);
|
|
var
|
|
len: integer;
|
|
begin
|
|
//if a stop is less than previous stops, it is set equal to the largest stop.
|
|
//If two stops are equal the last stop controls the color from that point.
|
|
len := Length(stops);
|
|
if (len > 0) and (stops[len-1].offset > offset) then
|
|
offset := stops[len-1].offset;
|
|
setLength(stops, len+1);
|
|
stops[len].offset := Min(1,Max(0, offset));
|
|
stops[len].color := color;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TGradientElement.AssignTo(other: TSvgElement);
|
|
var
|
|
i, len: integer;
|
|
begin
|
|
if not Assigned(other) or not (other is TGradientElement) then Exit;
|
|
inherited;
|
|
|
|
with TGradientElement(other) do
|
|
begin
|
|
if units = 0 then
|
|
units := Self.units;
|
|
|
|
if Length(stops) = 0 then
|
|
begin
|
|
len := Length(self.stops);
|
|
SetLength(stops, len);
|
|
for i := 0 to len -1 do
|
|
stops[i] := Self.stops[i];
|
|
end;
|
|
|
|
if IsIdentityMatrix(fDrawData.matrix) then
|
|
fDrawData.matrix := self.fDrawData.matrix;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TGradientElement.PrepareRenderer(
|
|
renderer: TCustomGradientRenderer; drawDat: TDrawData): Boolean;
|
|
var
|
|
el: TSvgElement;
|
|
begin
|
|
if (refEl <> '') then
|
|
begin
|
|
el := FindRefElement(refEl);
|
|
if Assigned(el) and (el is TGradientElement) then
|
|
TGradientElement(el).AssignTo(self);
|
|
end;
|
|
Result := Length(stops) > 0;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TRadGradElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TRadGradElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
radius.Init;
|
|
F.Init;
|
|
C.Init;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TRadGradElement.AssignTo(other: TSvgElement);
|
|
begin
|
|
if not Assigned(other) or not (other is TGradientElement) then Exit;
|
|
inherited;
|
|
if other is TRadGradElement then
|
|
with TRadGradElement(other) do
|
|
begin
|
|
if not radius.IsValid then radius := self.radius;
|
|
if not C.IsValid then C := self.C;
|
|
if not F.IsValid then F := self.F;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TRadGradElement.PrepareRenderer(renderer: TCustomGradientRenderer;
|
|
drawDat: TDrawData): Boolean;
|
|
var
|
|
i, hiStops: integer;
|
|
cp, fp, r: TPointD;
|
|
scale, scale2: TSizeD;
|
|
rec2, rec3: TRectD;
|
|
begin
|
|
inherited PrepareRenderer(renderer, drawDat);
|
|
hiStops := High(stops);
|
|
Result := hiStops >= 0;
|
|
if not Result then Exit;
|
|
|
|
if units = hUserSpaceOnUse then
|
|
rec2 := fReader.userSpaceBounds else
|
|
rec2 := drawDat.bounds;
|
|
|
|
if radius.IsValid then
|
|
begin
|
|
if radius.X.HasFontUnits then
|
|
r := radius.GetPoint(drawDat.fontInfo.size, GetRelFracLimit) else
|
|
r := radius.GetPoint(rec2, GetRelFracLimit);
|
|
end else
|
|
begin
|
|
r.X := rec2.Width * 0.5;
|
|
r.Y := rec2.Height * 0.5;
|
|
end;
|
|
scale := ExtractScaleFromMatrix(drawDat.matrix);
|
|
scale2 := ExtractScaleFromMatrix(fDrawData.matrix);
|
|
r := ScalePoint(r, scale.cx * scale2.cx, scale.cy * scale2.cy);
|
|
|
|
if C.IsValid then
|
|
begin
|
|
if C.X.HasFontUnits then
|
|
cp := C.GetPoint(drawDat.fontInfo.size, GetRelFracLimit) else
|
|
cp := C.GetPoint(rec2, GetRelFracLimit);
|
|
cp := OffsetPoint(cp, rec2.Left, rec2.Top);
|
|
end else
|
|
cp := rec2.MidPoint;
|
|
MatrixApply(fDrawData.matrix, cp);
|
|
MatrixApply(drawDat.matrix, cp);
|
|
|
|
rec3 := RectD(cp.X-r.X, cp.Y-r.Y, cp.X+r.X, cp.Y+r.Y);
|
|
|
|
if F.IsValid then
|
|
begin
|
|
if F.X.HasFontUnits then
|
|
fp := F.GetPoint(drawDat.fontInfo.size, GetRelFracLimit) else
|
|
fp := F.GetPoint(rec2, GetRelFracLimit);
|
|
fp := OffsetPoint(fp, rec2.Left, rec2.Top);
|
|
MatrixApply(fDrawData.matrix, fp);
|
|
MatrixApply(drawDat.matrix, fp);
|
|
end else
|
|
fp := MidPoint(rec3);
|
|
|
|
with renderer as TSvgRadialGradientRenderer do
|
|
begin
|
|
SetParameters(Rect(rec3), Point(fp),
|
|
stops[0].color, stops[hiStops].color, spreadMethod);
|
|
for i := 1 to hiStops -1 do
|
|
with stops[i] do
|
|
renderer.InsertColorStop(offset, color);
|
|
end;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TLinGradElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TLinGradElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
startPt.Init;
|
|
endPt.Init;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TLinGradElement.AssignTo(other: TSvgElement);
|
|
begin
|
|
if not Assigned(other) or not (other is TGradientElement) then Exit;
|
|
inherited;
|
|
if other is TLinGradElement then
|
|
with TLinGradElement(other) do
|
|
begin
|
|
if not startPt.IsValid then startPt := self.startPt;
|
|
if not endPt.IsValid then endPt := self.endPt;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TLinGradElement.PrepareRenderer(
|
|
renderer: TCustomGradientRenderer; drawDat: TDrawData): Boolean;
|
|
var
|
|
pt1, pt2: TPointD;
|
|
i, hiStops: integer;
|
|
rec2: TRectD;
|
|
begin
|
|
inherited PrepareRenderer(renderer, drawDat);
|
|
hiStops := High(stops);
|
|
Result := (hiStops >= 0);
|
|
if not Result then Exit;
|
|
|
|
//w3c-coords-units-01-b.svg
|
|
|
|
//if gradientUnits=objectBoundingBox (default) then all values must be
|
|
//percentages. Also... when the object's bounding box is not square, the
|
|
//gradient may render non-perpendicular relative to the gradient vector
|
|
//unless the gradient vector is vertical or horizontal.
|
|
//https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/gradientUnits
|
|
|
|
if units = hUserSpaceOnUse then
|
|
rec2 := fReader.userSpaceBounds else
|
|
rec2 := drawDat.bounds;
|
|
|
|
with TLinearGradientRenderer(renderer) do
|
|
begin
|
|
if startPt.X.HasFontUnits then
|
|
pt1 := startPt.GetPoint(drawDat.fontInfo.size, GetRelFracLimit) else
|
|
pt1 := startPt.GetPoint(rec2, GetRelFracLimit);
|
|
|
|
if (startPt.X.unitType <> utPixel) or
|
|
(units <> hUserSpaceOnUse) then
|
|
pt1.X := pt1.X + rec2.Left;
|
|
|
|
if (startPt.Y.unitType <> utPixel) or
|
|
(units <> hUserSpaceOnUse) then
|
|
pt1.Y := pt1.Y + rec2.Top;
|
|
|
|
MatrixApply(fDrawData.matrix, pt1);
|
|
MatrixApply(drawDat.matrix, pt1);
|
|
|
|
|
|
if not endPt.X.IsValid then
|
|
pt2.X := rec2.Width else
|
|
pt2.X := endPt.X.GetValue(rec2.Width, GetRelFracLimit);
|
|
pt2.Y := endPt.Y.GetValue(rec2.Height, GetRelFracLimit);
|
|
pt2 := OffsetPoint(pt2, rec2.Left, rec2.Top);
|
|
|
|
MatrixApply(fDrawData.matrix, pt2);
|
|
MatrixApply(drawDat.matrix, pt2);
|
|
|
|
if (units <> hUserSpaceOnUse) and
|
|
((pt2.X <> pt1.X) or (pt2.Y <> pt1.Y)) then
|
|
begin
|
|
//skew the gradient
|
|
end;
|
|
|
|
SetParameters(pt1, pt2, stops[0].color,
|
|
stops[hiStops].color, spreadMethod);
|
|
for i := 1 to hiStops -1 do
|
|
with stops[i] do
|
|
renderer.InsertColorStop(offset, color);
|
|
end;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TGradStopElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TGradStopElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
color := clBlack32;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFilterElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TFilterElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
fDrawData.visible := false;
|
|
elRectWH.Init;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
destructor TFilterElement.Destroy;
|
|
begin
|
|
Clear;
|
|
inherited;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFilterElement.Clear;
|
|
var
|
|
i: integer;
|
|
begin
|
|
for i := 0 to High(fImages) do
|
|
fImages[i].Free;
|
|
fImages := nil;
|
|
fNames := nil;
|
|
fLastImg := nil;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TFilterElement.GetRelFracLimit: double;
|
|
begin
|
|
//always assume fractional values below 2.5 are relative
|
|
Result := 2.5;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TFilterElement.GetAdjustedBounds(const bounds: TRectD): TRectD;
|
|
var
|
|
recWH: TRectWH;
|
|
delta: TSizeD;
|
|
d: double;
|
|
pt: TPointD;
|
|
i: integer;
|
|
hasOffset: Boolean;
|
|
begin
|
|
fObjectBounds := Rect(bounds);
|
|
if elRectWH.IsValid then
|
|
begin
|
|
recWH := elRectWH.GetRectWH(bounds, GetRelFracLimit);
|
|
Result.Left := bounds.Left + recWH.Left;
|
|
Result.Top := bounds.Top + recWH.Top;
|
|
Result.Right := Result.Left + recWH.Width;
|
|
Result.Bottom := Result.Top + recWH.Height;
|
|
end else
|
|
begin
|
|
Result := bounds;
|
|
|
|
//when the filter's width and height are undefined then limit the filter
|
|
//margin to 20% of the bounds when just blurring, not also offsetting.
|
|
hasOffset := false;
|
|
|
|
delta.cx := 0; delta.cy := 0;
|
|
for i := 0 to ChildCount -1 do
|
|
begin
|
|
if Child[i] is TFeGaussElement then
|
|
begin
|
|
d := TFeGaussElement(Child[i]).stdDev * 3 * fScale;
|
|
delta.cx := delta.cx + d;
|
|
delta.cy := delta.cy + d;
|
|
end
|
|
else if Child[i] is TFeDropShadowElement then
|
|
with TFeDropShadowElement(Child[i]) do
|
|
begin
|
|
d := stdDev * 0.75 * fScale;
|
|
pt := offset.GetPoint(bounds, 1);
|
|
delta.cx := delta.cx + d + Abs(pt.X) * fScale;
|
|
delta.cy := delta.cy + d + Abs(pt.Y) * fScale;
|
|
hasOffset := true;
|
|
end
|
|
else if Child[i] is TFeOffsetElement then
|
|
with TFeOffsetElement(Child[i]) do
|
|
begin
|
|
pt := offset.GetPoint(bounds, 1);
|
|
delta.cx := delta.cx + Abs(pt.X) * fScale;
|
|
delta.cy := delta.cy + Abs(pt.Y) * fScale;
|
|
hasOffset := true;
|
|
end;
|
|
end;
|
|
|
|
//limit the filter margin to 20% if only blurring
|
|
if not hasOffset then
|
|
with delta, bounds do
|
|
begin
|
|
if cx > Width * 0.2 then cx := Width * 0.2;
|
|
if cy > Height * 0.2 then cy := Height * 0.2;
|
|
end;
|
|
Img32.Vector.InflateRect(Result, delta.cx, delta.cy);
|
|
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TFilterElement.FindNamedImage(const name: UTF8String): TImage32;
|
|
var
|
|
i, len: integer;
|
|
begin
|
|
Result := nil;
|
|
len := Length(fNames);
|
|
for i := 0 to len -1 do
|
|
if name = fNames[i] then
|
|
begin
|
|
Result := fImages[i];
|
|
Break;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TFilterElement.AddNamedImage(const name: UTF8String): TImage32;
|
|
var
|
|
len, w, h: integer;
|
|
begin
|
|
len := Length(fNames);
|
|
SetLength(fNames, len+1);
|
|
SetLength(fImages, len+1);
|
|
RectWidthHeight(fFilterBounds, w, h);
|
|
Result := TImage32.Create(w, h);
|
|
fImages[len] := Result;
|
|
fNames[len] := name;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TFilterElement.GetNamedImage(const name: UTF8String): TImage32;
|
|
var
|
|
i, len: integer;
|
|
hash: Cardinal;
|
|
begin
|
|
hash := GetHash(name);
|
|
case hash of
|
|
hBackgroundImage:
|
|
begin
|
|
Result := FindNamedImage(name);
|
|
if not Assigned(Result) then
|
|
Result := AddNamedImage(name);
|
|
Result.Copy(fReader.BackgndImage, fFilterBounds, Result.Bounds);
|
|
Exit;
|
|
end;
|
|
hBackgroundAlpha:
|
|
begin
|
|
Result := FindNamedImage(name);
|
|
if not Assigned(Result) then
|
|
Result := AddNamedImage(name);
|
|
Result.Copy(fReader.BackgndImage, fFilterBounds, Result.Bounds);
|
|
Result.SetRGB(clNone32, Result.Bounds);
|
|
Exit;
|
|
end;
|
|
hSourceGraphic:
|
|
begin
|
|
Result := FindNamedImage(name);
|
|
if not Assigned(Result) then
|
|
Result := AddNamedImage(name);
|
|
Result.Copy(fSrcImg, fFilterBounds, Result.Bounds);
|
|
Exit;
|
|
end;
|
|
hSourceAlpha:
|
|
begin
|
|
Result := FindNamedImage(name);
|
|
if not Assigned(Result) then
|
|
begin
|
|
Result := AddNamedImage(name);
|
|
Result.Copy(fSrcImg, fFilterBounds, Result.Bounds);
|
|
Result.SetRGB(clNone32, Result.Bounds);
|
|
end;
|
|
Exit;
|
|
end;
|
|
end;
|
|
|
|
len := Length(fNames);
|
|
for i := 0 to len -1 do
|
|
if name = fNames[i] then
|
|
begin
|
|
Result := fImages[i];
|
|
Exit;
|
|
end;
|
|
Result := AddNamedImage(name);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFilterElement.Apply(img: TImage32;
|
|
const filterBounds: TRect; const matrix: TMatrixD);
|
|
var
|
|
i: integer;
|
|
begin
|
|
fScale := ExtractAvgScaleFromMatrix(matrix);
|
|
fFilterBounds := filterBounds;
|
|
Types.IntersectRect(fObjectBounds, fObjectBounds, img.Bounds);
|
|
fSrcImg := img;
|
|
|
|
try
|
|
for i := 0 to fChilds.Count -1 do
|
|
begin
|
|
case TSvgElement(fChilds[i]).fParserEl.hash of
|
|
hfeBlend : TFeBlendElement(fChilds[i]).Apply;
|
|
hfeColorMatrix : TFeColorMatrixElement(fChilds[i]).Apply;
|
|
hfeComposite : TFeCompositeElement(fChilds[i]).Apply;
|
|
hfeDefuseLighting : TFeDefuseLightElement(fChilds[i]).Apply;
|
|
hfeDropShadow : TFeDropShadowElement(fChilds[i]).Apply;
|
|
hfeFlood : TFeFloodElement(fChilds[i]).Apply;
|
|
hFeGaussianBlur : TFeGaussElement(fChilds[i]).Apply;
|
|
hfeMerge : TFeMergeElement(fChilds[i]).Apply;
|
|
hfeOffset : TFeOffsetElement(fChilds[i]).Apply;
|
|
hfeSpecularLighting : TFeSpecLightElement(fChilds[i]).Apply;
|
|
end;
|
|
end;
|
|
fSrcImg.Copy(fLastImg, fLastImg.Bounds, fFilterBounds);
|
|
finally
|
|
Clear;
|
|
end;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFeBaseElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TFeBaseElement.GetParentAsFilterEl: TFilterElement;
|
|
var
|
|
el: TSvgElement;
|
|
begin
|
|
el := fParent;
|
|
while Assigned(el) and not (el is TFilterElement) do
|
|
el := el.fParent;
|
|
if not Assigned(el) then
|
|
Result := nil else
|
|
Result := TFilterElement(el);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TFeBaseElement.GetBounds(img: TImage32): TRect;
|
|
var
|
|
pfe: TFilterElement;
|
|
begin
|
|
pfe := ParentFilterEl;
|
|
if img = pfe.fSrcImg then
|
|
Result := pfe.fFilterBounds else
|
|
Result := img.Bounds;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TFeBaseElement.GetSrcAndDst: Boolean;
|
|
var
|
|
pfe: TFilterElement;
|
|
begin
|
|
pfe := ParentFilterEl;
|
|
if (in1 <> '') then
|
|
srcImg := pfe.GetNamedImage(in1)
|
|
else if Assigned(pfe.fLastImg) then
|
|
srcImg := pfe.fLastImg
|
|
else
|
|
srcImg := pfe.GetNamedImage(SourceImage);
|
|
|
|
if (res <> '') then
|
|
dstImg := pfe.GetNamedImage(res) else
|
|
dstImg := pfe.GetNamedImage(SourceImage);
|
|
|
|
Result := Assigned(srcImg) and Assigned(dstImg);
|
|
if not Result then Exit;
|
|
pfe.fLastImg := dstImg;
|
|
srcRec := GetBounds(srcImg);
|
|
dstRec := GetBounds(dstImg);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFeBlendElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFeBlendElement.Apply;
|
|
var
|
|
pfe: TFilterElement;
|
|
srcImg2, dstImg2: TImage32;
|
|
srcRec2, dstRec2: TRect;
|
|
begin
|
|
if not GetSrcAndDst then Exit;
|
|
pfe := ParentFilterEl;
|
|
if (in2 = '') then Exit;
|
|
if dstImg = srcImg then
|
|
dstImg2 := pfe.AddNamedImage(tmpFilterImg) else
|
|
dstImg2 := dstImg;
|
|
dstRec2 := GetBounds(dstImg2);
|
|
|
|
srcImg2 := pfe.GetNamedImage(in2);
|
|
srcRec2 := GetBounds(srcImg2);
|
|
dstImg2.CopyBlend(srcImg2, srcRec2, dstRec2, BlendToAlpha);
|
|
dstImg2.CopyBlend(srcImg, srcRec, dstRec2, BlendToAlpha);
|
|
if dstImg = srcImg then
|
|
dstImg.Copy(dstImg2, dstRec2, dstRec);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFeCompositeElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TFeCompositeElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
fourKs[0] := InvalidD; fourKs[1] := InvalidD;
|
|
fourKs[2] := InvalidD; fourKs[3] := InvalidD;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Arithmetic(p1, p2, r: PColor32; const ks: array of byte);
|
|
var
|
|
c1 : PARGB absolute p1;
|
|
c2 : PARGB absolute p2;
|
|
res : PARGB absolute r;
|
|
begin
|
|
res.A := (((c1.A xor 255) * (c2.A xor 255)) shr 8) xor 255;
|
|
res.R := ClampByte((ks[0] * c1.R * c2.R +
|
|
ks[1] * c1.R * 255 + ks[2] * c2.R * 255 + ks[3] * 65025) shr 16);
|
|
res.G := ClampByte((ks[0] * c1.G * c2.G +
|
|
ks[1] * c1.G * 255 + ks[2] * c2.G * 255 + ks[3] * 65025) shr 16);
|
|
res.B := ClampByte((ks[0] * c1.B * c2.B +
|
|
ks[1] * c1.B * 255 + ks[2] * c2.B * 255 + ks[3] * 65025) shr 16);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure ArithmeticBlend(src1, src2, dst: TImage32;
|
|
const recS1, recS2, recDst: TRect; const ks: TFourDoubles);
|
|
var
|
|
kk: array[0..3] of byte;
|
|
w,h, w2,h2, w3,h3, i,j: integer;
|
|
p1,p2,r: PColor32;
|
|
begin
|
|
RectWidthHeight(recS1, w, h);
|
|
RectWidthHeight(recS2, w2, h2);
|
|
RectWidthHeight(recDst, w3, h3);
|
|
if (w2 <> w) or (w3 <> w) or (h2 <> h) or (h3 <> h) or
|
|
(ks[0] = InvalidD) or (ks[1] = InvalidD) or
|
|
(ks[2] = InvalidD) or (ks[3] = InvalidD) then Exit;
|
|
|
|
for i := 0 to 3 do
|
|
kk[i] := ClampByte(ks[i]*255);
|
|
|
|
for i := 0 to h -1 do
|
|
begin
|
|
p1 := @src1.Pixels[(recS1.Top + i) * src1.Width + recS1.Left];
|
|
p2 := @src2.Pixels[(recS2.Top + i) * src2.Width + recS2.Left];
|
|
r := @dst.Pixels[(recDst.Top + i) * dst.Width + recDst.Left];
|
|
for j := 0 to w -1 do
|
|
begin
|
|
Arithmetic(p1, p2, r, kk);
|
|
inc(p1); inc(p2); inc(r);
|
|
end;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFeCompositeElement.Apply;
|
|
var
|
|
pfe: TFilterElement;
|
|
srcImg2, dstImg2: TImage32;
|
|
srcRec2, dstRec2: TRect;
|
|
begin
|
|
if not GetSrcAndDst then Exit;
|
|
pfe := ParentFilterEl;
|
|
if (in2 = '') then Exit;
|
|
|
|
srcImg2 := pfe.GetNamedImage(in2);
|
|
srcRec2 := GetBounds(srcImg2); //either filter bounds or image bounds
|
|
|
|
if (dstImg = srcImg) or (dstImg = srcImg2) then
|
|
dstImg2 := pfe.AddNamedImage(tmpFilterImg) else
|
|
dstImg2 := dstImg;
|
|
dstRec2 := GetBounds(dstImg2); //either filter bounds or image bounds
|
|
|
|
case compositeOp of
|
|
coIn:
|
|
begin
|
|
dstImg2.Copy(srcImg, srcRec, dstRec2);
|
|
dstImg2.CopyBlend(srcImg2, srcRec2, dstRec2, BlendMask);
|
|
end;
|
|
coOut:
|
|
begin
|
|
dstImg2.Copy(srcImg, srcRec, dstRec2);
|
|
dstImg2.CopyBlend(srcImg2, srcRec2, dstRec2, BlendInvertedMask);
|
|
end;
|
|
coAtop:
|
|
begin
|
|
dstImg2.Copy(srcImg2, srcRec2, dstRec2);
|
|
dstImg2.CopyBlend(srcImg, srcRec, dstRec2, BlendToAlpha);
|
|
dstImg2.CopyBlend(srcImg2, srcRec2, dstRec2, BlendMask);
|
|
end;
|
|
coXOR:
|
|
begin
|
|
dstImg2.Copy(srcImg2, srcRec2, dstRec2);
|
|
dstImg2.CopyBlend(srcImg, srcRec, dstRec2, BlendToAlpha);
|
|
dstImg2.CopyBlend(srcImg2, srcRec2, dstRec2, BlendInvertedMask);
|
|
end;
|
|
coArithmetic:
|
|
begin
|
|
ArithmeticBlend(srcImg, srcImg2, dstImg2,
|
|
srcRec, srcRec2, dstRec2, fourKs);
|
|
end;
|
|
else //coOver
|
|
begin
|
|
dstImg2.CopyBlend(srcImg2, srcRec2, dstRec2, BlendToAlpha);
|
|
dstImg2.CopyBlend(srcImg, srcRec, dstRec2, BlendToAlpha);
|
|
end;
|
|
end;
|
|
if (dstImg <> dstImg2) then
|
|
dstImg.Copy(dstImg2, dstRec2, dstRec);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFeColorMatrixElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
type
|
|
TColorMatrix = array[0..19] of Byte;
|
|
|
|
function ApplyColorMatrix(color: TColor32; const mat: TColorMatrix): TColor32;
|
|
var
|
|
clrIn : TARGB absolute color;
|
|
clrOut: TARGB absolute Result;
|
|
begin
|
|
clrOut.R := ClampByte(MulBytes(mat[0],clrIn.R) + MulBytes(mat[1],clrIn.G) +
|
|
MulBytes(mat[2],clrIn.B) + MulBytes(mat[3],clrIn.A) + mat[4]);
|
|
clrOut.G := ClampByte(MulBytes(mat[5],clrIn.R) + MulBytes(mat[6],clrIn.G) +
|
|
MulBytes(mat[7],clrIn.B) + MulBytes(mat[8],clrIn.A) + mat[9]);
|
|
clrOut.B := ClampByte(MulBytes(mat[10],clrIn.R) + MulBytes(mat[11],clrIn.G) +
|
|
MulBytes(mat[12],clrIn.B) + MulBytes(mat[13],clrIn.A) + mat[14]);
|
|
clrOut.A := ClampByte(MulBytes(mat[15],clrIn.R) + MulBytes(mat[16],clrIn.G) +
|
|
MulBytes(mat[17],clrIn.B) + MulBytes(mat[18],clrIn.A) + mat[19]);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFeColorMatrixElement.Apply;
|
|
var
|
|
i,j, dx1,dx2: integer;
|
|
colorMatrix: TColorMatrix;
|
|
p1, p2: PColor32;
|
|
begin
|
|
if not GetSrcAndDst or not Assigned(values) then Exit;
|
|
for i := 0 to 19 do
|
|
colorMatrix[i] := ClampByte(Round(values[i]*255));
|
|
|
|
dx1 := srcImg.Width - RectWidth(srcRec);
|
|
dx2 := dstImg.Width - RectWidth(dstRec);
|
|
p1 := @srcImg.Pixels[srcRec.Top * srcImg.Width + srcRec.Left];
|
|
p2 := @dstImg.Pixels[dstRec.Top * dstImg.Width + dstRec.Left];
|
|
for i := srcRec.Top to srcRec.Bottom -1 do
|
|
begin
|
|
for j := srcRec.Left to srcRec.Right -1 do
|
|
begin
|
|
p2^ := ApplyColorMatrix(p1^, colorMatrix);
|
|
inc(p1); inc(p2);
|
|
end;
|
|
inc(p1, dx1); inc(p2, dx2);
|
|
end;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFeDefuseLightElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFeDefuseLightElement.Apply;
|
|
begin
|
|
//not implemented
|
|
if not GetSrcAndDst then Exit;
|
|
if srcImg <> dstImg then
|
|
dstImg.Copy(srcImg, srcRec, dstRec);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFeDropShadowElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TFeDropShadowElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
stdDev := InvalidD;
|
|
floodColor := clInvalid;
|
|
offset.X.SetValue(0);
|
|
offset.Y.SetValue(0);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFeDropShadowElement.Apply;
|
|
var
|
|
alpha: Byte;
|
|
off: TPointD;
|
|
dstOffRec: TRect;
|
|
pfe: TFilterElement;
|
|
dropShadImg: TImage32;
|
|
begin
|
|
if not GetSrcAndDst then Exit;
|
|
pfe := ParentFilterEl;
|
|
dropShadImg := pfe.GetNamedImage(tmpFilterImg);
|
|
dropShadImg.Copy(srcImg, srcRec, dropShadImg.Bounds);
|
|
|
|
off := offset.GetPoint(RectD(pfe.fObjectBounds), GetRelFracLimit);
|
|
off := ScalePoint(off, pfe.fScale);
|
|
dstOffRec := dstRec;
|
|
with Point(off) do Types.OffsetRect(dstOffRec, X, Y);
|
|
dstImg.Copy(srcImg, srcRec, dstOffRec);
|
|
dstImg.SetRGB(floodColor);
|
|
alpha := GetAlpha(floodColor);
|
|
if (alpha > 0) and (alpha < 255) then
|
|
dstImg.ReduceOpacity(alpha);
|
|
if stdDev > 0 then
|
|
FastGaussianBlur(dstImg, dstRec,
|
|
Ceil(stdDev *0.75 * ParentFilterEl.fScale) , 0);
|
|
dstImg.CopyBlend(dropShadImg, dropShadImg.Bounds, dstRec, BlendToAlpha);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFeFloodElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TFeFloodElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
floodColor := clInvalid;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFeFloodElement.Apply;
|
|
var
|
|
rec: TRect;
|
|
begin
|
|
if not GetSrcAndDst then Exit;
|
|
if elRectWH.IsValid then
|
|
rec := Rect(elRectWH.GetRectD(RectD(srcRec), GetRelFracLimit)) else
|
|
rec := dstRec;
|
|
dstImg.FillRect(rec, floodColor);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFeGaussElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TFeGaussElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
stdDev := InvalidD;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFeGaussElement.Apply;
|
|
begin
|
|
if not GetSrcAndDst then Exit;
|
|
|
|
if srcImg <> dstImg then
|
|
dstImg.Copy(srcImg, srcRec, dstRec);
|
|
|
|
////True GaussianBlur is visually optimal, but it's also *extremely* slow.
|
|
//GaussianBlur(dstImg, dstRec, Ceil(stdDev *PI * ParentFilterEl.fScale));
|
|
|
|
//FastGaussianBlur is a very good approximation and also very much faster.
|
|
//Empirically stdDev * PI/4 more closely emulates other renderers.
|
|
FastGaussianBlur(dstImg, dstRec,
|
|
Ceil(stdDev * PI/4 * ParentFilterEl.fScale), fReader.fBlurQuality);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFeMergeElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFeMergeElement.Apply;
|
|
var
|
|
i: integer;
|
|
tmpImg: TImage32;
|
|
pfe: TFilterElement;
|
|
begin
|
|
tmpImg := nil;
|
|
if not GetSrcAndDst then Exit;
|
|
pfe := ParentFilterEl;
|
|
|
|
for i := 0 to fChilds.Count -1 do
|
|
if TSvgElement(fChilds[i]) is TFeMergeNodeElement then
|
|
with TFeMergeNodeElement(fChilds[i]) do
|
|
begin
|
|
if not GetSrcAndDst then Continue;
|
|
if Assigned(tmpImg) then
|
|
tmpImg.CopyBlend(srcImg, srcRec, tmpImg.Bounds, BlendToAlpha)
|
|
else if srcImg = pfe.fSrcImg then
|
|
tmpImg := pfe.GetNamedImage(SourceImage)
|
|
else
|
|
tmpImg := srcImg;
|
|
end;
|
|
|
|
dstImg.Copy(tmpImg, tmpImg.Bounds, dstRec);
|
|
pfe.fLastImg := dstImg;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFeMergeNodeElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFeMergeNodeElement.Apply;
|
|
begin
|
|
//should never get here ;)
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFeOffsetElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFeOffsetElement.Apply;
|
|
var
|
|
off: TPointD;
|
|
dstOffRec: TRect;
|
|
tmpImg: TImage32;
|
|
pfe: TFilterElement;
|
|
begin
|
|
if not GetSrcAndDst then Exit;
|
|
pfe := ParentFilterEl;
|
|
off := offset.GetPoint(RectD(pfe.fObjectBounds), GetRelFracLimit);
|
|
off := ScalePoint(off, pfe.fScale);
|
|
dstOffRec := dstRec;
|
|
with Point(off) do Types.OffsetRect(dstOffRec, X, Y);
|
|
|
|
if srcImg = dstImg then
|
|
begin
|
|
tmpImg := pfe.GetNamedImage(tmpFilterImg);
|
|
tmpImg.Copy(srcImg, srcRec, tmpImg.Bounds);
|
|
dstImg.Clear(dstRec);
|
|
dstImg.Copy(tmpImg, tmpImg.Bounds, dstOffRec);
|
|
end else
|
|
begin
|
|
dstImg.Clear(dstRec);
|
|
dstImg.Copy(srcImg, srcRec, dstOffRec);
|
|
end;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFeSpecLightElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TFeSpecLightElement.Apply;
|
|
begin
|
|
//not implemented
|
|
if not GetSrcAndDst then Exit;
|
|
if srcImg <> dstImg then
|
|
dstImg.Copy(srcImg, srcRec, dstRec);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TClipPathElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TClipPathElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
fDrawData.visible := false;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TClipPathElement.GetPaths(const drawDat: TDrawData);
|
|
var
|
|
i: integer;
|
|
begin
|
|
if Assigned(drawPathsC) or Assigned(drawPathsO) then Exit;
|
|
for i := 0 to fChilds.Count -1 do
|
|
if TSvgElement(fChilds[i]) is TShapeElement then
|
|
with TShapeElement(fChilds[i]) do
|
|
begin
|
|
GetPaths(drawDat);
|
|
AppendPath(self.drawPathsO, drawPathsO);
|
|
AppendPath(self.drawPathsC, drawPathsC);
|
|
end;
|
|
drawPathsF := CopyPaths(drawPathsC);
|
|
AppendPath(drawPathsF, drawPathsO);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TShapeElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TShapeElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
elRectWH.Init;
|
|
hasPaths := true;
|
|
fDrawData.visible := true;
|
|
if fParserEl.name = '' then Exit;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TShapeElement.GetBounds: TRectD;
|
|
var
|
|
i: integer;
|
|
begin
|
|
Result := NullRectD;
|
|
for i := 0 to fChilds.Count -1 do
|
|
if TSvgElement(fChilds[i]) is TShapeElement then
|
|
Result := UnionRect(Result, TShapeElement(fChilds[i]).GetBounds);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TShapeElement.HasMarkers: Boolean;
|
|
begin
|
|
Result := IsStroked(fDrawData) and ((fDrawData.markerStart <> '') or
|
|
(fDrawData.markerMiddle <> '') or (fDrawData.markerEnd <> ''));
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TShapeElement.Draw(image: TImage32; drawDat: TDrawData);
|
|
var
|
|
d : double;
|
|
img : TImage32;
|
|
stroked : Boolean;
|
|
filled : Boolean;
|
|
clipRec : TRectD;
|
|
clipRec2 : TRect;
|
|
clipPathEl : TSvgElement;
|
|
filterEl : TSvgElement;
|
|
maskEl : TSvgElement;
|
|
clipPaths : TPathsD;
|
|
di : TDrawData;
|
|
usingTempImage: Boolean;
|
|
begin
|
|
UpdateDrawInfo(drawDat, self);
|
|
|
|
filled := IsFilled(drawDat);
|
|
stroked := IsStroked(drawDat);
|
|
GetPaths(drawDat);
|
|
|
|
if not (filled or stroked) or not hasPaths then Exit;
|
|
drawDat.bounds := GetBoundsD(drawPathsF);
|
|
|
|
img := image;
|
|
clipRec2 := NullRect;
|
|
|
|
maskEl := FindRefElement(drawDat.maskElRef);
|
|
clipPathEl := FindRefElement(drawDat.clipElRef);
|
|
filterEl := FindRefElement(drawDat.filterElRef);
|
|
|
|
if (drawDat.fillEl <> '') and
|
|
(drawDat.fillOpacity > 0) and (drawDat.fillOpacity < 1) then
|
|
drawDat.opacity := Round(drawDat.fillOpacity * 255);
|
|
usingTempImage := Assigned(clipPathEl) or
|
|
Assigned(filterEl) or Assigned(maskEl) or (drawDat.opacity < 255);
|
|
|
|
if usingTempImage then
|
|
begin
|
|
img := fReader.TempImage;
|
|
|
|
//get special effects bounds
|
|
if Assigned(clipPathEl) then
|
|
begin
|
|
drawDat.clipElRef := '';
|
|
di := drawDat;
|
|
with TClipPathElement(clipPathEl) do
|
|
begin
|
|
GetPaths(di);
|
|
clipPaths := MatrixApply(drawPathsF, di.matrix);
|
|
clipRec := GetBoundsD(clipPaths);
|
|
end;
|
|
end
|
|
else if Assigned(maskEl) then
|
|
begin
|
|
drawDat.maskElRef := '';
|
|
with TMaskElement(maskEl) do
|
|
begin
|
|
GetPaths(drawDat);
|
|
clipRec := RectD(maskRec);
|
|
end;
|
|
end else
|
|
begin
|
|
clipRec := drawDat.bounds;
|
|
if stroked and drawDat.strokeWidth.IsValid then
|
|
begin
|
|
with drawDat.strokeWidth do
|
|
if HasFontUnits then
|
|
d := GetValue(drawDat.fontInfo.size, GetRelFracLimit) else
|
|
d := GetValueXY(clipRec, GetRelFracLimit);
|
|
Img32.Vector.InflateRect(clipRec, d * 0.5, d * 0.5);
|
|
end;
|
|
if Assigned(filterEl) then
|
|
begin
|
|
drawDat.filterElRef := '';
|
|
with TFilterElement(filterEl) do
|
|
begin
|
|
fScale := ExtractAvgScaleFromMatrix(DrawData.matrix);
|
|
clipRec := GetAdjustedBounds(clipRec);
|
|
end;
|
|
end;
|
|
MatrixApply(drawDat.matrix, clipRec);
|
|
end;
|
|
clipRec2 := Rect(clipRec);
|
|
Types.IntersectRect(clipRec2, clipRec2, img.Bounds);
|
|
if IsEmptyRect(clipRec2) then Exit;
|
|
if image <> fReader.TempImage then
|
|
img.Clear(clipRec2);
|
|
end;
|
|
|
|
if not IsValidMatrix(drawDat.matrix) then
|
|
raise Exception.Create('Invalid matrix found when drawing element');
|
|
|
|
if filled then
|
|
DrawFilled(img, drawDat);
|
|
|
|
if stroked then
|
|
begin
|
|
if Assigned(drawPathsC) then
|
|
DrawStroke(img, drawDat, true);
|
|
if stroked and Assigned(drawPathsO) then
|
|
DrawStroke(img, drawDat, false);
|
|
end;
|
|
|
|
if Assigned(filterEl) then
|
|
with TFilterElement(filterEl) do
|
|
Apply(img, clipRec2, drawDat.matrix);
|
|
|
|
if drawDat.opacity < 255 then
|
|
img.ReduceOpacity(drawDat.opacity, clipRec2);
|
|
|
|
if Assigned(maskEl) then
|
|
TMaskElement(maskEl).ApplyMask(img, drawDat)
|
|
else if Assigned(clipPathEl) then
|
|
with TClipPathElement(clipPathEl) do
|
|
EraseOutsidePaths(img, clipPaths, fDrawData.fillRule, clipRec2);
|
|
|
|
if usingTempImage and (img <> image) then
|
|
image.CopyBlend(img, clipRec2, clipRec2, BlendToAlpha);
|
|
|
|
//todo: enable "paint-order" to change filled/stroked/marker paint order
|
|
if HasMarkers then DrawMarkers(img, drawDat);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TShapeElement.DrawMarkers(img: TImage32; drawDat: TDrawData);
|
|
var
|
|
i,j: integer;
|
|
sw: double;
|
|
markerEl: TSvgElement;
|
|
markerPaths: TPathsD;
|
|
pt1, pt2: TPointD;
|
|
di: TDrawData;
|
|
begin
|
|
markerPaths := GetSimplePath(drawDat);
|
|
markerPaths := StripNearDuplicates(markerPaths, 0.01, false);
|
|
|
|
if not Assigned(markerPaths) then Exit;
|
|
MatrixApply(drawDat.matrix, markerPaths);
|
|
|
|
di := emptyDrawInfo;
|
|
|
|
//prepare to scale the markers by the stroke width
|
|
with fDrawData.strokeWidth do
|
|
if not IsValid then sw := 1
|
|
else if HasFontUnits then
|
|
sw := GetValue(drawDat.fontInfo.size, GetRelFracLimit)
|
|
else sw := GetValueXY(drawDat.bounds, GetRelFracLimit);
|
|
|
|
MatrixScale(di.matrix, sw * ExtractAvgScaleFromMatrix(drawDat.matrix));
|
|
|
|
if (fDrawData.markerStart <> '') then
|
|
begin
|
|
markerEl := FindRefElement(fDrawData.markerStart);
|
|
if Assigned(markerEl) and (markerEl is TMarkerElement) then
|
|
with TMarkerElement(markerEl) do
|
|
begin
|
|
for i := 0 to High(markerPaths) do
|
|
begin
|
|
if Length(markerPaths[i]) < 2 then Continue;
|
|
pt1 := markerPaths[i][0];
|
|
pt2 := markerPaths[i][1];
|
|
if autoStartReverse then
|
|
SetEndPoint(pt1, GetAngle(pt2, pt1)) else
|
|
SetEndPoint(pt1, GetAngle(pt1, pt2));
|
|
Draw(img, di);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
if (fDrawData.markerMiddle <> '') then
|
|
begin
|
|
markerEl := FindRefElement(fDrawData.markerMiddle);
|
|
if Assigned(markerEl) and (markerEl is TMarkerElement) then
|
|
with TMarkerElement(markerEl) do
|
|
for i := 0 to High(markerPaths) do
|
|
if SetMiddlePoints(markerPaths[i]) then
|
|
Draw(img, di);
|
|
end;
|
|
|
|
if (fDrawData.markerEnd <> '') then
|
|
begin
|
|
markerEl := FindRefElement(fDrawData.markerEnd);
|
|
if Assigned(markerEl) and (markerEl is TMarkerElement) then
|
|
with TMarkerElement(markerEl) do
|
|
begin
|
|
for i := 0 to High(markerPaths) do
|
|
begin
|
|
j := High(markerPaths[i]);
|
|
if j < 1 then Continue;
|
|
pt1 := markerPaths[i][j];
|
|
pt2 := markerPaths[i][j-1];
|
|
SetEndPoint(pt1, GetAngle(pt2, pt1));
|
|
Draw(img, di);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TShapeElement.GetPaths(const drawDat: TDrawData);
|
|
begin
|
|
drawPathsO := nil; drawPathsC := nil; drawPathsF := nil;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TShapeElement.GetSimplePath(const drawDat: TDrawData): TPathsD;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TShapeElement.DrawFilled(img: TImage32; drawDat: TDrawData);
|
|
var
|
|
refEl: TSvgElement;
|
|
fillPaths: TPathsD;
|
|
begin
|
|
if not assigned(drawPathsF) then Exit;
|
|
if drawDat.fillColor = clCurrent then
|
|
drawDat.fillColor := fReader.currentColor;
|
|
|
|
fillPaths := MatrixApply(drawPathsF, drawDat.matrix);
|
|
if (drawDat.fillEl <> '') then
|
|
begin
|
|
refEl := FindRefElement(drawDat.fillEl);
|
|
if Assigned(refEl) and (refEl is TFillElement) then
|
|
begin
|
|
if refEl is TRadGradElement then
|
|
begin
|
|
with TRadGradElement(refEl), fReader do
|
|
if PrepareRenderer(RadGradRenderer, drawDat) then
|
|
DrawPolygon(img, fillPaths, drawDat.fillRule, RadGradRenderer);
|
|
end
|
|
else if refEl is TLinGradElement then
|
|
begin
|
|
with TLinGradElement(refEl), fReader do
|
|
if PrepareRenderer(LinGradRenderer, drawDat) then
|
|
DrawPolygon(img, fillPaths, drawDat.fillRule, LinGradRenderer);
|
|
end
|
|
else if refEl is TPatternElement then
|
|
begin
|
|
with TPatternElement(refEl), fReader do
|
|
if PrepareRenderer(ImageRenderer, drawDat) then
|
|
DrawPolygon(img, fillPaths, drawDat.fillRule, ImageRenderer);
|
|
end;
|
|
end;
|
|
end
|
|
else if drawDat.fillColor = clInvalid then
|
|
DrawPolygon(img, fillPaths, drawDat.fillRule, clBlack32)
|
|
else
|
|
with drawDat do
|
|
DrawPolygon(img, fillPaths, fillRule,
|
|
MergeColorAndOpacity(fillColor, fillOpacity));
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TShapeElement.DrawStroke(img: TImage32;
|
|
drawDat: TDrawData; isClosed: Boolean);
|
|
var
|
|
dashOffset, scaledStrokeWidth, roundingScale: double;
|
|
dashArray: TArrayOfInteger;
|
|
scale: Double;
|
|
strokeClr: TColor32;
|
|
strokePaths: TPathsD;
|
|
refEl: TSvgElement;
|
|
endStyle: TEndStyle;
|
|
joinStyle: TJoinStyle;
|
|
bounds: TRectD;
|
|
begin
|
|
if isClosed then
|
|
begin
|
|
strokePaths := MatrixApply(drawPathsC, drawDat.matrix);
|
|
endStyle := esPolygon;
|
|
end else
|
|
begin
|
|
strokePaths := MatrixApply(drawPathsO, drawDat.matrix);
|
|
if fDrawData.strokeCap = esPolygon then
|
|
endStyle := esButt else
|
|
endStyle := fDrawData.strokeCap;
|
|
end;
|
|
if not Assigned(strokePaths) then Exit;
|
|
joinStyle := fDrawData.strokeJoin;
|
|
if drawDat.strokeColor = clCurrent then
|
|
drawDat.strokeColor := fReader.currentColor;
|
|
|
|
scale := ExtractAvgScaleFromMatrix(drawDat.matrix);
|
|
bounds := fReader.userSpaceBounds;
|
|
with drawDat.strokeWidth do
|
|
begin
|
|
if not IsValid then
|
|
scaledStrokeWidth := scale
|
|
else if HasFontUnits then
|
|
scaledStrokeWidth :=
|
|
GetValue(drawDat.fontInfo.size, GetRelFracLimit) * scale
|
|
else
|
|
scaledStrokeWidth := GetValueXY(bounds, 0) * scale;
|
|
end;
|
|
roundingScale := scale;
|
|
|
|
if Length(drawDat.dashArray) > 0 then
|
|
dashArray := MakeDashArray(drawDat.dashArray, scale) else
|
|
dashArray := nil;
|
|
|
|
with drawDat do
|
|
strokeClr := MergeColorAndOpacity(strokeColor, strokeOpacity);
|
|
|
|
if Assigned(dashArray) then
|
|
begin
|
|
dashOffset := drawDat.dashOffset * scale;
|
|
DrawDashedLine(img, strokePaths, dashArray,
|
|
@dashOffset, scaledStrokeWidth, strokeClr, endStyle);
|
|
end
|
|
else if (drawDat.strokeEl <> '') then
|
|
begin
|
|
refEl := FindRefElement(drawDat.strokeEl);
|
|
if not Assigned(refEl) then Exit;
|
|
|
|
if refEl is TRadGradElement then
|
|
begin
|
|
with TRadGradElement(refEl) do
|
|
PrepareRenderer(fReader.RadGradRenderer, drawDat);
|
|
DrawLine(img, strokePaths, scaledStrokeWidth,
|
|
fReader.RadGradRenderer, endStyle, joinStyle, roundingScale);
|
|
end
|
|
else if refEl is TLinGradElement then
|
|
begin
|
|
with TLinGradElement(refEl) do
|
|
PrepareRenderer(fReader.LinGradRenderer, drawDat);
|
|
DrawLine(img, strokePaths, scaledStrokeWidth,
|
|
fReader.LinGradRenderer, endStyle, joinStyle, roundingScale);
|
|
end
|
|
else if refEl is TPatternElement then
|
|
begin
|
|
with TPatternElement(refEl) do
|
|
PrepareRenderer(fReader.ImageRenderer, drawDat);
|
|
DrawLine(img, strokePaths, scaledStrokeWidth,
|
|
fReader.ImageRenderer, endStyle, joinStyle, roundingScale);
|
|
end;
|
|
end
|
|
else if (joinStyle = jsMiter) then
|
|
DrawLine(img, strokePaths, scaledStrokeWidth,
|
|
strokeClr, endStyle, joinStyle, drawDat.strokeMitLim)
|
|
else
|
|
DrawLine(img, strokePaths, scaledStrokeWidth,
|
|
strokeClr, endStyle, joinStyle, roundingScale);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TPathElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TPathElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
fSvgPaths := TSvgPath.Create;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
destructor TPathElement.Destroy;
|
|
begin
|
|
fSvgPaths.Free;
|
|
inherited;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TPathElement.GetBounds: TRectD;
|
|
var
|
|
i: integer;
|
|
begin
|
|
Result := NullRectD;
|
|
for i := 0 to fSvgPaths.Count -1 do
|
|
Result := UnionRect(Result, fSvgPaths[i].GetBounds);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TPathElement.ParseDAttrib(const value: UTF8String);
|
|
begin
|
|
fSvgPaths.Parse(value);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TPathElement.Flatten(index: integer; scalePending: double;
|
|
out path: TPathD; out isClosed: Boolean);
|
|
begin
|
|
isClosed := fSvgPaths[index].isClosed;
|
|
path := fSvgPaths[index].GetFlattenedPath(scalePending);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TPathElement.GetPaths(const drawDat: TDrawData);
|
|
var
|
|
i: integer;
|
|
scalePending: double;
|
|
isClosed: Boolean;
|
|
path: TPathD;
|
|
begin
|
|
if Assigned(drawPathsC) or Assigned(drawPathsO) then inherited;
|
|
scalePending := ExtractAvgScaleFromMatrix(drawDat.matrix);
|
|
for i := 0 to fSvgPaths.Count -1 do
|
|
begin
|
|
Flatten(i, scalePending, path, isClosed);
|
|
if not Assigned(path) then Continue;
|
|
|
|
if isClosed then
|
|
AppendPath(drawPathsC, path) else
|
|
AppendPath(drawPathsO, path);
|
|
end;
|
|
AppendPath(drawPathsF, drawPathsO);
|
|
AppendPath(drawPathsF, drawPathsC);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TPathElement.GetSimplePath(const drawDat: TDrawData): TPathsD;
|
|
var
|
|
i: integer;
|
|
begin
|
|
Result := nil;
|
|
SetLength(Result, fSvgPaths.Count);
|
|
for i := 0 to fSvgPaths.Count -1 do
|
|
Result[i] := fSvgPaths[i].GetSimplePath;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TPolyElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TPolyElement.GetBounds: TRectD;
|
|
begin
|
|
Result := GetBoundsD(path);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TPolyElement.GetPaths(const drawDat: TDrawData);
|
|
begin
|
|
if Assigned(drawPathsC) or Assigned(drawPathsO) then Exit;
|
|
if not Assigned(path) then Exit;
|
|
if (fParserEl.hash = hPolygon) then
|
|
begin
|
|
AppendPath(drawPathsC, path); //hPolygon
|
|
drawPathsF := drawPathsC;
|
|
end else
|
|
begin
|
|
AppendPath(drawPathsO, path); //hPolyline
|
|
drawPathsF := drawPathsO;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TPolyElement.GetSimplePath(const drawDat: TDrawData): TPathsD;
|
|
begin
|
|
Result := nil;
|
|
AppendPath(Result, path);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TPolyElement.ParsePoints(const value: UTF8String);
|
|
var
|
|
currCnt, currCap: integer;
|
|
|
|
procedure AddPoint(const pt: TPointD);
|
|
begin
|
|
if currCnt = currCap then
|
|
begin
|
|
currCap := currCap + buffSize;
|
|
SetLength(path, currCap);
|
|
end;
|
|
path[currCnt] := pt;
|
|
inc(currCnt);
|
|
end;
|
|
|
|
var
|
|
pt: TPointD;
|
|
c, endC: PUTF8Char;
|
|
begin
|
|
currCnt := 0;
|
|
currCap := buffSize;
|
|
c := PUTF8Char(value);
|
|
endC := c + Length(value);
|
|
SetLength(path, currCap);
|
|
while IsNumPending(c, endC, true) and
|
|
ParseNextNum(c, endC, true, pt.X) and
|
|
ParseNextNum(c, endC, true, pt.Y) do
|
|
AddPoint(pt);
|
|
SetLength(path, currCnt);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TLineElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TLineElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
SetLength(path, 2);
|
|
path[0] := NullPointD; path[1] := NullPointD;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TLineElement.GetBounds: TRectD;
|
|
begin
|
|
Result := GetBoundsD(path);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TLineElement.GetPaths(const drawDat: TDrawData);
|
|
begin
|
|
if Assigned(drawPathsO) then Exit;
|
|
AppendPath(drawPathsO, path);
|
|
drawPathsF := drawPathsO;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TLineElement.GetSimplePath(const drawDat: TDrawData): TPathsD;
|
|
begin
|
|
Result := nil;
|
|
AppendPath(Result, path);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TCircleElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TCircleElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
centerPt.Init;
|
|
radius.Init;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TCircleElement.GetBounds: TRectD;
|
|
var
|
|
cp : TPointD;
|
|
r : double;
|
|
begin
|
|
Result := NullRectD;
|
|
if not radius.IsValid then Exit;
|
|
r := radius.GetValue(1, GetRelFracLimit);
|
|
cp := centerPt.GetPoint(NullRectD, GetRelFracLimit);
|
|
Result := RectD(cp.X -r, cp.Y -r, cp.X +r, cp.Y +r);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TCircleElement.GetPaths(const drawDat: TDrawData);
|
|
var
|
|
scalePending : double;
|
|
rec : TRectD;
|
|
pt : TPointD;
|
|
path : TPathD;
|
|
r: double;
|
|
begin
|
|
if Assigned(drawPathsC) then inherited;
|
|
if not radius.IsValid then Exit;
|
|
r := radius.GetValueXY(drawDat.bounds, GetRelFracLimit);
|
|
pt := centerPt.GetPoint(drawDat.bounds, GetRelFracLimit);
|
|
scalePending := ExtractAvgScaleFromMatrix(drawDat.matrix);
|
|
rec := RectD(pt.X -r, pt.Y -r, pt.X +r, pt.Y +r);
|
|
path := Ellipse(rec, scalePending);
|
|
AppendPath(drawPathsC, path);
|
|
drawPathsF := drawPathsC;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TEllipseElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TEllipseElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
centerPt.Init;
|
|
radius.Init;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TEllipseElement.GetBounds: TRectD;
|
|
var
|
|
cp : TPointD;
|
|
r : TPointD;
|
|
begin
|
|
Result := NullRectD;
|
|
if not radius.IsValid then Exit;
|
|
r := radius.GetPoint(NullRectD, GetRelFracLimit);
|
|
cp := centerPt.GetPoint(NullRectD, GetRelFracLimit);
|
|
Result := RectD(cp.X -r.X, cp.Y -r.Y, cp.X +r.X, cp.Y +r.X);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TEllipseElement.GetPaths(const drawDat: TDrawData);
|
|
var
|
|
scalePending : double;
|
|
rec : TRectD;
|
|
path : TPathD;
|
|
rad : TPointD;
|
|
centPt : TPointD;
|
|
begin
|
|
if Assigned(drawPathsC) then inherited;
|
|
rad := radius.GetPoint(drawDat.bounds, GetRelFracLimit);
|
|
centPt := centerPt.GetPoint(drawDat.bounds, GetRelFracLimit);
|
|
with centPt do
|
|
rec := RectD(X -rad.X, Y -rad.Y, X +rad.X, Y +rad.Y);
|
|
scalePending := ExtractAvgScaleFromMatrix(drawDat.matrix);
|
|
path := Ellipse(rec, scalePending);
|
|
AppendPath(drawPathsC, path);
|
|
drawPathsF := drawPathsC;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TRectElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TRectElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
radius.Init;
|
|
elRectWH.width.SetValue(100, utPercent);
|
|
elRectWH.height.SetValue(100, utPercent);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TRectElement.GetBounds: TRectD;
|
|
begin
|
|
Result := elRectWH.GetRectD(NullRectD, GetRelFracLimit);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TRectElement.GetPaths(const drawDat: TDrawData);
|
|
var
|
|
radXY : TPointD;
|
|
bounds: TRectD;
|
|
path : TPathD;
|
|
begin
|
|
if Assigned(drawPathsC) then Exit;
|
|
if elRectWH.width.HasFontUnits then
|
|
bounds := elRectWH.GetRectD(drawDat.fontInfo.size, GetRelFracLimit) else
|
|
bounds := elRectWH.GetRectD(drawDat.bounds, GetRelFracLimit);
|
|
if bounds.IsEmpty then Exit;
|
|
|
|
radXY := radius.GetPoint(bounds, GetRelFracLimit);
|
|
if (radXY.X > 0) or (radXY.Y > 0) then
|
|
begin
|
|
if (radXY.X <= 0) then radXY.X := radXY.Y
|
|
else if (radXY.Y <= 0) then radXY.Y := radXY.X;
|
|
path := RoundRect(bounds, radXY);
|
|
end else
|
|
path := Rectangle(bounds);
|
|
AppendPath(drawPathsC, path);
|
|
drawPathsF := drawPathsC;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TRectElement.GetSimplePath(const drawDat: TDrawData): TPathsD;
|
|
var
|
|
rec: TRectD;
|
|
begin
|
|
Result := nil;
|
|
rec := elRectWH.GetRectD(drawDat.bounds, GetRelFracLimit);
|
|
if not rec.IsEmpty then
|
|
AppendPath(Result, Rectangle(rec));
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TTextElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TTextElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
offset.Init;
|
|
hasPaths := false;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TTextElement.LoadContent: Boolean;
|
|
var
|
|
i : integer;
|
|
svgEl : TSvgTreeEl;
|
|
elClass : TElementClass;
|
|
el : TSvgElement;
|
|
begin
|
|
Result := false;
|
|
for i := 0 to fParserEl.childs.Count -1 do
|
|
begin
|
|
svgEl := TSvgTreeEl(fParserEl.childs[i]);
|
|
if svgEl.hash = 0 then
|
|
begin
|
|
el := TSubtextElement.Create(self, svgEl);
|
|
Self.fChilds.Add(el);
|
|
if svgEl.text <> '' then
|
|
TSubtextElement(el).text := svgEl.text;
|
|
end else
|
|
begin
|
|
elClass := HashToElementClass(svgEl.hash);
|
|
if elClass = TSvgElement then Continue;
|
|
el := elClass.Create(self, svgEl);
|
|
Self.fChilds.Add(el);
|
|
el.LoadAttributes;
|
|
if not el.LoadContent then Exit; //error
|
|
end;
|
|
end;
|
|
Result := true;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TTextElement.GetTopTextElement: TTextElement;
|
|
var
|
|
el: TSvgElement;
|
|
begin
|
|
el := self;
|
|
while Assigned(el.fParent) and (el.fParent is TTextElement) do
|
|
el := el.fParent;
|
|
Result := TTextElement(el);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TTextElement.DoOffsetX(dx: double);
|
|
var
|
|
i: integer;
|
|
begin
|
|
for i := 0 to fChilds.Count -1 do
|
|
if TSvgElement(fChilds[i]) is TTextElement then
|
|
TTextElement(fChilds[i]).DoOffsetX(dx)
|
|
else if TSvgElement(fChilds[i]) is TSubTextElement then
|
|
with TSubTextElement(fChilds[i]) do
|
|
begin
|
|
drawPathsC := OffsetPath(drawPathsC, dx, 0);
|
|
drawPathsO := OffsetPath(drawPathsO, dx, 0);
|
|
drawPathsF := OffsetPath(drawPathsF, dx, 0);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TTextElement.GetPaths(const drawDat: TDrawData);
|
|
var
|
|
i : integer;
|
|
el : TSvgElement;
|
|
di : TDrawData;
|
|
topTextEl : TTextElement;
|
|
begin
|
|
di := drawDat;
|
|
if self <> GetTopTextElement then
|
|
UpdateDrawInfo(di, self);
|
|
|
|
if Self is TTSpanElement then
|
|
begin
|
|
el := fParent;
|
|
while (el is TTSpanElement) do
|
|
el := el.fParent;
|
|
if not (el is TTextElement) then Exit; //ie error (eg <textarea>)
|
|
topTextEl := TTextElement(el);
|
|
|
|
if elRectWH.left.IsValid then
|
|
currentPt.X := elRectWH.left.rawVal else
|
|
currentPt.X := topTextEl.currentPt.X;
|
|
if elRectWH.top.IsValid then
|
|
currentPt.Y := elRectWH.top.rawVal else
|
|
currentPt.Y := topTextEl.currentPt.Y;
|
|
|
|
if offset.X.IsValid then
|
|
currentPt.X := currentPt.X + offset.X.GetValue(0, 0);
|
|
if offset.Y.IsValid then
|
|
currentPt.Y := currentPt.Y + offset.Y.GetValue(0, 0);
|
|
|
|
topTextEl.currentPt := currentPt;
|
|
end else
|
|
begin
|
|
if elRectWH.left.IsValid then
|
|
currentPt.X := elRectWH.left.rawVal else
|
|
currentPt.X := 0;
|
|
if elRectWH.top.IsValid then
|
|
currentPt.Y := elRectWH.top.rawVal else
|
|
currentPt.Y := 0;
|
|
startX := currentPt.X;
|
|
end;
|
|
|
|
for i := 0 to fChilds.Count -1 do
|
|
if TSvgElement(fChilds[i]) is TShapeElement then
|
|
TShapeElement(fChilds[i]).GetPaths(di);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TTextElement.ResetTmpPt;
|
|
begin
|
|
startX := 0;
|
|
currentPt := InvalidPointD;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TTextElement.Draw(img: TImage32; drawDat: TDrawData);
|
|
var
|
|
dx : double;
|
|
begin
|
|
if self = GetTopTextElement then
|
|
begin
|
|
UpdateDrawInfo(drawDat, self);
|
|
//get child paths
|
|
GetPaths(drawDat);
|
|
|
|
case drawDat.FontInfo.align of
|
|
staCenter:
|
|
begin
|
|
dx := (currentPt.X - startX) * 0.5;
|
|
DoOffsetX(-dx);
|
|
end;
|
|
staRight:
|
|
begin
|
|
dx := (currentPt.X - startX);
|
|
DoOffsetX(-dx);
|
|
end;
|
|
end;
|
|
end
|
|
else if (currentPt.X = InvalidD) or
|
|
(currentPt.Y = InvalidD) then
|
|
Exit; //probably a <textarea> element
|
|
|
|
DrawChildren(img, drawDat);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TSubtextElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TSubtextElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
hasPaths := true;
|
|
fDrawData := fParent.fDrawData;
|
|
fDrawData.matrix := IdentityMatrix;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function FixSpaces(const text: UnicodeString): UnicodeString;
|
|
var
|
|
i,j, len: integer;
|
|
begin
|
|
//changes \r\n\t chars to spaces
|
|
//and trims consecutive spaces
|
|
|
|
len := Length(text);
|
|
SetLength(Result, len);
|
|
if len = 0 then Exit;
|
|
|
|
if text[1] <= #32 then
|
|
Result[1] := #32 else
|
|
Result[1] := text[1];
|
|
|
|
j := 1;
|
|
for i := 2 to len do
|
|
begin
|
|
if text[i] <= #32 then
|
|
begin
|
|
if Result[j] = #32 then Continue
|
|
else Result[j+1] := #32;
|
|
end
|
|
else
|
|
Result[j+1] := text[i];
|
|
inc(j);
|
|
end;
|
|
SetLength(Result, j);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TSubtextElement.GetPaths(const drawDat: TDrawData);
|
|
var
|
|
el : TSvgElement;
|
|
topTextEl : TTextElement;
|
|
s: UnicodeString;
|
|
tmpX, offsetX, scale, fontSize, bs: double;
|
|
mat: TMatrixD;
|
|
begin
|
|
if Assigned(drawPathsC) then Exit;
|
|
fReader.GetBestFontForFontCache(drawDat.FontInfo);
|
|
if drawDat.FontInfo.size = 0 then
|
|
fontSize := 16 else
|
|
fontSize := drawDat.FontInfo.size;
|
|
if (Length(text) = 0) or (fontSize < 2) or
|
|
not Assigned(fReader.fFontCache) then Exit;
|
|
|
|
el := self;
|
|
while (el.fParent is TTextElement) do
|
|
el := el.fParent;
|
|
if not (el is TTextElement) then Exit;
|
|
topTextEl := TTextElement(el);
|
|
|
|
if (topTextEl.currentPt.X = InvalidD) or
|
|
(topTextEl.currentPt.Y = InvalidD) then Exit;
|
|
|
|
//trim CRLFs and multiple spaces
|
|
{$IFDEF UNICODE}
|
|
s := UTF8ToUnicodeString(HtmlDecode(text));
|
|
{$ELSE}
|
|
s := Utf8Decode(HtmlDecode(text));
|
|
{$ENDIF}
|
|
s := FixSpaces(s);
|
|
|
|
drawPathsC := fReader.fFontCache.GetTextOutline(0, 0, s, tmpX);
|
|
//by not changing the fontCache.FontHeight, the quality of
|
|
//small font render improves very significantly (though of course
|
|
//this requires additional glyph scaling and offsetting).
|
|
scale := fontSize / fReader.fFontCache.FontHeight;
|
|
|
|
with topTextEl.currentPt do
|
|
begin
|
|
offsetX := X;
|
|
X := X + tmpX * scale;
|
|
end;
|
|
|
|
with drawDat.fontInfo do
|
|
if baseShift.rawVal = 0 then
|
|
bs := 0 else
|
|
bs := baseShift.GetValue(size, GetRelFracLimit);
|
|
|
|
mat := IdentityMatrix;
|
|
MatrixScale(mat, scale);
|
|
MatrixTranslate(mat, offsetX, topTextEl.currentPt.Y - bs);
|
|
MatrixApply(mat, drawPathsC);
|
|
drawPathsF := drawPathsC;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TTSpanElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TTSpanElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
fDrawData.FontInfo.decoration := fdUndefined;
|
|
fDrawData.FontInfo.baseShift.SetValue(0);
|
|
|
|
elRectWH.Init;
|
|
currentPt := InvalidPointD;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TTextPathElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TTextPathElement.GetPaths(const drawDat: TDrawData);
|
|
var
|
|
parentTextEl, topTextEl: TTextElement;
|
|
el: TSvgElement;
|
|
isFirst: Boolean;
|
|
s: UnicodeString;
|
|
i, len, charsThatFit: integer;
|
|
d, fontScale, spacing: double;
|
|
utf8: UTF8String;
|
|
mat: TMatrixD;
|
|
tmpPath: TPathD;
|
|
isClosed: Boolean;
|
|
const
|
|
dblSpace: UnicodeString = #32#32;
|
|
begin
|
|
if Assigned(drawPathsC) then Exit;
|
|
fReader.GetBestFontForFontCache(drawDat.FontInfo);
|
|
if (drawDat.FontInfo.size < 2) or
|
|
not Assigned(fReader.fFontCache) then Exit;
|
|
|
|
parentTextEl := TTextElement(fParent);
|
|
topTextEl := parentTextEl;
|
|
isFirst := IsFirstChild;
|
|
while topTextEl.fParserEl.hash <> hText do
|
|
begin
|
|
isFirst := isFirst and topTextEl.IsFirstChild;
|
|
topTextEl := TTextElement(topTextEl.fParent);
|
|
end;
|
|
|
|
//if first subtext then reset X offset
|
|
if not isFirst then Exit;
|
|
topTextEl.ResetTmpPt;
|
|
utf8 := '';
|
|
|
|
//nb: only exit AFTER setting parentTextEl.tmpPt.
|
|
if (fParserEl.text = '') then
|
|
begin
|
|
if (fChilds.Count = 0) or
|
|
not (TSvgElement(fChilds[0]) is TTSpanElement) then
|
|
Exit;
|
|
el := TSvgElement(fChilds[0]);
|
|
if (el.fChilds.Count = 0) or
|
|
not (TSvgElement(el.fChilds[0]) is TSubtextElement) then
|
|
Exit;
|
|
with TSubtextElement(el.fChilds[0]) do
|
|
begin
|
|
utf8 := text;
|
|
spacing := fDrawData.FontInfo.spacing;
|
|
end;
|
|
end else
|
|
begin
|
|
utf8 := fParserEl.text;
|
|
spacing := drawDat.FontInfo.spacing;
|
|
end;
|
|
|
|
//trim CRLFs and multiple spaces
|
|
{$IFDEF UNICODE}
|
|
s := UTF8ToUnicodeString(HtmlDecode(utf8));
|
|
{$ELSE}
|
|
s := UnicodeString(Utf8Decode(HtmlDecode(utf8)));
|
|
{$ENDIF}
|
|
for i := 1 to Length(s) do
|
|
if s[i] < #32 then s[i] := #32;
|
|
|
|
i := PosEx(dblSpace, s);
|
|
while i > 0 do
|
|
begin
|
|
Delete(s, i, 1);
|
|
i := PosEx(dblSpace, s, i);
|
|
end;
|
|
|
|
el := FindRefElement(pathEl);
|
|
if not (el is TPathElement) then Exit;
|
|
fontScale := drawDat.FontInfo.size/fReader.fFontCache.FontHeight;
|
|
spacing := spacing /fontScale;
|
|
|
|
//adjust glyph spacing when fFontInfo.textLength is assigned.
|
|
len := Length(s);
|
|
if (len > 1) and (drawDat.FontInfo.textLength > 0) then
|
|
begin
|
|
d := fReader.fFontCache.GetTextWidth(s);
|
|
spacing := (drawDat.FontInfo.textLength/fontScale) - d;
|
|
spacing := spacing / (len -1);
|
|
end;
|
|
|
|
with TPathElement(el) do
|
|
begin
|
|
mat := fDrawData.matrix;
|
|
MatrixScale(mat, 1/fontScale);
|
|
for i := 0 to fSvgPaths.Count -1 do
|
|
begin
|
|
Flatten(i, fontScale, tmpPath, isClosed);
|
|
//'path' is temporarily scaled to accommodate fReader.fFontCache's
|
|
//static fontheight. The returned glyphs will be de-scaled later.
|
|
MatrixApply(mat, tmpPath);
|
|
AppendPath(self.drawPathsC,
|
|
GetTextOutlineOnPath(s, tmpPath, fReader.fFontCache,
|
|
taLeft, 0, spacing, charsThatFit));
|
|
if charsThatFit = Length(s) then Break;
|
|
Delete(s, 1, charsThatFit);
|
|
end;
|
|
end;
|
|
drawPathsC := ScalePath(drawPathsC, fontScale);
|
|
drawPathsF := drawPathsC;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TMarkerElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TMarkerElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
fDrawData.visible := false;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TMarkerElement.Draw(img: TImage32; drawDat: TDrawData);
|
|
var
|
|
i, len: integer;
|
|
l,t,w,h,scale, a, a2: double;
|
|
mat: TMatrixD;
|
|
angles: TArrayOfDouble;
|
|
begin
|
|
UpdateDrawInfo(drawDat, self);
|
|
mat := drawDat.matrix;
|
|
|
|
if elRectWH.width.IsValid and elRectWH.height.IsValid and
|
|
not markerBoxWH.IsEmpty then
|
|
begin
|
|
w := elRectWH.width.rawVal;
|
|
h := elRectWH.height.rawVal;
|
|
//currently assume preserve aspect ratio
|
|
scale := Min(w/markerBoxWH.Width, h/markerBoxWH.Height);
|
|
MatrixScale(mat, scale, scale);
|
|
end;
|
|
|
|
if refPt.X.IsValid and refPt.Y.IsValid then
|
|
begin
|
|
l := refPt.X.rawVal;
|
|
t := refPt.Y.rawVal;
|
|
scale := ExtractAvgScaleFromMatrix(mat);
|
|
MatrixTranslate(mat, -l * scale, -t * scale);
|
|
end;
|
|
|
|
len := Length(fPoints);
|
|
if len = 0 then Exit;
|
|
SetLength(angles, len);
|
|
angles[0] := angle;
|
|
a := angle;
|
|
for i := 0 to len -2 do
|
|
begin
|
|
a2 := GetAngle(fPoints[i], fPoints[i+1]);
|
|
angles[i] := Average(a, a2);
|
|
a := a2;
|
|
end;
|
|
if len > 1 then
|
|
angles[len -1] := Average(a, angle2);
|
|
|
|
//for each 'point' draw the marker
|
|
for i := 0 to len -1 do
|
|
begin
|
|
drawDat.matrix := mat;
|
|
MatrixRotate(drawDat.matrix, NullPointD, angles[i]);
|
|
MatrixTranslate(drawDat.matrix, fPoints[i].X, fPoints[i].Y);
|
|
DrawChildren(img, drawDat);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TMarkerElement.SetEndPoint(const pt: TPointD; angle: double);
|
|
begin
|
|
SetLength(fPoints, 1);
|
|
fPoints[0] := pt;
|
|
self.angle := angle;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TMarkerElement.SetMiddlePoints(const points: TPathD): Boolean;
|
|
var
|
|
len: integer;
|
|
begin
|
|
len := Length(points);
|
|
Result := len > 2;
|
|
if Result then
|
|
begin
|
|
angle := GetAngle(Points[0],Points[1]);
|
|
angle2 := GetAngle(Points[len-2],Points[len-1]);
|
|
Self.fPoints := Copy(points, 1, len -2);
|
|
end;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TFillElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TFillElement.GetRelFracLimit: double;
|
|
begin
|
|
//always assume fractional values below 1 are relative
|
|
Result := 1.0;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TPatternElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TPatternElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited;
|
|
elRectWH.Init;
|
|
pattBoxWH.Width := InvalidD;
|
|
pattBoxWH.Height := InvalidD;
|
|
fDrawData.visible := false;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TPatternElement.PrepareRenderer(renderer: TImageRenderer;
|
|
drawDat: TDrawData): Boolean;
|
|
var
|
|
i : integer;
|
|
recWH : TRectWH;
|
|
el : TSvgElement;
|
|
rec : TRectD;
|
|
mat : TMatrixD;
|
|
sx,sy : double;
|
|
scale: TSizeD;
|
|
begin
|
|
Result := false;
|
|
|
|
scale := ExtractScaleFromMatrix(drawDat.matrix);
|
|
if units = hUserSpaceOnUse then
|
|
rec := fReader.userSpaceBounds else
|
|
rec := drawDat.bounds;
|
|
|
|
//todo: implement patternUnits & patternContentUnits too
|
|
|
|
sx := 1; sy := 1;
|
|
if elRectWH.Width.IsValid and elRectWH.Height.IsValid then
|
|
begin
|
|
recWH := elRectWH.GetRectWH(rec, GetRelFracLimit);
|
|
|
|
//also scale if necessary
|
|
if not pattBoxWH.IsEmpty then
|
|
begin
|
|
sx := recWH.Width/pattBoxWH.Width;
|
|
sy := recWH.Height/pattBoxWH.Height;
|
|
end;
|
|
|
|
end
|
|
else if not pattBoxWH.IsEmpty then
|
|
begin
|
|
recWH.Width := pattBoxWH.Width;
|
|
recWH.Height := pattBoxWH.Width;
|
|
end else
|
|
Exit;
|
|
|
|
renderer.Image.SetSize(
|
|
Round(recWH.Width * scale.cx),
|
|
Round(recWH.Height * scale.cy));
|
|
|
|
Result := true;
|
|
|
|
mat := IdentityMatrix;
|
|
MatrixScale(mat, scale.cx * sx, scale.cy * sy);
|
|
|
|
//recWH.Left := 0; recWH.Top := 0;
|
|
if (refEl <> '') then
|
|
begin
|
|
el := FindRefElement(refEl);
|
|
if Assigned(el) and (el is TShapeElement) then
|
|
with TShapeElement(el) do
|
|
begin
|
|
drawDat := fDrawData;
|
|
drawDat.matrix := mat;
|
|
drawDat.bounds := recWH.RectD;
|
|
Draw(renderer.Image, drawDat);
|
|
end;
|
|
end;
|
|
|
|
for i := 0 to fChilds.Count -1 do
|
|
if TSvgElement(fChilds[i]) is TShapeElement then
|
|
with TShapeElement(fChilds[i]) do
|
|
begin
|
|
drawDat := fDrawData;
|
|
drawDat.matrix := mat;
|
|
drawDat.bounds := rec;
|
|
Draw(renderer.Image, drawDat);
|
|
end;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TSvgRootElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TSvgRootElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
inherited Create(parent, svgEl);
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TElement
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TSvgElement.Create(parent: TSvgElement; svgEl: TSvgTreeEl);
|
|
begin
|
|
{$IFDEF XPLAT_GENERICS}
|
|
fChilds := TList<TSvgElement>.create;
|
|
{$ELSE}
|
|
fChilds := TList.Create;
|
|
{$ENDIF}
|
|
fParserEl := svgEl;
|
|
self.fParent := parent;
|
|
fDrawData := emptyDrawInfo;
|
|
elRectWH.Init;
|
|
if Assigned(parent) then
|
|
fReader := parent.fReader;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
destructor TSvgElement.Destroy;
|
|
var
|
|
i: integer;
|
|
begin
|
|
for i := 0 to fChilds.Count -1 do
|
|
TSvgElement(fChilds[i]).Free;
|
|
fChilds.Free;
|
|
inherited;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgElement.IsFirstChild: Boolean;
|
|
begin
|
|
Result := not Assigned(fParent) or (self = fParent.fChilds[0]);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TSvgElement.Draw(image: TImage32; drawDat: TDrawData);
|
|
begin
|
|
DrawChildren(image, drawDat);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TSvgElement.DrawChildren(image: TImage32; drawDat: TDrawData);
|
|
var
|
|
i: integer;
|
|
begin
|
|
for i := 0 to fChilds.Count -1 do
|
|
with TSvgElement(fChilds[i]) do
|
|
if fDrawData.visible then Draw(image, drawDat);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgElement.GetChildCount: integer;
|
|
begin
|
|
Result := fChilds.Count;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgElement.FindChild(const idName: UTF8String): TSvgElement;
|
|
var
|
|
i: integer;
|
|
begin
|
|
if Match(self.fId, idName) then
|
|
begin
|
|
Result := self;
|
|
Exit;
|
|
end;
|
|
|
|
Result := nil;
|
|
for i := 0 to ChildCount -1 do
|
|
begin
|
|
Result := Child[i].FindChild(idName);
|
|
if Assigned(Result) then Break;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgElement.GetChild(index: integer): TSvgElement;
|
|
begin
|
|
if (index < 0) or (index >= fChilds.count) then
|
|
Result := nil else
|
|
Result := TSvgElement(fChilds[index]);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgElement.FindRefElement(refname: UTF8String): TSvgElement;
|
|
var
|
|
i, len: integer;
|
|
c, endC: PUTF8Char;
|
|
ref: UTF8String;
|
|
begin
|
|
result := nil;
|
|
len := Length(refname);
|
|
if len = 0 then Exit;
|
|
c := PUTF8Char(refname);
|
|
endC := c + len;
|
|
if Match(c, 'url(') then
|
|
begin
|
|
inc(c, 4);
|
|
dec(endC); //removes trailing ')'
|
|
end;
|
|
if c^ = '#' then inc(c);
|
|
ref := ToUTF8String(c, endC);
|
|
i := fReader.fIdList.IndexOf(string(ref));
|
|
if i >= 0 then
|
|
Result := TSvgElement(fReader.fIdList.Objects[i]) else
|
|
Result := nil;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// dozens of function to process various element attributes
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Id_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
aOwnerEl.fId := value;
|
|
aOwnerEl.fReader.fIdList.AddObject(string(value), aOwnerEl);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure In_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if aOwnerEl is TFeBaseElement then
|
|
TFeBaseElement(aOwnerEl).in1 := value;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure In2_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if aOwnerEl is TFeBaseElement then
|
|
TFeBaseElement(aOwnerEl).in2 := value;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure LetterSpacing_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
with TTextElement(aOwnerEl) do
|
|
UTF8StringToFloat(value, fDrawData.FontInfo.spacing);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Href_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
el: TSvgElement;
|
|
begin
|
|
el := aOwnerEl;
|
|
case el.fParserEl.Hash of
|
|
hUse:
|
|
TUseElement(el).refEl := ExtractRef(value);
|
|
hTextPath:
|
|
TTextPathElement(el).pathEl := ExtractRef(value);
|
|
else if el is TFillElement then
|
|
TFillElement(el).refEl := ExtractRef(value);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure BaselineShift_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
word: UTF8String;
|
|
c, endC: PUTF8Char;
|
|
begin
|
|
c := PUTF8Char(value);
|
|
endC := c + Length(value);
|
|
ParseNextWord(c, endC, word);
|
|
with aOwnerEl.fDrawData.FontInfo do
|
|
case GetHash(word) of
|
|
hSuper: baseShift.SetValue(50, utPercent);
|
|
hSub: baseShift.SetValue(-50, utPercent);
|
|
hBaseline: baseShift.SetValue(0, utPixel);
|
|
else
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
baseShift.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Color_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
color: TColor32;
|
|
begin
|
|
color := clInvalid;
|
|
UTF8StringToColor32(value, color);
|
|
//for setting currentcolor when drawing (eg drawing shapes)
|
|
aOwnerEl.fDrawData.currentColor := color;
|
|
//for setting currentcolor during element creation (eg gradient colors)
|
|
aOwnerEl.fReader.currentColor := color;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure LightingColor_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
color: TColor32;
|
|
begin
|
|
color := clInvalid;
|
|
UTF8StringToColor32(value, color);
|
|
if (aOwnerEl is TFeSpecLightElement) then
|
|
TFeSpecLightElement(aOwnerEl).color := color
|
|
else if (aOwnerEl is TFeDefuseLightElement) then
|
|
TFeDefuseLightElement(aOwnerEl).color := color
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure ClipPath_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
aOwnerEl.fDrawData.clipElRef := ExtractRef(value);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure D_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if aOwnerEl is TPathElement then
|
|
TPathElement(aOwnerEl).ParseDAttrib(value);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Fill_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hfeDropShadow:
|
|
UTF8StringToColor32(value, TFeDropShadowElement(aOwnerEl).floodColor);
|
|
hfeFlood:
|
|
UTF8StringToColor32(value, TFeFloodElement(aOwnerEl).floodColor);
|
|
else
|
|
begin
|
|
if Match(PUTF8Char(value), 'url(') then
|
|
aOwnerEl.fDrawData.fillEl := ExtractRef(value)
|
|
else
|
|
UTF8StringToColor32(value, aOwnerEl.fDrawData.fillColor);
|
|
end;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure FillOpacity_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
val: double;
|
|
begin
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hfeDropShadow:
|
|
UTF8StringToOpacity(value, TFeDropShadowElement(aOwnerEl).floodColor);
|
|
hfeFlood:
|
|
UTF8StringToOpacity(value, TFeFloodElement(aOwnerEl).floodColor);
|
|
else
|
|
begin
|
|
UTF8StringToFloat(value, val);
|
|
aOwnerEl.fDrawData.fillOpacity := ClampRange(val, 0,1);
|
|
end;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure DashArray_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
c, endC: PUTF8Char;
|
|
val: double;
|
|
len: integer;
|
|
begin
|
|
c := PUTF8Char(value);
|
|
endC := c + Length(value);
|
|
with aOwnerEl.fDrawData do
|
|
begin
|
|
len := Length(dashArray);
|
|
while ParseNextNum(c, endC, true, val) do
|
|
begin
|
|
SetLength(dashArray, len +1);
|
|
dashArray[len] := val;
|
|
inc(len);
|
|
end;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure DashOffset_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
c, endC: PUTF8Char;
|
|
begin
|
|
c := PUTF8Char(value);
|
|
endC := c + Length(value);
|
|
with aOwnerEl.fDrawData do
|
|
ParseNextNum(c, endC, true, dashOffset);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Display_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if GetHash(value) = hNone then
|
|
aOwnerEl.fDrawData.visible := false;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Font_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
GetSvgFontInfo(value, aOwnerEl.fDrawData.FontInfo);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure FontFamily_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
word: UTF8String;
|
|
c, endC: PUTF8Char;
|
|
begin
|
|
with aOwnerEl.fDrawData.FontInfo do
|
|
begin
|
|
family := ttfUnknown;
|
|
c := PUTF8Char(value);
|
|
endC := c + Length(value);
|
|
while ParseNextWordEx(c, endC, word) do
|
|
begin
|
|
case GetHash(word) of
|
|
hSans_045_Serif, hArial : family := ttfSansSerif;
|
|
hSerif, hTimes: family := ttfSerif;
|
|
hMonospace: family := ttfMonospace;
|
|
else Continue;
|
|
end;
|
|
break;
|
|
end;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure FontSize_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
num: double;
|
|
c, endC: PUTF8Char;
|
|
begin
|
|
c := PUTF8Char(value); endC := c + Length(value);
|
|
if not ParseNextNum(c, endC, false, num) then Exit;
|
|
aOwnerEl.fDrawData.FontInfo.size := num;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure FontStyle_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
with aOwnerEl.fDrawData.FontInfo do
|
|
if GetHash(value) = hItalic then
|
|
italic := sfsItalic else
|
|
italic := sfsNone;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure FontWeight_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
|
|
var
|
|
num: double;
|
|
word: UTF8String;
|
|
c, endC: PUTF8Char;
|
|
begin
|
|
c := PUTF8Char(value);
|
|
endC := c + Length(value);
|
|
with aOwnerEl.fDrawData.FontInfo do
|
|
begin
|
|
if IsNumPending(c, endC, false) and
|
|
ParseNextNum(c, endC, false, num) then
|
|
weight := Round(num)
|
|
else if ParseNextWord(c, endC, word) then
|
|
case GetHash(word) of
|
|
hBold : weight := 600;
|
|
hNormal : weight := 400;
|
|
hBolder : if weight >= 0 then weight := Min(900, weight + 200)
|
|
else weight := 600;
|
|
hLighter: if weight >= 0 then weight := Max(0, weight - 200)
|
|
else weight := 200;
|
|
|
|
end;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Fx_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if (aOwnerEl is TRadGradElement) then
|
|
with TRadGradElement(aOwnerEl) do
|
|
begin
|
|
UTF8StringToFloatEx(value, F.X.rawVal, F.X.unitType);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Fy_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if (aOwnerEl is TRadGradElement) then
|
|
with TRadGradElement(aOwnerEl) do
|
|
begin
|
|
UTF8StringToFloatEx(value, F.Y.rawVal, F.Y.unitType);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TextAlign_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
with aOwnerEl.fDrawData.FontInfo do
|
|
case GetHash(value) of
|
|
hMiddle : align := staCenter;
|
|
hEnd : align := staRight;
|
|
else align := staLeft;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TextDecoration_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
with aOwnerEl.fDrawData.FontInfo do
|
|
case GetHash(value) of
|
|
hUnderline : decoration := fdUnderline;
|
|
hline_045_through : decoration := fdStrikeThrough;
|
|
else decoration := fdNone;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TextLength_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
UTF8StringToFloat(value, aOwnerEl.fDrawData.FontInfo.textLength);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
procedure MarkerStart_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if not (aOwnerEl is TShapeElement) then Exit;
|
|
aOwnerEl.fDrawData.markerStart := ExtractRef(value);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure MarkerMiddle_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if not (aOwnerEl is TShapeElement) then Exit;
|
|
aOwnerEl.fDrawData.markerMiddle := ExtractRef(value);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure MarkerEnd_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if not (aOwnerEl is TShapeElement) then Exit;
|
|
aOwnerEl.fDrawData.markerEnd := ExtractRef(value);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Filter_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if (aOwnerEl is TShapeElement) then
|
|
aOwnerEl.fDrawData.filterElRef := ExtractRef(value);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Mask_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if (aOwnerEl is TShapeElement) then
|
|
aOwnerEl.fDrawData.maskElRef := ExtractRef(value);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Offset_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
val: TValue;
|
|
begin
|
|
if (aOwnerEl is TGradStopElement) then
|
|
with TGradStopElement(aOwnerEl) do
|
|
begin
|
|
val.Init;
|
|
UTF8StringToFloatEx(value, val.rawVal, val.unitType);
|
|
offset := val.GetValue(1, GetRelFracLimit);
|
|
end
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Opacity_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
opacity: double;
|
|
begin
|
|
if not UTF8StringToFloat(value, opacity) then Exit;
|
|
if opacity < 0 then opacity := 0
|
|
else if opacity > 1 then opacity := 1;
|
|
aOwnerEl.fDrawData.opacity := Round(opacity * 255);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Operator_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if (aOwnerEl is TFeCompositeElement) then
|
|
with TFeCompositeElement(aOwnerEl) do
|
|
case GetHash(value) of
|
|
hAtop : compositeOp := coAtop;
|
|
hIn : compositeOp := coIn;
|
|
hOut : compositeOp := coOut;
|
|
hOver : compositeOp := coOver;
|
|
hXor : compositeOp := coXor;
|
|
hArithmetic : compositeOp := coArithmetic;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Orient_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if (aOwnerEl is TMarkerElement) and
|
|
(GetHash(value) = hauto_045_start_045_reverse) then
|
|
TMarkerElement(aOwnerEl).autoStartReverse := true;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure StopColor_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
acolor: TColor32;
|
|
begin
|
|
if aOwnerEl is TGradStopElement then
|
|
begin
|
|
acolor := clInvalid;
|
|
UTF8StringToColor32(value, acolor);
|
|
with TGradStopElement(aOwnerEl) do
|
|
if acolor = clCurrent then
|
|
color := aOwnerEl.fReader.currentColor else
|
|
color := acolor;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure StopOpacity_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if aOwnerEl is TGradStopElement then
|
|
UTF8StringToOpacity(value, TGradStopElement(aOwnerEl).color);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Points_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if aOwnerEl is TPolyElement then
|
|
TPolyElement(aOwnerEl).ParsePoints(value);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Stroke_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if Match(PUTF8Char(value), 'url(') then
|
|
aOwnerEl.fDrawData.strokeEl := ExtractRef(value)
|
|
else
|
|
UTF8StringToColor32(value, aOwnerEl.fDrawData.strokeColor);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure StrokeLineCap_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
word: UTF8String;
|
|
c, endC: PUTF8Char;
|
|
begin
|
|
c := PUTF8Char(value);
|
|
endC := c + Length(value);
|
|
ParseNextWord(c, endC, word);
|
|
with aOwnerEl.fDrawData do
|
|
case GetHash(word) of
|
|
hButt : strokeCap := esButt;
|
|
hRound : strokeCap := esRound;
|
|
hSquare : strokeCap := esSquare;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure StrokeLineJoin_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
word: UTF8String;
|
|
c, endC: PUTF8Char;
|
|
begin
|
|
c := PUTF8Char(value);
|
|
endC := c + Length(value);
|
|
ParseNextWord(c, endC, word);
|
|
with aOwnerEl.fDrawData do
|
|
case GetHash(word) of
|
|
hMiter : strokeJoin := jsMiter;
|
|
hRound : strokeJoin := jsRound;
|
|
hBevel : strokeJoin := jsSquare;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure StrokeMiterLimit_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
UTF8StringToFloat(value, aOwnerEl.fDrawData.strokeMitLim);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure StrokeOpacity_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloat(value, val);
|
|
aOwnerEl.fDrawData.strokeOpacity := ClampRange(val, 0,1);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure StrokeWidth_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
with aOwnerEl do
|
|
begin
|
|
UTF8StringToFloatEx(value, fDrawData.strokewidth.rawVal,
|
|
fDrawData.strokewidth.unitType);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure FillRule_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if LowerCaseTable[value[1]] = 'e' then
|
|
aOwnerEl.fDrawData.fillRule := frEvenOdd else
|
|
aOwnerEl.fDrawData.fillRule := frNonZero;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Transform_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
with aOwnerEl.fDrawData do
|
|
matrix := MatrixMultiply(matrix, ParseTransform(value));
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Values_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
cnt: integer;
|
|
c, endC: PUTF8Char;
|
|
begin
|
|
if aOwnerEl is TFeColorMatrixElement then
|
|
with TFeColorMatrixElement(aOwnerEl) do
|
|
begin
|
|
SetLength(values, 20);
|
|
c := PUTF8Char(value);
|
|
endC := c + Length(value);
|
|
cnt := 0;
|
|
while (cnt < 20) and ParseNextNum(c, endC, true, values[cnt]) do
|
|
inc(cnt);
|
|
if cnt < 20 then values := nil;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure GradientTransform_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mat: TMatrixD;
|
|
begin
|
|
if not (aOwnerEl is TGradientElement) then Exit;
|
|
mat := ParseTransform(value);
|
|
with aOwnerEl.fDrawData do
|
|
matrix := MatrixMultiply(matrix, mat);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure GradientUnits_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if aOwnerEl is TFillElement then
|
|
with TFillElement(aOwnerEl) do
|
|
units := GetHash(value);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Viewbox_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
|
|
function LoadViewbox: TRectWH;
|
|
var
|
|
c, endC: PUTF8Char;
|
|
begin
|
|
c := PUTF8Char(value);
|
|
endC := c + Length(value);
|
|
with Result do
|
|
if not ParseNextNum(c, endC, false, Left) or
|
|
not ParseNextNum(c, endC, true, Top) or
|
|
not ParseNextNum(c, endC, true, Width) or
|
|
not ParseNextNum(c, endC, true, Height) then
|
|
Result := RectWH(0,0,0,0);
|
|
end;
|
|
|
|
begin
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hSvg : TSvgRootElement(aOwnerEl).viewboxWH := LoadViewbox;
|
|
hMarker : TMarkerElement(aOwnerEl).markerBoxWH := LoadViewbox;
|
|
hSymbol : TSymbolElement(aOwnerEl).viewboxWH := LoadViewbox;
|
|
else if aOwnerEl is TPatternElement then
|
|
TPatternElement(aOwnerEl).pattBoxWH := LoadViewbox;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Height_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
with aOwnerEl do
|
|
begin
|
|
elRectWH.height.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Width_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
with aOwnerEl do
|
|
begin
|
|
elRectWH.width.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Cx_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hCircle:
|
|
with TCircleElement(aOwnerEl) do centerPt.X.SetValue(val, mu);
|
|
hEllipse:
|
|
with TEllipseElement(aOwnerEl) do centerPt.X.SetValue(val, mu);
|
|
hRadialGradient:
|
|
with TRadGradElement(aOwnerEl) do
|
|
begin
|
|
C.X.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Cy_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hCircle:
|
|
with TCircleElement(aOwnerEl) do centerPt.Y.SetValue(val, mu);
|
|
hEllipse:
|
|
with TEllipseElement(aOwnerEl) do centerPt.Y.SetValue(val, mu);
|
|
hRadialGradient:
|
|
with TRadGradElement(aOwnerEl) do
|
|
begin
|
|
C.Y.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Dx_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hfeDropShadow:
|
|
TFeDropShadowElement(aOwnerEl).offset.X.SetValue(val, mu);
|
|
hfeOffset:
|
|
TFeOffsetElement(aOwnerEl).offset.X.SetValue(val, mu);
|
|
hText, hTSpan:
|
|
TTextElement(aOwnerEl).offset.X.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Dy_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hfeDropShadow:
|
|
TFeDropShadowElement(aOwnerEl).offset.Y.SetValue(val, mu);
|
|
hfeOffset:
|
|
TFeOffsetElement(aOwnerEl).offset.Y.SetValue(val, mu);
|
|
hText, hTSpan:
|
|
TTextElement(aOwnerEl).offset.Y.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Result_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
begin
|
|
if (aOwnerEl is TFeBaseElement) then
|
|
TFeBaseElement(aOwnerEl).res := ExtractRef(value);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Rx_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hRect:
|
|
with TRectElement(aOwnerEl) do
|
|
begin
|
|
radius.X.SetValue(val, mu);
|
|
end;
|
|
hCircle:
|
|
with TCircleElement(aOwnerEl) do
|
|
begin
|
|
radius.SetValue(val, mu);
|
|
end;
|
|
hEllipse:
|
|
with TEllipseElement(aOwnerEl) do
|
|
begin
|
|
radius.X.SetValue(val, mu);
|
|
end;
|
|
hRadialGradient:
|
|
with TRadGradElement(aOwnerEl) do
|
|
begin
|
|
radius.X. SetValue(val, mu);
|
|
radius.Y. SetValue(val, mu);
|
|
end;
|
|
hMarker:
|
|
with TMarkerElement(aOwnerEl) do
|
|
refPt.X.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Ry_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hRect:
|
|
with TRectElement(aOwnerEl) do
|
|
begin
|
|
radius.Y.SetValue(val, mu);
|
|
end;
|
|
hEllipse:
|
|
with TEllipseElement(aOwnerEl) do
|
|
begin
|
|
radius.Y.SetValue(val, mu);
|
|
end;
|
|
hMarker:
|
|
with TMarkerElement(aOwnerEl) do refPt.Y.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure SpreadMethod_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
word: UTF8String;
|
|
c, endC: PUTF8Char;
|
|
begin
|
|
if not (aOwnerEl is TGradientElement) then Exit;
|
|
c := PUTF8Char(value);
|
|
endC := c + Length(value);
|
|
ParseNextWord(c, endC, word);
|
|
with TGradientElement(aOwnerEl) do
|
|
case GetHash(word) of
|
|
hPad : spreadMethod := gfsClamp;
|
|
hReflect : spreadMethod := gfsMirror;
|
|
hRepeat : spreadMethod := gfsRepeat;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure SpectacularExponent(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
se: double;
|
|
begin
|
|
if not (aOwnerEl is TFeSpecLightElement) then Exit;
|
|
UTF8StringToFloat(value, se);
|
|
if (se > 0) and (se < 100) then
|
|
TFeSpecLightElement(aOwnerEl).exponent := se;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure StdDev_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
sd: double;
|
|
begin
|
|
UTF8StringToFloat(value, sd);
|
|
if (sd < 0) and (sd > 100) then Exit;
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hfeGaussianBlur:
|
|
TFeGaussElement(aOwnerEl).stdDev := sd;
|
|
hfeDropShadow:
|
|
TFeDropShadowElement(aOwnerEl).stdDev := sd;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure K1_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloat(value, val);
|
|
if aOwnerEl is TFeCompositeElement then
|
|
TFeCompositeElement(aOwnerEl).fourKs[0] := val;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure K2_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloat(value, val);
|
|
if aOwnerEl is TFeCompositeElement then
|
|
TFeCompositeElement(aOwnerEl).fourKs[1] := val;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure K3_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloat(value, val);
|
|
if aOwnerEl is TFeCompositeElement then
|
|
TFeCompositeElement(aOwnerEl).fourKs[2] := val;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure K4_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloat(value, val);
|
|
if aOwnerEl is TFeCompositeElement then
|
|
TFeCompositeElement(aOwnerEl).fourKs[3] := val;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure X1_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hLine:
|
|
TLineElement(aOwnerEl).path[0].X := val;
|
|
hLinearGradient:
|
|
with TLinGradElement(aOwnerEl) do
|
|
begin
|
|
startPt.X.SetValue(val, mu);
|
|
end;
|
|
hFilter:
|
|
with aOwnerEl do
|
|
begin
|
|
elRectWH.left.SetValue(val, mu);
|
|
end;
|
|
else
|
|
aOwnerEl.elRectWH.left.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure X2_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hLine:
|
|
TLineElement(aOwnerEl).path[1].X := val;
|
|
hLinearGradient:
|
|
with TLinGradElement(aOwnerEl) do
|
|
begin
|
|
endPt.X.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Y1_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hLine:
|
|
TLineElement(aOwnerEl).path[0].Y := val;
|
|
hLinearGradient:
|
|
with TLinGradElement(aOwnerEl) do
|
|
begin
|
|
startPt.Y.SetValue(val, mu);
|
|
end;
|
|
hFilter:
|
|
with aOwnerEl do
|
|
begin
|
|
elRectWH.top.SetValue(val, mu);
|
|
end;
|
|
else
|
|
aOwnerEl.elRectWH.top.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Y2_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
mu: TUnitType;
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloatEx(value, val, mu);
|
|
case aOwnerEl.fParserEl.Hash of
|
|
hLine:
|
|
TLineElement(aOwnerEl).path[1].Y := val;
|
|
hLinearGradient:
|
|
with TLinGradElement(aOwnerEl) do
|
|
begin
|
|
endPt.Y.SetValue(val, mu);
|
|
end;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure Z_Attrib(aOwnerEl: TSvgElement; const value: UTF8String);
|
|
var
|
|
val: double;
|
|
begin
|
|
UTF8StringToFloat(value, val);
|
|
if aOwnerEl is TFePointLightElement then
|
|
TFePointLightElement(aOwnerEl).z := val;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TSvgElement.LoadAttribute(attrib: PSvgAttrib);
|
|
begin
|
|
with attrib^ do
|
|
case hash of
|
|
hbaseline_045_shift: BaselineShift_Attrib(self, value);
|
|
hColor: Color_Attrib(self, value);
|
|
hClip_045_path: ClipPath_Attrib(self, value);
|
|
hCx: Cx_Attrib(self, value);
|
|
hCy: Cy_Attrib(self, value);
|
|
hD: D_Attrib(self, value);
|
|
hDisplay: Display_Attrib(self, value);
|
|
hDx: Dx_Attrib(self, value);
|
|
hDy: Dy_Attrib(self, value);
|
|
hStroke_045_DashArray: DashArray_Attrib(self, value);
|
|
hStroke_045_DashOffset: DashOffset_Attrib(self, value);
|
|
hFill: Fill_Attrib(self, value);
|
|
hFill_045_Opacity: FillOpacity_Attrib(self, value);
|
|
hFill_045_Rule: FillRule_Attrib(self, value);
|
|
hFilter: Filter_Attrib(self, value);
|
|
hflood_045_color: Fill_Attrib(self, value);
|
|
hflood_045_opacity: FillOpacity_Attrib(self, value);
|
|
hFont: Font_Attrib(self, value);
|
|
hFont_045_Family: FontFamily_Attrib(self, value);
|
|
hFont_045_Size: FontSize_Attrib(self, value);
|
|
hFont_045_Style: FontStyle_Attrib(self, value);
|
|
hFont_045_Weight: FontWeight_Attrib(self, value);
|
|
hFx: Fx_Attrib(self, value);
|
|
hFy: Fy_Attrib(self, value);
|
|
hGradientTransform: GradientTransform_Attrib(self, value);
|
|
hGradientUnits: GradientUnits_Attrib(self, value);
|
|
hHeight: Height_Attrib(self, value);
|
|
hHref: Href_Attrib(self, value);
|
|
hId: Id_Attrib(self, value);
|
|
hIn: In_Attrib(self, value);
|
|
hIn2: In2_Attrib(self, value);
|
|
hk1: K1_Attrib(self, value);
|
|
hk2: K2_Attrib(self, value);
|
|
hk3: K3_Attrib(self, value);
|
|
hk4: K4_Attrib(self, value);
|
|
hletter_045_spacing: LetterSpacing_Attrib(self, value);
|
|
// hlighting_045_color: LightingColor_Attrib(self, value);
|
|
hMarker_045_End: MarkerEnd_Attrib(self, value);
|
|
hMarkerHeight: Height_Attrib(self, value);
|
|
hMarker_045_Mid: MarkerMiddle_Attrib(self, value);
|
|
hMarker_045_Start: MarkerStart_Attrib(self, value);
|
|
hMarkerWidth: Width_Attrib(self, value);
|
|
hMask: Mask_Attrib(self, value);
|
|
hOffset: Offset_Attrib(self, value);
|
|
hOpacity: Opacity_Attrib(self, value);
|
|
hOperator: Operator_Attrib(self, value);
|
|
hOrient: Orient_Attrib(self, value);
|
|
hPatternUnits: GradientUnits_Attrib(self, value);
|
|
hPatternTransform: Transform_Attrib(self, value);
|
|
hPoints: Points_Attrib(self, value);
|
|
hR: Rx_Attrib(self, value);
|
|
hRefX: Rx_Attrib(self, value);
|
|
hRefY: Ry_Attrib(self, value);
|
|
hResult: Result_Attrib(self, value);
|
|
hRx: Rx_Attrib(self, value);
|
|
hRy: Ry_Attrib(self, value);
|
|
hspecularExponent: SpectacularExponent(self, value);
|
|
hSpreadMethod: SpreadMethod_Attrib(self, value);
|
|
hstdDeviation: StdDev_Attrib(self, value);
|
|
hStop_045_Color: StopColor_Attrib(self, value);
|
|
hStop_045_Opacity: StopOpacity_Attrib(self, value);
|
|
hStroke: Stroke_Attrib(self, value);
|
|
hstroke_045_linecap: StrokeLineCap_Attrib(self, value);
|
|
hstroke_045_linejoin: StrokeLineJoin_Attrib(self, value);
|
|
hstroke_045_miterlimit: StrokeMiterLimit_Attrib(self, value);
|
|
hStroke_045_Opacity: StrokeOpacity_Attrib(self, value);
|
|
hStroke_045_Width: StrokeWidth_Attrib(self, value);
|
|
hText_045_Anchor: TextAlign_Attrib(self, value);
|
|
hText_045_Decoration: TextDecoration_Attrib(self, value);
|
|
hTextLength: TextLength_Attrib(self, value);
|
|
hTransform: Transform_Attrib(self, value);
|
|
hValues: Values_Attrib(self, value);
|
|
hViewbox: Viewbox_Attrib(self, value);
|
|
hWidth: Width_Attrib(self, value);
|
|
hX: X1_Attrib(self, value);
|
|
hX1: X1_Attrib(self, value);
|
|
hX2: X2_Attrib(self, value);
|
|
hXlink_058_Href: Href_Attrib(self, value);
|
|
hY: Y1_Attrib(self, value);
|
|
hY1: Y1_Attrib(self, value);
|
|
hY2: Y2_Attrib(self, value);
|
|
hZ: Z_Attrib(self, value);
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TSvgElement.LoadAttributes;
|
|
var
|
|
i: integer;
|
|
begin
|
|
for i := 0 to fParserEl.AttribCount -1 do
|
|
LoadAttribute(PSvgAttrib(fParserEl.attrib[i]));
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function PreferRelativeFraction(val: TValue): TTriState;
|
|
{$IFDEF INLINE} inline; {$ENDIF}
|
|
begin
|
|
if (val.rawVal = InvalidD) or (val.unitType = utUnknown) then
|
|
Result := tsUnknown
|
|
else if val.unitType = utPercent then Result := tsYes
|
|
else if val.unitType <> utNumber then Result := tsNo
|
|
else if (Abs(val.rawVal) < 1) then Result := tsYes
|
|
else Result := tsNo;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgElement.GetRelFracLimit: double;
|
|
begin
|
|
//the default behaviour here is to assume untyped fractional values
|
|
//below 1.0 are values relative (to the bounding size) BUT ONLY WHEN
|
|
//the parent element's width or height are relative (ie percentages).
|
|
if Assigned(fParent) and (fParent.fParserEl.hash <> hSvg) then
|
|
begin
|
|
case PreferRelativeFraction(fParent.elRectWH.width) of
|
|
tsYes: begin Result := 1.0; Exit; end;
|
|
tsNo : begin Result := 0; Exit; end;
|
|
end;
|
|
case PreferRelativeFraction(fParent.elRectWH.height) of
|
|
tsYes: begin Result := 1.0; Exit; end;
|
|
tsNo : begin Result := 0; Exit; end;
|
|
end;
|
|
end;
|
|
Result := 0;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgElement.LoadContent: Boolean;
|
|
var
|
|
i : integer;
|
|
svgEl : TSvgTreeEl;
|
|
elClass : TElementClass;
|
|
el : TSvgElement;
|
|
begin
|
|
Result := false;
|
|
for i := 0 to fParserEl.childs.Count -1 do
|
|
begin
|
|
svgEl := TSvgTreeEl(fParserEl.childs[i]);
|
|
if svgEl.hash = 0 then
|
|
Continue;
|
|
elClass := HashToElementClass(svgEl.hash);
|
|
el := elClass.Create(self, svgEl);
|
|
Self.fChilds.Add(el);
|
|
el.LoadAttributes;
|
|
if el.fParserEl.childs.Count = 0 then Continue
|
|
else if not el.LoadContent then Exit; //error
|
|
end;
|
|
Result := true;
|
|
end;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// TSvgReader
|
|
//------------------------------------------------------------------------------
|
|
|
|
constructor TSvgReader.Create;
|
|
begin
|
|
fSvgParser := TSvgParser.Create;
|
|
fClassStyles := TClassStylesList.Create;
|
|
fLinGradRenderer := TLinearGradientRenderer.Create;
|
|
fRadGradRenderer := TSvgRadialGradientRenderer.Create;
|
|
fImgRenderer := TImageRenderer.Create;
|
|
|
|
fIdList := TStringList.Create;
|
|
fIdList.Duplicates := dupIgnore;
|
|
fIdList.CaseSensitive := false;
|
|
fIdList.Sorted := True;
|
|
|
|
fBlurQuality := 1; //0: draft (faster); 1: good; 2: excellent (slow)
|
|
currentColor := clBlack32;
|
|
fUsePropScale := true;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
destructor TSvgReader.Destroy;
|
|
begin
|
|
Clear;
|
|
fSvgParser.Free;
|
|
fIdList.Free;
|
|
fClassStyles.Free;
|
|
|
|
fLinGradRenderer.Free;
|
|
fRadGradRenderer.Free;
|
|
fImgRenderer.Free;
|
|
FreeAndNil(fFontCache);
|
|
inherited;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TSvgReader.Clear;
|
|
begin
|
|
FreeAndNil(fRootElement);
|
|
fSvgParser.Clear;
|
|
fIdList.Clear;
|
|
fClassStyles.Clear;
|
|
fLinGradRenderer.Clear;
|
|
fRadGradRenderer.Clear;
|
|
fImgRenderer.Image.Clear;
|
|
currentColor := clBlack32;
|
|
userSpaceBounds := NullRectD;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgReader.GetViewbox(containerWidth, containerHeight: integer): TRectWH;
|
|
begin
|
|
if not Assigned(RootElement) then
|
|
begin
|
|
Result := RectWH(0,0,0,0);
|
|
Exit;
|
|
end;
|
|
|
|
with RootElement do
|
|
begin
|
|
Result.Left := 0;
|
|
Result.Top := 0;
|
|
Result.Width := elRectWH.width.GetValue(containerWidth, 0);
|
|
Result.Height := elRectWH.height.GetValue(containerHeight, 0);
|
|
|
|
if viewboxWH.IsEmpty then
|
|
begin
|
|
if Result.IsEmpty then
|
|
Result := RectWH(0, 0,containerWidth, containerHeight);
|
|
viewboxWH := Result;
|
|
end else if Result.IsEmpty then
|
|
Result := viewboxWH;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TSvgReader.DrawImage(img: TImage32; scaleToImage: Boolean);
|
|
var
|
|
scale, scale2: double;
|
|
vbox: TRectWH;
|
|
di: TDrawData;
|
|
begin
|
|
if not Assigned(fRootElement) or not assigned(img) then Exit;
|
|
vbox := GetViewbox(img.Width, img.Height);
|
|
if vbox.IsEmpty then Exit;
|
|
fBackgndImage := img;
|
|
|
|
with fRootElement do
|
|
begin
|
|
di := fDrawData;
|
|
if di.currentColor = clInvalid then
|
|
di.currentColor := currentColor;
|
|
|
|
MatrixTranslate(di.matrix, -viewboxWH.Left, -viewboxWH.Top);
|
|
|
|
//the width and height attributes generally indicate the size of the
|
|
//rendered image unless they are percentage values. Nevertheless, these
|
|
//values can be still overridden by the scaleToImage parameter above
|
|
|
|
if vbox.IsEmpty then
|
|
di.bounds := RectD(img.Bounds) else
|
|
di.bounds := viewboxWH.RectD;
|
|
userSpaceBounds := fDrawData.bounds;
|
|
|
|
if scaleToImage and not img.IsEmpty then
|
|
begin
|
|
//nb: the calculated vbox.width and vbox.height are ignored here since
|
|
//we're scaling the SVG image to the display image. However we still
|
|
//need to call GetViewbox (above) to make sure that viewboxWH is filled.
|
|
|
|
scale := img.width / viewboxWH.Width;
|
|
scale2 := img.height / viewboxWH.Height;
|
|
if fUsePropScale then
|
|
begin
|
|
if scale2 < scale then scale := scale2
|
|
else scale2 := scale;
|
|
end;
|
|
MatrixScale(di.matrix, scale, scale2);
|
|
img.SetSize(
|
|
Round(viewboxWH.Width * scale),
|
|
Round(viewboxWH.Height * scale2));
|
|
end else
|
|
begin
|
|
img.SetSize(Round(vbox.Width), Round(vbox.Height));
|
|
scale := vbox.Width / viewboxWH.Width;
|
|
scale2 := vbox.Height / viewboxWH.Height;
|
|
MatrixScale(di.matrix, scale, scale2);
|
|
end;
|
|
end;
|
|
|
|
if fBkgndColor <> clNone32 then
|
|
img.Clear(fBkgndColor);
|
|
|
|
img.BeginUpdate;
|
|
fTempImage := TImage32.Create(img.Width, img.Height);
|
|
try
|
|
fTempImage.BlockNotify;
|
|
fRootElement.Draw(img, di);
|
|
finally
|
|
fTempImage.Free;
|
|
img.EndUpdate;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgReader.LoadInternal: Boolean;
|
|
begin
|
|
Result := false;
|
|
if not Assigned(fSvgParser.svgTree) or
|
|
(fSvgParser.svgTree.hash <> hSvg) then Exit;
|
|
fRootElement := TSvgRootElement.Create(nil, fSvgParser.svgTree);
|
|
fRootElement.fReader := self;
|
|
fRootElement.LoadAttributes;
|
|
Result := fRootElement.LoadContent;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgReader.LoadFromFile(const filename: string): Boolean;
|
|
begin
|
|
Clear;
|
|
Result := fSvgParser.LoadFromFile(filename) and LoadInternal;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgReader.LoadFromStream(stream: TStream): Boolean;
|
|
begin
|
|
Clear;
|
|
Result := fSvgParser.LoadFromStream(stream) and LoadInternal;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgReader.LoadFromString(const str: string): Boolean;
|
|
begin
|
|
Clear;
|
|
Result := fSvgParser.LoadFromString(str) and LoadInternal;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TSvgReader.SetOverrideFillColor(color: TColor32);
|
|
var
|
|
dd: TDrawData;
|
|
begin
|
|
if not Assigned(RootElement) or (color = clNone32) then Exit;
|
|
dd := RootElement.DrawData;
|
|
dd.fillColor := color;
|
|
RootElement.DrawData := dd;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TSvgReader.SetOverrideStrokeColor(color: TColor32);
|
|
var
|
|
dd: TDrawData;
|
|
begin
|
|
if not Assigned(RootElement) or (color = clNone32) then Exit;
|
|
dd := RootElement.DrawData;
|
|
if dd.strokeColor = clInvalid then Exit;
|
|
dd.strokeColor := color;
|
|
RootElement.DrawData := dd;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgReader.FindElement(const idName: UTF8String): TSvgElement;
|
|
begin
|
|
if Assigned(RootElement) then
|
|
Result := RootElement.FindChild(idName) else
|
|
Result := nil;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TSvgReader.GetBestFontForFontCache(const svgFontInfo: TSVGFontInfo);
|
|
var
|
|
bestFontReader: TFontReader;
|
|
fi: TFontInfo;
|
|
begin
|
|
fi.fontFamily := svgFontInfo.family;
|
|
fi.faceName := ''; //just match to a family here, not to a specific facename
|
|
fi.macStyles := [];
|
|
if svgFontInfo.italic = sfsItalic then
|
|
Include(fi.macStyles, msItalic);
|
|
if svgFontInfo.weight >= 600 then
|
|
Include(fi.macStyles, msBold);
|
|
|
|
bestFontReader := FontManager.GetBestMatchFont(fi);
|
|
if not Assigned(bestFontReader) then Exit;
|
|
|
|
if Assigned(fFontCache) then
|
|
fFontCache.FontReader := bestFontReader else
|
|
fFontCache := TFontCache.Create(bestFontReader, defaultFontHeight);
|
|
|
|
fFontCache.Underlined := False;
|
|
fFontCache.StrikeOut := False;
|
|
case svgFontInfo.decoration of
|
|
fdUnderline : fFontCache.Underlined := true;
|
|
fdStrikeThrough : fFontCache.StrikeOut := true;
|
|
end;
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
procedure TSvgReader.SetBlurQuality(quality: integer);
|
|
begin
|
|
fBlurQuality := Max(0, Min(2, quality));
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
|
|
function TSvgReader.GetIsEmpty: Boolean;
|
|
begin
|
|
Result := not Assigned(fRootElement);
|
|
end;
|
|
//------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
|
|
end.
|