2009 lines
54 KiB
Plaintext
2009 lines
54 KiB
Plaintext
unit VML;
|
|
interface
|
|
uses DocxML;
|
|
|
|
type Shapetype = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: Shapetype);override;
|
|
public
|
|
// attributes property
|
|
property AnchorId read ReadXmlAttrAnchorId write WriteXmlAttrAnchorId;
|
|
property Id read ReadXmlAttrId write WriteXmlAttrId;
|
|
property Coordsize read ReadXmlAttrCoordsize write WriteXmlAttrCoordsize;
|
|
property Spt read ReadXmlAttrSpt write WriteXmlAttrSpt;
|
|
property Adj read ReadXmlAttrAdj write WriteXmlAttrAdj;
|
|
property Preferrelative read ReadXmlAttrPreferrelative write WriteXmlAttrPreferrelative;
|
|
property Path read ReadXmlAttrPath write WriteXmlAttrPath;
|
|
property Filled read ReadXmlAttrFilled write WriteXmlAttrFilled;
|
|
property Stroked read ReadXmlAttrStroked write WriteXmlAttrStroked;
|
|
function ReadXmlAttrAnchorId();
|
|
function WriteXmlAttrAnchorId(_value);
|
|
function ReadXmlAttrId();
|
|
function WriteXmlAttrId(_value);
|
|
function ReadXmlAttrCoordsize();
|
|
function WriteXmlAttrCoordsize(_value);
|
|
function ReadXmlAttrSpt();
|
|
function WriteXmlAttrSpt(_value);
|
|
function ReadXmlAttrAdj();
|
|
function WriteXmlAttrAdj(_value);
|
|
function ReadXmlAttrPreferrelative();
|
|
function WriteXmlAttrPreferrelative(_value);
|
|
function ReadXmlAttrPath();
|
|
function WriteXmlAttrPath(_value);
|
|
function ReadXmlAttrFilled();
|
|
function WriteXmlAttrFilled(_value);
|
|
function ReadXmlAttrStroked();
|
|
function WriteXmlAttrStroked(_value);
|
|
|
|
// normal property
|
|
property Stroke read ReadXmlChildStroke;
|
|
property Formulas read ReadXmlChildFormulas;
|
|
property Path read ReadXmlChildPath;
|
|
property Textpath read ReadXmlChildTextpath;
|
|
property Handles read ReadXmlChildHandles;
|
|
property Lock read ReadXmlChildLock;
|
|
function ReadXmlChildStroke(): Stroke;
|
|
function ReadXmlChildFormulas(): formulas;
|
|
function ReadXmlChildPath(): Path;
|
|
function ReadXmlChildTextpath(): Textpath;
|
|
function ReadXmlChildHandles(): Handles;
|
|
function ReadXmlChildLock(): Lock;
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrAnchorId: OpenXmlAttribute;
|
|
XmlAttrId: OpenXmlAttribute;
|
|
XmlAttrCoordsize: OpenXmlAttribute;
|
|
XmlAttrSpt: OpenXmlAttribute;
|
|
XmlAttrAdj: OpenXmlAttribute;
|
|
XmlAttrPreferrelative: OpenXmlAttribute;
|
|
XmlAttrPath: OpenXmlAttribute;
|
|
XmlAttrFilled: OpenXmlAttribute;
|
|
XmlAttrStroked: OpenXmlAttribute;
|
|
|
|
// Children
|
|
XmlChildStroke: Stroke;
|
|
XmlChildFormulas: formulas;
|
|
XmlChildPath: Path;
|
|
XmlChildTextpath: Textpath;
|
|
XmlChildHandles: Handles;
|
|
XmlChildLock: Lock;
|
|
end;
|
|
|
|
type Formulas = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: Formulas);override;
|
|
public
|
|
|
|
// multi property
|
|
property Fs read ReadFs;
|
|
function ReadFs(_index);
|
|
function AddF(): Shapetype;
|
|
function AppendF(): Shapetype;
|
|
|
|
public
|
|
// Children
|
|
end;
|
|
|
|
type Lock = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: Lock);override;
|
|
public
|
|
// attributes property
|
|
property Ext read ReadXmlAttrExt write WriteXmlAttrExt;
|
|
property Aspectration read ReadXmlAttrAspectration write WriteXmlAttrAspectration;
|
|
function ReadXmlAttrExt();
|
|
function WriteXmlAttrExt(_value);
|
|
function ReadXmlAttrAspectration();
|
|
function WriteXmlAttrAspectration(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrExt: OpenXmlAttribute;
|
|
XmlAttrAspectration: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type F = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: F);override;
|
|
public
|
|
// attributes property
|
|
property Eqn read ReadXmlAttrEqn write WriteXmlAttrEqn;
|
|
function ReadXmlAttrEqn();
|
|
function WriteXmlAttrEqn(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrEqn: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type Stroke = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: Stroke);override;
|
|
public
|
|
// attributes property
|
|
property Joinstyle read ReadXmlAttrJoinstyle write WriteXmlAttrJoinstyle;
|
|
function ReadXmlAttrJoinstyle();
|
|
function WriteXmlAttrJoinstyle(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrJoinstyle: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type Path = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: Path);override;
|
|
public
|
|
// attributes property
|
|
property Extrusionok read ReadXmlAttrExtrusionok write WriteXmlAttrExtrusionok;
|
|
property Textpathok read ReadXmlAttrTextpathok write WriteXmlAttrTextpathok;
|
|
property Gradientshapeok read ReadXmlAttrGradientshapeok write WriteXmlAttrGradientshapeok;
|
|
property Connecttype read ReadXmlAttrConnecttype write WriteXmlAttrConnecttype;
|
|
property Connectlocs read ReadXmlAttrConnectlocs write WriteXmlAttrConnectlocs;
|
|
property Connectangles read ReadXmlAttrConnectangles write WriteXmlAttrConnectangles;
|
|
function ReadXmlAttrExtrusionok();
|
|
function WriteXmlAttrExtrusionok(_value);
|
|
function ReadXmlAttrTextpathok();
|
|
function WriteXmlAttrTextpathok(_value);
|
|
function ReadXmlAttrGradientshapeok();
|
|
function WriteXmlAttrGradientshapeok(_value);
|
|
function ReadXmlAttrConnecttype();
|
|
function WriteXmlAttrConnecttype(_value);
|
|
function ReadXmlAttrConnectlocs();
|
|
function WriteXmlAttrConnectlocs(_value);
|
|
function ReadXmlAttrConnectangles();
|
|
function WriteXmlAttrConnectangles(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrExtrusionok: OpenXmlAttribute;
|
|
XmlAttrTextpathok: OpenXmlAttribute;
|
|
XmlAttrGradientshapeok: OpenXmlAttribute;
|
|
XmlAttrConnecttype: OpenXmlAttribute;
|
|
XmlAttrConnectlocs: OpenXmlAttribute;
|
|
XmlAttrConnectangles: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type Textpath = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: Textpath);override;
|
|
public
|
|
// attributes property
|
|
property _On read ReadXmlAttr_On write WriteXmlAttr_On;
|
|
property Fitshape read ReadXmlAttrFitshape write WriteXmlAttrFitshape;
|
|
property Style read ReadXmlAttrStyle write WriteXmlAttrStyle;
|
|
property String read ReadXmlAttrString write WriteXmlAttrString;
|
|
function ReadXmlAttr_On();
|
|
function WriteXmlAttr_On(_value);
|
|
function ReadXmlAttrFitshape();
|
|
function WriteXmlAttrFitshape(_value);
|
|
function ReadXmlAttrStyle();
|
|
function WriteXmlAttrStyle(_value);
|
|
function ReadXmlAttrString();
|
|
function WriteXmlAttrString(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttr_On: OpenXmlAttribute;
|
|
XmlAttrFitshape: OpenXmlAttribute;
|
|
XmlAttrStyle: OpenXmlAttribute;
|
|
XmlAttrString: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type Handles = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: Handles);override;
|
|
public
|
|
|
|
// normal property
|
|
property H read ReadXmlChildH;
|
|
function ReadXmlChildH(): H;
|
|
|
|
public
|
|
// Children
|
|
XmlChildH: H;
|
|
end;
|
|
|
|
type H = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: H);override;
|
|
public
|
|
// attributes property
|
|
property Xrange read ReadXmlAttrXrange write WriteXmlAttrXrange;
|
|
property Position read ReadXmlAttrPosition write WriteXmlAttrPosition;
|
|
function ReadXmlAttrXrange();
|
|
function WriteXmlAttrXrange(_value);
|
|
function ReadXmlAttrPosition();
|
|
function WriteXmlAttrPosition(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrXrange: OpenXmlAttribute;
|
|
XmlAttrPosition: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type Shape = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: Shape);override;
|
|
public
|
|
// attributes property
|
|
property Id read ReadXmlAttrId write WriteXmlAttrId;
|
|
property Style read ReadXmlAttrStyle write WriteXmlAttrStyle;
|
|
property Spid read ReadXmlAttrSpid write WriteXmlAttrSpid;
|
|
property Type read ReadXmlAttrType write WriteXmlAttrType;
|
|
property Gfxdata read ReadXmlAttrGfxdata write WriteXmlAttrGfxdata;
|
|
property Filled read ReadXmlAttrFilled write WriteXmlAttrFilled;
|
|
property Allowincell read ReadXmlAttrAllowincell write WriteXmlAttrAllowincell;
|
|
property Fillcolor read ReadXmlAttrFillcolor write WriteXmlAttrFillcolor;
|
|
property Stroked read ReadXmlAttrStroked write WriteXmlAttrStroked;
|
|
property Ole read ReadXmlAttrOle write WriteXmlAttrOle;
|
|
function ReadXmlAttrId();
|
|
function WriteXmlAttrId(_value);
|
|
function ReadXmlAttrStyle();
|
|
function WriteXmlAttrStyle(_value);
|
|
function ReadXmlAttrSpid();
|
|
function WriteXmlAttrSpid(_value);
|
|
function ReadXmlAttrType();
|
|
function WriteXmlAttrType(_value);
|
|
function ReadXmlAttrGfxdata();
|
|
function WriteXmlAttrGfxdata(_value);
|
|
function ReadXmlAttrFilled();
|
|
function WriteXmlAttrFilled(_value);
|
|
function ReadXmlAttrAllowincell();
|
|
function WriteXmlAttrAllowincell(_value);
|
|
function ReadXmlAttrFillcolor();
|
|
function WriteXmlAttrFillcolor(_value);
|
|
function ReadXmlAttrStroked();
|
|
function WriteXmlAttrStroked(_value);
|
|
function ReadXmlAttrOle();
|
|
function WriteXmlAttrOle(_value);
|
|
|
|
// normal property
|
|
property Fill read ReadXmlChildFill;
|
|
property Textbox read ReadXmlChildTextbox;
|
|
property Textpath read ReadXmlChildTextpath;
|
|
property Imagedata read ReadXmlChildImagedata;
|
|
property Wrap read ReadXmlChildWrap;
|
|
function ReadXmlChildFill(): Fill;
|
|
function ReadXmlChildTextbox(): Textbox;
|
|
function ReadXmlChildTextpath(): Textpath;
|
|
function ReadXmlChildImagedata(): Imagedata;
|
|
function ReadXmlChildWrap(): Wrap;
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrId: OpenXmlAttribute;
|
|
XmlAttrStyle: OpenXmlAttribute;
|
|
XmlAttrSpid: OpenXmlAttribute;
|
|
XmlAttrType: OpenXmlAttribute;
|
|
XmlAttrGfxdata: OpenXmlAttribute;
|
|
XmlAttrFilled: OpenXmlAttribute;
|
|
XmlAttrAllowincell: OpenXmlAttribute;
|
|
XmlAttrFillcolor: OpenXmlAttribute;
|
|
XmlAttrStroked: OpenXmlAttribute;
|
|
XmlAttrOle: OpenXmlAttribute;
|
|
|
|
// Children
|
|
XmlChildFill: Fill;
|
|
XmlChildTextbox: Textbox;
|
|
XmlChildTextpath: Textpath;
|
|
XmlChildImagedata: Imagedata;
|
|
XmlChildWrap: Wrap;
|
|
end;
|
|
|
|
type Wrap = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: Wrap);override;
|
|
public
|
|
// attributes property
|
|
property Anchorx read ReadXmlAttrAnchorx write WriteXmlAttrAnchorx;
|
|
property Anchory read ReadXmlAttrAnchory write WriteXmlAttrAnchory;
|
|
function ReadXmlAttrAnchorx();
|
|
function WriteXmlAttrAnchorx(_value);
|
|
function ReadXmlAttrAnchory();
|
|
function WriteXmlAttrAnchory(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrAnchorx: OpenXmlAttribute;
|
|
XmlAttrAnchory: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type Fill = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: Fill);override;
|
|
public
|
|
// attributes property
|
|
property Opacity read ReadXmlAttrOpacity write WriteXmlAttrOpacity;
|
|
function ReadXmlAttrOpacity();
|
|
function WriteXmlAttrOpacity(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrOpacity: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type Imagedata = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: Imagedata);override;
|
|
public
|
|
// attributes property
|
|
property Id read ReadXmlAttrId write WriteXmlAttrId;
|
|
property Title read ReadXmlAttrTitle write WriteXmlAttrTitle;
|
|
function ReadXmlAttrId();
|
|
function WriteXmlAttrId(_value);
|
|
function ReadXmlAttrTitle();
|
|
function WriteXmlAttrTitle(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrId: OpenXmlAttribute;
|
|
XmlAttrTitle: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type Textbox = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: Textbox);override;
|
|
public
|
|
|
|
// normal property
|
|
property TxbxContent read ReadXmlChildTxbxContent;
|
|
function ReadXmlChildTxbxContent(): TxbxContent;
|
|
|
|
public
|
|
// Children
|
|
XmlChildTxbxContent: TxbxContent;
|
|
end;
|
|
|
|
type OLEObject = class(OpenXmlElement)
|
|
public
|
|
function Create();overload;
|
|
function Create(_node: XmlNode);overload;
|
|
function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
function Init();override;
|
|
function Copy(_obj: OLEObject);override;
|
|
public
|
|
// attributes property
|
|
property Type read ReadXmlAttrType write WriteXmlAttrType;
|
|
property ProgID read ReadXmlAttrProgID write WriteXmlAttrProgID;
|
|
property ShapeID read ReadXmlAttrShapeID write WriteXmlAttrShapeID;
|
|
property DrawAspect read ReadXmlAttrDrawAspect write WriteXmlAttrDrawAspect;
|
|
property ObjectID read ReadXmlAttrObjectID write WriteXmlAttrObjectID;
|
|
property Id read ReadXmlAttrId write WriteXmlAttrId;
|
|
function ReadXmlAttrType();
|
|
function WriteXmlAttrType(_value);
|
|
function ReadXmlAttrProgID();
|
|
function WriteXmlAttrProgID(_value);
|
|
function ReadXmlAttrShapeID();
|
|
function WriteXmlAttrShapeID(_value);
|
|
function ReadXmlAttrDrawAspect();
|
|
function WriteXmlAttrDrawAspect(_value);
|
|
function ReadXmlAttrObjectID();
|
|
function WriteXmlAttrObjectID(_value);
|
|
function ReadXmlAttrId();
|
|
function WriteXmlAttrId(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrType: OpenXmlAttribute;
|
|
XmlAttrProgID: OpenXmlAttribute;
|
|
XmlAttrShapeID: OpenXmlAttribute;
|
|
XmlAttrDrawAspect: OpenXmlAttribute;
|
|
XmlAttrObjectID: OpenXmlAttribute;
|
|
XmlAttrId: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
implementation
|
|
|
|
function Shapetype.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "v", "shapetype");
|
|
end;
|
|
|
|
function Shapetype.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Shapetype.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Shapetype.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"w14:anchorId": makeweakref(thisFunction(WriteXmlAttrAnchorId)),
|
|
"id": makeweakref(thisFunction(WriteXmlAttrId)),
|
|
"coordsize": makeweakref(thisFunction(WriteXmlAttrCoordsize)),
|
|
"o:spt": makeweakref(thisFunction(WriteXmlAttrSpt)),
|
|
"adj": makeweakref(thisFunction(WriteXmlAttrAdj)),
|
|
"preferrelative": makeweakref(thisFunction(WriteXmlAttrPreferrelative)),
|
|
"path": makeweakref(thisFunction(WriteXmlAttrPath)),
|
|
"filled": makeweakref(thisFunction(WriteXmlAttrFilled)),
|
|
"stroked": makeweakref(thisFunction(WriteXmlAttrStroked)),
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "stroke": array(0, makeweakref(thisFunction(ReadXmlChildStroke))),
|
|
pre + "formulas": array(1, makeweakref(thisFunction(ReadXmlChildFormulas))),
|
|
pre + "path": array(2, makeweakref(thisFunction(ReadXmlChildPath))),
|
|
pre + "textpath": array(3, makeweakref(thisFunction(ReadXmlChildTextpath))),
|
|
pre + "handles": array(4, makeweakref(thisFunction(ReadXmlChildHandles))),
|
|
"o:lock": array(5, makeweakref(thisFunction(ReadXmlChildLock))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Shapetype.Copy(_obj: Shapetype);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.AnchorId) then
|
|
{self.}AnchorId := _obj.AnchorId;
|
|
if not ifnil(_obj.Id) then
|
|
{self.}Id := _obj.Id;
|
|
if not ifnil(_obj.Coordsize) then
|
|
{self.}Coordsize := _obj.Coordsize;
|
|
if not ifnil(_obj.Spt) then
|
|
{self.}Spt := _obj.Spt;
|
|
if not ifnil(_obj.Adj) then
|
|
{self.}Adj := _obj.Adj;
|
|
if not ifnil(_obj.Preferrelative) then
|
|
{self.}Preferrelative := _obj.Preferrelative;
|
|
if not ifnil(_obj.Path) then
|
|
{self.}Path := _obj.Path;
|
|
if not ifnil(_obj.Filled) then
|
|
{self.}Filled := _obj.Filled;
|
|
if not ifnil(_obj.Stroked) then
|
|
{self.}Stroked := _obj.Stroked;
|
|
if not ifnil(_obj.XmlChildStroke) then
|
|
{self.}Stroke.Copy(_obj.XmlChildStroke);
|
|
if not ifnil(_obj.XmlChildFormulas) then
|
|
{self.}Formulas.Copy(_obj.XmlChildFormulas);
|
|
if not ifnil(_obj.XmlChildPath) then
|
|
{self.}Path.Copy(_obj.XmlChildPath);
|
|
if not ifnil(_obj.XmlChildTextpath) then
|
|
{self.}Textpath.Copy(_obj.XmlChildTextpath);
|
|
if not ifnil(_obj.XmlChildHandles) then
|
|
{self.}Handles.Copy(_obj.XmlChildHandles);
|
|
if not ifnil(_obj.XmlChildLock) then
|
|
{self.}Lock.Copy(_obj.XmlChildLock);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlAttrAnchorId();
|
|
begin
|
|
return {self.}XmlAttrAnchorId.Value;
|
|
end;
|
|
|
|
function Shapetype.WriteXmlAttrAnchorId(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrAnchorId) then
|
|
begin
|
|
{self.}XmlAttrAnchorId := new OpenXmlAttribute("w14", "anchorId", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrAnchorId;
|
|
end
|
|
{self.}XmlAttrAnchorId.Value := _value;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlAttrId();
|
|
begin
|
|
return {self.}XmlAttrId.Value;
|
|
end;
|
|
|
|
function Shapetype.WriteXmlAttrId(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrId) then
|
|
begin
|
|
{self.}XmlAttrId := new OpenXmlAttribute("", "id", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrId;
|
|
end
|
|
{self.}XmlAttrId.Value := _value;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlAttrCoordsize();
|
|
begin
|
|
return {self.}XmlAttrCoordsize.Value;
|
|
end;
|
|
|
|
function Shapetype.WriteXmlAttrCoordsize(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrCoordsize) then
|
|
begin
|
|
{self.}XmlAttrCoordsize := new OpenXmlAttribute("", "coordsize", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrCoordsize;
|
|
end
|
|
{self.}XmlAttrCoordsize.Value := _value;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlAttrSpt();
|
|
begin
|
|
return {self.}XmlAttrSpt.Value;
|
|
end;
|
|
|
|
function Shapetype.WriteXmlAttrSpt(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrSpt) then
|
|
begin
|
|
{self.}XmlAttrSpt := new OpenXmlAttribute("o", "spt", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrSpt;
|
|
end
|
|
{self.}XmlAttrSpt.Value := _value;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlAttrAdj();
|
|
begin
|
|
return {self.}XmlAttrAdj.Value;
|
|
end;
|
|
|
|
function Shapetype.WriteXmlAttrAdj(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrAdj) then
|
|
begin
|
|
{self.}XmlAttrAdj := new OpenXmlAttribute("", "adj", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrAdj;
|
|
end
|
|
{self.}XmlAttrAdj.Value := _value;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlAttrPreferrelative();
|
|
begin
|
|
return {self.}XmlAttrPreferrelative.Value;
|
|
end;
|
|
|
|
function Shapetype.WriteXmlAttrPreferrelative(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrPreferrelative) then
|
|
begin
|
|
{self.}XmlAttrPreferrelative := new OpenXmlAttribute("", "preferrelative", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrPreferrelative;
|
|
end
|
|
{self.}XmlAttrPreferrelative.Value := _value;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlAttrPath();
|
|
begin
|
|
return {self.}XmlAttrPath.Value;
|
|
end;
|
|
|
|
function Shapetype.WriteXmlAttrPath(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrPath) then
|
|
begin
|
|
{self.}XmlAttrPath := new OpenXmlAttribute("", "path", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrPath;
|
|
end
|
|
{self.}XmlAttrPath.Value := _value;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlAttrFilled();
|
|
begin
|
|
return {self.}XmlAttrFilled.Value;
|
|
end;
|
|
|
|
function Shapetype.WriteXmlAttrFilled(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrFilled) then
|
|
begin
|
|
{self.}XmlAttrFilled := new OpenXmlAttribute("", "filled", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrFilled;
|
|
end
|
|
{self.}XmlAttrFilled.Value := _value;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlAttrStroked();
|
|
begin
|
|
return {self.}XmlAttrStroked.Value;
|
|
end;
|
|
|
|
function Shapetype.WriteXmlAttrStroked(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrStroked) then
|
|
begin
|
|
{self.}XmlAttrStroked := new OpenXmlAttribute("", "stroked", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrStroked;
|
|
end
|
|
{self.}XmlAttrStroked.Value := _value;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlChildStroke(): Stroke;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildStroke) then
|
|
begin
|
|
{self.}XmlChildStroke := new Stroke(self, {self.}Prefix, "stroke");
|
|
container_.Set({self.}XmlChildStroke);
|
|
end
|
|
return {self.}XmlChildStroke;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlChildFormulas(): formulas;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildFormulas) then
|
|
begin
|
|
{self.}XmlChildFormulas := new formulas(self, {self.}Prefix, "formulas");
|
|
container_.Set({self.}XmlChildFormulas);
|
|
end
|
|
return {self.}XmlChildFormulas;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlChildPath(): Path;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildPath) then
|
|
begin
|
|
{self.}XmlChildPath := new Path(self, {self.}Prefix, "path");
|
|
container_.Set({self.}XmlChildPath);
|
|
end
|
|
return {self.}XmlChildPath;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlChildTextpath(): Textpath;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildTextpath) then
|
|
begin
|
|
{self.}XmlChildTextpath := new Textpath(self, {self.}Prefix, "textpath");
|
|
container_.Set({self.}XmlChildTextpath);
|
|
end
|
|
return {self.}XmlChildTextpath;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlChildHandles(): Handles;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildHandles) then
|
|
begin
|
|
{self.}XmlChildHandles := new Handles(self, {self.}Prefix, "handles");
|
|
container_.Set({self.}XmlChildHandles);
|
|
end
|
|
return {self.}XmlChildHandles;
|
|
end;
|
|
|
|
function Shapetype.ReadXmlChildLock(): Lock;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildLock) then
|
|
begin
|
|
{self.}XmlChildLock := new Lock(self, "o", "lock");
|
|
container_.Set({self.}XmlChildLock);
|
|
end
|
|
return {self.}XmlChildLock;
|
|
end;
|
|
|
|
function Formulas.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "v", "formulas");
|
|
end;
|
|
|
|
function Formulas.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Formulas.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Formulas.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
"v:f": array(0, makeweakref(thisFunction(AppendF))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Formulas.Copy(_obj: Formulas);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Formulas.ReadFs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get("v:f", ind);
|
|
end;
|
|
|
|
function Formulas.AddF(): Shapetype;
|
|
begin
|
|
obj := new Shapetype(self, "v", "f");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Formulas.AppendF(): Shapetype;
|
|
begin
|
|
obj := new Shapetype(self, "v", "f");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Lock.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "o", "lock");
|
|
end;
|
|
|
|
function Lock.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Lock.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Lock.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"v:ext": makeweakref(thisFunction(WriteXmlAttrExt)),
|
|
"aspectration": makeweakref(thisFunction(WriteXmlAttrAspectration)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Lock.Copy(_obj: Lock);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.Ext) then
|
|
{self.}Ext := _obj.Ext;
|
|
if not ifnil(_obj.Aspectration) then
|
|
{self.}Aspectration := _obj.Aspectration;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Lock.ReadXmlAttrExt();
|
|
begin
|
|
return {self.}XmlAttrExt.Value;
|
|
end;
|
|
|
|
function Lock.WriteXmlAttrExt(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrExt) then
|
|
begin
|
|
{self.}XmlAttrExt := new OpenXmlAttribute("v", "ext", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrExt;
|
|
end
|
|
{self.}XmlAttrExt.Value := _value;
|
|
end;
|
|
|
|
function Lock.ReadXmlAttrAspectration();
|
|
begin
|
|
return {self.}XmlAttrAspectration.Value;
|
|
end;
|
|
|
|
function Lock.WriteXmlAttrAspectration(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrAspectration) then
|
|
begin
|
|
{self.}XmlAttrAspectration := new OpenXmlAttribute("", "aspectration", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrAspectration;
|
|
end
|
|
{self.}XmlAttrAspectration.Value := _value;
|
|
end;
|
|
|
|
function F.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "v", "f");
|
|
end;
|
|
|
|
function F.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function F.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function F.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"eqn": makeweakref(thisFunction(WriteXmlAttrEqn)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function F.Copy(_obj: F);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.Eqn) then
|
|
{self.}Eqn := _obj.Eqn;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function F.ReadXmlAttrEqn();
|
|
begin
|
|
return {self.}XmlAttrEqn.Value;
|
|
end;
|
|
|
|
function F.WriteXmlAttrEqn(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrEqn) then
|
|
begin
|
|
{self.}XmlAttrEqn := new OpenXmlAttribute("", "eqn", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrEqn;
|
|
end
|
|
{self.}XmlAttrEqn.Value := _value;
|
|
end;
|
|
|
|
function Stroke.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "v", "stroke");
|
|
end;
|
|
|
|
function Stroke.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Stroke.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Stroke.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"joinstyle": makeweakref(thisFunction(WriteXmlAttrJoinstyle)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Stroke.Copy(_obj: Stroke);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.Joinstyle) then
|
|
{self.}Joinstyle := _obj.Joinstyle;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Stroke.ReadXmlAttrJoinstyle();
|
|
begin
|
|
return {self.}XmlAttrJoinstyle.Value;
|
|
end;
|
|
|
|
function Stroke.WriteXmlAttrJoinstyle(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrJoinstyle) then
|
|
begin
|
|
{self.}XmlAttrJoinstyle := new OpenXmlAttribute("", "joinstyle", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrJoinstyle;
|
|
end
|
|
{self.}XmlAttrJoinstyle.Value := _value;
|
|
end;
|
|
|
|
function Path.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "v", "path");
|
|
end;
|
|
|
|
function Path.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Path.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Path.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"o:extrusionok": makeweakref(thisFunction(WriteXmlAttrExtrusionok)),
|
|
"textpathok": makeweakref(thisFunction(WriteXmlAttrTextpathok)),
|
|
"gradientshapeok": makeweakref(thisFunction(WriteXmlAttrGradientshapeok)),
|
|
"o:connecttype": makeweakref(thisFunction(WriteXmlAttrConnecttype)),
|
|
"o:connectlocs": makeweakref(thisFunction(WriteXmlAttrConnectlocs)),
|
|
"o:connectangles": makeweakref(thisFunction(WriteXmlAttrConnectangles)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Path.Copy(_obj: Path);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.Extrusionok) then
|
|
{self.}Extrusionok := _obj.Extrusionok;
|
|
if not ifnil(_obj.Textpathok) then
|
|
{self.}Textpathok := _obj.Textpathok;
|
|
if not ifnil(_obj.Gradientshapeok) then
|
|
{self.}Gradientshapeok := _obj.Gradientshapeok;
|
|
if not ifnil(_obj.Connecttype) then
|
|
{self.}Connecttype := _obj.Connecttype;
|
|
if not ifnil(_obj.Connectlocs) then
|
|
{self.}Connectlocs := _obj.Connectlocs;
|
|
if not ifnil(_obj.Connectangles) then
|
|
{self.}Connectangles := _obj.Connectangles;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Path.ReadXmlAttrExtrusionok();
|
|
begin
|
|
return {self.}XmlAttrExtrusionok.Value;
|
|
end;
|
|
|
|
function Path.WriteXmlAttrExtrusionok(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrExtrusionok) then
|
|
begin
|
|
{self.}XmlAttrExtrusionok := new OpenXmlAttribute("o", "extrusionok", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrExtrusionok;
|
|
end
|
|
{self.}XmlAttrExtrusionok.Value := _value;
|
|
end;
|
|
|
|
function Path.ReadXmlAttrTextpathok();
|
|
begin
|
|
return {self.}XmlAttrTextpathok.Value;
|
|
end;
|
|
|
|
function Path.WriteXmlAttrTextpathok(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrTextpathok) then
|
|
begin
|
|
{self.}XmlAttrTextpathok := new OpenXmlAttribute("", "textpathok", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrTextpathok;
|
|
end
|
|
{self.}XmlAttrTextpathok.Value := _value;
|
|
end;
|
|
|
|
function Path.ReadXmlAttrGradientshapeok();
|
|
begin
|
|
return {self.}XmlAttrGradientshapeok.Value;
|
|
end;
|
|
|
|
function Path.WriteXmlAttrGradientshapeok(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrGradientshapeok) then
|
|
begin
|
|
{self.}XmlAttrGradientshapeok := new OpenXmlAttribute("", "gradientshapeok", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrGradientshapeok;
|
|
end
|
|
{self.}XmlAttrGradientshapeok.Value := _value;
|
|
end;
|
|
|
|
function Path.ReadXmlAttrConnecttype();
|
|
begin
|
|
return {self.}XmlAttrConnecttype.Value;
|
|
end;
|
|
|
|
function Path.WriteXmlAttrConnecttype(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrConnecttype) then
|
|
begin
|
|
{self.}XmlAttrConnecttype := new OpenXmlAttribute("o", "connecttype", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrConnecttype;
|
|
end
|
|
{self.}XmlAttrConnecttype.Value := _value;
|
|
end;
|
|
|
|
function Path.ReadXmlAttrConnectlocs();
|
|
begin
|
|
return {self.}XmlAttrConnectlocs.Value;
|
|
end;
|
|
|
|
function Path.WriteXmlAttrConnectlocs(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrConnectlocs) then
|
|
begin
|
|
{self.}XmlAttrConnectlocs := new OpenXmlAttribute("o", "connectlocs", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrConnectlocs;
|
|
end
|
|
{self.}XmlAttrConnectlocs.Value := _value;
|
|
end;
|
|
|
|
function Path.ReadXmlAttrConnectangles();
|
|
begin
|
|
return {self.}XmlAttrConnectangles.Value;
|
|
end;
|
|
|
|
function Path.WriteXmlAttrConnectangles(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrConnectangles) then
|
|
begin
|
|
{self.}XmlAttrConnectangles := new OpenXmlAttribute("o", "connectangles", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrConnectangles;
|
|
end
|
|
{self.}XmlAttrConnectangles.Value := _value;
|
|
end;
|
|
|
|
function Textpath.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "v", "textpath");
|
|
end;
|
|
|
|
function Textpath.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Textpath.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Textpath.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"on": makeweakref(thisFunction(WriteXmlAttr_On)),
|
|
"fitshape": makeweakref(thisFunction(WriteXmlAttrFitshape)),
|
|
"style": makeweakref(thisFunction(WriteXmlAttrStyle)),
|
|
"string": makeweakref(thisFunction(WriteXmlAttrString)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Textpath.Copy(_obj: Textpath);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj._On) then
|
|
{self.}_On := _obj._On;
|
|
if not ifnil(_obj.Fitshape) then
|
|
{self.}Fitshape := _obj.Fitshape;
|
|
if not ifnil(_obj.Style) then
|
|
{self.}Style := _obj.Style;
|
|
if not ifnil(_obj.String) then
|
|
{self.}String := _obj.String;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Textpath.ReadXmlAttr_On();
|
|
begin
|
|
return {self.}XmlAttr_On.Value;
|
|
end;
|
|
|
|
function Textpath.WriteXmlAttr_On(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttr_On) then
|
|
begin
|
|
{self.}XmlAttr_On := new OpenXmlAttribute("", "on", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttr_On;
|
|
end
|
|
{self.}XmlAttr_On.Value := _value;
|
|
end;
|
|
|
|
function Textpath.ReadXmlAttrFitshape();
|
|
begin
|
|
return {self.}XmlAttrFitshape.Value;
|
|
end;
|
|
|
|
function Textpath.WriteXmlAttrFitshape(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrFitshape) then
|
|
begin
|
|
{self.}XmlAttrFitshape := new OpenXmlAttribute("", "fitshape", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrFitshape;
|
|
end
|
|
{self.}XmlAttrFitshape.Value := _value;
|
|
end;
|
|
|
|
function Textpath.ReadXmlAttrStyle();
|
|
begin
|
|
return {self.}XmlAttrStyle.Value;
|
|
end;
|
|
|
|
function Textpath.WriteXmlAttrStyle(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrStyle) then
|
|
begin
|
|
{self.}XmlAttrStyle := new OpenXmlAttribute("", "style", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrStyle;
|
|
end
|
|
{self.}XmlAttrStyle.Value := _value;
|
|
end;
|
|
|
|
function Textpath.ReadXmlAttrString();
|
|
begin
|
|
return {self.}XmlAttrString.Value;
|
|
end;
|
|
|
|
function Textpath.WriteXmlAttrString(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrString) then
|
|
begin
|
|
{self.}XmlAttrString := new OpenXmlAttribute("", "string", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrString;
|
|
end
|
|
{self.}XmlAttrString.Value := _value;
|
|
end;
|
|
|
|
function Handles.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "v", "handles");
|
|
end;
|
|
|
|
function Handles.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Handles.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Handles.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "h": array(0, makeweakref(thisFunction(ReadXmlChildH))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Handles.Copy(_obj: Handles);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildH) then
|
|
{self.}H.Copy(_obj.XmlChildH);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Handles.ReadXmlChildH(): H;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildH) then
|
|
begin
|
|
{self.}XmlChildH := new H(self, {self.}Prefix, "h");
|
|
container_.Set({self.}XmlChildH);
|
|
end
|
|
return {self.}XmlChildH;
|
|
end;
|
|
|
|
function H.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "v", "h");
|
|
end;
|
|
|
|
function H.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function H.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function H.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"xrange": makeweakref(thisFunction(WriteXmlAttrXrange)),
|
|
"position": makeweakref(thisFunction(WriteXmlAttrPosition)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function H.Copy(_obj: H);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.Xrange) then
|
|
{self.}Xrange := _obj.Xrange;
|
|
if not ifnil(_obj.Position) then
|
|
{self.}Position := _obj.Position;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function H.ReadXmlAttrXrange();
|
|
begin
|
|
return {self.}XmlAttrXrange.Value;
|
|
end;
|
|
|
|
function H.WriteXmlAttrXrange(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrXrange) then
|
|
begin
|
|
{self.}XmlAttrXrange := new OpenXmlAttribute("", "xrange", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrXrange;
|
|
end
|
|
{self.}XmlAttrXrange.Value := _value;
|
|
end;
|
|
|
|
function H.ReadXmlAttrPosition();
|
|
begin
|
|
return {self.}XmlAttrPosition.Value;
|
|
end;
|
|
|
|
function H.WriteXmlAttrPosition(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrPosition) then
|
|
begin
|
|
{self.}XmlAttrPosition := new OpenXmlAttribute("", "position", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrPosition;
|
|
end
|
|
{self.}XmlAttrPosition.Value := _value;
|
|
end;
|
|
|
|
function Shape.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "v", "shape");
|
|
end;
|
|
|
|
function Shape.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Shape.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Shape.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"id": makeweakref(thisFunction(WriteXmlAttrId)),
|
|
"style": makeweakref(thisFunction(WriteXmlAttrStyle)),
|
|
"o:spid": makeweakref(thisFunction(WriteXmlAttrSpid)),
|
|
"type": makeweakref(thisFunction(WriteXmlAttrType)),
|
|
"o:gfxdata": makeweakref(thisFunction(WriteXmlAttrGfxdata)),
|
|
"filled": makeweakref(thisFunction(WriteXmlAttrFilled)),
|
|
"o:allowincell": makeweakref(thisFunction(WriteXmlAttrAllowincell)),
|
|
"fillcolor": makeweakref(thisFunction(WriteXmlAttrFillcolor)),
|
|
"stroked": makeweakref(thisFunction(WriteXmlAttrStroked)),
|
|
"o:ole": makeweakref(thisFunction(WriteXmlAttrOle)),
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "fill": array(0, makeweakref(thisFunction(ReadXmlChildFill))),
|
|
pre + "textbox": array(1, makeweakref(thisFunction(ReadXmlChildTextbox))),
|
|
pre + "textpath": array(2, makeweakref(thisFunction(ReadXmlChildTextpath))),
|
|
pre + "imagedata": array(3, makeweakref(thisFunction(ReadXmlChildImagedata))),
|
|
"w10:wrap": array(4, makeweakref(thisFunction(ReadXmlChildWrap))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Shape.Copy(_obj: Shape);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.Id) then
|
|
{self.}Id := _obj.Id;
|
|
if not ifnil(_obj.Style) then
|
|
{self.}Style := _obj.Style;
|
|
if not ifnil(_obj.Spid) then
|
|
{self.}Spid := _obj.Spid;
|
|
if not ifnil(_obj.Type) then
|
|
{self.}Type := _obj.Type;
|
|
if not ifnil(_obj.Gfxdata) then
|
|
{self.}Gfxdata := _obj.Gfxdata;
|
|
if not ifnil(_obj.Filled) then
|
|
{self.}Filled := _obj.Filled;
|
|
if not ifnil(_obj.Allowincell) then
|
|
{self.}Allowincell := _obj.Allowincell;
|
|
if not ifnil(_obj.Fillcolor) then
|
|
{self.}Fillcolor := _obj.Fillcolor;
|
|
if not ifnil(_obj.Stroked) then
|
|
{self.}Stroked := _obj.Stroked;
|
|
if not ifnil(_obj.Ole) then
|
|
{self.}Ole := _obj.Ole;
|
|
if not ifnil(_obj.XmlChildFill) then
|
|
{self.}Fill.Copy(_obj.XmlChildFill);
|
|
if not ifnil(_obj.XmlChildTextbox) then
|
|
{self.}Textbox.Copy(_obj.XmlChildTextbox);
|
|
if not ifnil(_obj.XmlChildTextpath) then
|
|
{self.}Textpath.Copy(_obj.XmlChildTextpath);
|
|
if not ifnil(_obj.XmlChildImagedata) then
|
|
{self.}Imagedata.Copy(_obj.XmlChildImagedata);
|
|
if not ifnil(_obj.XmlChildWrap) then
|
|
{self.}Wrap.Copy(_obj.XmlChildWrap);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Shape.ReadXmlAttrId();
|
|
begin
|
|
return {self.}XmlAttrId.Value;
|
|
end;
|
|
|
|
function Shape.WriteXmlAttrId(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrId) then
|
|
begin
|
|
{self.}XmlAttrId := new OpenXmlAttribute("", "id", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrId;
|
|
end
|
|
{self.}XmlAttrId.Value := _value;
|
|
end;
|
|
|
|
function Shape.ReadXmlAttrStyle();
|
|
begin
|
|
return {self.}XmlAttrStyle.Value;
|
|
end;
|
|
|
|
function Shape.WriteXmlAttrStyle(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrStyle) then
|
|
begin
|
|
{self.}XmlAttrStyle := new OpenXmlAttribute("", "style", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrStyle;
|
|
end
|
|
{self.}XmlAttrStyle.Value := _value;
|
|
end;
|
|
|
|
function Shape.ReadXmlAttrSpid();
|
|
begin
|
|
return {self.}XmlAttrSpid.Value;
|
|
end;
|
|
|
|
function Shape.WriteXmlAttrSpid(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrSpid) then
|
|
begin
|
|
{self.}XmlAttrSpid := new OpenXmlAttribute("o", "spid", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrSpid;
|
|
end
|
|
{self.}XmlAttrSpid.Value := _value;
|
|
end;
|
|
|
|
function Shape.ReadXmlAttrType();
|
|
begin
|
|
return {self.}XmlAttrType.Value;
|
|
end;
|
|
|
|
function Shape.WriteXmlAttrType(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrType) then
|
|
begin
|
|
{self.}XmlAttrType := new OpenXmlAttribute("", "type", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrType;
|
|
end
|
|
{self.}XmlAttrType.Value := _value;
|
|
end;
|
|
|
|
function Shape.ReadXmlAttrGfxdata();
|
|
begin
|
|
return {self.}XmlAttrGfxdata.Value;
|
|
end;
|
|
|
|
function Shape.WriteXmlAttrGfxdata(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrGfxdata) then
|
|
begin
|
|
{self.}XmlAttrGfxdata := new OpenXmlAttribute("o", "gfxdata", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrGfxdata;
|
|
end
|
|
{self.}XmlAttrGfxdata.Value := _value;
|
|
end;
|
|
|
|
function Shape.ReadXmlAttrFilled();
|
|
begin
|
|
return {self.}XmlAttrFilled.Value;
|
|
end;
|
|
|
|
function Shape.WriteXmlAttrFilled(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrFilled) then
|
|
begin
|
|
{self.}XmlAttrFilled := new OpenXmlAttribute("", "filled", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrFilled;
|
|
end
|
|
{self.}XmlAttrFilled.Value := _value;
|
|
end;
|
|
|
|
function Shape.ReadXmlAttrAllowincell();
|
|
begin
|
|
return {self.}XmlAttrAllowincell.Value;
|
|
end;
|
|
|
|
function Shape.WriteXmlAttrAllowincell(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrAllowincell) then
|
|
begin
|
|
{self.}XmlAttrAllowincell := new OpenXmlAttribute("o", "allowincell", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrAllowincell;
|
|
end
|
|
{self.}XmlAttrAllowincell.Value := _value;
|
|
end;
|
|
|
|
function Shape.ReadXmlAttrFillcolor();
|
|
begin
|
|
return {self.}XmlAttrFillcolor.Value;
|
|
end;
|
|
|
|
function Shape.WriteXmlAttrFillcolor(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrFillcolor) then
|
|
begin
|
|
{self.}XmlAttrFillcolor := new OpenXmlAttribute("", "fillcolor", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrFillcolor;
|
|
end
|
|
{self.}XmlAttrFillcolor.Value := _value;
|
|
end;
|
|
|
|
function Shape.ReadXmlAttrStroked();
|
|
begin
|
|
return {self.}XmlAttrStroked.Value;
|
|
end;
|
|
|
|
function Shape.WriteXmlAttrStroked(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrStroked) then
|
|
begin
|
|
{self.}XmlAttrStroked := new OpenXmlAttribute("", "stroked", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrStroked;
|
|
end
|
|
{self.}XmlAttrStroked.Value := _value;
|
|
end;
|
|
|
|
function Shape.ReadXmlAttrOle();
|
|
begin
|
|
return {self.}XmlAttrOle.Value;
|
|
end;
|
|
|
|
function Shape.WriteXmlAttrOle(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrOle) then
|
|
begin
|
|
{self.}XmlAttrOle := new OpenXmlAttribute("o", "ole", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrOle;
|
|
end
|
|
{self.}XmlAttrOle.Value := _value;
|
|
end;
|
|
|
|
function Shape.ReadXmlChildFill(): Fill;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildFill) then
|
|
begin
|
|
{self.}XmlChildFill := new Fill(self, {self.}Prefix, "fill");
|
|
container_.Set({self.}XmlChildFill);
|
|
end
|
|
return {self.}XmlChildFill;
|
|
end;
|
|
|
|
function Shape.ReadXmlChildTextbox(): Textbox;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildTextbox) then
|
|
begin
|
|
{self.}XmlChildTextbox := new Textbox(self, {self.}Prefix, "textbox");
|
|
container_.Set({self.}XmlChildTextbox);
|
|
end
|
|
return {self.}XmlChildTextbox;
|
|
end;
|
|
|
|
function Shape.ReadXmlChildTextpath(): Textpath;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildTextpath) then
|
|
begin
|
|
{self.}XmlChildTextpath := new Textpath(self, {self.}Prefix, "textpath");
|
|
container_.Set({self.}XmlChildTextpath);
|
|
end
|
|
return {self.}XmlChildTextpath;
|
|
end;
|
|
|
|
function Shape.ReadXmlChildImagedata(): Imagedata;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildImagedata) then
|
|
begin
|
|
{self.}XmlChildImagedata := new Imagedata(self, {self.}Prefix, "imagedata");
|
|
container_.Set({self.}XmlChildImagedata);
|
|
end
|
|
return {self.}XmlChildImagedata;
|
|
end;
|
|
|
|
function Shape.ReadXmlChildWrap(): Wrap;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildWrap) then
|
|
begin
|
|
{self.}XmlChildWrap := new Wrap(self, "w10", "wrap");
|
|
container_.Set({self.}XmlChildWrap);
|
|
end
|
|
return {self.}XmlChildWrap;
|
|
end;
|
|
|
|
function Wrap.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "w10", "wrap");
|
|
end;
|
|
|
|
function Wrap.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Wrap.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Wrap.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"anchorx": makeweakref(thisFunction(WriteXmlAttrAnchorx)),
|
|
"anchory": makeweakref(thisFunction(WriteXmlAttrAnchory)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Wrap.Copy(_obj: Wrap);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.Anchorx) then
|
|
{self.}Anchorx := _obj.Anchorx;
|
|
if not ifnil(_obj.Anchory) then
|
|
{self.}Anchory := _obj.Anchory;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Wrap.ReadXmlAttrAnchorx();
|
|
begin
|
|
return {self.}XmlAttrAnchorx.Value;
|
|
end;
|
|
|
|
function Wrap.WriteXmlAttrAnchorx(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrAnchorx) then
|
|
begin
|
|
{self.}XmlAttrAnchorx := new OpenXmlAttribute("", "anchorx", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrAnchorx;
|
|
end
|
|
{self.}XmlAttrAnchorx.Value := _value;
|
|
end;
|
|
|
|
function Wrap.ReadXmlAttrAnchory();
|
|
begin
|
|
return {self.}XmlAttrAnchory.Value;
|
|
end;
|
|
|
|
function Wrap.WriteXmlAttrAnchory(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrAnchory) then
|
|
begin
|
|
{self.}XmlAttrAnchory := new OpenXmlAttribute("", "anchory", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrAnchory;
|
|
end
|
|
{self.}XmlAttrAnchory.Value := _value;
|
|
end;
|
|
|
|
function Fill.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "v", "fill");
|
|
end;
|
|
|
|
function Fill.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Fill.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Fill.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"opacity": makeweakref(thisFunction(WriteXmlAttrOpacity)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Fill.Copy(_obj: Fill);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.Opacity) then
|
|
{self.}Opacity := _obj.Opacity;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Fill.ReadXmlAttrOpacity();
|
|
begin
|
|
return {self.}XmlAttrOpacity.Value;
|
|
end;
|
|
|
|
function Fill.WriteXmlAttrOpacity(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrOpacity) then
|
|
begin
|
|
{self.}XmlAttrOpacity := new OpenXmlAttribute("", "opacity", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrOpacity;
|
|
end
|
|
{self.}XmlAttrOpacity.Value := _value;
|
|
end;
|
|
|
|
function Imagedata.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "v", "imagedata");
|
|
end;
|
|
|
|
function Imagedata.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Imagedata.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Imagedata.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"r:id": makeweakref(thisFunction(WriteXmlAttrId)),
|
|
"o:title": makeweakref(thisFunction(WriteXmlAttrTitle)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Imagedata.Copy(_obj: Imagedata);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.Id) then
|
|
{self.}Id := _obj.Id;
|
|
if not ifnil(_obj.Title) then
|
|
{self.}Title := _obj.Title;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Imagedata.ReadXmlAttrId();
|
|
begin
|
|
return {self.}XmlAttrId.Value;
|
|
end;
|
|
|
|
function Imagedata.WriteXmlAttrId(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrId) then
|
|
begin
|
|
{self.}XmlAttrId := new OpenXmlAttribute("r", "id", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrId;
|
|
end
|
|
{self.}XmlAttrId.Value := _value;
|
|
end;
|
|
|
|
function Imagedata.ReadXmlAttrTitle();
|
|
begin
|
|
return {self.}XmlAttrTitle.Value;
|
|
end;
|
|
|
|
function Imagedata.WriteXmlAttrTitle(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrTitle) then
|
|
begin
|
|
{self.}XmlAttrTitle := new OpenXmlAttribute("o", "title", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrTitle;
|
|
end
|
|
{self.}XmlAttrTitle.Value := _value;
|
|
end;
|
|
|
|
function Textbox.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "v", "textbox");
|
|
end;
|
|
|
|
function Textbox.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Textbox.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Textbox.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
"w:txbxContent": array(0, makeweakref(thisFunction(ReadXmlChildTxbxContent))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Textbox.Copy(_obj: Textbox);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildTxbxContent) then
|
|
{self.}TxbxContent.Copy(_obj.XmlChildTxbxContent);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Textbox.ReadXmlChildTxbxContent(): TxbxContent;
|
|
begin
|
|
if tslassigning and ifnil({self.}XmlChildTxbxContent) then
|
|
begin
|
|
{self.}XmlChildTxbxContent := new DocxML.TxbxContent(self, "w", "txbxContent");
|
|
container_.Set({self.}XmlChildTxbxContent);
|
|
end
|
|
return {self.}XmlChildTxbxContent;
|
|
end;
|
|
|
|
function OLEObject.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "o", "OLEObject");
|
|
end;
|
|
|
|
function OLEObject.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function OLEObject.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function OLEObject.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
pre + "Type": makeweakref(thisFunction(WriteXmlAttrType)),
|
|
pre + "ProgID": makeweakref(thisFunction(WriteXmlAttrProgID)),
|
|
pre + "ShapeID": makeweakref(thisFunction(WriteXmlAttrShapeID)),
|
|
pre + "DrawAspect": makeweakref(thisFunction(WriteXmlAttrDrawAspect)),
|
|
pre + "DrawAspect": makeweakref(thisFunction(WriteXmlAttrObjectID)),
|
|
"r:id": makeweakref(thisFunction(WriteXmlAttrId)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function OLEObject.Copy(_obj: OLEObject);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlElement).Copy(_obj);
|
|
if not ifnil(_obj.Type) then
|
|
{self.}Type := _obj.Type;
|
|
if not ifnil(_obj.ProgID) then
|
|
{self.}ProgID := _obj.ProgID;
|
|
if not ifnil(_obj.ShapeID) then
|
|
{self.}ShapeID := _obj.ShapeID;
|
|
if not ifnil(_obj.DrawAspect) then
|
|
{self.}DrawAspect := _obj.DrawAspect;
|
|
if not ifnil(_obj.ObjectID) then
|
|
{self.}ObjectID := _obj.ObjectID;
|
|
if not ifnil(_obj.Id) then
|
|
{self.}Id := _obj.Id;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function OLEObject.ReadXmlAttrType();
|
|
begin
|
|
return {self.}XmlAttrType.Value;
|
|
end;
|
|
|
|
function OLEObject.WriteXmlAttrType(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrType) then
|
|
begin
|
|
{self.}XmlAttrType := new OpenXmlAttribute({self.}Prefix, "Type", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrType;
|
|
end
|
|
{self.}XmlAttrType.Value := _value;
|
|
end;
|
|
|
|
function OLEObject.ReadXmlAttrProgID();
|
|
begin
|
|
return {self.}XmlAttrProgID.Value;
|
|
end;
|
|
|
|
function OLEObject.WriteXmlAttrProgID(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrProgID) then
|
|
begin
|
|
{self.}XmlAttrProgID := new OpenXmlAttribute({self.}Prefix, "ProgID", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrProgID;
|
|
end
|
|
{self.}XmlAttrProgID.Value := _value;
|
|
end;
|
|
|
|
function OLEObject.ReadXmlAttrShapeID();
|
|
begin
|
|
return {self.}XmlAttrShapeID.Value;
|
|
end;
|
|
|
|
function OLEObject.WriteXmlAttrShapeID(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrShapeID) then
|
|
begin
|
|
{self.}XmlAttrShapeID := new OpenXmlAttribute({self.}Prefix, "ShapeID", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrShapeID;
|
|
end
|
|
{self.}XmlAttrShapeID.Value := _value;
|
|
end;
|
|
|
|
function OLEObject.ReadXmlAttrDrawAspect();
|
|
begin
|
|
return {self.}XmlAttrDrawAspect.Value;
|
|
end;
|
|
|
|
function OLEObject.WriteXmlAttrDrawAspect(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrDrawAspect) then
|
|
begin
|
|
{self.}XmlAttrDrawAspect := new OpenXmlAttribute({self.}Prefix, "DrawAspect", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrDrawAspect;
|
|
end
|
|
{self.}XmlAttrDrawAspect.Value := _value;
|
|
end;
|
|
|
|
function OLEObject.ReadXmlAttrObjectID();
|
|
begin
|
|
return {self.}XmlAttrObjectID.Value;
|
|
end;
|
|
|
|
function OLEObject.WriteXmlAttrObjectID(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrObjectID) then
|
|
begin
|
|
{self.}XmlAttrObjectID := new OpenXmlAttribute({self.}Prefix, "DrawAspect", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrObjectID;
|
|
end
|
|
{self.}XmlAttrObjectID.Value := _value;
|
|
end;
|
|
|
|
function OLEObject.ReadXmlAttrId();
|
|
begin
|
|
return {self.}XmlAttrId.Value;
|
|
end;
|
|
|
|
function OLEObject.WriteXmlAttrId(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrId) then
|
|
begin
|
|
{self.}XmlAttrId := new OpenXmlAttribute("r", "id", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrId;
|
|
end
|
|
{self.}XmlAttrId.Value := _value;
|
|
end;
|
|
|
|
end. |