3912 lines
113 KiB
Plaintext
3912 lines
113 KiB
Plaintext
unit SharedML;
|
|
interface
|
|
uses DrawingML, DocxML;
|
|
|
|
type MathPr = class(OpenXmlCompositeElement)
|
|
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: MathPr);override;
|
|
public
|
|
|
|
// simple_type property
|
|
property DispDef read ReadXmlChildDispDef;
|
|
function ReadXmlChildDispDef(): OpenXmlSimpleType;
|
|
|
|
// normal property
|
|
property MathFont read ReadXmlChildMathFont;
|
|
property BrkBin read ReadXmlChildBrkBin;
|
|
property BrkBinSub read ReadXmlChildBrkBinSub;
|
|
property SmallFrac read ReadXmlChildSmallFrac;
|
|
property LMargin read ReadXmlChildLMargin;
|
|
property RMargin read ReadXmlChildRMargin;
|
|
property DefJc read ReadXmlChildDefJc;
|
|
property WrapIndent read ReadXmlChildWrapIndent;
|
|
property IntLim read ReadXmlChildIntLim;
|
|
property NaryLim read ReadXmlChildNaryLim;
|
|
function ReadXmlChildMathFont(): PureMVal;
|
|
function ReadXmlChildBrkBin(): PureMVal;
|
|
function ReadXmlChildBrkBinSub(): PureMVal;
|
|
function ReadXmlChildSmallFrac(): PureMVal;
|
|
function ReadXmlChildLMargin(): PureMVal;
|
|
function ReadXmlChildRMargin(): PureMVal;
|
|
function ReadXmlChildDefJc(): PureMVal;
|
|
function ReadXmlChildWrapIndent(): PureMVal;
|
|
function ReadXmlChildIntLim(): PureMVal;
|
|
function ReadXmlChildNaryLim(): PureMVal;
|
|
|
|
public
|
|
// Children
|
|
XmlChildMathFont: PureMVal;
|
|
XmlChildBrkBin: PureMVal;
|
|
XmlChildBrkBinSub: PureMVal;
|
|
XmlChildSmallFrac: PureMVal;
|
|
XmlChildDispDef: OpenXmlSimpleType;
|
|
XmlChildLMargin: PureMVal;
|
|
XmlChildRMargin: PureMVal;
|
|
XmlChildDefJc: PureMVal;
|
|
XmlChildWrapIndent: PureMVal;
|
|
XmlChildIntLim: PureMVal;
|
|
XmlChildNaryLim: PureMVal;
|
|
end;
|
|
|
|
type OMathPara = class(OpenXmlCompositeElement)
|
|
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: OMathPara);override;
|
|
public
|
|
|
|
// normal property
|
|
property OMathParaPr read ReadXmlChildOMathParaPr;
|
|
property OMath read ReadXmlChildOMath;
|
|
function ReadXmlChildOMathParaPr(): OMathParaPr;
|
|
function ReadXmlChildOMath(): OMath;
|
|
|
|
public
|
|
// Children
|
|
XmlChildOMathParaPr: OMathParaPr;
|
|
XmlChildOMath: OMath;
|
|
end;
|
|
|
|
type OMathParaPr = class(OpenXmlCompositeElement)
|
|
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: OMathParaPr);override;
|
|
public
|
|
|
|
// normal property
|
|
property Jc read ReadXmlChildJc;
|
|
function ReadXmlChildJc(): PureMVal;
|
|
|
|
public
|
|
// Children
|
|
XmlChildJc: PureMVal;
|
|
end;
|
|
|
|
type PureMVal = class(OpenXmlCompositeElement)
|
|
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: PureMVal);override;
|
|
public
|
|
// attributes property
|
|
property Val read ReadXmlAttrVal write WriteXmlAttrVal;
|
|
function ReadXmlAttrVal();
|
|
function WriteXmlAttrVal(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrVal: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type OMath = class(OpenXmlCompositeElement)
|
|
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: OMath);override;
|
|
public
|
|
|
|
// multi property
|
|
property Rs read ReadRs;
|
|
property Ds read ReadDs;
|
|
property Fs read ReadFs;
|
|
property Rads read ReadRads;
|
|
property SSubs read ReadSSubs;
|
|
property Naries read ReadNaries;
|
|
function ReadRs(_index);
|
|
function ReadDs(_index);
|
|
function ReadFs(_index);
|
|
function ReadRads(_index);
|
|
function ReadSSubs(_index);
|
|
function ReadNaries(_index);
|
|
function AddR(): R;
|
|
function AddD(): D;
|
|
function AddF(): F;
|
|
function AddRad(): Rad;
|
|
function AddSSub(): SSub;
|
|
function AddNary(): Nary;
|
|
function AppendR(): R;
|
|
function AppendD(): D;
|
|
function AppendF(): F;
|
|
function AppendRad(): Rad;
|
|
function AppendSSub(): SSub;
|
|
function AppendNary(): Nary;
|
|
|
|
public
|
|
// Children
|
|
end;
|
|
|
|
type R = class(OpenXmlCompositeElement)
|
|
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: R);override;
|
|
public
|
|
|
|
// normal property
|
|
property RPr read ReadXmlChildRPr;
|
|
property ARPr read ReadXmlChildARPr;
|
|
property WRPr read ReadXmlChildWRPr;
|
|
property T read ReadXmlChildT;
|
|
function ReadXmlChildRPr(_ns: string): RPr;
|
|
function ReadXmlChildARPr(): RPr;
|
|
function ReadXmlChildWRPr(): RPr;
|
|
function ReadXmlChildT(): T;
|
|
|
|
public
|
|
// Children
|
|
XmlChildRPr: RPr;
|
|
XmlChildARPr: RPr;
|
|
XmlChildWRPr: RPr;
|
|
XmlChildT: T;
|
|
end;
|
|
|
|
type RPr = class(OpenXmlCompositeElement)
|
|
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: RPr);override;
|
|
public
|
|
|
|
// normal property
|
|
property Sty read ReadXmlChildSty;
|
|
function ReadXmlChildSty(): PureMVal;
|
|
|
|
public
|
|
// Children
|
|
XmlChildSty: PureMVal;
|
|
end;
|
|
|
|
type T = class(OpenXmlTextElement)
|
|
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: T);override;
|
|
public
|
|
// attributes property
|
|
property Space read ReadXmlAttrSpace write WriteXmlAttrSpace;
|
|
function ReadXmlAttrSpace();
|
|
function WriteXmlAttrSpace(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrSpace: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type D = class(OpenXmlCompositeElement)
|
|
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: D);override;
|
|
public
|
|
|
|
// normal property
|
|
property DPr read ReadXmlChildDPr;
|
|
property E read ReadXmlChildE;
|
|
function ReadXmlChildDPr(): DPr;
|
|
function ReadXmlChildE(): E;
|
|
|
|
public
|
|
// Children
|
|
XmlChildDPr: DPr;
|
|
XmlChildE: E;
|
|
end;
|
|
|
|
type DPr = class(OpenXmlCompositeElement)
|
|
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: DPr);override;
|
|
public
|
|
|
|
// normal property
|
|
property BegChr read ReadXmlChildBegChr;
|
|
property EndChr read ReadXmlChildEndChr;
|
|
property SepChr read ReadXmlChildSepChr;
|
|
property Shp read ReadXmlChildShp;
|
|
property Grow read ReadXmlChildGrow;
|
|
property CtrlPr read ReadXmlChildCtrlPr;
|
|
property RPr read ReadXmlChildRPr;
|
|
function ReadXmlChildBegChr(): PureMVal;
|
|
function ReadXmlChildEndChr(): PureMVal;
|
|
function ReadXmlChildSepChr(): PureMVal;
|
|
function ReadXmlChildShp(): PureMVal;
|
|
function ReadXmlChildGrow(): PureMVal;
|
|
function ReadXmlChildCtrlPr(): CtrlPr;
|
|
function ReadXmlChildRPr(): RPr;
|
|
|
|
public
|
|
// Children
|
|
XmlChildBegChr: PureMVal;
|
|
XmlChildEndChr: PureMVal;
|
|
XmlChildSepChr: PureMVal;
|
|
XmlChildShp: PureMVal;
|
|
XmlChildGrow: PureMVal;
|
|
XmlChildCtrlPr: CtrlPr;
|
|
XmlChildRPr: RPr;
|
|
end;
|
|
|
|
type CtrlPr = class(OpenXmlCompositeElement)
|
|
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: CtrlPr);override;
|
|
public
|
|
|
|
// normal property
|
|
property RPr read ReadXmlChildRPr;
|
|
property Del read ReadXmlChildDel;
|
|
function ReadXmlChildRPr(): RPr;
|
|
function ReadXmlChildDel(): Del;
|
|
|
|
public
|
|
// Children
|
|
XmlChildRPr: RPr;
|
|
XmlChildDel: Del;
|
|
end;
|
|
|
|
type E = class(OpenXmlCompositeElement)
|
|
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: E);override;
|
|
public
|
|
|
|
// normal property
|
|
property F read ReadXmlChildF;
|
|
property CtrlPr read ReadXmlChildCtrlPr;
|
|
function ReadXmlChildF(): F;
|
|
function ReadXmlChildCtrlPr(): CtrlPr;
|
|
|
|
// multi property
|
|
property Rs read ReadRs;
|
|
property Ds read ReadDs;
|
|
property SSups read ReadSSups;
|
|
property SSubs read ReadSSubs;
|
|
property Funcs read ReadFuncs;
|
|
function ReadRs(_index);
|
|
function ReadDs(_index);
|
|
function ReadSSups(_index);
|
|
function ReadSSubs(_index);
|
|
function ReadFuncs(_index);
|
|
function AddR(): R;
|
|
function AddD(): D;
|
|
function AddSSup(): SSup;
|
|
function AddSSub(): SSub;
|
|
function AddFunc(): Func;
|
|
function AppendR(): R;
|
|
function AppendD(): D;
|
|
function AppendSSup(): SSup;
|
|
function AppendSSub(): SSub;
|
|
function AppendFunc(): Func;
|
|
|
|
public
|
|
// Children
|
|
XmlChildF: F;
|
|
XmlChildCtrlPr: CtrlPr;
|
|
end;
|
|
|
|
type SSup = class(OpenXmlCompositeElement)
|
|
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: SSup);override;
|
|
public
|
|
|
|
// normal property
|
|
property SSupPr read ReadXmlChildSSupPr;
|
|
property E read ReadXmlChildE;
|
|
property Sup read ReadXmlChildSup;
|
|
function ReadXmlChildSSupPr(): SSupPr;
|
|
function ReadXmlChildE(): E;
|
|
function ReadXmlChildSup(): Sup;
|
|
|
|
public
|
|
// Children
|
|
XmlChildSSupPr: SSupPr;
|
|
XmlChildE: E;
|
|
XmlChildSup: Sup;
|
|
end;
|
|
|
|
type SSupPr = class(OpenXmlCompositeElement)
|
|
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: SSupPr);override;
|
|
public
|
|
|
|
// normal property
|
|
property CtrlPr read ReadXmlChildCtrlPr;
|
|
function ReadXmlChildCtrlPr(): CtrlPr;
|
|
|
|
public
|
|
// Children
|
|
XmlChildCtrlPr: CtrlPr;
|
|
end;
|
|
|
|
type Sup = class(OpenXmlCompositeElement)
|
|
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: Sup);override;
|
|
public
|
|
|
|
// normal property
|
|
property CtrlPr read ReadXmlChildCtrlPr;
|
|
function ReadXmlChildCtrlPr(): CtrlPr;
|
|
|
|
// multi property
|
|
property Rs read ReadRs;
|
|
function ReadRs(_index);
|
|
function AddR(): R;
|
|
function AppendR(): R;
|
|
|
|
public
|
|
// Children
|
|
XmlChildCtrlPr: CtrlPr;
|
|
end;
|
|
|
|
type F = class(OpenXmlCompositeElement)
|
|
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
|
|
|
|
// normal property
|
|
property FPr read ReadXmlChildFPr;
|
|
property Num read ReadXmlChildNum;
|
|
property Den read ReadXmlChildDen;
|
|
function ReadXmlChildFPr(): FPr;
|
|
function ReadXmlChildNum(): Num;
|
|
function ReadXmlChildDen(): Den;
|
|
|
|
public
|
|
// Children
|
|
XmlChildFPr: FPr;
|
|
XmlChildNum: Num;
|
|
XmlChildDen: Den;
|
|
end;
|
|
|
|
type FPr = class(OpenXmlCompositeElement)
|
|
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: FPr);override;
|
|
public
|
|
|
|
// normal property
|
|
property Type read ReadXmlChildType;
|
|
property CtrlPr read ReadXmlChildCtrlPr;
|
|
function ReadXmlChildType(): PureMVal;
|
|
function ReadXmlChildCtrlPr(): CtrlPr;
|
|
|
|
public
|
|
// Children
|
|
XmlChildType: PureMVal;
|
|
XmlChildCtrlPr: CtrlPr;
|
|
end;
|
|
|
|
type Num = class(OpenXmlCompositeElement)
|
|
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: Num);override;
|
|
public
|
|
|
|
// normal property
|
|
property Rad read ReadXmlChildRad;
|
|
property CtrlPr read ReadXmlChildCtrlPr;
|
|
function ReadXmlChildRad(): Rad;
|
|
function ReadXmlChildCtrlPr(): CtrlPr;
|
|
|
|
// multi property
|
|
property Rs read ReadRs;
|
|
function ReadRs(_index);
|
|
function AddR(): R;
|
|
function AppendR(): R;
|
|
|
|
public
|
|
// Children
|
|
XmlChildRad: Rad;
|
|
XmlChildCtrlPr: CtrlPr;
|
|
end;
|
|
|
|
type Rad = class(OpenXmlCompositeElement)
|
|
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: Rad);override;
|
|
public
|
|
|
|
// normal property
|
|
property RadPr read ReadXmlChildRadPr;
|
|
property Deg read ReadXmlChildDeg;
|
|
property E read ReadXmlChildE;
|
|
function ReadXmlChildRadPr(): RadPr;
|
|
function ReadXmlChildDeg(): Deg;
|
|
function ReadXmlChildE(): E;
|
|
|
|
public
|
|
// Children
|
|
XmlChildRadPr: RadPr;
|
|
XmlChildDeg: Deg;
|
|
XmlChildE: E;
|
|
end;
|
|
|
|
type RadPr = class(OpenXmlCompositeElement)
|
|
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: RadPr);override;
|
|
public
|
|
|
|
// normal property
|
|
property DegHide read ReadXmlChildDegHide;
|
|
property CtrlPr read ReadXmlChildCtrlPr;
|
|
function ReadXmlChildDegHide(): PureMVal;
|
|
function ReadXmlChildCtrlPr(): CtrlPr;
|
|
|
|
public
|
|
// Children
|
|
XmlChildDegHide: PureMVal;
|
|
XmlChildCtrlPr: CtrlPr;
|
|
end;
|
|
|
|
type Deg = class(OpenXmlCompositeElement)
|
|
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: Deg);override;
|
|
public
|
|
|
|
// normal property
|
|
property CtrlPr read ReadXmlChildCtrlPr;
|
|
function ReadXmlChildCtrlPr(): CtrlPr;
|
|
|
|
public
|
|
// Children
|
|
XmlChildCtrlPr: CtrlPr;
|
|
end;
|
|
|
|
type Den = class(OpenXmlCompositeElement)
|
|
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: Den);override;
|
|
public
|
|
|
|
// multi property
|
|
property Rs read ReadRs;
|
|
function ReadRs(_index);
|
|
function AddR(): R;
|
|
function AppendR(): R;
|
|
|
|
public
|
|
// Children
|
|
end;
|
|
|
|
type SSub = class(OpenXmlCompositeElement)
|
|
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: SSub);override;
|
|
public
|
|
|
|
// normal property
|
|
property SSubPr read ReadXmlChildSSubPr;
|
|
property E read ReadXmlChildE;
|
|
property Sub read ReadXmlChildSub;
|
|
function ReadXmlChildSSubPr(): SSubPr;
|
|
function ReadXmlChildE(): E;
|
|
function ReadXmlChildSub(): Sub;
|
|
|
|
public
|
|
// Children
|
|
XmlChildSSubPr: SSubPr;
|
|
XmlChildE: E;
|
|
XmlChildSub: Sub;
|
|
end;
|
|
|
|
type SSubPr = class(OpenXmlCompositeElement)
|
|
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: SSubPr);override;
|
|
public
|
|
|
|
// normal property
|
|
property CtrlPr read ReadXmlChildCtrlPr;
|
|
function ReadXmlChildCtrlPr(): CtrlPr;
|
|
|
|
public
|
|
// Children
|
|
XmlChildCtrlPr: CtrlPr;
|
|
end;
|
|
|
|
type Sub = class(OpenXmlCompositeElement)
|
|
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: Sub);override;
|
|
public
|
|
|
|
// normal property
|
|
property CtrlPr read ReadXmlChildCtrlPr;
|
|
function ReadXmlChildCtrlPr(): CtrlPr;
|
|
|
|
// multi property
|
|
property Rs read ReadRs;
|
|
function ReadRs(_index);
|
|
function AddR(): R;
|
|
function AppendR(): R;
|
|
|
|
public
|
|
// Children
|
|
XmlChildCtrlPr: CtrlPr;
|
|
end;
|
|
|
|
type Nary = class(OpenXmlCompositeElement)
|
|
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: Nary);override;
|
|
public
|
|
|
|
// normal property
|
|
property NaryPr read ReadXmlChildNaryPr;
|
|
property Sub read ReadXmlChildSub;
|
|
property Sup read ReadXmlChildSup;
|
|
property E read ReadXmlChildE;
|
|
function ReadXmlChildNaryPr(): NaryPr;
|
|
function ReadXmlChildSub(): Sub;
|
|
function ReadXmlChildSup(): Sup;
|
|
function ReadXmlChildE(): E;
|
|
|
|
public
|
|
// Children
|
|
XmlChildNaryPr: NaryPr;
|
|
XmlChildSub: Sub;
|
|
XmlChildSup: Sup;
|
|
XmlChildE: E;
|
|
end;
|
|
|
|
type NaryPr = class(OpenXmlCompositeElement)
|
|
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: NaryPr);override;
|
|
public
|
|
|
|
// normal property
|
|
property Chr read ReadXmlChildChr;
|
|
property Grow read ReadXmlChildGrow;
|
|
property SubHide read ReadXmlChildSubHide;
|
|
property SupHide read ReadXmlChildSupHide;
|
|
property LimLoc read ReadXmlChildLimLoc;
|
|
property CtrlPr read ReadXmlChildCtrlPr;
|
|
function ReadXmlChildChr(): PureMVal;
|
|
function ReadXmlChildGrow(): PureMVal;
|
|
function ReadXmlChildSubHide(): PureMVal;
|
|
function ReadXmlChildSupHide(): PureMVal;
|
|
function ReadXmlChildLimLoc(): PureMVal;
|
|
function ReadXmlChildCtrlPr(): CtrlPr;
|
|
|
|
public
|
|
// Children
|
|
XmlChildChr: PureMVal;
|
|
XmlChildGrow: PureMVal;
|
|
XmlChildSubHide: PureMVal;
|
|
XmlChildSupHide: PureMVal;
|
|
XmlChildLimLoc: PureMVal;
|
|
XmlChildCtrlPr: CtrlPr;
|
|
end;
|
|
|
|
type Func = class(OpenXmlCompositeElement)
|
|
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: Func);override;
|
|
public
|
|
|
|
// normal property
|
|
property FuncPr read ReadXmlChildFuncPr;
|
|
property FName read ReadXmlChildFName;
|
|
property E read ReadXmlChildE;
|
|
function ReadXmlChildFuncPr(): FuncPr;
|
|
function ReadXmlChildFName(): FName;
|
|
function ReadXmlChildE(): E;
|
|
|
|
public
|
|
// Children
|
|
XmlChildFuncPr: FuncPr;
|
|
XmlChildFName: FName;
|
|
XmlChildE: E;
|
|
end;
|
|
|
|
type FName = class(OpenXmlCompositeElement)
|
|
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: FName);override;
|
|
public
|
|
|
|
// multi property
|
|
property Rs read ReadRs;
|
|
function ReadRs(_index);
|
|
function AddR(): R;
|
|
function AppendR(): R;
|
|
|
|
public
|
|
// Children
|
|
end;
|
|
|
|
type FuncPr = class(OpenXmlCompositeElement)
|
|
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: FuncPr);override;
|
|
public
|
|
|
|
// normal property
|
|
property CtrlPr read ReadXmlChildCtrlPr;
|
|
function ReadXmlChildCtrlPr(): CtrlPr;
|
|
|
|
public
|
|
// Children
|
|
XmlChildCtrlPr: CtrlPr;
|
|
end;
|
|
|
|
type CoreProperties = class(OpenXmlCompositeElement)
|
|
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: CoreProperties);override;
|
|
public
|
|
|
|
// pcdata property
|
|
property Title read ReadXmlChildTitle;
|
|
property Subject read ReadXmlChildSubject;
|
|
property Creator read ReadXmlChildCreator;
|
|
property Keywords read ReadXmlChildKeywords;
|
|
property Description read ReadXmlChildDescription;
|
|
property LastModifiedBy read ReadXmlChildLastModifiedBy;
|
|
property Revision read ReadXmlChildRevision;
|
|
property LastPrinted read ReadXmlChildLastPrinted;
|
|
property Created read ReadXmlChildCreated;
|
|
property Modified read ReadXmlChildModified;
|
|
function ReadXmlChildTitle();
|
|
function ReadXmlChildSubject();
|
|
function ReadXmlChildCreator();
|
|
function ReadXmlChildKeywords();
|
|
function ReadXmlChildDescription();
|
|
function ReadXmlChildLastModifiedBy();
|
|
function ReadXmlChildRevision();
|
|
function ReadXmlChildLastPrinted();
|
|
function ReadXmlChildCreated();
|
|
function ReadXmlChildModified();
|
|
|
|
public
|
|
// Children
|
|
XmlChildTitle: OpenXmlTextElement;
|
|
XmlChildSubject: OpenXmlTextElement;
|
|
XmlChildCreator: OpenXmlTextElement;
|
|
XmlChildKeywords: OpenXmlTextElement;
|
|
XmlChildDescription: OpenXmlTextElement;
|
|
XmlChildLastModifiedBy: OpenXmlTextElement;
|
|
XmlChildRevision: OpenXmlTextElement;
|
|
XmlChildLastPrinted: OpenXmlTextElement;
|
|
XmlChildCreated: Created;
|
|
XmlChildModified: Modified;
|
|
end;
|
|
|
|
type Created = class(OpenXmlTextElement)
|
|
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: Created);override;
|
|
public
|
|
// attributes property
|
|
property Type read ReadXmlAttrType write WriteXmlAttrType;
|
|
function ReadXmlAttrType();
|
|
function WriteXmlAttrType(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrType: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type Modified = class(OpenXmlTextElement)
|
|
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: Modified);override;
|
|
public
|
|
// attributes property
|
|
property Type read ReadXmlAttrType write WriteXmlAttrType;
|
|
function ReadXmlAttrType();
|
|
function WriteXmlAttrType(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrType: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type Relationships = class(OpenXmlCompositeElement)
|
|
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: Relationships);override;
|
|
public
|
|
|
|
// multi property
|
|
property Relationships read ReadRelationships;
|
|
function ReadRelationships(_index);
|
|
function AddRelationship(): Relationship;
|
|
function AppendRelationship(): Relationship;
|
|
|
|
public
|
|
// Children
|
|
end;
|
|
|
|
type Relationship = class(OpenXmlCompositeElement)
|
|
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: Relationship);override;
|
|
public
|
|
// attributes property
|
|
property Id read ReadXmlAttrId write WriteXmlAttrId;
|
|
property Type read ReadXmlAttrType write WriteXmlAttrType;
|
|
property Target read ReadXmlAttrTarget write WriteXmlAttrTarget;
|
|
function ReadXmlAttrId();
|
|
function WriteXmlAttrId(_value);
|
|
function ReadXmlAttrType();
|
|
function WriteXmlAttrType(_value);
|
|
function ReadXmlAttrTarget();
|
|
function WriteXmlAttrTarget(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrId: OpenXmlAttribute;
|
|
XmlAttrType: OpenXmlAttribute;
|
|
XmlAttrTarget: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type Types = class(OpenXmlCompositeElement)
|
|
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: Types);override;
|
|
public
|
|
|
|
// multi property
|
|
property Defaults read ReadDefaults;
|
|
property Overrides read ReadOverrides;
|
|
function ReadDefaults(_index);
|
|
function ReadOverrides(_index);
|
|
function AddDefault(): Default;
|
|
function AddOverride(): _Override;
|
|
function AppendDefault(): Default;
|
|
function AppendOverride(): _Override;
|
|
|
|
public
|
|
// Children
|
|
end;
|
|
|
|
type Default = class(OpenXmlCompositeElement)
|
|
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: Default);override;
|
|
public
|
|
// attributes property
|
|
property Extension read ReadXmlAttrExtension write WriteXmlAttrExtension;
|
|
property ContentType read ReadXmlAttrContentType write WriteXmlAttrContentType;
|
|
function ReadXmlAttrExtension();
|
|
function WriteXmlAttrExtension(_value);
|
|
function ReadXmlAttrContentType();
|
|
function WriteXmlAttrContentType(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrExtension: OpenXmlAttribute;
|
|
XmlAttrContentType: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
type _Override = class(OpenXmlCompositeElement)
|
|
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: _Override);override;
|
|
public
|
|
// attributes property
|
|
property PartName read ReadXmlAttrPartName write WriteXmlAttrPartName;
|
|
property ContentType read ReadXmlAttrContentType write WriteXmlAttrContentType;
|
|
function ReadXmlAttrPartName();
|
|
function WriteXmlAttrPartName(_value);
|
|
function ReadXmlAttrContentType();
|
|
function WriteXmlAttrContentType(_value);
|
|
|
|
public
|
|
// Attributes
|
|
XmlAttrPartName: OpenXmlAttribute;
|
|
XmlAttrContentType: OpenXmlAttribute;
|
|
|
|
end;
|
|
|
|
implementation
|
|
|
|
function MathPr.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "mathPr");
|
|
end;
|
|
|
|
function MathPr.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function MathPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function MathPr.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "mathFont": array(0, makeweakref(thisFunction(ReadXmlChildMathFont))),
|
|
pre + "brkBin": array(1, makeweakref(thisFunction(ReadXmlChildBrkBin))),
|
|
pre + "brkBinSub": array(2, makeweakref(thisFunction(ReadXmlChildBrkBinSub))),
|
|
pre + "smallFrac": array(3, makeweakref(thisFunction(ReadXmlChildSmallFrac))),
|
|
pre + "dispDef": array(4, makeweakref(thisFunction(ReadXmlChildDispDef))),
|
|
pre + "lMargin": array(5, makeweakref(thisFunction(ReadXmlChildLMargin))),
|
|
pre + "rMargin": array(6, makeweakref(thisFunction(ReadXmlChildRMargin))),
|
|
pre + "defJc": array(7, makeweakref(thisFunction(ReadXmlChildDefJc))),
|
|
pre + "wrapIndent": array(8, makeweakref(thisFunction(ReadXmlChildWrapIndent))),
|
|
pre + "intLim": array(9, makeweakref(thisFunction(ReadXmlChildIntLim))),
|
|
pre + "naryLim": array(10, makeweakref(thisFunction(ReadXmlChildNaryLim))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function MathPr.Copy(_obj: MathPr);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildMathFont) then
|
|
{self.}MathFont.Copy(_obj.XmlChildMathFont);
|
|
if not ifnil(_obj.XmlChildBrkBin) then
|
|
{self.}BrkBin.Copy(_obj.XmlChildBrkBin);
|
|
if not ifnil(_obj.XmlChildBrkBinSub) then
|
|
{self.}BrkBinSub.Copy(_obj.XmlChildBrkBinSub);
|
|
if not ifnil(_obj.XmlChildSmallFrac) then
|
|
{self.}SmallFrac.Copy(_obj.XmlChildSmallFrac);
|
|
if not ifnil(_obj.XmlChildDispDef) then
|
|
ifnil({self.}XmlChildDispDef) ? {self.}DispDef.Copy(_obj.XmlChildDispDef) : {self.}XmlChildDispDef.Copy(_obj.XmlChildDispDef);
|
|
if not ifnil(_obj.XmlChildLMargin) then
|
|
{self.}LMargin.Copy(_obj.XmlChildLMargin);
|
|
if not ifnil(_obj.XmlChildRMargin) then
|
|
{self.}RMargin.Copy(_obj.XmlChildRMargin);
|
|
if not ifnil(_obj.XmlChildDefJc) then
|
|
{self.}DefJc.Copy(_obj.XmlChildDefJc);
|
|
if not ifnil(_obj.XmlChildWrapIndent) then
|
|
{self.}WrapIndent.Copy(_obj.XmlChildWrapIndent);
|
|
if not ifnil(_obj.XmlChildIntLim) then
|
|
{self.}IntLim.Copy(_obj.XmlChildIntLim);
|
|
if not ifnil(_obj.XmlChildNaryLim) then
|
|
{self.}NaryLim.Copy(_obj.XmlChildNaryLim);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function MathPr.ReadXmlChildDispDef();
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildDispDef) or {self.}XmlChildDispDef.Removed) then
|
|
begin
|
|
{self.}XmlChildDispDef := new OpenXmlSimpleType(self, {self.}Prefix, "dispDef");
|
|
container_.Set({self.}XmlChildDispDef);
|
|
end
|
|
return {self.}XmlChildDispDef;
|
|
end;
|
|
|
|
function MathPr.ReadXmlChildMathFont(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildMathFont) or {self.}XmlChildMathFont.Removed) then
|
|
begin
|
|
{self.}XmlChildMathFont := new PureMVal(self, {self.}Prefix, "mathFont");
|
|
container_.Set({self.}XmlChildMathFont);
|
|
end
|
|
return {self.}XmlChildMathFont;
|
|
end;
|
|
|
|
function MathPr.ReadXmlChildBrkBin(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildBrkBin) or {self.}XmlChildBrkBin.Removed) then
|
|
begin
|
|
{self.}XmlChildBrkBin := new PureMVal(self, {self.}Prefix, "brkBin");
|
|
container_.Set({self.}XmlChildBrkBin);
|
|
end
|
|
return {self.}XmlChildBrkBin;
|
|
end;
|
|
|
|
function MathPr.ReadXmlChildBrkBinSub(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildBrkBinSub) or {self.}XmlChildBrkBinSub.Removed) then
|
|
begin
|
|
{self.}XmlChildBrkBinSub := new PureMVal(self, {self.}Prefix, "brkBinSub");
|
|
container_.Set({self.}XmlChildBrkBinSub);
|
|
end
|
|
return {self.}XmlChildBrkBinSub;
|
|
end;
|
|
|
|
function MathPr.ReadXmlChildSmallFrac(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildSmallFrac) or {self.}XmlChildSmallFrac.Removed) then
|
|
begin
|
|
{self.}XmlChildSmallFrac := new PureMVal(self, {self.}Prefix, "smallFrac");
|
|
container_.Set({self.}XmlChildSmallFrac);
|
|
end
|
|
return {self.}XmlChildSmallFrac;
|
|
end;
|
|
|
|
function MathPr.ReadXmlChildLMargin(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildLMargin) or {self.}XmlChildLMargin.Removed) then
|
|
begin
|
|
{self.}XmlChildLMargin := new PureMVal(self, {self.}Prefix, "lMargin");
|
|
container_.Set({self.}XmlChildLMargin);
|
|
end
|
|
return {self.}XmlChildLMargin;
|
|
end;
|
|
|
|
function MathPr.ReadXmlChildRMargin(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildRMargin) or {self.}XmlChildRMargin.Removed) then
|
|
begin
|
|
{self.}XmlChildRMargin := new PureMVal(self, {self.}Prefix, "rMargin");
|
|
container_.Set({self.}XmlChildRMargin);
|
|
end
|
|
return {self.}XmlChildRMargin;
|
|
end;
|
|
|
|
function MathPr.ReadXmlChildDefJc(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildDefJc) or {self.}XmlChildDefJc.Removed) then
|
|
begin
|
|
{self.}XmlChildDefJc := new PureMVal(self, {self.}Prefix, "defJc");
|
|
container_.Set({self.}XmlChildDefJc);
|
|
end
|
|
return {self.}XmlChildDefJc;
|
|
end;
|
|
|
|
function MathPr.ReadXmlChildWrapIndent(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildWrapIndent) or {self.}XmlChildWrapIndent.Removed) then
|
|
begin
|
|
{self.}XmlChildWrapIndent := new PureMVal(self, {self.}Prefix, "wrapIndent");
|
|
container_.Set({self.}XmlChildWrapIndent);
|
|
end
|
|
return {self.}XmlChildWrapIndent;
|
|
end;
|
|
|
|
function MathPr.ReadXmlChildIntLim(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildIntLim) or {self.}XmlChildIntLim.Removed) then
|
|
begin
|
|
{self.}XmlChildIntLim := new PureMVal(self, {self.}Prefix, "intLim");
|
|
container_.Set({self.}XmlChildIntLim);
|
|
end
|
|
return {self.}XmlChildIntLim;
|
|
end;
|
|
|
|
function MathPr.ReadXmlChildNaryLim(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildNaryLim) or {self.}XmlChildNaryLim.Removed) then
|
|
begin
|
|
{self.}XmlChildNaryLim := new PureMVal(self, {self.}Prefix, "naryLim");
|
|
container_.Set({self.}XmlChildNaryLim);
|
|
end
|
|
return {self.}XmlChildNaryLim;
|
|
end;
|
|
|
|
function OMathPara.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "oMathPara");
|
|
end;
|
|
|
|
function OMathPara.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function OMathPara.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function OMathPara.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "oMathParaPr": array(0, makeweakref(thisFunction(ReadXmlChildOMathParaPr))),
|
|
pre + "oMath": array(1, makeweakref(thisFunction(ReadXmlChildOMath))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function OMathPara.Copy(_obj: OMathPara);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildOMathParaPr) then
|
|
{self.}OMathParaPr.Copy(_obj.XmlChildOMathParaPr);
|
|
if not ifnil(_obj.XmlChildOMath) then
|
|
{self.}OMath.Copy(_obj.XmlChildOMath);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function OMathPara.ReadXmlChildOMathParaPr(): OMathParaPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildOMathParaPr) or {self.}XmlChildOMathParaPr.Removed) then
|
|
begin
|
|
{self.}XmlChildOMathParaPr := new OMathParaPr(self, {self.}Prefix, "oMathParaPr");
|
|
container_.Set({self.}XmlChildOMathParaPr);
|
|
end
|
|
return {self.}XmlChildOMathParaPr;
|
|
end;
|
|
|
|
function OMathPara.ReadXmlChildOMath(): OMath;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildOMath) or {self.}XmlChildOMath.Removed) then
|
|
begin
|
|
{self.}XmlChildOMath := new OMath(self, {self.}Prefix, "oMath");
|
|
container_.Set({self.}XmlChildOMath);
|
|
end
|
|
return {self.}XmlChildOMath;
|
|
end;
|
|
|
|
function OMathParaPr.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "oMathParaPr");
|
|
end;
|
|
|
|
function OMathParaPr.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function OMathParaPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function OMathParaPr.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "jc": array(0, makeweakref(thisFunction(ReadXmlChildJc))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function OMathParaPr.Copy(_obj: OMathParaPr);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildJc) then
|
|
{self.}Jc.Copy(_obj.XmlChildJc);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function OMathParaPr.ReadXmlChildJc(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildJc) or {self.}XmlChildJc.Removed) then
|
|
begin
|
|
{self.}XmlChildJc := new PureMVal(self, {self.}Prefix, "jc");
|
|
container_.Set({self.}XmlChildJc);
|
|
end
|
|
return {self.}XmlChildJc;
|
|
end;
|
|
|
|
function PureMVal.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "");
|
|
end;
|
|
|
|
function PureMVal.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function PureMVal.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function PureMVal.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
pre + "val": makeweakref(thisFunction(WriteXmlAttrVal)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function PureMVal.Copy(_obj: PureMVal);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.Val) then
|
|
{self.}Val := _obj.Val;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function PureMVal.ReadXmlAttrVal();
|
|
begin
|
|
return {self.}XmlAttrVal.Value;
|
|
end;
|
|
|
|
function PureMVal.WriteXmlAttrVal(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrVal) then
|
|
begin
|
|
{self.}XmlAttrVal := new OpenXmlAttribute({self.}Prefix, "val", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrVal;
|
|
end
|
|
{self.}XmlAttrVal.Value := _value;
|
|
end;
|
|
|
|
function OMath.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "oMath");
|
|
end;
|
|
|
|
function OMath.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function OMath.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function OMath.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "r": array(0, makeweakref(thisFunction(AppendR))),
|
|
pre + "d": array(1, makeweakref(thisFunction(AppendD))),
|
|
pre + "f": array(2, makeweakref(thisFunction(AppendF))),
|
|
pre + "rad": array(3, makeweakref(thisFunction(AppendRad))),
|
|
pre + "sSub": array(4, makeweakref(thisFunction(AppendSSub))),
|
|
pre + "nary": array(5, makeweakref(thisFunction(AppendNary))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function OMath.Copy(_obj: OMath);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function OMath.ReadRs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "r", ind);
|
|
end;
|
|
|
|
function OMath.ReadDs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "d", ind);
|
|
end;
|
|
|
|
function OMath.ReadFs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "f", ind);
|
|
end;
|
|
|
|
function OMath.ReadRads(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "rad", ind);
|
|
end;
|
|
|
|
function OMath.ReadSSubs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "sSub", ind);
|
|
end;
|
|
|
|
function OMath.ReadNaries(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "nary", ind);
|
|
end;
|
|
|
|
function OMath.AddR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function OMath.AddD(): D;
|
|
begin
|
|
obj := new D(self, {self.}Prefix, "d");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function OMath.AddF(): F;
|
|
begin
|
|
obj := new F(self, {self.}Prefix, "f");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function OMath.AddRad(): Rad;
|
|
begin
|
|
obj := new Rad(self, {self.}Prefix, "rad");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function OMath.AddSSub(): SSub;
|
|
begin
|
|
obj := new SSub(self, {self.}Prefix, "sSub");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function OMath.AddNary(): Nary;
|
|
begin
|
|
obj := new Nary(self, {self.}Prefix, "nary");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function OMath.AppendR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function OMath.AppendD(): D;
|
|
begin
|
|
obj := new D(self, {self.}Prefix, "d");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function OMath.AppendF(): F;
|
|
begin
|
|
obj := new F(self, {self.}Prefix, "f");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function OMath.AppendRad(): Rad;
|
|
begin
|
|
obj := new Rad(self, {self.}Prefix, "rad");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function OMath.AppendSSub(): SSub;
|
|
begin
|
|
obj := new SSub(self, {self.}Prefix, "sSub");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function OMath.AppendNary(): Nary;
|
|
begin
|
|
obj := new Nary(self, {self.}Prefix, "nary");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function R.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "r");
|
|
end;
|
|
|
|
function R.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function R.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function R.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "rPr": array(0, makeweakref(thisFunction(ReadXmlChildRPr))),
|
|
"a:rPr": array(1, makeweakref(thisFunction(ReadXmlChildARPr))),
|
|
"w:rPr": array(2, makeweakref(thisFunction(ReadXmlChildWRPr))),
|
|
pre + "t": array(3, makeweakref(thisFunction(ReadXmlChildT))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function R.Copy(_obj: R);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildRPr) then
|
|
{self.}RPr.Copy(_obj.XmlChildRPr);
|
|
if not ifnil(_obj.XmlChildARPr) then
|
|
{self.}ARPr.Copy(_obj.XmlChildARPr);
|
|
if not ifnil(_obj.XmlChildWRPr) then
|
|
{self.}WRPr.Copy(_obj.XmlChildWRPr);
|
|
if not ifnil(_obj.XmlChildT) then
|
|
{self.}T.Copy(_obj.XmlChildT);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function R.ReadXmlChildRPr(_ns: string): RPr;
|
|
begin
|
|
if _ns = "a" then
|
|
return ReadXmlChildARPr();
|
|
else if _ns = "w" then
|
|
return ReadXmlChildWRPr();
|
|
if tslassigning and (ifnil({self.}XmlChildRPr) or {self.}XmlChildRPr.Removed) then
|
|
begin
|
|
{self.}XmlChildRPr := new RPr(self, {self.}Prefix, "rPr");
|
|
container_.Set({self.}XmlChildRPr);
|
|
end
|
|
return {self.}XmlChildRPr;
|
|
end;
|
|
|
|
function R.ReadXmlChildARPr(): RPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildARPr) or {self.}XmlChildARPr.Removed) then
|
|
begin
|
|
{self.}XmlChildARPr := new DrawingML.RPr(self, "a", "rPr");
|
|
container_.Set({self.}XmlChildARPr);
|
|
end
|
|
return {self.}XmlChildARPr;
|
|
end;
|
|
|
|
function R.ReadXmlChildWRPr(): RPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildWRPr) or {self.}XmlChildWRPr.Removed) then
|
|
begin
|
|
{self.}XmlChildWRPr := new DocxML.RPr(self, "w", "rPr");
|
|
container_.Set({self.}XmlChildWRPr);
|
|
end
|
|
return {self.}XmlChildWRPr;
|
|
end;
|
|
|
|
function R.ReadXmlChildT(): T;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildT) or {self.}XmlChildT.Removed) then
|
|
begin
|
|
{self.}XmlChildT := new T(self, {self.}Prefix, "t");
|
|
container_.Set({self.}XmlChildT);
|
|
end
|
|
return {self.}XmlChildT;
|
|
end;
|
|
|
|
function RPr.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "rPr");
|
|
end;
|
|
|
|
function RPr.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function RPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function RPr.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "sty": array(0, makeweakref(thisFunction(ReadXmlChildSty))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function RPr.Copy(_obj: RPr);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildSty) then
|
|
{self.}Sty.Copy(_obj.XmlChildSty);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function RPr.ReadXmlChildSty(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildSty) or {self.}XmlChildSty.Removed) then
|
|
begin
|
|
{self.}XmlChildSty := new PureMVal(self, {self.}Prefix, "sty");
|
|
container_.Set({self.}XmlChildSty);
|
|
end
|
|
return {self.}XmlChildSty;
|
|
end;
|
|
|
|
function T.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "w", "t");
|
|
end;
|
|
|
|
function T.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlTextElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function T.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlTextElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function T.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"xml:space": makeweakref(thisFunction(WriteXmlAttrSpace)),
|
|
);
|
|
end;
|
|
|
|
function T.Copy(_obj: T);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlTextElement).Copy(_obj);
|
|
if not ifnil(_obj.Space) then
|
|
{self.}Space := _obj.Space;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function T.ReadXmlAttrSpace();
|
|
begin
|
|
return {self.}XmlAttrSpace.Value;
|
|
end;
|
|
|
|
function T.WriteXmlAttrSpace(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrSpace) then
|
|
begin
|
|
{self.}XmlAttrSpace := new OpenXmlAttribute("xml", "space", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrSpace;
|
|
end
|
|
{self.}XmlAttrSpace.Value := _value;
|
|
end;
|
|
|
|
function D.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "d");
|
|
end;
|
|
|
|
function D.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function D.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function D.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "dPr": array(0, makeweakref(thisFunction(ReadXmlChildDPr))),
|
|
pre + "e": array(1, makeweakref(thisFunction(ReadXmlChildE))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function D.Copy(_obj: D);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildDPr) then
|
|
{self.}DPr.Copy(_obj.XmlChildDPr);
|
|
if not ifnil(_obj.XmlChildE) then
|
|
{self.}E.Copy(_obj.XmlChildE);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function D.ReadXmlChildDPr(): DPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildDPr) or {self.}XmlChildDPr.Removed) then
|
|
begin
|
|
{self.}XmlChildDPr := new DPr(self, {self.}Prefix, "dPr");
|
|
container_.Set({self.}XmlChildDPr);
|
|
end
|
|
return {self.}XmlChildDPr;
|
|
end;
|
|
|
|
function D.ReadXmlChildE(): E;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildE) or {self.}XmlChildE.Removed) then
|
|
begin
|
|
{self.}XmlChildE := new E(self, {self.}Prefix, "e");
|
|
container_.Set({self.}XmlChildE);
|
|
end
|
|
return {self.}XmlChildE;
|
|
end;
|
|
|
|
function DPr.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "dPr");
|
|
end;
|
|
|
|
function DPr.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function DPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function DPr.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "begChr": array(0, makeweakref(thisFunction(ReadXmlChildBegChr))),
|
|
pre + "endChr": array(1, makeweakref(thisFunction(ReadXmlChildEndChr))),
|
|
pre + "sepChr": array(2, makeweakref(thisFunction(ReadXmlChildSepChr))),
|
|
pre + "shp": array(3, makeweakref(thisFunction(ReadXmlChildShp))),
|
|
pre + "grow": array(4, makeweakref(thisFunction(ReadXmlChildGrow))),
|
|
pre + "ctrlPr": array(5, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
|
|
"w:rPr": array(6, makeweakref(thisFunction(ReadXmlChildRPr))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function DPr.Copy(_obj: DPr);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildBegChr) then
|
|
{self.}BegChr.Copy(_obj.XmlChildBegChr);
|
|
if not ifnil(_obj.XmlChildEndChr) then
|
|
{self.}EndChr.Copy(_obj.XmlChildEndChr);
|
|
if not ifnil(_obj.XmlChildSepChr) then
|
|
{self.}SepChr.Copy(_obj.XmlChildSepChr);
|
|
if not ifnil(_obj.XmlChildShp) then
|
|
{self.}Shp.Copy(_obj.XmlChildShp);
|
|
if not ifnil(_obj.XmlChildGrow) then
|
|
{self.}Grow.Copy(_obj.XmlChildGrow);
|
|
if not ifnil(_obj.XmlChildCtrlPr) then
|
|
{self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
|
|
if not ifnil(_obj.XmlChildRPr) then
|
|
{self.}RPr.Copy(_obj.XmlChildRPr);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function DPr.ReadXmlChildBegChr(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildBegChr) or {self.}XmlChildBegChr.Removed) then
|
|
begin
|
|
{self.}XmlChildBegChr := new PureMVal(self, {self.}Prefix, "begChr");
|
|
container_.Set({self.}XmlChildBegChr);
|
|
end
|
|
return {self.}XmlChildBegChr;
|
|
end;
|
|
|
|
function DPr.ReadXmlChildEndChr(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildEndChr) or {self.}XmlChildEndChr.Removed) then
|
|
begin
|
|
{self.}XmlChildEndChr := new PureMVal(self, {self.}Prefix, "endChr");
|
|
container_.Set({self.}XmlChildEndChr);
|
|
end
|
|
return {self.}XmlChildEndChr;
|
|
end;
|
|
|
|
function DPr.ReadXmlChildSepChr(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildSepChr) or {self.}XmlChildSepChr.Removed) then
|
|
begin
|
|
{self.}XmlChildSepChr := new PureMVal(self, {self.}Prefix, "sepChr");
|
|
container_.Set({self.}XmlChildSepChr);
|
|
end
|
|
return {self.}XmlChildSepChr;
|
|
end;
|
|
|
|
function DPr.ReadXmlChildShp(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildShp) or {self.}XmlChildShp.Removed) then
|
|
begin
|
|
{self.}XmlChildShp := new PureMVal(self, {self.}Prefix, "shp");
|
|
container_.Set({self.}XmlChildShp);
|
|
end
|
|
return {self.}XmlChildShp;
|
|
end;
|
|
|
|
function DPr.ReadXmlChildGrow(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildGrow) or {self.}XmlChildGrow.Removed) then
|
|
begin
|
|
{self.}XmlChildGrow := new PureMVal(self, {self.}Prefix, "grow");
|
|
container_.Set({self.}XmlChildGrow);
|
|
end
|
|
return {self.}XmlChildGrow;
|
|
end;
|
|
|
|
function DPr.ReadXmlChildCtrlPr(): CtrlPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
|
|
begin
|
|
{self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
|
|
container_.Set({self.}XmlChildCtrlPr);
|
|
end
|
|
return {self.}XmlChildCtrlPr;
|
|
end;
|
|
|
|
function DPr.ReadXmlChildRPr(): RPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildRPr) or {self.}XmlChildRPr.Removed) then
|
|
begin
|
|
{self.}XmlChildRPr := new DocxML.RPr(self, "w", "rPr");
|
|
container_.Set({self.}XmlChildRPr);
|
|
end
|
|
return {self.}XmlChildRPr;
|
|
end;
|
|
|
|
function CtrlPr.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "ctrlPr");
|
|
end;
|
|
|
|
function CtrlPr.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function CtrlPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function CtrlPr.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "rPr": array(0, makeweakref(thisFunction(ReadXmlChildRPr))),
|
|
pre + "del": array(1, makeweakref(thisFunction(ReadXmlChildDel))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function CtrlPr.Copy(_obj: CtrlPr);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildRPr) then
|
|
{self.}RPr.Copy(_obj.XmlChildRPr);
|
|
if not ifnil(_obj.XmlChildDel) then
|
|
{self.}Del.Copy(_obj.XmlChildDel);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function CtrlPr.ReadXmlChildRPr(): RPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildRPr) or {self.}XmlChildRPr.Removed) then
|
|
begin
|
|
{self.}XmlChildRPr := new DrawingML.RPr(self, {self.}Prefix, "rPr");
|
|
container_.Set({self.}XmlChildRPr);
|
|
end
|
|
return {self.}XmlChildRPr;
|
|
end;
|
|
|
|
function CtrlPr.ReadXmlChildDel(): Del;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildDel) or {self.}XmlChildDel.Removed) then
|
|
begin
|
|
{self.}XmlChildDel := new Del(self, {self.}Prefix, "del");
|
|
container_.Set({self.}XmlChildDel);
|
|
end
|
|
return {self.}XmlChildDel;
|
|
end;
|
|
|
|
function E.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "e");
|
|
end;
|
|
|
|
function E.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function E.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function E.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "r": array(0, makeweakref(thisFunction(AppendR))),
|
|
pre + "d": array(1, makeweakref(thisFunction(AppendD))),
|
|
pre + "sSup": array(2, makeweakref(thisFunction(AppendSSup))),
|
|
pre + "sSub": array(3, makeweakref(thisFunction(AppendSSub))),
|
|
pre + "func": array(4, makeweakref(thisFunction(AppendFunc))),
|
|
pre + "f": array(5, makeweakref(thisFunction(ReadXmlChildF))),
|
|
pre + "ctrlPr": array(6, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function E.Copy(_obj: E);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildF) then
|
|
{self.}F.Copy(_obj.XmlChildF);
|
|
if not ifnil(_obj.XmlChildCtrlPr) then
|
|
{self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function E.ReadXmlChildF(): F;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildF) or {self.}XmlChildF.Removed) then
|
|
begin
|
|
{self.}XmlChildF := new F(self, {self.}Prefix, "f");
|
|
container_.Set({self.}XmlChildF);
|
|
end
|
|
return {self.}XmlChildF;
|
|
end;
|
|
|
|
function E.ReadXmlChildCtrlPr(): CtrlPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
|
|
begin
|
|
{self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
|
|
container_.Set({self.}XmlChildCtrlPr);
|
|
end
|
|
return {self.}XmlChildCtrlPr;
|
|
end;
|
|
|
|
function E.ReadRs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "r", ind);
|
|
end;
|
|
|
|
function E.ReadDs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "d", ind);
|
|
end;
|
|
|
|
function E.ReadSSups(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "sSup", ind);
|
|
end;
|
|
|
|
function E.ReadSSubs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "sSub", ind);
|
|
end;
|
|
|
|
function E.ReadFuncs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "func", ind);
|
|
end;
|
|
|
|
function E.AddR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function E.AddD(): D;
|
|
begin
|
|
obj := new D(self, {self.}Prefix, "d");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function E.AddSSup(): SSup;
|
|
begin
|
|
obj := new SSup(self, {self.}Prefix, "sSup");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function E.AddSSub(): SSub;
|
|
begin
|
|
obj := new SSub(self, {self.}Prefix, "sSub");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function E.AddFunc(): Func;
|
|
begin
|
|
obj := new Func(self, {self.}Prefix, "func");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function E.AppendR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function E.AppendD(): D;
|
|
begin
|
|
obj := new D(self, {self.}Prefix, "d");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function E.AppendSSup(): SSup;
|
|
begin
|
|
obj := new SSup(self, {self.}Prefix, "sSup");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function E.AppendSSub(): SSub;
|
|
begin
|
|
obj := new SSub(self, {self.}Prefix, "sSub");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function E.AppendFunc(): Func;
|
|
begin
|
|
obj := new Func(self, {self.}Prefix, "func");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function SSup.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "sSup");
|
|
end;
|
|
|
|
function SSup.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function SSup.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function SSup.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "sSupPr": array(0, makeweakref(thisFunction(ReadXmlChildSSupPr))),
|
|
pre + "e": array(1, makeweakref(thisFunction(ReadXmlChildE))),
|
|
pre + "sup": array(2, makeweakref(thisFunction(ReadXmlChildSup))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function SSup.Copy(_obj: SSup);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildSSupPr) then
|
|
{self.}SSupPr.Copy(_obj.XmlChildSSupPr);
|
|
if not ifnil(_obj.XmlChildE) then
|
|
{self.}E.Copy(_obj.XmlChildE);
|
|
if not ifnil(_obj.XmlChildSup) then
|
|
{self.}Sup.Copy(_obj.XmlChildSup);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function SSup.ReadXmlChildSSupPr(): SSupPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildSSupPr) or {self.}XmlChildSSupPr.Removed) then
|
|
begin
|
|
{self.}XmlChildSSupPr := new SSupPr(self, {self.}Prefix, "sSupPr");
|
|
container_.Set({self.}XmlChildSSupPr);
|
|
end
|
|
return {self.}XmlChildSSupPr;
|
|
end;
|
|
|
|
function SSup.ReadXmlChildE(): E;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildE) or {self.}XmlChildE.Removed) then
|
|
begin
|
|
{self.}XmlChildE := new E(self, {self.}Prefix, "e");
|
|
container_.Set({self.}XmlChildE);
|
|
end
|
|
return {self.}XmlChildE;
|
|
end;
|
|
|
|
function SSup.ReadXmlChildSup(): Sup;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildSup) or {self.}XmlChildSup.Removed) then
|
|
begin
|
|
{self.}XmlChildSup := new Sup(self, {self.}Prefix, "sup");
|
|
container_.Set({self.}XmlChildSup);
|
|
end
|
|
return {self.}XmlChildSup;
|
|
end;
|
|
|
|
function SSupPr.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "sSupPr");
|
|
end;
|
|
|
|
function SSupPr.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function SSupPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function SSupPr.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "ctrlPr": array(0, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function SSupPr.Copy(_obj: SSupPr);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildCtrlPr) then
|
|
{self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function SSupPr.ReadXmlChildCtrlPr(): CtrlPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
|
|
begin
|
|
{self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
|
|
container_.Set({self.}XmlChildCtrlPr);
|
|
end
|
|
return {self.}XmlChildCtrlPr;
|
|
end;
|
|
|
|
function Sup.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "sup");
|
|
end;
|
|
|
|
function Sup.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Sup.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Sup.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "r": array(0, makeweakref(thisFunction(AppendR))),
|
|
pre + "ctrlPr": array(1, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Sup.Copy(_obj: Sup);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildCtrlPr) then
|
|
{self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Sup.ReadXmlChildCtrlPr(): CtrlPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
|
|
begin
|
|
{self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
|
|
container_.Set({self.}XmlChildCtrlPr);
|
|
end
|
|
return {self.}XmlChildCtrlPr;
|
|
end;
|
|
|
|
function Sup.ReadRs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "r", ind);
|
|
end;
|
|
|
|
function Sup.AddR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Sup.AppendR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function F.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "f");
|
|
end;
|
|
|
|
function F.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function F.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function F.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "fPr": array(0, makeweakref(thisFunction(ReadXmlChildFPr))),
|
|
pre + "num": array(1, makeweakref(thisFunction(ReadXmlChildNum))),
|
|
pre + "den": array(2, makeweakref(thisFunction(ReadXmlChildDen))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function F.Copy(_obj: F);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildFPr) then
|
|
{self.}FPr.Copy(_obj.XmlChildFPr);
|
|
if not ifnil(_obj.XmlChildNum) then
|
|
{self.}Num.Copy(_obj.XmlChildNum);
|
|
if not ifnil(_obj.XmlChildDen) then
|
|
{self.}Den.Copy(_obj.XmlChildDen);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function F.ReadXmlChildFPr(): FPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildFPr) or {self.}XmlChildFPr.Removed) then
|
|
begin
|
|
{self.}XmlChildFPr := new FPr(self, {self.}Prefix, "fPr");
|
|
container_.Set({self.}XmlChildFPr);
|
|
end
|
|
return {self.}XmlChildFPr;
|
|
end;
|
|
|
|
function F.ReadXmlChildNum(): Num;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildNum) or {self.}XmlChildNum.Removed) then
|
|
begin
|
|
{self.}XmlChildNum := new Num(self, {self.}Prefix, "num");
|
|
container_.Set({self.}XmlChildNum);
|
|
end
|
|
return {self.}XmlChildNum;
|
|
end;
|
|
|
|
function F.ReadXmlChildDen(): Den;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildDen) or {self.}XmlChildDen.Removed) then
|
|
begin
|
|
{self.}XmlChildDen := new Den(self, {self.}Prefix, "den");
|
|
container_.Set({self.}XmlChildDen);
|
|
end
|
|
return {self.}XmlChildDen;
|
|
end;
|
|
|
|
function FPr.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "fPr");
|
|
end;
|
|
|
|
function FPr.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function FPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function FPr.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "type": array(0, makeweakref(thisFunction(ReadXmlChildType))),
|
|
pre + "ctrlPr": array(1, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function FPr.Copy(_obj: FPr);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildType) then
|
|
{self.}Type.Copy(_obj.XmlChildType);
|
|
if not ifnil(_obj.XmlChildCtrlPr) then
|
|
{self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function FPr.ReadXmlChildType(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildType) or {self.}XmlChildType.Removed) then
|
|
begin
|
|
{self.}XmlChildType := new PureMVal(self, {self.}Prefix, "type");
|
|
container_.Set({self.}XmlChildType);
|
|
end
|
|
return {self.}XmlChildType;
|
|
end;
|
|
|
|
function FPr.ReadXmlChildCtrlPr(): CtrlPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
|
|
begin
|
|
{self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
|
|
container_.Set({self.}XmlChildCtrlPr);
|
|
end
|
|
return {self.}XmlChildCtrlPr;
|
|
end;
|
|
|
|
function Num.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "num");
|
|
end;
|
|
|
|
function Num.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Num.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Num.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "r": array(0, makeweakref(thisFunction(AppendR))),
|
|
pre + "rad": array(1, makeweakref(thisFunction(ReadXmlChildRad))),
|
|
pre + "ctrlPr": array(2, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Num.Copy(_obj: Num);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildRad) then
|
|
{self.}Rad.Copy(_obj.XmlChildRad);
|
|
if not ifnil(_obj.XmlChildCtrlPr) then
|
|
{self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Num.ReadXmlChildRad(): Rad;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildRad) or {self.}XmlChildRad.Removed) then
|
|
begin
|
|
{self.}XmlChildRad := new Rad(self, {self.}Prefix, "rad");
|
|
container_.Set({self.}XmlChildRad);
|
|
end
|
|
return {self.}XmlChildRad;
|
|
end;
|
|
|
|
function Num.ReadXmlChildCtrlPr(): CtrlPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
|
|
begin
|
|
{self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
|
|
container_.Set({self.}XmlChildCtrlPr);
|
|
end
|
|
return {self.}XmlChildCtrlPr;
|
|
end;
|
|
|
|
function Num.ReadRs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "r", ind);
|
|
end;
|
|
|
|
function Num.AddR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Num.AppendR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Rad.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "rad");
|
|
end;
|
|
|
|
function Rad.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Rad.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Rad.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "radPr": array(0, makeweakref(thisFunction(ReadXmlChildRadPr))),
|
|
pre + "deg": array(1, makeweakref(thisFunction(ReadXmlChildDeg))),
|
|
pre + "e": array(2, makeweakref(thisFunction(ReadXmlChildE))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Rad.Copy(_obj: Rad);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildRadPr) then
|
|
{self.}RadPr.Copy(_obj.XmlChildRadPr);
|
|
if not ifnil(_obj.XmlChildDeg) then
|
|
{self.}Deg.Copy(_obj.XmlChildDeg);
|
|
if not ifnil(_obj.XmlChildE) then
|
|
{self.}E.Copy(_obj.XmlChildE);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Rad.ReadXmlChildRadPr(): RadPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildRadPr) or {self.}XmlChildRadPr.Removed) then
|
|
begin
|
|
{self.}XmlChildRadPr := new RadPr(self, {self.}Prefix, "radPr");
|
|
container_.Set({self.}XmlChildRadPr);
|
|
end
|
|
return {self.}XmlChildRadPr;
|
|
end;
|
|
|
|
function Rad.ReadXmlChildDeg(): Deg;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildDeg) or {self.}XmlChildDeg.Removed) then
|
|
begin
|
|
{self.}XmlChildDeg := new Deg(self, {self.}Prefix, "deg");
|
|
container_.Set({self.}XmlChildDeg);
|
|
end
|
|
return {self.}XmlChildDeg;
|
|
end;
|
|
|
|
function Rad.ReadXmlChildE(): E;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildE) or {self.}XmlChildE.Removed) then
|
|
begin
|
|
{self.}XmlChildE := new E(self, {self.}Prefix, "e");
|
|
container_.Set({self.}XmlChildE);
|
|
end
|
|
return {self.}XmlChildE;
|
|
end;
|
|
|
|
function RadPr.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "radPr");
|
|
end;
|
|
|
|
function RadPr.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function RadPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function RadPr.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "degHide": array(0, makeweakref(thisFunction(ReadXmlChildDegHide))),
|
|
pre + "ctrlPr": array(1, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function RadPr.Copy(_obj: RadPr);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildDegHide) then
|
|
{self.}DegHide.Copy(_obj.XmlChildDegHide);
|
|
if not ifnil(_obj.XmlChildCtrlPr) then
|
|
{self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function RadPr.ReadXmlChildDegHide(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildDegHide) or {self.}XmlChildDegHide.Removed) then
|
|
begin
|
|
{self.}XmlChildDegHide := new PureMVal(self, {self.}Prefix, "degHide");
|
|
container_.Set({self.}XmlChildDegHide);
|
|
end
|
|
return {self.}XmlChildDegHide;
|
|
end;
|
|
|
|
function RadPr.ReadXmlChildCtrlPr(): CtrlPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
|
|
begin
|
|
{self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
|
|
container_.Set({self.}XmlChildCtrlPr);
|
|
end
|
|
return {self.}XmlChildCtrlPr;
|
|
end;
|
|
|
|
function Deg.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "deg");
|
|
end;
|
|
|
|
function Deg.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Deg.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Deg.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "ctrlPr": array(0, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Deg.Copy(_obj: Deg);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildCtrlPr) then
|
|
{self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Deg.ReadXmlChildCtrlPr(): CtrlPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
|
|
begin
|
|
{self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
|
|
container_.Set({self.}XmlChildCtrlPr);
|
|
end
|
|
return {self.}XmlChildCtrlPr;
|
|
end;
|
|
|
|
function Den.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "den");
|
|
end;
|
|
|
|
function Den.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Den.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Den.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "r": array(0, makeweakref(thisFunction(AppendR))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Den.Copy(_obj: Den);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Den.ReadRs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "r", ind);
|
|
end;
|
|
|
|
function Den.AddR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Den.AppendR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function SSub.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "sSub");
|
|
end;
|
|
|
|
function SSub.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function SSub.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function SSub.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "sSubPr": array(0, makeweakref(thisFunction(ReadXmlChildSSubPr))),
|
|
pre + "e": array(1, makeweakref(thisFunction(ReadXmlChildE))),
|
|
pre + "sub": array(2, makeweakref(thisFunction(ReadXmlChildSub))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function SSub.Copy(_obj: SSub);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildSSubPr) then
|
|
{self.}SSubPr.Copy(_obj.XmlChildSSubPr);
|
|
if not ifnil(_obj.XmlChildE) then
|
|
{self.}E.Copy(_obj.XmlChildE);
|
|
if not ifnil(_obj.XmlChildSub) then
|
|
{self.}Sub.Copy(_obj.XmlChildSub);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function SSub.ReadXmlChildSSubPr(): SSubPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildSSubPr) or {self.}XmlChildSSubPr.Removed) then
|
|
begin
|
|
{self.}XmlChildSSubPr := new SSubPr(self, {self.}Prefix, "sSubPr");
|
|
container_.Set({self.}XmlChildSSubPr);
|
|
end
|
|
return {self.}XmlChildSSubPr;
|
|
end;
|
|
|
|
function SSub.ReadXmlChildE(): E;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildE) or {self.}XmlChildE.Removed) then
|
|
begin
|
|
{self.}XmlChildE := new E(self, {self.}Prefix, "e");
|
|
container_.Set({self.}XmlChildE);
|
|
end
|
|
return {self.}XmlChildE;
|
|
end;
|
|
|
|
function SSub.ReadXmlChildSub(): Sub;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildSub) or {self.}XmlChildSub.Removed) then
|
|
begin
|
|
{self.}XmlChildSub := new Sub(self, {self.}Prefix, "sub");
|
|
container_.Set({self.}XmlChildSub);
|
|
end
|
|
return {self.}XmlChildSub;
|
|
end;
|
|
|
|
function SSubPr.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "sSubPr");
|
|
end;
|
|
|
|
function SSubPr.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function SSubPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function SSubPr.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "ctrlPr": array(0, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function SSubPr.Copy(_obj: SSubPr);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildCtrlPr) then
|
|
{self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function SSubPr.ReadXmlChildCtrlPr(): CtrlPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
|
|
begin
|
|
{self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
|
|
container_.Set({self.}XmlChildCtrlPr);
|
|
end
|
|
return {self.}XmlChildCtrlPr;
|
|
end;
|
|
|
|
function Sub.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "sub");
|
|
end;
|
|
|
|
function Sub.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Sub.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Sub.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "r": array(0, makeweakref(thisFunction(AppendR))),
|
|
pre + "ctrlPr": array(1, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Sub.Copy(_obj: Sub);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildCtrlPr) then
|
|
{self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Sub.ReadXmlChildCtrlPr(): CtrlPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
|
|
begin
|
|
{self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
|
|
container_.Set({self.}XmlChildCtrlPr);
|
|
end
|
|
return {self.}XmlChildCtrlPr;
|
|
end;
|
|
|
|
function Sub.ReadRs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "r", ind);
|
|
end;
|
|
|
|
function Sub.AddR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Sub.AppendR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Nary.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "nary");
|
|
end;
|
|
|
|
function Nary.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Nary.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Nary.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "naryPr": array(0, makeweakref(thisFunction(ReadXmlChildNaryPr))),
|
|
pre + "sub": array(1, makeweakref(thisFunction(ReadXmlChildSub))),
|
|
pre + "sup": array(2, makeweakref(thisFunction(ReadXmlChildSup))),
|
|
pre + "e": array(3, makeweakref(thisFunction(ReadXmlChildE))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Nary.Copy(_obj: Nary);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildNaryPr) then
|
|
{self.}NaryPr.Copy(_obj.XmlChildNaryPr);
|
|
if not ifnil(_obj.XmlChildSub) then
|
|
{self.}Sub.Copy(_obj.XmlChildSub);
|
|
if not ifnil(_obj.XmlChildSup) then
|
|
{self.}Sup.Copy(_obj.XmlChildSup);
|
|
if not ifnil(_obj.XmlChildE) then
|
|
{self.}E.Copy(_obj.XmlChildE);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Nary.ReadXmlChildNaryPr(): NaryPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildNaryPr) or {self.}XmlChildNaryPr.Removed) then
|
|
begin
|
|
{self.}XmlChildNaryPr := new NaryPr(self, {self.}Prefix, "naryPr");
|
|
container_.Set({self.}XmlChildNaryPr);
|
|
end
|
|
return {self.}XmlChildNaryPr;
|
|
end;
|
|
|
|
function Nary.ReadXmlChildSub(): Sub;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildSub) or {self.}XmlChildSub.Removed) then
|
|
begin
|
|
{self.}XmlChildSub := new Sub(self, {self.}Prefix, "sub");
|
|
container_.Set({self.}XmlChildSub);
|
|
end
|
|
return {self.}XmlChildSub;
|
|
end;
|
|
|
|
function Nary.ReadXmlChildSup(): Sup;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildSup) or {self.}XmlChildSup.Removed) then
|
|
begin
|
|
{self.}XmlChildSup := new Sup(self, {self.}Prefix, "sup");
|
|
container_.Set({self.}XmlChildSup);
|
|
end
|
|
return {self.}XmlChildSup;
|
|
end;
|
|
|
|
function Nary.ReadXmlChildE(): E;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildE) or {self.}XmlChildE.Removed) then
|
|
begin
|
|
{self.}XmlChildE := new E(self, {self.}Prefix, "e");
|
|
container_.Set({self.}XmlChildE);
|
|
end
|
|
return {self.}XmlChildE;
|
|
end;
|
|
|
|
function NaryPr.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "naryPr");
|
|
end;
|
|
|
|
function NaryPr.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function NaryPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function NaryPr.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "chr": array(0, makeweakref(thisFunction(ReadXmlChildChr))),
|
|
pre + "grow": array(1, makeweakref(thisFunction(ReadXmlChildGrow))),
|
|
pre + "subHide": array(2, makeweakref(thisFunction(ReadXmlChildSubHide))),
|
|
pre + "supHide": array(3, makeweakref(thisFunction(ReadXmlChildSupHide))),
|
|
pre + "limLoc": array(4, makeweakref(thisFunction(ReadXmlChildLimLoc))),
|
|
pre + "ctrlPr": array(5, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function NaryPr.Copy(_obj: NaryPr);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildChr) then
|
|
{self.}Chr.Copy(_obj.XmlChildChr);
|
|
if not ifnil(_obj.XmlChildGrow) then
|
|
{self.}Grow.Copy(_obj.XmlChildGrow);
|
|
if not ifnil(_obj.XmlChildSubHide) then
|
|
{self.}SubHide.Copy(_obj.XmlChildSubHide);
|
|
if not ifnil(_obj.XmlChildSupHide) then
|
|
{self.}SupHide.Copy(_obj.XmlChildSupHide);
|
|
if not ifnil(_obj.XmlChildLimLoc) then
|
|
{self.}LimLoc.Copy(_obj.XmlChildLimLoc);
|
|
if not ifnil(_obj.XmlChildCtrlPr) then
|
|
{self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function NaryPr.ReadXmlChildChr(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildChr) or {self.}XmlChildChr.Removed) then
|
|
begin
|
|
{self.}XmlChildChr := new PureMVal(self, {self.}Prefix, "chr");
|
|
container_.Set({self.}XmlChildChr);
|
|
end
|
|
return {self.}XmlChildChr;
|
|
end;
|
|
|
|
function NaryPr.ReadXmlChildGrow(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildGrow) or {self.}XmlChildGrow.Removed) then
|
|
begin
|
|
{self.}XmlChildGrow := new PureMVal(self, {self.}Prefix, "grow");
|
|
container_.Set({self.}XmlChildGrow);
|
|
end
|
|
return {self.}XmlChildGrow;
|
|
end;
|
|
|
|
function NaryPr.ReadXmlChildSubHide(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildSubHide) or {self.}XmlChildSubHide.Removed) then
|
|
begin
|
|
{self.}XmlChildSubHide := new PureMVal(self, {self.}Prefix, "subHide");
|
|
container_.Set({self.}XmlChildSubHide);
|
|
end
|
|
return {self.}XmlChildSubHide;
|
|
end;
|
|
|
|
function NaryPr.ReadXmlChildSupHide(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildSupHide) or {self.}XmlChildSupHide.Removed) then
|
|
begin
|
|
{self.}XmlChildSupHide := new PureMVal(self, {self.}Prefix, "supHide");
|
|
container_.Set({self.}XmlChildSupHide);
|
|
end
|
|
return {self.}XmlChildSupHide;
|
|
end;
|
|
|
|
function NaryPr.ReadXmlChildLimLoc(): PureMVal;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildLimLoc) or {self.}XmlChildLimLoc.Removed) then
|
|
begin
|
|
{self.}XmlChildLimLoc := new PureMVal(self, {self.}Prefix, "limLoc");
|
|
container_.Set({self.}XmlChildLimLoc);
|
|
end
|
|
return {self.}XmlChildLimLoc;
|
|
end;
|
|
|
|
function NaryPr.ReadXmlChildCtrlPr(): CtrlPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
|
|
begin
|
|
{self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
|
|
container_.Set({self.}XmlChildCtrlPr);
|
|
end
|
|
return {self.}XmlChildCtrlPr;
|
|
end;
|
|
|
|
function Func.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "func");
|
|
end;
|
|
|
|
function Func.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Func.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Func.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "funcPr": array(0, makeweakref(thisFunction(ReadXmlChildFuncPr))),
|
|
pre + "fname": array(1, makeweakref(thisFunction(ReadXmlChildFName))),
|
|
pre + "e": array(2, makeweakref(thisFunction(ReadXmlChildE))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Func.Copy(_obj: Func);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildFuncPr) then
|
|
{self.}FuncPr.Copy(_obj.XmlChildFuncPr);
|
|
if not ifnil(_obj.XmlChildFName) then
|
|
{self.}FName.Copy(_obj.XmlChildFName);
|
|
if not ifnil(_obj.XmlChildE) then
|
|
{self.}E.Copy(_obj.XmlChildE);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Func.ReadXmlChildFuncPr(): FuncPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildFuncPr) or {self.}XmlChildFuncPr.Removed) then
|
|
begin
|
|
{self.}XmlChildFuncPr := new FuncPr(self, {self.}Prefix, "funcPr");
|
|
container_.Set({self.}XmlChildFuncPr);
|
|
end
|
|
return {self.}XmlChildFuncPr;
|
|
end;
|
|
|
|
function Func.ReadXmlChildFName(): FName;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildFName) or {self.}XmlChildFName.Removed) then
|
|
begin
|
|
{self.}XmlChildFName := new FName(self, {self.}Prefix, "fname");
|
|
container_.Set({self.}XmlChildFName);
|
|
end
|
|
return {self.}XmlChildFName;
|
|
end;
|
|
|
|
function Func.ReadXmlChildE(): E;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildE) or {self.}XmlChildE.Removed) then
|
|
begin
|
|
{self.}XmlChildE := new E(self, {self.}Prefix, "e");
|
|
container_.Set({self.}XmlChildE);
|
|
end
|
|
return {self.}XmlChildE;
|
|
end;
|
|
|
|
function FName.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "fname");
|
|
end;
|
|
|
|
function FName.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function FName.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function FName.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "r": array(0, makeweakref(thisFunction(AppendR))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function FName.Copy(_obj: FName);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function FName.ReadRs(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get(pre + "r", ind);
|
|
end;
|
|
|
|
function FName.AddR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function FName.AppendR(): R;
|
|
begin
|
|
obj := new R(self, {self.}Prefix, "r");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function FuncPr.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "m", "funcPr");
|
|
end;
|
|
|
|
function FuncPr.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function FuncPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function FuncPr.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
pre + "ctrlPr": array(0, makeweakref(thisFunction(ReadXmlChildCtrlPr))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function FuncPr.Copy(_obj: FuncPr);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildCtrlPr) then
|
|
{self.}CtrlPr.Copy(_obj.XmlChildCtrlPr);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function FuncPr.ReadXmlChildCtrlPr(): CtrlPr;
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCtrlPr) or {self.}XmlChildCtrlPr.Removed) then
|
|
begin
|
|
{self.}XmlChildCtrlPr := new CtrlPr(self, {self.}Prefix, "ctrlPr");
|
|
container_.Set({self.}XmlChildCtrlPr);
|
|
end
|
|
return {self.}XmlChildCtrlPr;
|
|
end;
|
|
|
|
function CoreProperties.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "cp", "coreProperties");
|
|
end;
|
|
|
|
function CoreProperties.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function CoreProperties.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function CoreProperties.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
"dc:title": array(0, makeweakref(thisFunction(ReadXmlChildTitle))),
|
|
"dc:subject": array(1, makeweakref(thisFunction(ReadXmlChildSubject))),
|
|
"dc:creator": array(2, makeweakref(thisFunction(ReadXmlChildCreator))),
|
|
"cp:keywords": array(3, makeweakref(thisFunction(ReadXmlChildKeywords))),
|
|
"cp:description": array(4, makeweakref(thisFunction(ReadXmlChildDescription))),
|
|
"cp:lastModifiedBy": array(5, makeweakref(thisFunction(ReadXmlChildLastModifiedBy))),
|
|
"cp:revision": array(6, makeweakref(thisFunction(ReadXmlChildRevision))),
|
|
"cp:lastPrinted": array(7, makeweakref(thisFunction(ReadXmlChildLastPrinted))),
|
|
"dcterms:created": array(8, makeweakref(thisFunction(ReadXmlChildCreated))),
|
|
"dcterms:modified": array(9, makeweakref(thisFunction(ReadXmlChildModified))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function CoreProperties.Copy(_obj: CoreProperties);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.XmlChildTitle) then
|
|
{self.}Title.Copy(_obj.XmlChildTitle);
|
|
if not ifnil(_obj.XmlChildSubject) then
|
|
{self.}Subject.Copy(_obj.XmlChildSubject);
|
|
if not ifnil(_obj.XmlChildCreator) then
|
|
{self.}Creator.Copy(_obj.XmlChildCreator);
|
|
if not ifnil(_obj.XmlChildKeywords) then
|
|
{self.}Keywords.Copy(_obj.XmlChildKeywords);
|
|
if not ifnil(_obj.XmlChildDescription) then
|
|
{self.}Description.Copy(_obj.XmlChildDescription);
|
|
if not ifnil(_obj.XmlChildLastModifiedBy) then
|
|
{self.}LastModifiedBy.Copy(_obj.XmlChildLastModifiedBy);
|
|
if not ifnil(_obj.XmlChildRevision) then
|
|
{self.}Revision.Copy(_obj.XmlChildRevision);
|
|
if not ifnil(_obj.XmlChildLastPrinted) then
|
|
{self.}LastPrinted.Copy(_obj.XmlChildLastPrinted);
|
|
if not ifnil(_obj.XmlChildCreated) then
|
|
{self.}Created.Copy(_obj.XmlChildCreated);
|
|
if not ifnil(_obj.XmlChildModified) then
|
|
{self.}Modified.Copy(_obj.XmlChildModified);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function CoreProperties.ReadXmlChildTitle();
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildTitle) or {self.}XmlChildTitle.Removed) then
|
|
begin
|
|
{self.}XmlChildTitle := new OpenXmlTextElement(self, "dc", "title");
|
|
container_.Set({self.}XmlChildTitle);
|
|
end
|
|
return {self.}XmlChildTitle;
|
|
end;
|
|
|
|
function CoreProperties.ReadXmlChildSubject();
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildSubject) or {self.}XmlChildSubject.Removed) then
|
|
begin
|
|
{self.}XmlChildSubject := new OpenXmlTextElement(self, "dc", "subject");
|
|
container_.Set({self.}XmlChildSubject);
|
|
end
|
|
return {self.}XmlChildSubject;
|
|
end;
|
|
|
|
function CoreProperties.ReadXmlChildCreator();
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCreator) or {self.}XmlChildCreator.Removed) then
|
|
begin
|
|
{self.}XmlChildCreator := new OpenXmlTextElement(self, "dc", "creator");
|
|
container_.Set({self.}XmlChildCreator);
|
|
end
|
|
return {self.}XmlChildCreator;
|
|
end;
|
|
|
|
function CoreProperties.ReadXmlChildKeywords();
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildKeywords) or {self.}XmlChildKeywords.Removed) then
|
|
begin
|
|
{self.}XmlChildKeywords := new OpenXmlTextElement(self, "cp", "keywords");
|
|
container_.Set({self.}XmlChildKeywords);
|
|
end
|
|
return {self.}XmlChildKeywords;
|
|
end;
|
|
|
|
function CoreProperties.ReadXmlChildDescription();
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildDescription) or {self.}XmlChildDescription.Removed) then
|
|
begin
|
|
{self.}XmlChildDescription := new OpenXmlTextElement(self, "cp", "description");
|
|
container_.Set({self.}XmlChildDescription);
|
|
end
|
|
return {self.}XmlChildDescription;
|
|
end;
|
|
|
|
function CoreProperties.ReadXmlChildLastModifiedBy();
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildLastModifiedBy) or {self.}XmlChildLastModifiedBy.Removed) then
|
|
begin
|
|
{self.}XmlChildLastModifiedBy := new OpenXmlTextElement(self, "cp", "lastModifiedBy");
|
|
container_.Set({self.}XmlChildLastModifiedBy);
|
|
end
|
|
return {self.}XmlChildLastModifiedBy;
|
|
end;
|
|
|
|
function CoreProperties.ReadXmlChildRevision();
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildRevision) or {self.}XmlChildRevision.Removed) then
|
|
begin
|
|
{self.}XmlChildRevision := new OpenXmlTextElement(self, "cp", "revision");
|
|
container_.Set({self.}XmlChildRevision);
|
|
end
|
|
return {self.}XmlChildRevision;
|
|
end;
|
|
|
|
function CoreProperties.ReadXmlChildLastPrinted();
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildLastPrinted) or {self.}XmlChildLastPrinted.Removed) then
|
|
begin
|
|
{self.}XmlChildLastPrinted := new OpenXmlTextElement(self, "cp", "lastPrinted");
|
|
container_.Set({self.}XmlChildLastPrinted);
|
|
end
|
|
return {self.}XmlChildLastPrinted;
|
|
end;
|
|
|
|
function CoreProperties.ReadXmlChildCreated();
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildCreated) or {self.}XmlChildCreated.Removed) then
|
|
begin
|
|
{self.}XmlChildCreated := new Created(self, "dcterms", "created");
|
|
container_.Set({self.}XmlChildCreated);
|
|
end
|
|
return {self.}XmlChildCreated;
|
|
end;
|
|
|
|
function CoreProperties.ReadXmlChildModified();
|
|
begin
|
|
if tslassigning and (ifnil({self.}XmlChildModified) or {self.}XmlChildModified.Removed) then
|
|
begin
|
|
{self.}XmlChildModified := new Modified(self, "dcterms", "modified");
|
|
container_.Set({self.}XmlChildModified);
|
|
end
|
|
return {self.}XmlChildModified;
|
|
end;
|
|
|
|
function Created.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "dcterms", "created");
|
|
end;
|
|
|
|
function Created.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlTextElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Created.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlTextElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Created.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"xsi:type": makeweakref(thisFunction(WriteXmlAttrType)),
|
|
);
|
|
end;
|
|
|
|
function Created.Copy(_obj: Created);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlTextElement).Copy(_obj);
|
|
if not ifnil(_obj.Type) then
|
|
{self.}Type := _obj.Type;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Created.ReadXmlAttrType();
|
|
begin
|
|
return {self.}XmlAttrType.Value;
|
|
end;
|
|
|
|
function Created.WriteXmlAttrType(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrType) then
|
|
begin
|
|
{self.}XmlAttrType := new OpenXmlAttribute("xsi", "type", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrType;
|
|
end
|
|
{self.}XmlAttrType.Value := _value;
|
|
end;
|
|
|
|
function Modified.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "dcterms", "modified");
|
|
end;
|
|
|
|
function Modified.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlTextElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Modified.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlTextElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Modified.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"xsi:type": makeweakref(thisFunction(WriteXmlAttrType)),
|
|
);
|
|
end;
|
|
|
|
function Modified.Copy(_obj: Modified);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlTextElement).Copy(_obj);
|
|
if not ifnil(_obj.Type) then
|
|
{self.}Type := _obj.Type;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Modified.ReadXmlAttrType();
|
|
begin
|
|
return {self.}XmlAttrType.Value;
|
|
end;
|
|
|
|
function Modified.WriteXmlAttrType(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrType) then
|
|
begin
|
|
{self.}XmlAttrType := new OpenXmlAttribute("xsi", "type", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrType;
|
|
end
|
|
{self.}XmlAttrType.Value := _value;
|
|
end;
|
|
|
|
function Relationships.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "", "Relationships");
|
|
end;
|
|
|
|
function Relationships.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Relationships.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Relationships.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
"Relationship": array(0, makeweakref(thisFunction(AppendRelationship))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Relationships.Copy(_obj: Relationships);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Relationships.ReadRelationships(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get("Relationship", ind);
|
|
end;
|
|
|
|
function Relationships.AddRelationship(): Relationship;
|
|
begin
|
|
obj := new Relationship(self, "", "Relationship");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Relationships.AppendRelationship(): Relationship;
|
|
begin
|
|
obj := new Relationship(self, "", "Relationship");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Relationship.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "", "Relationship");
|
|
end;
|
|
|
|
function Relationship.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Relationship.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Relationship.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"Id": makeweakref(thisFunction(WriteXmlAttrId)),
|
|
"Type": makeweakref(thisFunction(WriteXmlAttrType)),
|
|
"Target": makeweakref(thisFunction(WriteXmlAttrTarget)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Relationship.Copy(_obj: Relationship);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.Id) then
|
|
{self.}Id := _obj.Id;
|
|
if not ifnil(_obj.Type) then
|
|
{self.}Type := _obj.Type;
|
|
if not ifnil(_obj.Target) then
|
|
{self.}Target := _obj.Target;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Relationship.ReadXmlAttrId();
|
|
begin
|
|
return {self.}XmlAttrId.Value;
|
|
end;
|
|
|
|
function Relationship.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 Relationship.ReadXmlAttrType();
|
|
begin
|
|
return {self.}XmlAttrType.Value;
|
|
end;
|
|
|
|
function Relationship.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 Relationship.ReadXmlAttrTarget();
|
|
begin
|
|
return {self.}XmlAttrTarget.Value;
|
|
end;
|
|
|
|
function Relationship.WriteXmlAttrTarget(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrTarget) then
|
|
begin
|
|
{self.}XmlAttrTarget := new OpenXmlAttribute("", "Target", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrTarget;
|
|
end
|
|
{self.}XmlAttrTarget.Value := _value;
|
|
end;
|
|
|
|
function Types.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "", "Types");
|
|
end;
|
|
|
|
function Types.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Types.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Types.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
);
|
|
sorted_child_ := array(
|
|
"Default": array(0, makeweakref(thisFunction(AppendDefault))),
|
|
"Override": array(1, makeweakref(thisFunction(AppendOverride))),
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Types.Copy(_obj: Types);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Types.ReadDefaults(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get("Default", ind);
|
|
end;
|
|
|
|
function Types.ReadOverrides(_index);
|
|
begin
|
|
ind := ifnil(_index) ? -2 : _index;
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
return container_.Get("Override", ind);
|
|
end;
|
|
|
|
function Types.AddDefault(): Default;
|
|
begin
|
|
obj := new Default(self, "", "Default");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Types.AddOverride(): _Override;
|
|
begin
|
|
obj := new _Override(self, "", "Override");
|
|
container_.Insert(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Types.AppendDefault(): Default;
|
|
begin
|
|
obj := new Default(self, "", "Default");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Types.AppendOverride(): _Override;
|
|
begin
|
|
obj := new _Override(self, "", "Override");
|
|
container_.Append(obj);
|
|
return obj;
|
|
end;
|
|
|
|
function Default.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "", "Default");
|
|
end;
|
|
|
|
function Default.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function Default.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function Default.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"Extension": makeweakref(thisFunction(WriteXmlAttrExtension)),
|
|
"ContentType": makeweakref(thisFunction(WriteXmlAttrContentType)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function Default.Copy(_obj: Default);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.Extension) then
|
|
{self.}Extension := _obj.Extension;
|
|
if not ifnil(_obj.ContentType) then
|
|
{self.}ContentType := _obj.ContentType;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function Default.ReadXmlAttrExtension();
|
|
begin
|
|
return {self.}XmlAttrExtension.Value;
|
|
end;
|
|
|
|
function Default.WriteXmlAttrExtension(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrExtension) then
|
|
begin
|
|
{self.}XmlAttrExtension := new OpenXmlAttribute("", "Extension", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrExtension;
|
|
end
|
|
{self.}XmlAttrExtension.Value := _value;
|
|
end;
|
|
|
|
function Default.ReadXmlAttrContentType();
|
|
begin
|
|
return {self.}XmlAttrContentType.Value;
|
|
end;
|
|
|
|
function Default.WriteXmlAttrContentType(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrContentType) then
|
|
begin
|
|
{self.}XmlAttrContentType := new OpenXmlAttribute("", "ContentType", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrContentType;
|
|
end
|
|
{self.}XmlAttrContentType.Value := _value;
|
|
end;
|
|
|
|
function _Override.Create();overload;
|
|
begin
|
|
{self.}Create(nil, "", "Override");
|
|
end;
|
|
|
|
function _Override.Create(_node: XmlNode);overload;
|
|
begin
|
|
class(OpenXmlCompositeElement).Create(_node: XmlNode);
|
|
end;
|
|
|
|
function _Override.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
|
|
begin
|
|
setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
|
|
class(OpenXmlCompositeElement).Create(_parent, _prefix, _local_name);
|
|
end;
|
|
|
|
function _Override.Init();override;
|
|
begin
|
|
pre := {self.}Prefix ? {self.}Prefix + ":" : "";
|
|
attributes_ := array();
|
|
attributes_pf_ := array(
|
|
"PartName": makeweakref(thisFunction(WriteXmlAttrPartName)),
|
|
"ContentType": makeweakref(thisFunction(WriteXmlAttrContentType)),
|
|
);
|
|
sorted_child_ := array(
|
|
);
|
|
container_ := new TSOfficeContainer(sorted_child_);
|
|
end;
|
|
|
|
function _Override.Copy(_obj: _Override);override;
|
|
begin
|
|
tslassigning_backup := tslassigning;
|
|
tslassigning := 1;
|
|
class(OpenXmlCompositeElement).Copy(_obj);
|
|
if not ifnil(_obj.PartName) then
|
|
{self.}PartName := _obj.PartName;
|
|
if not ifnil(_obj.ContentType) then
|
|
{self.}ContentType := _obj.ContentType;
|
|
tslassigning := tslassigning_backup;
|
|
end;
|
|
|
|
function _Override.ReadXmlAttrPartName();
|
|
begin
|
|
return {self.}XmlAttrPartName.Value;
|
|
end;
|
|
|
|
function _Override.WriteXmlAttrPartName(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrPartName) then
|
|
begin
|
|
{self.}XmlAttrPartName := new OpenXmlAttribute("", "PartName", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrPartName;
|
|
end
|
|
{self.}XmlAttrPartName.Value := _value;
|
|
end;
|
|
|
|
function _Override.ReadXmlAttrContentType();
|
|
begin
|
|
return {self.}XmlAttrContentType.Value;
|
|
end;
|
|
|
|
function _Override.WriteXmlAttrContentType(_value);
|
|
begin
|
|
if ifnil({self.}XmlAttrContentType) then
|
|
begin
|
|
{self.}XmlAttrContentType := new OpenXmlAttribute("", "ContentType", nil);
|
|
attributes_[length(attributes_)] := {self.}XmlAttrContentType;
|
|
end
|
|
{self.}XmlAttrContentType.Value := _value;
|
|
end;
|
|
|
|
end. |