1667 lines
41 KiB
ObjectPascal
1667 lines
41 KiB
ObjectPascal
|
|
{******************************************}
|
|
{ }
|
|
{ FastReport VCL }
|
|
{ SVG Attributes }
|
|
{ }
|
|
{ Copyright (c) 1998-2021 }
|
|
{ by Fast Reports Inc. }
|
|
{ }
|
|
{******************************************}
|
|
unit frxSVGAttribute;
|
|
|
|
interface
|
|
|
|
{$I frx.inc}
|
|
|
|
uses
|
|
Classes, Types, Math,
|
|
frxSVGParse, frxSVGComponents, frxSVGHelpers, frxSVGColor,
|
|
frxCSSTransform, frxCSSStyle;
|
|
|
|
const
|
|
DefaultBase = -MaxSingle;
|
|
|
|
type
|
|
TSVGAttributeObj = class (TPersistent)
|
|
private
|
|
protected
|
|
FDefault: Boolean;
|
|
FTL: TCSSSVGTransformList;
|
|
|
|
FLengthPercentageAuto: TSVGLength;
|
|
FColorSWRootDefault: TSVGColorSW;
|
|
FPaintRootDefault: TSVGPaint;
|
|
|
|
procedure SetDefault; virtual;
|
|
public
|
|
destructor Destroy; override;
|
|
|
|
function IsCSS: Boolean; virtual; abstract;
|
|
function IsDefault: Boolean;
|
|
function IsPercent: Boolean; virtual; abstract;
|
|
function IsCanReadSVGValue(Style: TfrxCSSStyle): Boolean; virtual; abstract;
|
|
|
|
procedure PartToPercent; virtual; abstract;
|
|
procedure SetTransform(Matrix: TSVGTransform);
|
|
|
|
function GetAlpha: Single; virtual; abstract;
|
|
function GetBounds: TSingleBounds; virtual; abstract;
|
|
|
|
function GetLength(Base: Single = DefaultBase): Single; virtual; abstract;
|
|
function GetLengthAuto: Single; virtual; abstract;
|
|
procedure SetLengthAuto(Value: Single);
|
|
function GetLengthInherit: TSVGLengthSW; virtual; abstract;
|
|
function GetLengthList: TSingleDynArray; virtual; abstract;
|
|
function GetLengthListNoneInherit(out Value: TSingleDynArray): TSVGSpecificWord; virtual; abstract;
|
|
|
|
function GetNumber: Single; virtual; abstract;
|
|
function GetNumberSW: TNumberSW; virtual; abstract;
|
|
function GetFontWeight: TNumberSW; virtual; abstract;
|
|
|
|
function GetColorCurrent: TSVGColorSW; virtual; abstract;
|
|
function GetColorInherit: TSVGColorSW; virtual; abstract;
|
|
|
|
function GetPaint: TSVGPaint; virtual; abstract;
|
|
|
|
function GetSinglePointDynSrray: TSinglePointDynArray; virtual; abstract;
|
|
|
|
function GetSpecificWord: TSVGSpecificWord; virtual; abstract;
|
|
function GetSpecificWordSet: TSVGSpecificWordSet; virtual; abstract;
|
|
|
|
function GetString: string; virtual; abstract;
|
|
function GetStringInherit: TSVGStringSW; virtual; abstract;
|
|
function GetURI: string; virtual; abstract;
|
|
|
|
function GetPreserveAspectRatio: TSVGPreserveAspectRatio; virtual; abstract;
|
|
|
|
function GetTransform: TSVGTransform; virtual; abstract;
|
|
end;
|
|
|
|
function CreateAttribute(ElementObj: pointer; Attribute: TSVGAttribute): TSVGAttributeObj;
|
|
|
|
implementation
|
|
|
|
uses
|
|
SysUtils, Windows,
|
|
frxSVGElement, frxSVGPaint, frxSVGBase, frxSVGPath;
|
|
|
|
type
|
|
TSVGValue = (
|
|
svAlphaPercentage,
|
|
svBounds,
|
|
svColorCurrent,
|
|
svColorInherit,
|
|
svLengthPercentage,
|
|
svLengthPercentageAuto,
|
|
svLengthPercentageInherit,
|
|
svLengthPercentageList,
|
|
svLengthPercentageListNoneInherit,
|
|
svNumber,
|
|
svNumberInherit,
|
|
svNumberFontWeight,
|
|
svPaint,
|
|
svPath,
|
|
svPreserveAspectRatio,
|
|
svSinglePointList,
|
|
svSpecificWordSet,
|
|
svSpecificWord,
|
|
svString,
|
|
svStringInherit,
|
|
svTransform,
|
|
svURI
|
|
);
|
|
|
|
Tat_ = class (TSVGAttributeObj)
|
|
private
|
|
FElement: TSVGElement;
|
|
FAttribute: TSVGAttribute;
|
|
FElementObj: TSVGElementObj;
|
|
FSVGValue: TSVGValue;
|
|
protected
|
|
FLengthPercentage: TSVGLength;
|
|
FLengthPercentageRootDefault: TSVGLength;
|
|
FLengthPercentageSW: TSVGLengthSW;
|
|
FLengthLengthPercentageList: TSVGLengthArray;
|
|
FLengthPercentageListNoneInherit: TSVGLengthArraySW;
|
|
|
|
FString: string;
|
|
FStringInherit: TSVGStringSW;
|
|
FStringInheritRootDefault: TSVGStringSW;
|
|
|
|
FSpecificWord: TSVGSpecificWord;
|
|
FSpecificWordRootDefault: TSVGSpecificWord;
|
|
FSpecificWordSet: TSVGSpecificWordSet;
|
|
FSpecificWordSetRootDefault: TSVGSpecificWordSet;
|
|
|
|
FColorSW: TSVGColorSW;
|
|
|
|
FAlphaPercentage: Single;
|
|
|
|
FNumber: Single;
|
|
FNumberSW: TNumberSW;
|
|
FNumberSWRootDefault: TNumberSW;
|
|
|
|
FSinglePointList: TSinglePointDynArray;
|
|
|
|
FTransform: TSVGTransform;
|
|
|
|
FPreserveAspectRatio: TSVGPreserveAspectRatio;
|
|
|
|
FBounds: TSingleBounds;
|
|
|
|
FPaint: TSVGPaint;
|
|
|
|
FAcceptableSW: array of TSVGSpecificWord;
|
|
|
|
procedure AssignTo(Dest: TPersistent); override;
|
|
function GetBaseLength: Single;
|
|
function GetFontSize: Single; virtual;
|
|
function CalcLength(LengthPercentage: TSVGLength; Base: Single = DefaultBase): Single;
|
|
procedure ParseSpecificWord(const S: string);
|
|
procedure ParseSpecificPair(const S: string); virtual; // raise Exception
|
|
procedure UseSpecificWord(const S: string);
|
|
function IsStyleContain(Style: TfrxCSSStyle; out S: string): Boolean; virtual;
|
|
procedure CreateTransform(const S: string);
|
|
procedure SetAcceptableSW(sw: array of TSVGSpecificWord);
|
|
|
|
procedure TestValue(Value: TSVGValue);
|
|
public
|
|
constructor Create(ElementObj: TSVGElementObj; Attribute: TSVGAttribute);
|
|
|
|
function IsCSS: Boolean; override;
|
|
function IsPercent: Boolean; override;
|
|
function IsCanReadSVGValue(Style: TfrxCSSStyle): Boolean; override;
|
|
|
|
procedure PartToPercent; override;
|
|
|
|
function GetBounds: TSingleBounds; override;
|
|
function GetAlpha: Single; override;
|
|
|
|
function GetLength(Base: Single = DefaultBase): Single; override;
|
|
function GetLengthAuto: Single; override;
|
|
function GetLengthInherit: TSVGLengthSW; override;
|
|
function GetLengthList: TSingleDynArray; override;
|
|
function GetLengthListNoneInherit(out Value: TSingleDynArray): TSVGSpecificWord; override;
|
|
|
|
function GetNumber: Single; override;
|
|
function GetNumberSW: TNumberSW; override;
|
|
function GetFontWeight: TNumberSW; override;
|
|
|
|
function GetColorCurrent: TSVGColorSW; override;
|
|
function GetColorInherit: TSVGColorSW; override;
|
|
|
|
function GetPaint: TSVGPaint; override;
|
|
|
|
function GetSinglePointDynSrray: TSinglePointDynArray; override;
|
|
|
|
function GetSpecificWord: TSVGSpecificWord; override;
|
|
function GetSpecificWordSet: TSVGSpecificWordSet; override;
|
|
|
|
function GetURI: string; override;
|
|
function GetString: string; override;
|
|
function GetStringInherit: TSVGStringSW; override;
|
|
|
|
function GetPreserveAspectRatio: TSVGPreserveAspectRatio; override;
|
|
function GetTransform: TSVGTransform; override;
|
|
end;
|
|
|
|
Tat_clip_path = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_clip_rule = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_clipPathUnits = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_color = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_cx = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_cy = class (Tat_cx);
|
|
|
|
Tat_d = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_display = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_dominant_baseline = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_dx = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_dy = class (Tat_dx);
|
|
|
|
Tat_fill = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_fill_opacity = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_fill_rule = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_font_family = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_font_size = class (Tat_)
|
|
protected
|
|
function GetFontSize: Single; override;
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_font_style = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_font_weight = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_fr = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_fx = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_fy = class (Tat_fx);
|
|
|
|
Tat_gradientTransform = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_gradientUnits = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_heigth = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_href = class (Tat_)
|
|
protected
|
|
function IsStyleContain(Style: TfrxCSSStyle; out S: string): Boolean; override;
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_method = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_offset = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_opacity = class (Tat_fill_opacity);
|
|
|
|
Tat_path = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_points = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_preserveAspectRatio = class (Tat_)
|
|
protected
|
|
procedure ParseSpecificPair(const S: string); override;
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_r = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_rx = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_ry = class (Tat_rx);
|
|
|
|
Tat_side = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_spacing = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_spreadMethod = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_startOffset = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_stop_color = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_stop_opacity = class (Tat_fill_opacity);
|
|
|
|
Tat_stroke = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_stroke_dasharray = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
public
|
|
function GetLengthListNoneInherit(out Value: TSingleDynArray): TSVGSpecificWord; override;
|
|
end;
|
|
|
|
Tat_stroke_dashoffset = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_stroke_linecap = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_stroke_linejoin = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_stroke_miterlimit = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
public
|
|
function GetNumberSW: TNumberSW; override;
|
|
end;
|
|
|
|
Tat_stroke_opacity = class (Tat_fill_opacity);
|
|
|
|
Tat_stroke_width = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_systemLanguage = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_text_anchor = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_text_decoration = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_transform = class (Tat_gradientTransform)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_viewBox = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_visibility = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_width = class (Tat_heigth);
|
|
|
|
Tat_x = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_x1 = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_x2 = class (Tat_)
|
|
protected
|
|
procedure SetDefault; override;
|
|
end;
|
|
|
|
Tat_y = class (Tat_x);
|
|
|
|
Tat_y1 = class (Tat_x1);
|
|
|
|
Tat_y2 = class (Tat_y1);
|
|
|
|
{ Utility routines }
|
|
|
|
function CopyLengthArray(A: TSVGLengthArray): TSVGLengthArray;
|
|
begin
|
|
SetLength(Result, Length(A));
|
|
Move(A[0], Result[0], Length(A) * SizeOf(A[0]));
|
|
end;
|
|
|
|
function CreateAttribute(ElementObj: pointer; Attribute: TSVGAttribute): TSVGAttributeObj;
|
|
var
|
|
EO: TSVGElementObj;
|
|
begin
|
|
EO := TSVGElementObj(ElementObj);
|
|
case Attribute of
|
|
// at_class: ;
|
|
at_clip_path: Result := Tat_clip_path.Create(EO, Attribute);
|
|
at_clip_rule: Result := Tat_clip_rule.Create(EO, Attribute);
|
|
at_clipPathUnits: Result := Tat_clipPathUnits.Create(EO, Attribute);
|
|
at_color: Result := Tat_color.Create(EO, Attribute);
|
|
at_cx: Result := Tat_cx.Create(EO, Attribute);
|
|
at_cy: Result := Tat_cy.Create(EO, Attribute);
|
|
at_d: Result := Tat_d.Create(EO, Attribute);
|
|
at_display: Result := Tat_display.Create(EO, Attribute);
|
|
at_dominant_baseline: Result := Tat_dominant_baseline.Create(EO, Attribute);
|
|
at_dx: Result := Tat_dx.Create(EO, Attribute);
|
|
at_dy: Result := Tat_dy.Create(EO, Attribute);
|
|
at_fill: Result := Tat_fill.Create(EO, Attribute);
|
|
at_fill_opacity: Result := Tat_fill_opacity.Create(EO, Attribute);
|
|
at_fill_rule: Result := Tat_fill_rule.Create(EO, Attribute);
|
|
at_font_family: Result := Tat_font_family.Create(EO, Attribute);
|
|
at_font_size: Result := Tat_font_size.Create(EO, Attribute);
|
|
at_font_style: Result := Tat_font_style.Create(EO, Attribute);
|
|
at_font_weight: Result := Tat_font_weight.Create(EO, Attribute);
|
|
at_fr: Result := Tat_fr.Create(EO, Attribute);
|
|
at_fx: Result := Tat_fx.Create(EO, Attribute);
|
|
at_fy: Result := Tat_fy.Create(EO, Attribute);
|
|
at_gradientTransform: Result := Tat_gradientTransform.Create(EO, Attribute);
|
|
at_gradientUnits: Result := Tat_gradientUnits.Create(EO, Attribute);
|
|
at_height: Result := Tat_heigth.Create(EO, Attribute);
|
|
at_href: Result := Tat_href.Create(EO, Attribute);
|
|
// at_id: ;
|
|
at_method: Result := Tat_method.Create(EO, Attribute);
|
|
at_offset: Result := Tat_offset.Create(EO, Attribute);
|
|
at_opacity: Result := Tat_opacity.Create(EO, Attribute);
|
|
at_path: Result := Tat_path.Create(EO, Attribute);
|
|
at_points: Result := Tat_points.Create(EO, Attribute);
|
|
at_preserveAspectRatio: Result := Tat_preserveAspectRatio.Create(EO, Attribute);
|
|
at_r: Result := Tat_r.Create(EO, Attribute);
|
|
at_rx: Result := Tat_rx.Create(EO, Attribute);
|
|
at_ry: Result := Tat_ry.Create(EO, Attribute);
|
|
at_side: Result := Tat_side.Create(EO, Attribute);
|
|
at_spacing: Result := Tat_spacing.Create(EO, Attribute);
|
|
at_spreadMethod: Result := Tat_spreadMethod.Create(EO, Attribute);
|
|
at_startOffset: Result := Tat_startOffset.Create(EO, Attribute);
|
|
at_stop_color: Result := Tat_stop_color.Create(EO, Attribute);
|
|
at_stop_opacity: Result := Tat_stop_opacity.Create(EO, Attribute);
|
|
at_stroke: Result := Tat_stroke.Create(EO, Attribute);
|
|
at_stroke_dasharray: Result := Tat_stroke_dasharray.Create(EO, Attribute);
|
|
at_stroke_dashoffset: Result := Tat_stroke_dashoffset.Create(EO, Attribute);
|
|
at_stroke_linecap: Result := Tat_stroke_linecap.Create(EO, Attribute);
|
|
at_stroke_linejoin: Result := Tat_stroke_linejoin.Create(EO, Attribute);
|
|
at_stroke_miterlimit: Result := Tat_stroke_miterlimit.Create(EO, Attribute);
|
|
at_stroke_opacity: Result := Tat_stroke_opacity.Create(EO, Attribute);
|
|
at_stroke_width: Result := Tat_stroke_width.Create(EO, Attribute);
|
|
// at_style: ;
|
|
at_systemLanguage: Result := Tat_systemLanguage.Create(EO, Attribute);
|
|
at_text_anchor: Result := Tat_text_anchor.Create(EO, Attribute);
|
|
at_text_decoration: Result := Tat_text_decoration.Create(EO, Attribute);
|
|
at_transform: Result := Tat_transform.Create(EO, Attribute);
|
|
at_viewBox: Result := Tat_viewBox.Create(EO, Attribute);
|
|
at_visibility: Result := Tat_visibility.Create(EO, Attribute);
|
|
at_width: Result := Tat_width.Create(EO, Attribute);
|
|
at_x: Result := Tat_x.Create(EO, Attribute);
|
|
at_x1: Result := Tat_x1.Create(EO, Attribute);
|
|
at_x2: Result := Tat_x2.Create(EO, Attribute);
|
|
at_y: Result := Tat_y.Create(EO, Attribute);
|
|
at_y1: Result := Tat_y1.Create(EO, Attribute);
|
|
at_y2: Result := Tat_y2.Create(EO, Attribute);
|
|
else
|
|
raise Exception.Create('Unsupported SVG attribute: "' + SVGAttribute[Attribute].Name + '"');
|
|
end;
|
|
end;
|
|
|
|
{ Tat_ }
|
|
|
|
procedure Tat_.AssignTo(Dest: TPersistent);
|
|
var
|
|
D: Tat_;
|
|
i: Integer;
|
|
begin
|
|
if Dest is Tat_ then
|
|
begin
|
|
D := Tat_(Dest);
|
|
|
|
D.FElement := FElement;
|
|
D.FAttribute := FAttribute;
|
|
|
|
D.FDefault := FDefault;
|
|
D.FSVGValue := FSVGValue;
|
|
|
|
case FSVGValue of
|
|
svAlphaPercentage: D.FAlphaPercentage := FAlphaPercentage;
|
|
|
|
svBounds: D.FBounds := FBounds;
|
|
|
|
svColorCurrent, svColorInherit:
|
|
D.FColorSW := FColorSW;
|
|
|
|
svLengthPercentage: D.FLengthPercentage := FLengthPercentage;
|
|
svLengthPercentageAuto, svLengthPercentageInherit:
|
|
D.FLengthPercentageSW := FLengthPercentageSW;
|
|
|
|
svLengthPercentageList: D.FLengthLengthPercentageList := CopyLengthArray(FLengthLengthPercentageList);
|
|
svLengthPercentageListNoneInherit:
|
|
with D.FLengthPercentageListNoneInherit do
|
|
begin
|
|
Arr := CopyLengthArray(FLengthPercentageListNoneInherit.Arr);
|
|
SW := FLengthPercentageListNoneInherit.SW;
|
|
end;
|
|
|
|
svNumber: D.FNumber := FNumber;
|
|
svNumberInherit, svNumberFontWeight:
|
|
D.FNumberSW := FNumberSW;
|
|
|
|
svPaint: D.FPaint := FPaint;
|
|
|
|
svPath: ;
|
|
|
|
svPreserveAspectRatio: D.FPreserveAspectRatio := FPreserveAspectRatio;
|
|
|
|
svSinglePointList: D.FSinglePointList := DynArrayCopy(FSinglePointList);
|
|
|
|
svSpecificWord: D.FSpecificWord := FSpecificWord;
|
|
svSpecificWordSet: D.FSpecificWordSet := FSpecificWordSet;
|
|
|
|
svString: D.FString := FString;
|
|
svStringInherit: D.FStringInherit := FStringInherit;
|
|
|
|
svTransform:
|
|
begin
|
|
D.FTransform := FTransform;
|
|
if Assigned(FTL) then
|
|
begin
|
|
D.CreateTransform('');
|
|
for i := 0 to FTL.Count - 1 do
|
|
D.FTL.Add(FTL.CloneItem(i));
|
|
end;
|
|
end;
|
|
|
|
svURI: D.FString := FString;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function Tat_.CalcLength(LengthPercentage: TSVGLength; Base: Single = DefaultBase): Single;
|
|
begin
|
|
if LengthPercentage.SVGUnit in SVGAbsoluteUnits then
|
|
Result := LengthPercentage.Value
|
|
else if LengthPercentage.SVGUnit in SVGFontRelativeUnits then
|
|
Result := GetFontSize * LengthPercentage.Value
|
|
else if LengthPercentage.SVGUnit <> suPercent then
|
|
raise Exception.Create('Unsupported SVG unit')
|
|
else if IsSameSingle(Base, DefaultBase) then
|
|
Result := GetBaseLength * LengthPercentage.Value / 100
|
|
else // (LengthPercentage.SVGUnit = suPercent) and (Base <> DefaultBase)
|
|
Result := Base * LengthPercentage.Value / 100;
|
|
end;
|
|
|
|
constructor Tat_.Create(ElementObj: TSVGElementObj; Attribute: TSVGAttribute);
|
|
begin
|
|
FElementObj := ElementObj;
|
|
FElement := FElementObj.Element;
|
|
FAttribute := Attribute;
|
|
|
|
SetDefault;
|
|
end;
|
|
|
|
procedure Tat_.CreateTransform(const S: string);
|
|
begin
|
|
FTL.Free;
|
|
FTL := TCSSSVGTransformList.Create(S);
|
|
end;
|
|
|
|
function Tat_.GetAlpha: Single;
|
|
begin
|
|
TestValue(svAlphaPercentage);
|
|
Result := FAlphaPercentage;
|
|
end;
|
|
|
|
function Tat_.GetBaseLength: Single;
|
|
var
|
|
Direction: TSVGDirection;
|
|
begin
|
|
Direction := SVGAttribute[FAttribute].Direction;
|
|
|
|
if Direction = sdNo then
|
|
raise Exception.Create('Wrong Direction');
|
|
|
|
Result := 0.0;
|
|
if FElement in [el_linearGradient, el_radialGradient] then
|
|
case Direction of
|
|
sdHorizontal: Result := TSVGPaintServer(FElementObj).User.GetWidth;
|
|
sdVertical: Result := TSVGPaintServer(FElementObj).User.GetHeight;
|
|
sdDiagonal: Result := TSVGPaintServer(FElementObj).User.GetNormalizedDiagonal;
|
|
end
|
|
else
|
|
case Direction of
|
|
sdHorizontal: Result := FElementObj.GetHostViewBoxWidth;
|
|
sdVertical: Result := FElementObj.GetHostViewBoxHeight;
|
|
sdDiagonal: Result := FElementObj.GetHostNormalizedDiagonal;
|
|
end;
|
|
end;
|
|
|
|
function Tat_.GetBounds: TSingleBounds;
|
|
begin
|
|
TestValue(svBounds);
|
|
Result := FBounds;
|
|
end;
|
|
|
|
function Tat_.GetColorCurrent: TSVGColorSW;
|
|
begin
|
|
TestValue(svColorCurrent);
|
|
if FColorSW.SW = svg_currentcolor then
|
|
Result.SW := svg_currentcolor
|
|
else // FColorSW.SW = frx_RGBA then
|
|
Result := FColorSW;
|
|
end;
|
|
|
|
function Tat_.GetColorInherit: TSVGColorSW;
|
|
begin
|
|
TestValue(svColorInherit);
|
|
if FColorSW.SW <> svg_inherit then // FColorSW.SW = svg_RGBA
|
|
Result := FColorSW
|
|
else if FElementObj.IsRoot then
|
|
Result := FColorSWRootDefault
|
|
else
|
|
Result := SVGColorInherit;
|
|
end;
|
|
|
|
function Tat_.GetFontSize: Single;
|
|
begin
|
|
TestValue(svLengthPercentage);
|
|
Result := FElementObj.atLengthInherit(at_font_size);
|
|
end;
|
|
|
|
function Tat_.GetFontWeight: TNumberSW;
|
|
begin
|
|
TestValue(svNumberFontWeight);
|
|
if not FElementObj.IsRoot then
|
|
Result := FNumberSW
|
|
else if FNumberSW.SW = svg_inherit then
|
|
Result := FNumberSWRootDefault
|
|
else if FNumberSW.SW in [svg_bolder, svg_lighter] then
|
|
begin
|
|
Result.SW := frx_noMater;
|
|
Result.Value := RelativeFontWeight(FNumberSW.SW, FNumberSWRootDefault.Value);
|
|
end;
|
|
end;
|
|
|
|
function Tat_.GetLength(Base: Single = DefaultBase): Single;
|
|
begin
|
|
TestValue(svLengthPercentage);
|
|
Result := CalcLength(FLengthPercentage, Base);
|
|
end;
|
|
|
|
function Tat_.GetLengthAuto: Single;
|
|
begin
|
|
TestValue(svLengthPercentageAuto);
|
|
FSVGValue := svLengthPercentage;
|
|
FLengthPercentage := ToSVGLength(FLengthPercentageSW, FLengthPercentageAuto);
|
|
Result := GetLength;
|
|
FSVGValue := svLengthPercentageAuto;
|
|
end;
|
|
|
|
function Tat_.GetLengthInherit: TSVGLengthSW;
|
|
|
|
function CalcLengthSW(SL: TSVGLength): TSVGLengthSW;
|
|
begin
|
|
FLengthPercentage := SL;
|
|
FSVGValue := svLengthPercentage;
|
|
Result.Value := GetLength;
|
|
FSVGValue := svLengthPercentageInherit;
|
|
Result.SW := frx_noMater;
|
|
Result.SVGUnit := suNone;
|
|
end;
|
|
begin
|
|
TestValue(svLengthPercentageInherit);
|
|
|
|
if FLengthPercentageSW.SW <> svg_inherit then
|
|
Result := CalcLengthSW(ToSVGLength(FLengthPercentageSW))
|
|
else if FElementObj.IsRoot then
|
|
Result := CalcLengthSW(FLengthPercentageRootDefault)
|
|
else
|
|
Result := FLengthPercentageSW;
|
|
end;
|
|
|
|
function Tat_.GetLengthList: TSingleDynArray;
|
|
var
|
|
i: Integer;
|
|
begin
|
|
TestValue(svLengthPercentageList);
|
|
SetLength(Result, Length(FLengthLengthPercentageList));
|
|
for i := Low(Result) to High(Result) do
|
|
Result[i] := CalcLength(FLengthLengthPercentageList[i]);
|
|
end;
|
|
|
|
function Tat_.GetLengthListNoneInherit(out Value: TSingleDynArray): TSVGSpecificWord;
|
|
var
|
|
i: Integer;
|
|
begin
|
|
TestValue(svLengthPercentageListNoneInherit);
|
|
Result := FLengthPercentageListNoneInherit.SW;
|
|
if not (FLengthPercentageListNoneInherit.SW in [svg_inherit, svg_none]) then
|
|
begin
|
|
Result := frx_noMater;
|
|
SetLength(Value, Length(FLengthPercentageListNoneInherit.Arr));
|
|
for i := Low(Value) to High(Value) do
|
|
Value[i] := CalcLength(FLengthPercentageListNoneInherit.Arr[i]);
|
|
end
|
|
else if (FLengthPercentageListNoneInherit.SW = svg_inherit) and FElementObj.IsRoot then
|
|
Result := svg_none;
|
|
end;
|
|
|
|
function Tat_.GetNumber: Single;
|
|
begin
|
|
TestValue(svNumber);
|
|
Result := FNumber;
|
|
end;
|
|
|
|
function Tat_.GetNumberSW: TNumberSW;
|
|
begin
|
|
TestValue(svNumberInherit);
|
|
if FElementObj.IsRoot and (FNumberSW.SW = svg_inherit) then
|
|
Result := FNumberSWRootDefault
|
|
else
|
|
Result := FNumberSW;
|
|
end;
|
|
|
|
function Tat_.GetPaint: TSVGPaint;
|
|
begin
|
|
TestValue(svPaint);
|
|
if (FPaint.SW = svg_inherit) and (FElementObj.IsRoot) then
|
|
Result := FPaintRootDefault
|
|
else
|
|
Result := FPaint;
|
|
end;
|
|
|
|
function Tat_.GetPreserveAspectRatio: TSVGPreserveAspectRatio;
|
|
begin
|
|
TestValue(svPreserveAspectRatio);
|
|
Result := FPreserveAspectRatio;
|
|
end;
|
|
|
|
function Tat_.GetSinglePointDynSrray: TSinglePointDynArray;
|
|
begin
|
|
TestValue(svSinglePointList);
|
|
Result := FSinglePointList;
|
|
end;
|
|
|
|
function Tat_.GetSpecificWord: TSVGSpecificWord;
|
|
begin
|
|
TestValue(svSpecificWord);
|
|
if (FSpecificWord = svg_inherit) and FElementObj.IsRoot then
|
|
Result := FSpecificWordRootDefault
|
|
else
|
|
Result := FSpecificWord;
|
|
end;
|
|
|
|
function Tat_.GetSpecificWordSet: TSVGSpecificWordSet;
|
|
begin
|
|
TestValue(svSpecificWordSet);
|
|
if (svg_inherit in FSpecificWordSet) and FElementObj.IsRoot then
|
|
Result := FSpecificWordSetRootDefault
|
|
else
|
|
Result := FSpecificWordSet;
|
|
end;
|
|
|
|
function Tat_.GetString: string;
|
|
begin
|
|
TestValue(svString);
|
|
Result := FString;
|
|
end;
|
|
|
|
function Tat_.GetStringInherit: TSVGStringSW;
|
|
begin
|
|
TestValue(svStringInherit);
|
|
if (FStringInherit.SW = svg_inherit) and (FElementObj.IsRoot) then
|
|
Result := ToStringInherit(TSVGRootObj(FElementObj).ExternalFontName)
|
|
else
|
|
Result := FStringInherit;
|
|
end;
|
|
|
|
function Tat_.GetTransform: TSVGTransform;
|
|
var
|
|
OldAttribute: TSVGAttribute;
|
|
RawData: TSVGLengthArray;
|
|
Direction: TSVGDirectionArray;
|
|
Data: TSingleDynArray;
|
|
i: Integer;
|
|
begin
|
|
TestValue(svTransform);
|
|
if FTL = nil then
|
|
Result := tmIdentity
|
|
else
|
|
begin
|
|
FTL.GetRawData(RawData, Direction);
|
|
OldAttribute := FAttribute;
|
|
FSVGValue := svLengthPercentage;
|
|
try
|
|
SetLength(Data, Length(RawData));
|
|
for i := 0 to High(RawData) do
|
|
begin
|
|
case Direction[i] of
|
|
sdHorizontal: FAttribute := at_rx;
|
|
sdVertical: FAttribute := at_ry;
|
|
sdDiagonal: FAttribute := at_r;
|
|
else FAttribute := at_transform;
|
|
end;
|
|
FLengthPercentage := RawData[i];
|
|
Data[i] := GetLength;
|
|
end;
|
|
FTL.SetData(Data);
|
|
finally
|
|
FSVGValue := svTransform;
|
|
FAttribute := OldAttribute;
|
|
end;
|
|
Result := FTL.GetMatrix;
|
|
end;
|
|
end;
|
|
|
|
function Tat_.GetURI: string;
|
|
begin
|
|
TestValue(svURI);
|
|
Result := FString;
|
|
end;
|
|
|
|
function Tat_.IsCanReadSVGValue(Style: TfrxCSSStyle): Boolean;
|
|
var
|
|
S: string;
|
|
begin
|
|
Result := IsStyleContain(Style, {out} S);
|
|
FDefault := not Result;
|
|
if Result then
|
|
case FSVGValue of
|
|
svAlphaPercentage: ParseAlpha(S, FAlphaPercentage);
|
|
|
|
svBounds: ParseViewBox(S, FBounds);
|
|
|
|
svColorCurrent: ParseColorSW(S, svg_currentcolor, FColorSW);
|
|
svColorInherit: ParseColorSW(S, svg_inherit, FColorSW);
|
|
|
|
svLengthPercentage: ParseLength(S, FLengthPercentage);
|
|
svLengthPercentageAuto: ParseLengthSW(S, svg_auto, FLengthPercentageSW);
|
|
svLengthPercentageInherit: ParseLengthSW(S, svg_inherit, FLengthPercentageSW);
|
|
|
|
svLengthPercentageList: ParseLengthArray(S, FLengthLengthPercentageList);
|
|
svLengthPercentageListNoneInherit: ParseLengthArrayNoneInherit(S, FLengthPercentageListNoneInherit);
|
|
|
|
svNumber: ParseNumber(S, FNumber);
|
|
svNumberInherit: ParseNumberInherit(S, FNumberSW);
|
|
svNumberFontWeight: ParseFontWeight(S, FNumberSW);
|
|
|
|
svPaint: ParsePaint(S, FPaint);
|
|
|
|
svPath: ParsePath(S, FElementObj);
|
|
|
|
svPreserveAspectRatio: ParseSpecificPair(S);
|
|
|
|
svSinglePointList: ParsePoints(S, FSinglePointList);
|
|
|
|
svSpecificWord: ParseSpecificWord(S);
|
|
svSpecificWordSet: ParseTextDecorations(S, FSpecificWordSet);
|
|
|
|
svString: FString := S;
|
|
svStringInherit: ParseStringInherit(S, FStringInherit);
|
|
|
|
svTransform: CreateTransform(S);
|
|
|
|
svURI: ParseURI(S, FString);
|
|
else
|
|
raise Exception.Create('Unknown SVG Value');
|
|
end;
|
|
|
|
end;
|
|
|
|
function Tat_.IsCSS: Boolean;
|
|
begin
|
|
Result := FElement in SVGAttribute[FAttribute].CSS;
|
|
end;
|
|
|
|
function Tat_.IsPercent: Boolean;
|
|
begin
|
|
Result := (FSVGValue = svLengthPercentage) and (FLengthPercentage.SVGUnit = suPercent) or
|
|
(FSVGValue = svLengthPercentageAuto) and (FLengthPercentageSW.SVGUnit = suPercent);
|
|
end;
|
|
|
|
function Tat_.IsStyleContain(Style: TfrxCSSStyle; out S: string): Boolean;
|
|
begin
|
|
S := Style[SVGAttribute[FAttribute].Name];
|
|
Result := S <> '';
|
|
end;
|
|
|
|
procedure Tat_.ParseSpecificPair(const S: string);
|
|
begin
|
|
raise Exception.Create(SVGAttribute[FAttribute].Name + ' - Can''t parse specific value');
|
|
end;
|
|
|
|
procedure Tat_.ParseSpecificWord(const S: string);
|
|
begin
|
|
UseSpecificWord(S);
|
|
end;
|
|
|
|
procedure Tat_.PartToPercent;
|
|
begin
|
|
if (FSVGValue = svLengthPercentage) and (FLengthPercentage.SVGUnit = suNone) then
|
|
begin
|
|
FLengthPercentage.SVGUnit := suPercent;
|
|
FLengthPercentage.Value := FLengthPercentage.Value * 100.0;
|
|
end;
|
|
end;
|
|
|
|
procedure Tat_.SetAcceptableSW(sw: array of TSVGSpecificWord);
|
|
var
|
|
Len: Integer;
|
|
begin
|
|
Len := Length(sw);
|
|
SetLength(FAcceptableSW, Len);
|
|
Move(sw[0], FAcceptableSW[0], Len * SizeOf(sw[0]));
|
|
end;
|
|
|
|
procedure Tat_.TestValue(Value: TSVGValue);
|
|
begin
|
|
if FSVGValue <> Value then
|
|
raise Exception.Create('Wrong SVG Value');
|
|
end;
|
|
|
|
procedure Tat_.UseSpecificWord(const S: string);
|
|
var
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to High(FAcceptableSW) do
|
|
if S = SVGSpecificWord[FAcceptableSW[i]] then
|
|
begin
|
|
FSpecificWord := FAcceptableSW[i];
|
|
Break;
|
|
end;
|
|
end;
|
|
|
|
{ Tat_x }
|
|
|
|
procedure Tat_x.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
if FElement in [el_image, el_rect, el_svg, el_use] then
|
|
begin
|
|
FSVGValue := svLengthPercentage;
|
|
FLengthPercentage := ToSVGLength(0.0);
|
|
end
|
|
else // el_text, el_tspan:
|
|
begin
|
|
FSVGValue := svLengthPercentageList;
|
|
SetLength(FLengthLengthPercentageList, 0);
|
|
end;
|
|
end;
|
|
|
|
{ Tat_x1 }
|
|
|
|
procedure Tat_x1.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentage;
|
|
if FElement = el_line then
|
|
FLengthPercentage := ToSVGLength(0.0)
|
|
else // el_linearGradient
|
|
FLengthPercentage := ToSVGLength(0.0, suPercent);
|
|
end;
|
|
|
|
{ Tat_x2 }
|
|
|
|
procedure Tat_x2.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentage;
|
|
if FElement = el_line then
|
|
FLengthPercentage := ToSVGLength(0.0)
|
|
else // el_linearGradient
|
|
FLengthPercentage := ToSVGLength(100.0, suPercent);
|
|
end;
|
|
|
|
{ Tat_clip_path }
|
|
|
|
procedure Tat_clip_path.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svURI;
|
|
FString := '';
|
|
end;
|
|
|
|
{ Tat_clip_rule }
|
|
|
|
procedure Tat_clip_rule.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_inherit;
|
|
FSpecificWordRootDefault := svg_nonzero;
|
|
SetAcceptableSW([svg_evenodd, svg_inherit, svg_nonzero]);
|
|
end;
|
|
|
|
{ Tat_clipPathUnits }
|
|
|
|
procedure Tat_clipPathUnits.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_userSpaceOnUse;
|
|
SetAcceptableSW([svg_userSpaceOnUse, svg_objectBoundingBox]);
|
|
end;
|
|
|
|
{ Tat_color }
|
|
|
|
procedure Tat_color.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
// As a presentation attribute, it can be applied to any element, but it has no direct effect on SVG elements.
|
|
FSVGValue := svColorInherit;
|
|
FColorSW := SVGColorInherit;
|
|
FColorSWRootDefault := SVGColorSWBlack;
|
|
end;
|
|
|
|
{ Tat_cx }
|
|
|
|
procedure Tat_cx.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentage;
|
|
if FElement in [el_circle, el_ellipse] then
|
|
FLengthPercentage := ToSVGLength(0.0)
|
|
else // el_radialGradient
|
|
FLengthPercentage := ToSVGLength(50.0, suPercent);
|
|
end;
|
|
|
|
{ Tat_d }
|
|
|
|
procedure Tat_d.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svPath;
|
|
// No Value
|
|
end;
|
|
|
|
{ Tat_display }
|
|
|
|
procedure Tat_display.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_inherit;
|
|
FSpecificWordRootDefault := frx_noMater; // Any value other than none or inherit indicates that the given element will be rendered
|
|
SetAcceptableSW([svg_inherit, svg_none]);
|
|
end;
|
|
|
|
{ Tat_dominant_baseline }
|
|
|
|
procedure Tat_dominant_baseline.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_auto;
|
|
end;
|
|
|
|
{ Tat_dx }
|
|
|
|
procedure Tat_dx.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentageList;
|
|
SetLength(FLengthLengthPercentageList, 0);
|
|
end;
|
|
|
|
{ Tat_fill }
|
|
|
|
procedure Tat_fill.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svPaint;
|
|
FPaint := SVGPaintInherit;
|
|
FPaintRootDefault := DefaultFill;
|
|
end;
|
|
|
|
{ Tat_fill_opacity }
|
|
|
|
procedure Tat_fill_opacity.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svAlphaPercentage;
|
|
FAlphaPercentage := 1.0;
|
|
end;
|
|
|
|
{ Tat_fill_rule }
|
|
|
|
procedure Tat_fill_rule.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_inherit;
|
|
FSpecificWordRootDefault := svg_nonzero;
|
|
SetAcceptableSW([svg_evenodd, svg_inherit, svg_nonzero]);
|
|
end;
|
|
|
|
{ Tat_font_family }
|
|
|
|
procedure Tat_font_family.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svStringInherit;
|
|
FStringInherit.SW := svg_inherit;
|
|
FStringInheritRootDefault := ToStringInherit('times');
|
|
end;
|
|
|
|
{ Tat_font_size }
|
|
|
|
function Tat_font_size.GetFontSize: Single;
|
|
begin
|
|
TestValue(svLengthPercentage);
|
|
if FElementObj.IsRoot then
|
|
Result := TSVGRootObj(FElementObj).ExternalFontSize
|
|
else
|
|
Result := FElementObj.Parent.atLengthInherit(at_font_size);
|
|
end;
|
|
|
|
procedure Tat_font_size.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentageInherit;
|
|
FLengthPercentageSW.SW := svg_inherit;
|
|
FLengthPercentageRootDefault := ToSVGLength(1.0, suEM);
|
|
end;
|
|
|
|
{ Tat_font_style }
|
|
|
|
procedure Tat_font_style.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_inherit;
|
|
FSpecificWordRootDefault := svg_normal;
|
|
SetAcceptableSW([svg_inherit, svg_italic, svg_normal, svg_oblique]);
|
|
end;
|
|
|
|
{ Tat_font_weight }
|
|
|
|
procedure Tat_font_weight.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svNumberFontWeight;
|
|
FNumberSW.SW := svg_inherit;
|
|
FNumberSWRootDefault.SW := frx_noMater;
|
|
FNumberSWRootDefault.Value := FW_NORMAL;
|
|
end;
|
|
|
|
{ Tat_fr }
|
|
|
|
procedure Tat_fr.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentage;
|
|
FLengthPercentage := ToSVGLength(0.0);
|
|
end;
|
|
|
|
{ Tat_fx }
|
|
|
|
procedure Tat_fx.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentage;
|
|
FLengthPercentage := ToSVGLength(50.0, suPercent);
|
|
end;
|
|
|
|
{ Tat_gradientTransform }
|
|
|
|
procedure Tat_gradientTransform.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svTransform;
|
|
FTransform := tmIdentity;
|
|
end;
|
|
|
|
{ Tat_gradientUnits }
|
|
|
|
procedure Tat_gradientUnits.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_objectBoundingBox;
|
|
SetAcceptableSW([svg_userSpaceOnUse, svg_objectBoundingBox]);
|
|
end;
|
|
|
|
{ Tat_href }
|
|
|
|
function Tat_href.IsStyleContain(Style: TfrxCSSStyle; out S: string): Boolean;
|
|
begin
|
|
S := Style[SVGAttribute[FAttribute].Name];
|
|
if S = '' then
|
|
S := Style['xlink:' + SVGAttribute[FAttribute].Name]; // Deprecated
|
|
Result := S <> '';
|
|
end;
|
|
|
|
procedure Tat_href.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svString;
|
|
FString := '';
|
|
end;
|
|
|
|
{ Tat_method }
|
|
|
|
procedure Tat_method.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_align;
|
|
end;
|
|
|
|
{ Tat_offset }
|
|
|
|
procedure Tat_offset.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svAlphaPercentage;
|
|
FAlphaPercentage := 0.0;
|
|
end;
|
|
|
|
{ Tat_path }
|
|
|
|
procedure Tat_path.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svString;
|
|
FString := '';
|
|
end;
|
|
|
|
{ Tat_points }
|
|
|
|
procedure Tat_points.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSinglePointList;
|
|
SetLength(FSinglePointList, 0);
|
|
end;
|
|
|
|
{ TpreserveAspectRatio }
|
|
|
|
procedure Tat_preserveAspectRatio.ParseSpecificPair(const S: string);
|
|
begin
|
|
ParsePreserveAspectRatio(S, FPreserveAspectRatio);
|
|
end;
|
|
|
|
procedure Tat_preserveAspectRatio.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svPreserveAspectRatio;
|
|
FPreserveAspectRatio.Align := svg_xMidYMid;
|
|
FPreserveAspectRatio.MeetOrSlice := svg_meet;
|
|
end;
|
|
|
|
{ Tat_r }
|
|
|
|
procedure Tat_r.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentage;
|
|
if FElement = el_circle then
|
|
FLengthPercentage := ToSVGLength(0.0)
|
|
else // el_radialGradient
|
|
FLengthPercentage := ToSVGLength(50.0, suPercent);
|
|
end;
|
|
|
|
{ Tat_rx }
|
|
|
|
procedure Tat_rx.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentageAuto;
|
|
FLengthPercentageSW.SW := svg_auto;
|
|
FLengthPercentageAuto := ToSVGLength(0.0);
|
|
end;
|
|
|
|
{ Tat_side }
|
|
|
|
procedure Tat_side.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_left;
|
|
end;
|
|
|
|
{ Tat_spacing }
|
|
|
|
procedure Tat_spacing.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_exact;
|
|
end;
|
|
|
|
{ Tat_spreadMethod }
|
|
|
|
procedure Tat_spreadMethod.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_pad;
|
|
SetAcceptableSW([svg_pad, svg_reflect, svg_repeat]);
|
|
end;
|
|
|
|
{ Tat_startOffset }
|
|
|
|
procedure Tat_startOffset.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentage;
|
|
FLengthPercentage := ToSVGLength(0.0);
|
|
end;
|
|
|
|
{ Tat_stop_color }
|
|
|
|
procedure Tat_stop_color.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svColorCurrent;
|
|
FColorSW.SW := svg_currentcolor;
|
|
end;
|
|
|
|
{ Tat_stroke }
|
|
|
|
procedure Tat_stroke.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svPaint;
|
|
FPaint := SVGPaintInherit;
|
|
FPaintRootDefault := DefaultStroke;
|
|
end;
|
|
|
|
{ Tat_stroke_dasharray }
|
|
|
|
function Tat_stroke_dasharray.GetLengthListNoneInherit(out Value: TSingleDynArray): TSVGSpecificWord;
|
|
var
|
|
Len: Integer;
|
|
begin
|
|
Result := inherited GetLengthListNoneInherit(Value);
|
|
if (Result = frx_noMater) and Odd(Length(Value)) then // duplicate
|
|
begin
|
|
Len := Length(Value);
|
|
SetLength(Value, 2 * Len);
|
|
Move(Value[0], Value[Len], SizeOf(Value[0]) * Len);
|
|
end;
|
|
end;
|
|
|
|
procedure Tat_stroke_dasharray.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentageListNoneInherit;
|
|
FLengthPercentageListNoneInherit.SW := svg_inherit;
|
|
end;
|
|
|
|
{ Tat_stroke_dashoffset }
|
|
|
|
procedure Tat_stroke_dashoffset.SetDefault;
|
|
begin
|
|
// The offset is usually expressed in user units resolved against the pathLength but if a <percentage> is used, the value is resolved as a percentage of the current viewport.
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentageInherit;
|
|
FLengthPercentageSW.SW := svg_inherit;
|
|
FLengthPercentageRootDefault := ToSVGLength(0.0);
|
|
end;
|
|
|
|
{ Tat_stroke_linecap }
|
|
|
|
procedure Tat_stroke_linecap.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_inherit;
|
|
FSpecificWordRootDefault := svg_butt;
|
|
SetAcceptableSW([svg_butt, svg_inherit, svg_round, svg_square]);
|
|
end;
|
|
|
|
{ Tat_stroke_linejoin }
|
|
|
|
procedure Tat_stroke_linejoin.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_inherit;
|
|
FSpecificWordRootDefault := svg_miter;
|
|
SetAcceptableSW([svg_arcs, svg_bevel, svg_inherit, svg_miter, svg_miter_clip, svg_round]);
|
|
end;
|
|
|
|
{ Tat_stroke_miterlimit }
|
|
|
|
function Tat_stroke_miterlimit.GetNumberSW: TNumberSW;
|
|
begin
|
|
Result := inherited GetNumberSW;
|
|
Result.Value := Max(1.0, Result.Value); // The value of stroke-miterlimit must be greater than or equal to 1.
|
|
end;
|
|
|
|
procedure Tat_stroke_miterlimit.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svNumberInherit;
|
|
FNumberSW.SW := svg_inherit;
|
|
FNumberSWRootDefault.SW := frx_noMater;
|
|
FNumberSWRootDefault.Value := 4.0;
|
|
end;
|
|
|
|
{ Tat_stroke_width }
|
|
|
|
procedure Tat_stroke_width.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentageInherit;
|
|
FLengthPercentageSW.SW := svg_inherit;
|
|
FLengthPercentageRootDefault := ToSVGLength(1.0);
|
|
end;
|
|
|
|
{ Tat_transform }
|
|
|
|
procedure Tat_transform.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svTransform;
|
|
end;
|
|
|
|
{ Tat_viewBox }
|
|
|
|
procedure Tat_viewBox.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svBounds;
|
|
// No default
|
|
end;
|
|
|
|
{ Tat_visibility }
|
|
|
|
procedure Tat_visibility.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
// As a presentation attribute, it can be applied to any element but it has effect only on the following nineteen elements...
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_visible;
|
|
SetAcceptableSW([svg_hidden, svg_collapse, svg_visible]);
|
|
end;
|
|
|
|
{ Tat_heigth }
|
|
|
|
procedure Tat_heigth.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svLengthPercentageAuto;
|
|
FLengthPercentageSW.SW := svg_auto;
|
|
if FElement = el_svg then
|
|
FLengthPercentageAuto := ToSVGLength(100.0, suPercent)
|
|
else if FElement in [el_rect, el_use] then
|
|
FLengthPercentageAuto := ToSVGLength(0.0);
|
|
end;
|
|
|
|
{ TSVGAttributeObj }
|
|
|
|
destructor TSVGAttributeObj.Destroy;
|
|
begin
|
|
FTL.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
function TSVGAttributeObj.IsDefault: Boolean;
|
|
begin
|
|
Result := FDefault;
|
|
end;
|
|
|
|
procedure TSVGAttributeObj.SetDefault;
|
|
begin
|
|
FDefault := True;
|
|
end;
|
|
|
|
procedure TSVGAttributeObj.SetLengthAuto(Value: Single);
|
|
begin
|
|
FLengthPercentageAuto := ToSVGLength(Value);
|
|
end;
|
|
|
|
procedure TSVGAttributeObj.SetTransform(Matrix: TSVGTransform);
|
|
begin
|
|
FTL.Free;
|
|
FTL := TCSSSVGTransformList.Create('');
|
|
FTL.SetTransform(Matrix);
|
|
end;
|
|
|
|
{ Tat_text_decoration }
|
|
|
|
procedure Tat_text_decoration.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWordSet;
|
|
FSpecificWordSet := [svg_inherit];
|
|
FSpecificWordSetRootDefault := [];
|
|
end;
|
|
|
|
{ Tat_systemLanguage }
|
|
|
|
procedure Tat_systemLanguage.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svString;
|
|
FString := '';
|
|
end;
|
|
|
|
{ Tat_text_anchor }
|
|
|
|
procedure Tat_text_anchor.SetDefault;
|
|
begin
|
|
inherited SetDefault;
|
|
|
|
FSVGValue := svSpecificWord;
|
|
FSpecificWord := svg_inherit;
|
|
FSpecificWordRootDefault := svg_start;
|
|
SetAcceptableSW([svg_end, svg_inherit, svg_middle, svg_start]);
|
|
end;
|
|
|
|
end.
|
|
|