OfficeXml/autounit/DrawingML.tsf

unit DrawingML;
interface
uses DrawingML;

type Theme = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Theme);override;
public
	// attributes property
	property Name read ReadXmlAttrName write WriteXmlAttrName;
	function ReadXmlAttrName();
	function WriteXmlAttrName(_value);

	// empty property
	property ObjectDefaults read ReadXmlChildObjectDefaults write WriteXmlChildObjectDefaults;
	property ExtraClrSchemeLst read ReadXmlChildExtraClrSchemeLst write WriteXmlChildExtraClrSchemeLst;
	function ReadXmlChildObjectDefaults();
	function WriteXmlChildObjectDefaults(_value);
	function ReadXmlChildExtraClrSchemeLst();
	function WriteXmlChildExtraClrSchemeLst(_value);

	// normal property
	property ThemeElements read ReadXmlChildThemeElements;
	property ExtLst read ReadXmlChildExtLst;
	function ReadXmlChildThemeElements(): ThemeElements;
	function ReadXmlChildExtLst(): ExtLst;

public
	// Attributes
	XmlAttrName: OpenXmlAttribute;

	// Children
	XmlChildThemeElements: ThemeElements;
	XmlChildObjectDefaults: OpenXmlEmpty;
	XmlChildExtraClrSchemeLst: OpenXmlEmpty;
	XmlChildExtLst: ExtLst;
end;

type ThemeElements = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: ThemeElements);override;
public
	// attributes property
	property Name read ReadXmlAttrName write WriteXmlAttrName;
	function ReadXmlAttrName();
	function WriteXmlAttrName(_value);

	// normal property
	property ClrScheme read ReadXmlChildClrScheme;
	property FontScheme read ReadXmlChildFontScheme;
	property FmtScheme read ReadXmlChildFmtScheme;
	function ReadXmlChildClrScheme(): ClrScheme;
	function ReadXmlChildFontScheme(): FontScheme;
	function ReadXmlChildFmtScheme(): FmtScheme;

public
	// Attributes
	XmlAttrName: OpenXmlAttribute;

	// Children
	XmlChildClrScheme: ClrScheme;
	XmlChildFontScheme: FontScheme;
	XmlChildFmtScheme: FmtScheme;
end;

type ClrScheme = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: ClrScheme);override;
public
	// attributes property
	property Name read ReadXmlAttrName write WriteXmlAttrName;
	function ReadXmlAttrName();
	function WriteXmlAttrName(_value);

	// normal property
	property Dk1 read ReadXmlChildDk1;
	property Lt1 read ReadXmlChildLt1;
	property Dk2 read ReadXmlChildDk2;
	property Lt2 read ReadXmlChildLt2;
	property Accent1 read ReadXmlChildAccent1;
	property Accent2 read ReadXmlChildAccent2;
	property Accent3 read ReadXmlChildAccent3;
	property Accent4 read ReadXmlChildAccent4;
	property Accent5 read ReadXmlChildAccent5;
	property Accent6 read ReadXmlChildAccent6;
	property Hlink read ReadXmlChildHlink;
	property FolHlink read ReadXmlChildFolHlink;
	function ReadXmlChildDk1(): Clr1;
	function ReadXmlChildLt1(): Clr1;
	function ReadXmlChildDk2(): Clr2;
	function ReadXmlChildLt2(): Clr2;
	function ReadXmlChildAccent1(): Clr2;
	function ReadXmlChildAccent2(): Clr2;
	function ReadXmlChildAccent3(): Clr2;
	function ReadXmlChildAccent4(): Clr2;
	function ReadXmlChildAccent5(): Clr2;
	function ReadXmlChildAccent6(): Clr2;
	function ReadXmlChildHlink(): Clr2;
	function ReadXmlChildFolHlink(): Clr2;

public
	// Attributes
	XmlAttrName: OpenXmlAttribute;

	// Children
	XmlChildDk1: Clr1;
	XmlChildLt1: Clr1;
	XmlChildDk2: Clr2;
	XmlChildLt2: Clr2;
	XmlChildAccent1: Clr2;
	XmlChildAccent2: Clr2;
	XmlChildAccent3: Clr2;
	XmlChildAccent4: Clr2;
	XmlChildAccent5: Clr2;
	XmlChildAccent6: Clr2;
	XmlChildHlink: Clr2;
	XmlChildFolHlink: Clr2;
end;

type Clr1 = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Clr1);override;
public

	// normal property
	property SysClr read ReadXmlChildSysClr;
	function ReadXmlChildSysClr(): SysClr;

public
	// Children
	XmlChildSysClr: SysClr;
end;

type SysClr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: SysClr);override;
public
	// attributes property
	property Val read ReadXmlAttrVal write WriteXmlAttrVal;
	property LastClr read ReadXmlAttrLastClr write WriteXmlAttrLastClr;
	function ReadXmlAttrVal();
	function WriteXmlAttrVal(_value);
	function ReadXmlAttrLastClr();
	function WriteXmlAttrLastClr(_value);

public
	// Attributes
	XmlAttrVal: OpenXmlAttribute;
	XmlAttrLastClr: OpenXmlAttribute;

end;

type Clr2 = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Clr2);override;
public

	// normal property
	property SrgbClr read ReadXmlChildSrgbClr;
	function ReadXmlChildSrgbClr(): SrgbClr;

public
	// Children
	XmlChildSrgbClr: SrgbClr;
end;

type SrgbClr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: SrgbClr);override;
public
	// attributes property
	property Val read ReadXmlAttrVal write WriteXmlAttrVal;
	function ReadXmlAttrVal();
	function WriteXmlAttrVal(_value);

	// normal property
	property Alpha read ReadXmlChildAlpha;
	function ReadXmlChildAlpha(): PureVal;

public
	// Attributes
	XmlAttrVal: OpenXmlAttribute;

	// Children
	XmlChildAlpha: PureVal;
end;

type PureVal = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: PureVal);override;
public
	// attributes property
	property Val read ReadXmlAttrVal write WriteXmlAttrVal;
	function ReadXmlAttrVal();
	function WriteXmlAttrVal(_value);

public
	// Attributes
	XmlAttrVal: OpenXmlAttribute;

end;

type FontScheme = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: FontScheme);override;
public
	// attributes property
	property Name read ReadXmlAttrName write WriteXmlAttrName;
	function ReadXmlAttrName();
	function WriteXmlAttrName(_value);

	// normal property
	property Majorfont read ReadXmlChildMajorfont;
	property Minorfont read ReadXmlChildMinorfont;
	function ReadXmlChildMajorfont(): Mfont;
	function ReadXmlChildMinorfont(): Mfont;

public
	// Attributes
	XmlAttrName: OpenXmlAttribute;

	// Children
	XmlChildMajorfont: Mfont;
	XmlChildMinorfont: Mfont;
end;

type MFont = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: MFont);override;
public

	// normal property
	property Latin read ReadXmlChildLatin;
	property Ea read ReadXmlChildEa;
	property Cs read ReadXmlChildCs;
	function ReadXmlChildLatin(): Latin;
	function ReadXmlChildEa(): Latin;
	function ReadXmlChildCs(): Latin;

	// multi property
	property Fonts read ReadFonts;
	function ReadFonts(_index);
	function AddFont(): Font;
	function AppendFont(): Font;

public
	// Children
	XmlChildLatin: Latin;
	XmlChildEa: Latin;
	XmlChildCs: Latin;
end;

type Font = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Font);override;
public
	// attributes property
	property Script read ReadXmlAttrScript write WriteXmlAttrScript;
	property Typeface read ReadXmlAttrTypeface write WriteXmlAttrTypeface;
	function ReadXmlAttrScript();
	function WriteXmlAttrScript(_value);
	function ReadXmlAttrTypeface();
	function WriteXmlAttrTypeface(_value);

public
	// Attributes
	XmlAttrScript: OpenXmlAttribute;
	XmlAttrTypeface: OpenXmlAttribute;

end;

type FmtScheme = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: FmtScheme);override;
public
	// attributes property
	property Name read ReadXmlAttrName write WriteXmlAttrName;
	function ReadXmlAttrName();
	function WriteXmlAttrName(_value);

	// normal property
	property FillStyleLst read ReadXmlChildFillStyleLst;
	property LnStyleLst read ReadXmlChildLnStyleLst;
	property EffectStyleLst read ReadXmlChildEffectStyleLst;
	property BgFillStyleLst read ReadXmlChildBgFillStyleLst;
	function ReadXmlChildFillStyleLst(): FillStyleLst;
	function ReadXmlChildLnStyleLst(): LnStyleLst;
	function ReadXmlChildEffectStyleLst(): EffectStyleLst;
	function ReadXmlChildBgFillStyleLst(): FillStyleLst;

public
	// Attributes
	XmlAttrName: OpenXmlAttribute;

	// Children
	XmlChildFillStyleLst: FillStyleLst;
	XmlChildLnStyleLst: LnStyleLst;
	XmlChildEffectStyleLst: EffectStyleLst;
	XmlChildBgFillStyleLst: FillStyleLst;
end;

type FillStyleLst = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: FillStyleLst);override;
public

	// multi property
	property SolidFills read ReadSolidFills;
	property GradFills read ReadGradFills;
	function ReadSolidFills(_index);
	function ReadGradFills(_index);
	function AddSolidFill(): SolidFill;
	function AddGradFill(): GradFill;
	function AppendSolidFill(): SolidFill;
	function AppendGradFill(): GradFill;

public
	// Children
end;

type SolidFill = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: SolidFill);override;
public

	// normal property
	property SchemeClr read ReadXmlChildSchemeClr;
	function ReadXmlChildSchemeClr(): SchemeClr;

public
	// Children
	XmlChildSchemeClr: SchemeClr;
end;

type SchemeClr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: SchemeClr);override;
public
	// attributes property
	property Val read ReadXmlAttrVal write WriteXmlAttrVal;
	function ReadXmlAttrVal();
	function WriteXmlAttrVal(_value);

	// normal property
	property LumMod read ReadXmlChildLumMod;
	property SatMod read ReadXmlChildSatMod;
	property Tint read ReadXmlChildTint;
	function ReadXmlChildLumMod(): PureVal;
	function ReadXmlChildSatMod(): PureVal;
	function ReadXmlChildTint(): PureVal;

public
	// Attributes
	XmlAttrVal: OpenXmlAttribute;

	// Children
	XmlChildLumMod: PureVal;
	XmlChildSatMod: PureVal;
	XmlChildTint: PureVal;
end;

type GradFill = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: GradFill);override;
public
	// attributes property
	property RotWithShape read ReadXmlAttrRotWithShape write WriteXmlAttrRotWithShape;
	function ReadXmlAttrRotWithShape();
	function WriteXmlAttrRotWithShape(_value);

	// normal property
	property GsLst read ReadXmlChildGsLst;
	property Lin read ReadXmlChildLin;
	function ReadXmlChildGsLst(): GsLst;
	function ReadXmlChildLin(): Lin;

public
	// Attributes
	XmlAttrRotWithShape: OpenXmlAttribute;

	// Children
	XmlChildGsLst: GsLst;
	XmlChildLin: Lin;
end;

type GsLst = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: GsLst);override;
public

	// multi property
	property Gses read ReadGses;
	function ReadGses(_index);
	function AddGs(): Gs;
	function AppendGs(): Gs;

public
	// Children
end;

type Gs = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Gs);override;
public
	// attributes property
	property Pos read ReadXmlAttrPos write WriteXmlAttrPos;
	function ReadXmlAttrPos();
	function WriteXmlAttrPos(_value);

	// normal property
	property SchemeClr read ReadXmlChildSchemeClr;
	function ReadXmlChildSchemeClr(): SchemeClr;

public
	// Attributes
	XmlAttrPos: OpenXmlAttribute;

	// Children
	XmlChildSchemeClr: SchemeClr;
end;

type Lin = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Lin);override;
public
	// attributes property
	property Ang read ReadXmlAttrAng write WriteXmlAttrAng;
	property Scaled read ReadXmlAttrScaled write WriteXmlAttrScaled;
	function ReadXmlAttrAng();
	function WriteXmlAttrAng(_value);
	function ReadXmlAttrScaled();
	function WriteXmlAttrScaled(_value);

public
	// Attributes
	XmlAttrAng: OpenXmlAttribute;
	XmlAttrScaled: OpenXmlAttribute;

end;

type LnStyleLst = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: LnStyleLst);override;
public

	// multi property
	property Lns read ReadLns;
	function ReadLns(_index);
	function AddLn(): Ln;
	function AppendLn(): Ln;

public
	// Children
end;

type EffectStyleLst = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: EffectStyleLst);override;
public

	// multi property
	property EffectStyles read ReadEffectStyles;
	function ReadEffectStyles(_index);
	function AddEffectStyle(): EffectStyle;
	function AppendEffectStyle(): EffectStyle;

public
	// Children
end;

type EffectStyle = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: EffectStyle);override;
public

	// normal property
	property EffectLst read ReadXmlChildEffectLst;
	function ReadXmlChildEffectLst(): EffectLst;

public
	// Children
	XmlChildEffectLst: EffectLst;
end;

type OuterShdw = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: OuterShdw);override;
public
	// attributes property
	property BlurRad read ReadXmlAttrBlurRad write WriteXmlAttrBlurRad;
	property Dist read ReadXmlAttrDist write WriteXmlAttrDist;
	property Dir read ReadXmlAttrDir write WriteXmlAttrDir;
	property Algn read ReadXmlAttrAlgn write WriteXmlAttrAlgn;
	property RotWithShape read ReadXmlAttrRotWithShape write WriteXmlAttrRotWithShape;
	function ReadXmlAttrBlurRad();
	function WriteXmlAttrBlurRad(_value);
	function ReadXmlAttrDist();
	function WriteXmlAttrDist(_value);
	function ReadXmlAttrDir();
	function WriteXmlAttrDir(_value);
	function ReadXmlAttrAlgn();
	function WriteXmlAttrAlgn(_value);
	function ReadXmlAttrRotWithShape();
	function WriteXmlAttrRotWithShape(_value);

	// normal property
	property SrgbClr read ReadXmlChildSrgbClr;
	function ReadXmlChildSrgbClr(): SrgbClr;

public
	// Attributes
	XmlAttrBlurRad: OpenXmlAttribute;
	XmlAttrDist: OpenXmlAttribute;
	XmlAttrDir: OpenXmlAttribute;
	XmlAttrAlgn: OpenXmlAttribute;
	XmlAttrRotWithShape: OpenXmlAttribute;

	// Children
	XmlChildSrgbClr: SrgbClr;
end;

type ExtLst = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: ExtLst);override;
public

	// multi property
	property Exts read ReadExts;
	function ReadExts(_index);
	function AddExt(): Ext;
	function AppendExt(): Ext;

public
	// Children
end;

type Ext = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Ext);override;
public
	// attributes property
	property Uri read ReadXmlAttrUri write WriteXmlAttrUri;
	function ReadXmlAttrUri();
	function WriteXmlAttrUri(_value);

	// normal property
	property Thm15ThemeFamily read ReadXmlChildThm15ThemeFamily;
	property UniqueId read ReadXmlChildUniqueId;
	property SlicerStyles read ReadXmlChildSlicerStyles;
	property TimelineStyles read ReadXmlChildTimelineStyles;
	function ReadXmlChildThm15ThemeFamily(): ThemeFamily;
	function ReadXmlChildUniqueId(): PureVal;
	function ReadXmlChildSlicerStyles(): SlicerStyles;
	function ReadXmlChildTimelineStyles(): TimelineStyles;

public
	// Attributes
	XmlAttrUri: OpenXmlAttribute;

	// Children
	XmlChildThm15ThemeFamily: ThemeFamily;
	XmlChildUniqueId: PureVal;
	XmlChildSlicerStyles: SlicerStyles;
	XmlChildTimelineStyles: TimelineStyles;
end;

type SlicerStyles = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: SlicerStyles);override;
public
	// attributes property
	property DefaultSlicerStyle read ReadXmlAttrDefaultSlicerStyle write WriteXmlAttrDefaultSlicerStyle;
	function ReadXmlAttrDefaultSlicerStyle();
	function WriteXmlAttrDefaultSlicerStyle(_value);

public
	// Attributes
	XmlAttrDefaultSlicerStyle: OpenXmlAttribute;

end;

type TimelineStyles = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: TimelineStyles);override;
public
	// attributes property
	property DefaultTimelineStyle read ReadXmlAttrDefaultTimelineStyle write WriteXmlAttrDefaultTimelineStyle;
	function ReadXmlAttrDefaultTimelineStyle();
	function WriteXmlAttrDefaultTimelineStyle(_value);

public
	// Attributes
	XmlAttrDefaultTimelineStyle: OpenXmlAttribute;

end;

type ThemeFamily = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: ThemeFamily);override;
public
	// attributes property
	property Name read ReadXmlAttrName write WriteXmlAttrName;
	property Id read ReadXmlAttrId write WriteXmlAttrId;
	property Vid read ReadXmlAttrVid write WriteXmlAttrVid;
	function ReadXmlAttrName();
	function WriteXmlAttrName(_value);
	function ReadXmlAttrId();
	function WriteXmlAttrId(_value);
	function ReadXmlAttrVid();
	function WriteXmlAttrVid(_value);

public
	// Attributes
	XmlAttrName: OpenXmlAttribute;
	XmlAttrId: OpenXmlAttribute;
	XmlAttrVid: OpenXmlAttribute;

end;

type ChartSpace = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: ChartSpace);override;
public

	// empty property
	property Lang read ReadXmlChildLang write WriteXmlChildLang;
	function ReadXmlChildLang();
	function WriteXmlChildLang(_value);

	// normal property
	property Date1904 read ReadXmlChildDate1904;
	property AlternateContent read ReadXmlChildAlternateContent;
	property Chart read ReadXmlChildChart;
	property SpPr read ReadXmlChildSpPr;
	property ExternalData read ReadXmlChildExternalData;
	function ReadXmlChildDate1904(): PureVal;
	function ReadXmlChildAlternateContent(): AlternateContent;
	function ReadXmlChildChart(): Chart;
	function ReadXmlChildSpPr(): SpPr;
	function ReadXmlChildExternalData(): ExternalData;

public
	// Children
	XmlChildDate1904: PureVal;
	XmlChildLang: OpenXmlEmpty;
	XmlChildAlternateContent: AlternateContent;
	XmlChildChart: Chart;
	XmlChildSpPr: SpPr;
	XmlChildExternalData: ExternalData;
end;

type Chart = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Chart);override;
public
	// attributes property
	property Id read ReadXmlAttrId write WriteXmlAttrId;
	function ReadXmlAttrId();
	function WriteXmlAttrId(_value);

	// normal property
	property Title read ReadXmlChildTitle;
	property AutoTitleDeleted read ReadXmlChildAutoTitleDeleted;
	property View3D read ReadXmlChildView3D;
	property PlotArea read ReadXmlChildPlotArea;
	property Legend read ReadXmlChildLegend;
	property PlotVisOnly read ReadXmlChildPlotVisOnly;
	property DispBlanksAs read ReadXmlChildDispBlanksAs;
	property ShowDLblsOverMax read ReadXmlChildShowDLblsOverMax;
	function ReadXmlChildTitle(): Title;
	function ReadXmlChildAutoTitleDeleted(): PureVal;
	function ReadXmlChildView3D(): View3D;
	function ReadXmlChildPlotArea(): PlotArea;
	function ReadXmlChildLegend(): Legend;
	function ReadXmlChildPlotVisOnly(): PureVal;
	function ReadXmlChildDispBlanksAs(): PureVal;
	function ReadXmlChildShowDLblsOverMax(): PureVal;

public
	// Attributes
	XmlAttrId: OpenXmlAttribute;

	// Children
	XmlChildTitle: Title;
	XmlChildAutoTitleDeleted: PureVal;
	XmlChildView3D: View3D;
	XmlChildPlotArea: PlotArea;
	XmlChildLegend: Legend;
	XmlChildPlotVisOnly: PureVal;
	XmlChildDispBlanksAs: PureVal;
	XmlChildShowDLblsOverMax: PureVal;
end;

type Legend = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Legend);override;
public

	// empty property
	property Layout read ReadXmlChildLayout write WriteXmlChildLayout;
	function ReadXmlChildLayout();
	function WriteXmlChildLayout(_value);

	// normal property
	property LegendPos read ReadXmlChildLegendPos;
	property Overlay read ReadXmlChildOverlay;
	property TxPr read ReadXmlChildTxPr;
	function ReadXmlChildLegendPos(): PureVal;
	function ReadXmlChildOverlay(): PureVal;
	function ReadXmlChildTxPr(): TxPr;

public
	// Children
	XmlChildLegendPos: PureVal;
	XmlChildLayout: OpenXmlEmpty;
	XmlChildOverlay: PureVal;
	XmlChildTxPr: TxPr;
end;

type View3D = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: View3D);override;
public

	// normal property
	property RotX read ReadXmlChildRotX;
	property RotY read ReadXmlChildRotY;
	property RAngAx read ReadXmlChildRAngAx;
	function ReadXmlChildRotX(): PureVal;
	function ReadXmlChildRotY(): PureVal;
	function ReadXmlChildRAngAx(): PureVal;

public
	// Children
	XmlChildRotX: PureVal;
	XmlChildRotY: PureVal;
	XmlChildRAngAx: PureVal;
end;

type PlotArea = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: PlotArea);override;
public

	// empty property
	property Layout read ReadXmlChildLayout write WriteXmlChildLayout;
	function ReadXmlChildLayout();
	function WriteXmlChildLayout(_value);

	// normal property
	property BarChart read ReadXmlChildBarChart;
	property CatAx read ReadXmlChildCatAx;
	property ValAx read ReadXmlChildValAx;
	property DTable read ReadXmlChildDTable;
	property SpPr read ReadXmlChildSpPr;
	function ReadXmlChildBarChart(): BarChart;
	function ReadXmlChildCatAx(): Ax;
	function ReadXmlChildValAx(): Ax;
	function ReadXmlChildDTable(): DTable;
	function ReadXmlChildSpPr(): SpPr;

public
	// Children
	XmlChildLayout: OpenXmlEmpty;
	XmlChildBarChart: BarChart;
	XmlChildCatAx: Ax;
	XmlChildValAx: Ax;
	XmlChildDTable: DTable;
	XmlChildSpPr: SpPr;
end;

type BarChart = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: BarChart);override;
public

	// normal property
	property BarDir read ReadXmlChildBarDir;
	property Grouping read ReadXmlChildGrouping;
	property VaryColors read ReadXmlChildVaryColors;
	property GapWidth read ReadXmlChildGapWidth;
	function ReadXmlChildBarDir(): PureVal;
	function ReadXmlChildGrouping(): PureVal;
	function ReadXmlChildVaryColors(): PureVal;
	function ReadXmlChildGapWidth(): PureVal;

	// multi property
	property Sers read ReadSers;
	property AxIds read ReadAxIds;
	function ReadSers(_index);
	function ReadAxIds(_index);
	function AddSer(): Ser;
	function AddAxId(): PureVal;
	function AppendSer(): Ser;
	function AppendAxId(): PureVal;

public
	// Children
	XmlChildBarDir: PureVal;
	XmlChildGrouping: PureVal;
	XmlChildVaryColors: PureVal;
	XmlChildGapWidth: PureVal;
end;

type Ser = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Ser);override;
public

	// normal property
	property Idx read ReadXmlChildIdx;
	property _Order read ReadXmlChild_Order;
	property Tx read ReadXmlChildTx;
	property InvertIfNegative read ReadXmlChildInvertIfNegative;
	property DLbls read ReadXmlChildDLbls;
	property Cat read ReadXmlChildCat;
	property Val read ReadXmlChildVal;
	property ExtLst read ReadXmlChildExtLst;
	function ReadXmlChildIdx(): PureVal;
	function ReadXmlChild_Order(): PureVal;
	function ReadXmlChildTx(): Tx;
	function ReadXmlChildInvertIfNegative(): PureVal;
	function ReadXmlChildDLbls(): DLbls;
	function ReadXmlChildCat(): Cat;
	function ReadXmlChildVal(): Val;
	function ReadXmlChildExtLst(): ExtLst;

public
	// Children
	XmlChildIdx: PureVal;
	XmlChild_Order: PureVal;
	XmlChildTx: Tx;
	XmlChildInvertIfNegative: PureVal;
	XmlChildDLbls: DLbls;
	XmlChildCat: Cat;
	XmlChildVal: Val;
	XmlChildExtLst: ExtLst;
end;

type DLbls = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: DLbls);override;
public

	// normal property
	property SpPr read ReadXmlChildSpPr;
	property ShowLegendKey read ReadXmlChildShowLegendKey;
	property ShowVal read ReadXmlChildShowVal;
	property ShowCatName read ReadXmlChildShowCatName;
	property ShowSerName read ReadXmlChildShowSerName;
	property ShowPercent read ReadXmlChildShowPercent;
	property ShowBubbleSize read ReadXmlChildShowBubbleSize;
	property ShowLeaderLines read ReadXmlChildShowLeaderLines;
	property ExtLst read ReadXmlChildExtLst;
	function ReadXmlChildSpPr(): SpPr;
	function ReadXmlChildShowLegendKey(): PureVal;
	function ReadXmlChildShowVal(): PureVal;
	function ReadXmlChildShowCatName(): PureVal;
	function ReadXmlChildShowSerName(): PureVal;
	function ReadXmlChildShowPercent(): PureVal;
	function ReadXmlChildShowBubbleSize(): PureVal;
	function ReadXmlChildShowLeaderLines(): PureVal;
	function ReadXmlChildExtLst(): ExtLst;

public
	// Children
	XmlChildSpPr: SpPr;
	XmlChildShowLegendKey: PureVal;
	XmlChildShowVal: PureVal;
	XmlChildShowCatName: PureVal;
	XmlChildShowSerName: PureVal;
	XmlChildShowPercent: PureVal;
	XmlChildShowBubbleSize: PureVal;
	XmlChildShowLeaderLines: PureVal;
	XmlChildExtLst: ExtLst;
end;

type Cat = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Cat);override;
public

	// normal property
	property StrRef read ReadXmlChildStrRef;
	function ReadXmlChildStrRef(): StrRef;

public
	// Children
	XmlChildStrRef: StrRef;
end;

type StrRef = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: StrRef);override;
public

	// pcdata property
	property F read ReadXmlChildF;
	function ReadXmlChildF();

	// normal property
	property StrCache read ReadXmlChildStrCache;
	function ReadXmlChildStrCache(): StrCache;

public
	// Children
	XmlChildF: OpenXmlPcdata;
	XmlChildStrCache: StrCache;
end;

type Val = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Val);override;
public

	// normal property
	property NumRef read ReadXmlChildNumRef;
	function ReadXmlChildNumRef(): NumRef;

public
	// Children
	XmlChildNumRef: NumRef;
end;

type NumRef = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: NumRef);override;
public

	// pcdata property
	property F read ReadXmlChildF;
	function ReadXmlChildF();

	// normal property
	property NumCache read ReadXmlChildNumCache;
	function ReadXmlChildNumCache(): NumCache;

public
	// Children
	XmlChildF: OpenXmlPcdata;
	XmlChildNumCache: NumCache;
end;

type StrCache = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: StrCache);override;
public

	// normal property
	property PtCount read ReadXmlChildPtCount;
	function ReadXmlChildPtCount(): PureVal;

	// multi property
	property Pts read ReadPts;
	function ReadPts(_index);
	function AddPt(): Pt;
	function AppendPt(): Pt;

public
	// Children
	XmlChildPtCount: PureVal;
end;

type NumCache = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: NumCache);override;
public

	// pcdata property
	property FormatCode read ReadXmlChildFormatCode;
	function ReadXmlChildFormatCode();

	// normal property
	property PtCount read ReadXmlChildPtCount;
	function ReadXmlChildPtCount(): PureVal;

	// multi property
	property Pts read ReadPts;
	function ReadPts(_index);
	function AddPt(): Pt;
	function AppendPt(): Pt;

public
	// Children
	XmlChildFormatCode: OpenXmlPcdata;
	XmlChildPtCount: PureVal;
end;

type Pt = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Pt);override;
public
	// attributes property
	property Idx read ReadXmlAttrIdx write WriteXmlAttrIdx;
	function ReadXmlAttrIdx();
	function WriteXmlAttrIdx(_value);

	// pcdata property
	property V read ReadXmlChildV;
	function ReadXmlChildV();

public
	// Attributes
	XmlAttrIdx: OpenXmlAttribute;

	// Children
	XmlChildV: OpenXmlPcdata;
end;

type Ax = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Ax);override;
public

	// normal property
	property AxId read ReadXmlChildAxId;
	property Scaling read ReadXmlChildScaling;
	property _Delete read ReadXmlChild_Delete;
	property AxPos read ReadXmlChildAxPos;
	property NumFmt read ReadXmlChildNumFmt;
	property MajorTickMark read ReadXmlChildMajorTickMark;
	property MinorTickMark read ReadXmlChildMinorTickMark;
	property TickLblPos read ReadXmlChildTickLblPos;
	property SpPr read ReadXmlChildSpPr;
	property TxPr read ReadXmlChildTxPr;
	property CrossAx read ReadXmlChildCrossAx;
	property Crosses read ReadXmlChildCrosses;
	property CrossBetween read ReadXmlChildCrossBetween;
	property Auto read ReadXmlChildAuto;
	property LblAlgn read ReadXmlChildLblAlgn;
	property LblOffset read ReadXmlChildLblOffset;
	property NoMultiLvlLbl read ReadXmlChildNoMultiLvlLbl;
	function ReadXmlChildAxId(): PureVal;
	function ReadXmlChildScaling(): Scaling;
	function ReadXmlChild_Delete(): PureVal;
	function ReadXmlChildAxPos(): PureVal;
	function ReadXmlChildNumFmt(): NumFmt;
	function ReadXmlChildMajorTickMark(): PureVal;
	function ReadXmlChildMinorTickMark(): PureVal;
	function ReadXmlChildTickLblPos(): PureVal;
	function ReadXmlChildSpPr(): SpPr;
	function ReadXmlChildTxPr(): TxPr;
	function ReadXmlChildCrossAx(): PureVal;
	function ReadXmlChildCrosses(): PureVal;
	function ReadXmlChildCrossBetween(): PureVal;
	function ReadXmlChildAuto(): PureVal;
	function ReadXmlChildLblAlgn(): PureVal;
	function ReadXmlChildLblOffset(): PureVal;
	function ReadXmlChildNoMultiLvlLbl(): PureVal;

public
	// Children
	XmlChildAxId: PureVal;
	XmlChildScaling: Scaling;
	XmlChild_Delete: PureVal;
	XmlChildAxPos: PureVal;
	XmlChildNumFmt: NumFmt;
	XmlChildMajorTickMark: PureVal;
	XmlChildMinorTickMark: PureVal;
	XmlChildTickLblPos: PureVal;
	XmlChildSpPr: SpPr;
	XmlChildTxPr: TxPr;
	XmlChildCrossAx: PureVal;
	XmlChildCrosses: PureVal;
	XmlChildCrossBetween: PureVal;
	XmlChildAuto: PureVal;
	XmlChildLblAlgn: PureVal;
	XmlChildLblOffset: PureVal;
	XmlChildNoMultiLvlLbl: PureVal;
end;

type NumFmt = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: NumFmt);override;
public
	// attributes property
	property FormatCode read ReadXmlAttrFormatCode write WriteXmlAttrFormatCode;
	property SourceLinked read ReadXmlAttrSourceLinked write WriteXmlAttrSourceLinked;
	function ReadXmlAttrFormatCode();
	function WriteXmlAttrFormatCode(_value);
	function ReadXmlAttrSourceLinked();
	function WriteXmlAttrSourceLinked(_value);

public
	// Attributes
	XmlAttrFormatCode: OpenXmlAttribute;
	XmlAttrSourceLinked: OpenXmlAttribute;

end;

type Scaling = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Scaling);override;
public

	// empty property
	property Orientation read ReadXmlChildOrientation write WriteXmlChildOrientation;
	function ReadXmlChildOrientation();
	function WriteXmlChildOrientation(_value);

public
	// Children
	XmlChildOrientation: OpenXmlEmpty;
end;

type DTable = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: DTable);override;
public

	// normal property
	property ShowHorzBorder read ReadXmlChildShowHorzBorder;
	property ShowVertBorder read ReadXmlChildShowVertBorder;
	property ShowOutline read ReadXmlChildShowOutline;
	property ShowKeys read ReadXmlChildShowKeys;
	property TxPr read ReadXmlChildTxPr;
	function ReadXmlChildShowHorzBorder(): PureVal;
	function ReadXmlChildShowVertBorder(): PureVal;
	function ReadXmlChildShowOutline(): PureVal;
	function ReadXmlChildShowKeys(): PureVal;
	function ReadXmlChildTxPr(): TxPr;

public
	// Children
	XmlChildShowHorzBorder: PureVal;
	XmlChildShowVertBorder: PureVal;
	XmlChildShowOutline: PureVal;
	XmlChildShowKeys: PureVal;
	XmlChildTxPr: TxPr;
end;

type TxPr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: TxPr);override;
public

	// empty property
	property LstStyle read ReadXmlChildLstStyle write WriteXmlChildLstStyle;
	function ReadXmlChildLstStyle();
	function WriteXmlChildLstStyle(_value);

	// normal property
	property BodyPr read ReadXmlChildBodyPr;
	function ReadXmlChildBodyPr(): BodyPr;

	// multi property
	property Ps read ReadPs;
	function ReadPs(_index);
	function AddP(): P;
	function AppendP(): P;

public
	// Children
	XmlChildBodyPr: BodyPr;
	XmlChildLstStyle: OpenXmlEmpty;
end;

type Title = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Title);override;
public

	// empty property
	property Layout read ReadXmlChildLayout write WriteXmlChildLayout;
	function ReadXmlChildLayout();
	function WriteXmlChildLayout(_value);

	// normal property
	property Tx read ReadXmlChildTx;
	property Overlay read ReadXmlChildOverlay;
	function ReadXmlChildTx(): Tx;
	function ReadXmlChildOverlay(): PureVal;

public
	// Children
	XmlChildTx: Tx;
	XmlChildLayout: OpenXmlEmpty;
	XmlChildOverlay: PureVal;
end;

type Tx = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Tx);override;
public

	// normal property
	property StrRef read ReadXmlChildStrRef;
	property Rich read ReadXmlChildRich;
	function ReadXmlChildStrRef(): StrRef;
	function ReadXmlChildRich(): Rich;

public
	// Children
	XmlChildStrRef: StrRef;
	XmlChildRich: Rich;
end;

type Rich = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Rich);override;
public

	// empty property
	property LstStyle read ReadXmlChildLstStyle write WriteXmlChildLstStyle;
	function ReadXmlChildLstStyle();
	function WriteXmlChildLstStyle(_value);

	// normal property
	property BodyPr read ReadXmlChildBodyPr;
	function ReadXmlChildBodyPr(): BodyPr;

	// multi property
	property Ps read ReadPs;
	function ReadPs(_index);
	function AddP(): P;
	function AppendP(): P;

public
	// Children
	XmlChildBodyPr: BodyPr;
	XmlChildLstStyle: OpenXmlEmpty;
end;

type BodyPr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: BodyPr);override;
public
	// attributes property
	property Rot read ReadXmlAttrRot write WriteXmlAttrRot;
	property SpcFirstLastPara read ReadXmlAttrSpcFirstLastPara write WriteXmlAttrSpcFirstLastPara;
	property VertOverflow read ReadXmlAttrVertOverflow write WriteXmlAttrVertOverflow;
	property HorzOverflow read ReadXmlAttrHorzOverflow write WriteXmlAttrHorzOverflow;
	property Vert read ReadXmlAttrVert write WriteXmlAttrVert;
	property Wrap read ReadXmlAttrWrap write WriteXmlAttrWrap;
	property LIns read ReadXmlAttrLIns write WriteXmlAttrLIns;
	property TIns read ReadXmlAttrTIns write WriteXmlAttrTIns;
	property RIns read ReadXmlAttrRIns write WriteXmlAttrRIns;
	property BIns read ReadXmlAttrBIns write WriteXmlAttrBIns;
	property NumCol read ReadXmlAttrNumCol write WriteXmlAttrNumCol;
	property SpcCol read ReadXmlAttrSpcCol write WriteXmlAttrSpcCol;
	property RtlCol read ReadXmlAttrRtlCol write WriteXmlAttrRtlCol;
	property FromWordArt read ReadXmlAttrFromWordArt write WriteXmlAttrFromWordArt;
	property Anchor read ReadXmlAttrAnchor write WriteXmlAttrAnchor;
	property AnchorCtr read ReadXmlAttrAnchorCtr write WriteXmlAttrAnchorCtr;
	property ForceAA read ReadXmlAttrForceAA write WriteXmlAttrForceAA;
	property CompatLnSpc read ReadXmlAttrCompatLnSpc write WriteXmlAttrCompatLnSpc;
	function ReadXmlAttrRot();
	function WriteXmlAttrRot(_value);
	function ReadXmlAttrSpcFirstLastPara();
	function WriteXmlAttrSpcFirstLastPara(_value);
	function ReadXmlAttrVertOverflow();
	function WriteXmlAttrVertOverflow(_value);
	function ReadXmlAttrHorzOverflow();
	function WriteXmlAttrHorzOverflow(_value);
	function ReadXmlAttrVert();
	function WriteXmlAttrVert(_value);
	function ReadXmlAttrWrap();
	function WriteXmlAttrWrap(_value);
	function ReadXmlAttrLIns();
	function WriteXmlAttrLIns(_value);
	function ReadXmlAttrTIns();
	function WriteXmlAttrTIns(_value);
	function ReadXmlAttrRIns();
	function WriteXmlAttrRIns(_value);
	function ReadXmlAttrBIns();
	function WriteXmlAttrBIns(_value);
	function ReadXmlAttrNumCol();
	function WriteXmlAttrNumCol(_value);
	function ReadXmlAttrSpcCol();
	function WriteXmlAttrSpcCol(_value);
	function ReadXmlAttrRtlCol();
	function WriteXmlAttrRtlCol(_value);
	function ReadXmlAttrFromWordArt();
	function WriteXmlAttrFromWordArt(_value);
	function ReadXmlAttrAnchor();
	function WriteXmlAttrAnchor(_value);
	function ReadXmlAttrAnchorCtr();
	function WriteXmlAttrAnchorCtr(_value);
	function ReadXmlAttrForceAA();
	function WriteXmlAttrForceAA(_value);
	function ReadXmlAttrCompatLnSpc();
	function WriteXmlAttrCompatLnSpc(_value);

	// empty property
	property NoAutofit read ReadXmlChildNoAutofit write WriteXmlChildNoAutofit;
	function ReadXmlChildNoAutofit();
	function WriteXmlChildNoAutofit(_value);

	// normal property
	property PrstTxWrap read ReadXmlChildPrstTxWrap;
	function ReadXmlChildPrstTxWrap(): PrstTxWrap;

public
	// Attributes
	XmlAttrRot: OpenXmlAttribute;
	XmlAttrSpcFirstLastPara: OpenXmlAttribute;
	XmlAttrVertOverflow: OpenXmlAttribute;
	XmlAttrHorzOverflow: OpenXmlAttribute;
	XmlAttrVert: OpenXmlAttribute;
	XmlAttrWrap: OpenXmlAttribute;
	XmlAttrLIns: OpenXmlAttribute;
	XmlAttrTIns: OpenXmlAttribute;
	XmlAttrRIns: OpenXmlAttribute;
	XmlAttrBIns: OpenXmlAttribute;
	XmlAttrNumCol: OpenXmlAttribute;
	XmlAttrSpcCol: OpenXmlAttribute;
	XmlAttrRtlCol: OpenXmlAttribute;
	XmlAttrFromWordArt: OpenXmlAttribute;
	XmlAttrAnchor: OpenXmlAttribute;
	XmlAttrAnchorCtr: OpenXmlAttribute;
	XmlAttrForceAA: OpenXmlAttribute;
	XmlAttrCompatLnSpc: OpenXmlAttribute;

	// Children
	XmlChildPrstTxWrap: PrstTxWrap;
	XmlChildNoAutofit: OpenXmlEmpty;
end;

type PrstTxWrap = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: PrstTxWrap);override;
public
	// attributes property
	property Prst read ReadXmlAttrPrst write WriteXmlAttrPrst;
	function ReadXmlAttrPrst();
	function WriteXmlAttrPrst(_value);

	// empty property
	property AvLst read ReadXmlChildAvLst write WriteXmlChildAvLst;
	function ReadXmlChildAvLst();
	function WriteXmlChildAvLst(_value);

public
	// Attributes
	XmlAttrPrst: OpenXmlAttribute;

	// Children
	XmlChildAvLst: OpenXmlEmpty;
end;

type P = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: P);override;
public

	// normal property
	property PPr read ReadXmlChildPPr;
	property EndParaRPr read ReadXmlChildEndParaRPr;
	function ReadXmlChildPPr(): PPr;
	function ReadXmlChildEndParaRPr(): RPr;

	// multi property
	property Rs read ReadRs;
	function ReadRs(_index);
	function AddR(): R;
	function AppendR(): R;

public
	// Children
	XmlChildPPr: PPr;
	XmlChildEndParaRPr: RPr;
end;

type RPr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: RPr);override;
public
	// attributes property
	property Lang read ReadXmlAttrLang write WriteXmlAttrLang;
	property AltLang read ReadXmlAttrAltLang write WriteXmlAttrAltLang;
	property B read ReadXmlAttrB write WriteXmlAttrB;
	property Baseline read ReadXmlAttrBaseline write WriteXmlAttrBaseline;
	property I read ReadXmlAttrI write WriteXmlAttrI;
	property Kern read ReadXmlAttrKern write WriteXmlAttrKern;
	property Spc read ReadXmlAttrSpc write WriteXmlAttrSpc;
	property Strike read ReadXmlAttrStrike write WriteXmlAttrStrike;
	property Sz read ReadXmlAttrSz write WriteXmlAttrSz;
	property U read ReadXmlAttrU write WriteXmlAttrU;
	function ReadXmlAttrLang();
	function WriteXmlAttrLang(_value);
	function ReadXmlAttrAltLang();
	function WriteXmlAttrAltLang(_value);
	function ReadXmlAttrB();
	function WriteXmlAttrB(_value);
	function ReadXmlAttrBaseline();
	function WriteXmlAttrBaseline(_value);
	function ReadXmlAttrI();
	function WriteXmlAttrI(_value);
	function ReadXmlAttrKern();
	function WriteXmlAttrKern(_value);
	function ReadXmlAttrSpc();
	function WriteXmlAttrSpc(_value);
	function ReadXmlAttrStrike();
	function WriteXmlAttrStrike(_value);
	function ReadXmlAttrSz();
	function WriteXmlAttrSz(_value);
	function ReadXmlAttrU();
	function WriteXmlAttrU(_value);

	// normal property
	property SolidFill read ReadXmlChildSolidFill;
	property Latin read ReadXmlChildLatin;
	property Ea read ReadXmlChildEa;
	property Cs read ReadXmlChildCs;
	function ReadXmlChildSolidFill(): SolidFill;
	function ReadXmlChildLatin(): Latin;
	function ReadXmlChildEa(): Latin;
	function ReadXmlChildCs(): Latin;

public
	// Attributes
	XmlAttrLang: OpenXmlAttribute;
	XmlAttrAltLang: OpenXmlAttribute;
	XmlAttrB: OpenXmlAttribute;
	XmlAttrBaseline: OpenXmlAttribute;
	XmlAttrI: OpenXmlAttribute;
	XmlAttrKern: OpenXmlAttribute;
	XmlAttrSpc: OpenXmlAttribute;
	XmlAttrStrike: OpenXmlAttribute;
	XmlAttrSz: OpenXmlAttribute;
	XmlAttrU: OpenXmlAttribute;

	// Children
	XmlChildSolidFill: SolidFill;
	XmlChildLatin: Latin;
	XmlChildEa: Latin;
	XmlChildCs: Latin;
end;

type PPr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: PPr);override;
public

	// normal property
	property DefRPr read ReadXmlChildDefRPr;
	function ReadXmlChildDefRPr(): RPr;

public
	// Children
	XmlChildDefRPr: RPr;
end;

type Latin = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Latin);override;
public
	// attributes property
	property Typeface read ReadXmlAttrTypeface write WriteXmlAttrTypeface;
	function ReadXmlAttrTypeface();
	function WriteXmlAttrTypeface(_value);

public
	// Attributes
	XmlAttrTypeface: OpenXmlAttribute;

end;

type R = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: R);override;
public

	// normal property
	property RPr read ReadXmlChildRPr;
	property T read ReadXmlChildT;
	function ReadXmlChildRPr(): RPr;
	function ReadXmlChildT(): T;

public
	// Children
	XmlChildRPr: RPr;
	XmlChildT: T;
end;

type ExternalData = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: ExternalData);override;
public
	// attributes property
	property Id read ReadXmlAttrId write WriteXmlAttrId;
	function ReadXmlAttrId();
	function WriteXmlAttrId(_value);

	// normal property
	property AutoUpdate read ReadXmlChildAutoUpdate;
	function ReadXmlChildAutoUpdate(): PureVal;

public
	// Attributes
	XmlAttrId: OpenXmlAttribute;

	// Children
	XmlChildAutoUpdate: PureVal;
end;

type _Inline = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: _Inline);override;
public
	// attributes property
	property DistT read ReadXmlAttrDistT write WriteXmlAttrDistT;
	property DistB read ReadXmlAttrDistB write WriteXmlAttrDistB;
	property DistL read ReadXmlAttrDistL write WriteXmlAttrDistL;
	property DistR read ReadXmlAttrDistR write WriteXmlAttrDistR;
	property AnchorId read ReadXmlAttrAnchorId write WriteXmlAttrAnchorId;
	property EditId read ReadXmlAttrEditId write WriteXmlAttrEditId;
	function ReadXmlAttrDistT();
	function WriteXmlAttrDistT(_value);
	function ReadXmlAttrDistB();
	function WriteXmlAttrDistB(_value);
	function ReadXmlAttrDistL();
	function WriteXmlAttrDistL(_value);
	function ReadXmlAttrDistR();
	function WriteXmlAttrDistR(_value);
	function ReadXmlAttrAnchorId();
	function WriteXmlAttrAnchorId(_value);
	function ReadXmlAttrEditId();
	function WriteXmlAttrEditId(_value);

	// normal property
	property Extent read ReadXmlChildExtent;
	property EffectExtent read ReadXmlChildEffectExtent;
	property DocPr read ReadXmlChildDocPr;
	property CNvGraphicFramePr read ReadXmlChildCNvGraphicFramePr;
	property Graphic read ReadXmlChildGraphic;
	function ReadXmlChildExtent(): CXY;
	function ReadXmlChildEffectExtent(): EffectExtent;
	function ReadXmlChildDocPr(): DocPr;
	function ReadXmlChildCNvGraphicFramePr(): CNvGraphicFramePr;
	function ReadXmlChildGraphic(): Graphic;

public
	// Attributes
	XmlAttrDistT: OpenXmlAttribute;
	XmlAttrDistB: OpenXmlAttribute;
	XmlAttrDistL: OpenXmlAttribute;
	XmlAttrDistR: OpenXmlAttribute;
	XmlAttrAnchorId: OpenXmlAttribute;
	XmlAttrEditId: OpenXmlAttribute;

	// Children
	XmlChildExtent: CXY;
	XmlChildEffectExtent: EffectExtent;
	XmlChildDocPr: DocPr;
	XmlChildCNvGraphicFramePr: CNvGraphicFramePr;
	XmlChildGraphic: Graphic;
end;

type EffectExtent = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: EffectExtent);override;
public
	// attributes property
	property L read ReadXmlAttrL write WriteXmlAttrL;
	property T read ReadXmlAttrT write WriteXmlAttrT;
	property R read ReadXmlAttrR write WriteXmlAttrR;
	property B read ReadXmlAttrB write WriteXmlAttrB;
	function ReadXmlAttrL();
	function WriteXmlAttrL(_value);
	function ReadXmlAttrT();
	function WriteXmlAttrT(_value);
	function ReadXmlAttrR();
	function WriteXmlAttrR(_value);
	function ReadXmlAttrB();
	function WriteXmlAttrB(_value);

public
	// Attributes
	XmlAttrL: OpenXmlAttribute;
	XmlAttrT: OpenXmlAttribute;
	XmlAttrR: OpenXmlAttribute;
	XmlAttrB: OpenXmlAttribute;

end;

type DocPr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: DocPr);override;
public
	// attributes property
	property Id read ReadXmlAttrId write WriteXmlAttrId;
	property Name read ReadXmlAttrName write WriteXmlAttrName;
	property Descr read ReadXmlAttrDescr write WriteXmlAttrDescr;
	function ReadXmlAttrId();
	function WriteXmlAttrId(_value);
	function ReadXmlAttrName();
	function WriteXmlAttrName(_value);
	function ReadXmlAttrDescr();
	function WriteXmlAttrDescr(_value);

	// normal property
	property ExtLst read ReadXmlChildExtLst;
	function ReadXmlChildExtLst(): ExtLst;

public
	// Attributes
	XmlAttrId: OpenXmlAttribute;
	XmlAttrName: OpenXmlAttribute;
	XmlAttrDescr: OpenXmlAttribute;

	// Children
	XmlChildExtLst: ExtLst;
end;

type CNvGraphicFramePr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: CNvGraphicFramePr);override;
public

	// normal property
	property GraphicFrameLocks read ReadXmlChildGraphicFrameLocks;
	function ReadXmlChildGraphicFrameLocks(): GraphicFrameLocks;

public
	// Children
	XmlChildGraphicFrameLocks: GraphicFrameLocks;
end;

type GraphicFrameLocks = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: GraphicFrameLocks);override;
public
	// attributes property
	property NoChangeAspect read ReadXmlAttrNoChangeAspect write WriteXmlAttrNoChangeAspect;
	function ReadXmlAttrNoChangeAspect();
	function WriteXmlAttrNoChangeAspect(_value);

public
	// Attributes
	XmlAttrNoChangeAspect: OpenXmlAttribute;

end;

type Graphic = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Graphic);override;
public

	// normal property
	property GraphicData read ReadXmlChildGraphicData;
	function ReadXmlChildGraphicData(): GraphicData;

public
	// Children
	XmlChildGraphicData: GraphicData;
end;

type GraphicData = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: GraphicData);override;
public
	// attributes property
	property Uri read ReadXmlAttrUri write WriteXmlAttrUri;
	function ReadXmlAttrUri();
	function WriteXmlAttrUri(_value);

	// normal property
	property Pic read ReadXmlChildPic;
	property Chart read ReadXmlChildChart;
	property Wsp read ReadXmlChildWsp;
	function ReadXmlChildPic(): Pic;
	function ReadXmlChildChart(): Chart;
	function ReadXmlChildWsp(): Wsp;

public
	// Attributes
	XmlAttrUri: OpenXmlAttribute;

	// Children
	XmlChildPic: Pic;
	XmlChildChart: Chart;
	XmlChildWsp: Wsp;
end;

type Wsp = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Wsp);override;
public

	// normal property
	property CNvSpPr read ReadXmlChildCNvSpPr;
	property SpPr read ReadXmlChildSpPr;
	property Txbx read ReadXmlChildTxbx;
	property Style read ReadXmlChildStyle;
	property BodyPr read ReadXmlChildBodyPr;
	function ReadXmlChildCNvSpPr(): CNvSpPr;
	function ReadXmlChildSpPr(): SpPr;
	function ReadXmlChildTxbx(): Txbx;
	function ReadXmlChildStyle(): WpsStyle;
	function ReadXmlChildBodyPr(): BodyPr;

public
	// Children
	XmlChildCNvSpPr: CNvSpPr;
	XmlChildSpPr: SpPr;
	XmlChildTxbx: Txbx;
	XmlChildStyle: WpsStyle;
	XmlChildBodyPr: BodyPr;
end;

type WpsStyle = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: WpsStyle);override;
public

	// normal property
	property LnRef read ReadXmlChildLnRef;
	property FillRef read ReadXmlChildFillRef;
	property EffectRef read ReadXmlChildEffectRef;
	property FontRef read ReadXmlChildFontRef;
	function ReadXmlChildLnRef(): XRef;
	function ReadXmlChildFillRef(): XRef;
	function ReadXmlChildEffectRef(): XRef;
	function ReadXmlChildFontRef(): XRef;

public
	// Children
	XmlChildLnRef: XRef;
	XmlChildFillRef: XRef;
	XmlChildEffectRef: XRef;
	XmlChildFontRef: XRef;
end;

type XRef = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: XRef);override;
public
	// attributes property
	property Idx read ReadXmlAttrIdx write WriteXmlAttrIdx;
	function ReadXmlAttrIdx();
	function WriteXmlAttrIdx(_value);

	// normal property
	property SchemeClr read ReadXmlChildSchemeClr;
	function ReadXmlChildSchemeClr(): SchemeClr;

public
	// Attributes
	XmlAttrIdx: OpenXmlAttribute;

	// Children
	XmlChildSchemeClr: SchemeClr;
end;

type Txbx = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Txbx);override;
public

	// normal property
	property TxbxContent read ReadXmlChildTxbxContent;
	function ReadXmlChildTxbxContent(): TxbxContent;

public
	// Children
	XmlChildTxbxContent: TxbxContent;
end;

type CNvSpPr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: CNvSpPr);override;
public
	// attributes property
	property TxBox read ReadXmlAttrTxBox write WriteXmlAttrTxBox;
	function ReadXmlAttrTxBox();
	function WriteXmlAttrTxBox(_value);

	// normal property
	property SpLocks read ReadXmlChildSpLocks;
	function ReadXmlChildSpLocks(): SpLocks;

public
	// Attributes
	XmlAttrTxBox: OpenXmlAttribute;

	// Children
	XmlChildSpLocks: SpLocks;
end;

type SpLocks = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: SpLocks);override;
public
	// attributes property
	property NoChangeArrowheads read ReadXmlAttrNoChangeArrowheads write WriteXmlAttrNoChangeArrowheads;
	function ReadXmlAttrNoChangeArrowheads();
	function WriteXmlAttrNoChangeArrowheads(_value);

public
	// Attributes
	XmlAttrNoChangeArrowheads: OpenXmlAttribute;

end;

type Pic = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Pic);override;
public

	// normal property
	property NvPicPr read ReadXmlChildNvPicPr;
	property BlipFill read ReadXmlChildBlipFill;
	property SpPr read ReadXmlChildSpPr;
	function ReadXmlChildNvPicPr(): NvPicPr;
	function ReadXmlChildBlipFill(): BlipFill;
	function ReadXmlChildSpPr(): SpPr;

public
	// Children
	XmlChildNvPicPr: NvPicPr;
	XmlChildBlipFill: BlipFill;
	XmlChildSpPr: SpPr;
end;

type NvPicPr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: NvPicPr);override;
public

	// normal property
	property CNvPr read ReadXmlChildCNvPr;
	property CNvPicPr read ReadXmlChildCNvPicPr;
	function ReadXmlChildCNvPr(): CNvPr;
	function ReadXmlChildCNvPicPr(): CNvPicPr;

public
	// Children
	XmlChildCNvPr: CNvPr;
	XmlChildCNvPicPr: CNvPicPr;
end;

type CNvPr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: CNvPr);override;
public
	// attributes property
	property Id read ReadXmlAttrId write WriteXmlAttrId;
	property Name read ReadXmlAttrName write WriteXmlAttrName;
	property Descr read ReadXmlAttrDescr write WriteXmlAttrDescr;
	function ReadXmlAttrId();
	function WriteXmlAttrId(_value);
	function ReadXmlAttrName();
	function WriteXmlAttrName(_value);
	function ReadXmlAttrDescr();
	function WriteXmlAttrDescr(_value);

public
	// Attributes
	XmlAttrId: OpenXmlAttribute;
	XmlAttrName: OpenXmlAttribute;
	XmlAttrDescr: OpenXmlAttribute;

end;

type CNvPicPr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: CNvPicPr);override;
public

	// normal property
	property PicLocks read ReadXmlChildPicLocks;
	function ReadXmlChildPicLocks(): PicLocks;

public
	// Children
	XmlChildPicLocks: PicLocks;
end;

type PicLocks = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: PicLocks);override;
public
	// attributes property
	property NoChangeAspect read ReadXmlAttrNoChangeAspect write WriteXmlAttrNoChangeAspect;
	function ReadXmlAttrNoChangeAspect();
	function WriteXmlAttrNoChangeAspect(_value);

public
	// Attributes
	XmlAttrNoChangeAspect: OpenXmlAttribute;

end;

type BlipFill = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: BlipFill);override;
public

	// normal property
	property Blip read ReadXmlChildBlip;
	property Stretch read ReadXmlChildStretch;
	function ReadXmlChildBlip(): Blip;
	function ReadXmlChildStretch(): Stretch;

public
	// Children
	XmlChildBlip: Blip;
	XmlChildStretch: Stretch;
end;

type Blip = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Blip);override;
public
	// attributes property
	property Embed read ReadXmlAttrEmbed write WriteXmlAttrEmbed;
	property Cstate read ReadXmlAttrCstate write WriteXmlAttrCstate;
	function ReadXmlAttrEmbed();
	function WriteXmlAttrEmbed(_value);
	function ReadXmlAttrCstate();
	function WriteXmlAttrCstate(_value);

public
	// Attributes
	XmlAttrEmbed: OpenXmlAttribute;
	XmlAttrCstate: OpenXmlAttribute;

end;

type Stretch = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Stretch);override;
public

	// normal property
	property FillRect read ReadXmlChildFillRect;
	function ReadXmlChildFillRect(): PureVal;

public
	// Children
	XmlChildFillRect: PureVal;
end;

type SpPr = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: SpPr);override;
public
	// attributes property
	property BwMode read ReadXmlAttrBwMode write WriteXmlAttrBwMode;
	function ReadXmlAttrBwMode();
	function WriteXmlAttrBwMode(_value);

	// empty property
	property NoFill read ReadXmlChildNoFill write WriteXmlChildNoFill;
	function ReadXmlChildNoFill();
	function WriteXmlChildNoFill(_value);

	// normal property
	property Xfrm read ReadXmlChildXfrm;
	property PrstGeom read ReadXmlChildPrstGeom;
	property SolidFill read ReadXmlChildSolidFill;
	property Ln read ReadXmlChildLn;
	property EffectLst read ReadXmlChildEffectLst;
	function ReadXmlChildXfrm(): Xfrm;
	function ReadXmlChildPrstGeom(): PrstGeom;
	function ReadXmlChildSolidFill(): SolidFill;
	function ReadXmlChildLn(): Ln;
	function ReadXmlChildEffectLst(): EffectLst;

public
	// Attributes
	XmlAttrBwMode: OpenXmlAttribute;

	// Children
	XmlChildXfrm: Xfrm;
	XmlChildPrstGeom: PrstGeom;
	XmlChildNoFill: OpenXmlEmpty;
	XmlChildSolidFill: SolidFill;
	XmlChildLn: Ln;
	XmlChildEffectLst: EffectLst;
end;

type EffectLst = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: EffectLst);override;
public

	// normal property
	property OuterShdw read ReadXmlChildOuterShdw;
	function ReadXmlChildOuterShdw(): OuterShdw;

public
	// Children
	XmlChildOuterShdw: OuterShdw;
end;

type Ln = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Ln);override;
public
	// attributes property
	property W read ReadXmlAttrW write WriteXmlAttrW;
	property Cap read ReadXmlAttrCap write WriteXmlAttrCap;
	property Cmpd read ReadXmlAttrCmpd write WriteXmlAttrCmpd;
	property Algn read ReadXmlAttrAlgn write WriteXmlAttrAlgn;
	function ReadXmlAttrW();
	function WriteXmlAttrW(_value);
	function ReadXmlAttrCap();
	function WriteXmlAttrCap(_value);
	function ReadXmlAttrCmpd();
	function WriteXmlAttrCmpd(_value);
	function ReadXmlAttrAlgn();
	function WriteXmlAttrAlgn(_value);

	// empty property
	property NoFill read ReadXmlChildNoFill write WriteXmlChildNoFill;
	property HeadEnd read ReadXmlChildHeadEnd write WriteXmlChildHeadEnd;
	property TailEnd read ReadXmlChildTailEnd write WriteXmlChildTailEnd;
	function ReadXmlChildNoFill();
	function WriteXmlChildNoFill(_value);
	function ReadXmlChildHeadEnd();
	function WriteXmlChildHeadEnd(_value);
	function ReadXmlChildTailEnd();
	function WriteXmlChildTailEnd(_value);

	// normal property
	property SolidFill read ReadXmlChildSolidFill;
	property PrstDash read ReadXmlChildPrstDash;
	property Miter read ReadXmlChildMiter;
	function ReadXmlChildSolidFill(): SolidFill;
	function ReadXmlChildPrstDash(): PureVal;
	function ReadXmlChildMiter(): Miter;

public
	// Attributes
	XmlAttrW: OpenXmlAttribute;
	XmlAttrCap: OpenXmlAttribute;
	XmlAttrCmpd: OpenXmlAttribute;
	XmlAttrAlgn: OpenXmlAttribute;

	// Children
	XmlChildNoFill: OpenXmlEmpty;
	XmlChildSolidFill: SolidFill;
	XmlChildPrstDash: PureVal;
	XmlChildMiter: Miter;
	XmlChildHeadEnd: OpenXmlEmpty;
	XmlChildTailEnd: OpenXmlEmpty;
end;

type Miter = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Miter);override;
public
	// attributes property
	property Lim read ReadXmlAttrLim write WriteXmlAttrLim;
	function ReadXmlAttrLim();
	function WriteXmlAttrLim(_value);

public
	// Attributes
	XmlAttrLim: OpenXmlAttribute;

end;

type Xfrm = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Xfrm);override;
public

	// normal property
	property Off read ReadXmlChildOff;
	property Ext read ReadXmlChildExt;
	function ReadXmlChildOff(): XY;
	function ReadXmlChildExt(): CXY;

public
	// Children
	XmlChildOff: XY;
	XmlChildExt: CXY;
end;

type XY = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: XY);override;
public
	// attributes property
	property X read ReadXmlAttrX write WriteXmlAttrX;
	property Y read ReadXmlAttrY write WriteXmlAttrY;
	function ReadXmlAttrX();
	function WriteXmlAttrX(_value);
	function ReadXmlAttrY();
	function WriteXmlAttrY(_value);

public
	// Attributes
	XmlAttrX: OpenXmlAttribute;
	XmlAttrY: OpenXmlAttribute;

end;

type CXY = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: CXY);override;
public
	// attributes property
	property Cx read ReadXmlAttrCx write WriteXmlAttrCx;
	property Cy read ReadXmlAttrCy write WriteXmlAttrCy;
	function ReadXmlAttrCx();
	function WriteXmlAttrCx(_value);
	function ReadXmlAttrCy();
	function WriteXmlAttrCy(_value);

public
	// Attributes
	XmlAttrCx: OpenXmlAttribute;
	XmlAttrCy: OpenXmlAttribute;

end;

type PrstGeom = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: PrstGeom);override;
public
	// attributes property
	property Prst read ReadXmlAttrPrst write WriteXmlAttrPrst;
	function ReadXmlAttrPrst();
	function WriteXmlAttrPrst(_value);

	// normal property
	property AvLst read ReadXmlChildAvLst;
	function ReadXmlChildAvLst(): PureVal;

public
	// Attributes
	XmlAttrPrst: OpenXmlAttribute;

	// Children
	XmlChildAvLst: PureVal;
end;

type Anchor = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: Anchor);override;
public
	// attributes property
	property DistT read ReadXmlAttrDistT write WriteXmlAttrDistT;
	property DistB read ReadXmlAttrDistB write WriteXmlAttrDistB;
	property DistL read ReadXmlAttrDistL write WriteXmlAttrDistL;
	property DistR read ReadXmlAttrDistR write WriteXmlAttrDistR;
	property SimplePos read ReadXmlAttrSimplePos write WriteXmlAttrSimplePos;
	property RelativeHeight read ReadXmlAttrRelativeHeight write WriteXmlAttrRelativeHeight;
	property BehindDoc read ReadXmlAttrBehindDoc write WriteXmlAttrBehindDoc;
	property Locked read ReadXmlAttrLocked write WriteXmlAttrLocked;
	property Hidden read ReadXmlAttrHidden write WriteXmlAttrHidden;
	property LayoutInCell read ReadXmlAttrLayoutInCell write WriteXmlAttrLayoutInCell;
	property AllowOverlap read ReadXmlAttrAllowOverlap write WriteXmlAttrAllowOverlap;
	property AnchorId read ReadXmlAttrAnchorId write WriteXmlAttrAnchorId;
	property EditId read ReadXmlAttrEditId write WriteXmlAttrEditId;
	function ReadXmlAttrDistT();
	function WriteXmlAttrDistT(_value);
	function ReadXmlAttrDistB();
	function WriteXmlAttrDistB(_value);
	function ReadXmlAttrDistL();
	function WriteXmlAttrDistL(_value);
	function ReadXmlAttrDistR();
	function WriteXmlAttrDistR(_value);
	function ReadXmlAttrSimplePos();
	function WriteXmlAttrSimplePos(_value);
	function ReadXmlAttrRelativeHeight();
	function WriteXmlAttrRelativeHeight(_value);
	function ReadXmlAttrBehindDoc();
	function WriteXmlAttrBehindDoc(_value);
	function ReadXmlAttrLocked();
	function WriteXmlAttrLocked(_value);
	function ReadXmlAttrHidden();
	function WriteXmlAttrHidden(_value);
	function ReadXmlAttrLayoutInCell();
	function WriteXmlAttrLayoutInCell(_value);
	function ReadXmlAttrAllowOverlap();
	function WriteXmlAttrAllowOverlap(_value);
	function ReadXmlAttrAnchorId();
	function WriteXmlAttrAnchorId(_value);
	function ReadXmlAttrEditId();
	function WriteXmlAttrEditId(_value);

	// empty property
	property WrapNone read ReadXmlChildWrapNone write WriteXmlChildWrapNone;
	function ReadXmlChildWrapNone();
	function WriteXmlChildWrapNone(_value);

	// normal property
	property SimplePos read ReadXmlChildSimplePos;
	property PositionH read ReadXmlChildPositionH;
	property PositionV read ReadXmlChildPositionV;
	property Extent read ReadXmlChildExtent;
	property EffectExtent read ReadXmlChildEffectExtent;
	property DocPr read ReadXmlChildDocPr;
	property CNvGraphicFramePr read ReadXmlChildCNvGraphicFramePr;
	property Graphic read ReadXmlChildGraphic;
	property SizeRelH read ReadXmlChildSizeRelH;
	property SizeRelV read ReadXmlChildSizeRelV;
	function ReadXmlChildSimplePos(): XY;
	function ReadXmlChildPositionH(): PositionH;
	function ReadXmlChildPositionV(): PositionV;
	function ReadXmlChildExtent(): CXY;
	function ReadXmlChildEffectExtent(): EffectExtent;
	function ReadXmlChildDocPr(): DocPr;
	function ReadXmlChildCNvGraphicFramePr(): CNvGraphicFramePr;
	function ReadXmlChildGraphic(): Graphic;
	function ReadXmlChildSizeRelH(): SizeRelH;
	function ReadXmlChildSizeRelV(): SizeRelV;

public
	// Attributes
	XmlAttrDistT: OpenXmlAttribute;
	XmlAttrDistB: OpenXmlAttribute;
	XmlAttrDistL: OpenXmlAttribute;
	XmlAttrDistR: OpenXmlAttribute;
	XmlAttrSimplePos: OpenXmlAttribute;
	XmlAttrRelativeHeight: OpenXmlAttribute;
	XmlAttrBehindDoc: OpenXmlAttribute;
	XmlAttrLocked: OpenXmlAttribute;
	XmlAttrHidden: OpenXmlAttribute;
	XmlAttrLayoutInCell: OpenXmlAttribute;
	XmlAttrAllowOverlap: OpenXmlAttribute;
	XmlAttrAnchorId: OpenXmlAttribute;
	XmlAttrEditId: OpenXmlAttribute;

	// Children
	XmlChildSimplePos: XY;
	XmlChildPositionH: PositionH;
	XmlChildPositionV: PositionV;
	XmlChildExtent: CXY;
	XmlChildEffectExtent: EffectExtent;
	XmlChildWrapNone: OpenXmlEmpty;
	XmlChildDocPr: DocPr;
	XmlChildCNvGraphicFramePr: CNvGraphicFramePr;
	XmlChildGraphic: Graphic;
	XmlChildSizeRelH: SizeRelH;
	XmlChildSizeRelV: SizeRelV;
end;

type PositionV = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: PositionV);override;
public
	// attributes property
	property RelativeFrom read ReadXmlAttrRelativeFrom write WriteXmlAttrRelativeFrom;
	function ReadXmlAttrRelativeFrom();
	function WriteXmlAttrRelativeFrom(_value);

	// pcdata property
	property PosOffset read ReadXmlChildPosOffset;
	function ReadXmlChildPosOffset();

public
	// Attributes
	XmlAttrRelativeFrom: OpenXmlAttribute;

	// Children
	XmlChildPosOffset: OpenXmlPcdata;
end;

type PositionH = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: PositionH);override;
public
	// attributes property
	property RelativeFrom read ReadXmlAttrRelativeFrom write WriteXmlAttrRelativeFrom;
	function ReadXmlAttrRelativeFrom();
	function WriteXmlAttrRelativeFrom(_value);

	// pcdata property
	property PosOffset read ReadXmlChildPosOffset;
	function ReadXmlChildPosOffset();

public
	// Attributes
	XmlAttrRelativeFrom: OpenXmlAttribute;

	// Children
	XmlChildPosOffset: OpenXmlPcdata;
end;

type SizeRelH = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: SizeRelH);override;
public
	// attributes property
	property RelativeFrom read ReadXmlAttrRelativeFrom write WriteXmlAttrRelativeFrom;
	function ReadXmlAttrRelativeFrom();
	function WriteXmlAttrRelativeFrom(_value);

	// pcdata property
	property PctWidth read ReadXmlChildPctWidth;
	function ReadXmlChildPctWidth();

public
	// Attributes
	XmlAttrRelativeFrom: OpenXmlAttribute;

	// Children
	XmlChildPctWidth: OpenXmlPcdata;
end;

type SizeRelV = class(OpenXmlElement)
public
	function Create();overload;
	function Create(_node: XmlNode);overload;
	function Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
	function Init();override;
	function Copy(_obj: SizeRelV);override;
public
	// attributes property
	property RelativeFrom read ReadXmlAttrRelativeFrom write WriteXmlAttrRelativeFrom;
	function ReadXmlAttrRelativeFrom();
	function WriteXmlAttrRelativeFrom(_value);

	// pcdata property
	property PctHeight read ReadXmlChildPctHeight;
	function ReadXmlChildPctHeight();

public
	// Attributes
	XmlAttrRelativeFrom: OpenXmlAttribute;

	// Children
	XmlChildPctHeight: OpenXmlPcdata;
end;

implementation

function Theme.Create();overload;
begin
	{self.}Create(nil, "a", "theme");
end;

function Theme.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Theme.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Theme.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"name": makeweakref(thisFunction(WriteXmlAttrName)),
	);
	sorted_child_ := array(
		pre + "themeElements": array(0, makeweakref(thisFunction(ReadXmlChildThemeElements))),
		pre + "objectDefaults": array(1, makeweakref(thisFunction(ReadXmlChildObjectDefaults))),
		pre + "extraClrSchemeLst": array(2, makeweakref(thisFunction(ReadXmlChildExtraClrSchemeLst))),
		pre + "extLst": array(3, makeweakref(thisFunction(ReadXmlChildExtLst))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Theme.Copy(_obj: Theme);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Name) then
		{self.}Name := _obj.Name;
	if not ifnil(_obj.XmlChildThemeElements) then
		{self.}ThemeElements.Copy(_obj.XmlChildThemeElements);
	if not ifnil(_obj.XmlChildObjectDefaults) then
		ifnil({self.}XmlChildObjectDefaults) ? {self.}ObjectDefaults.Copy(_obj.XmlChildObjectDefaults) : {self.}XmlChildObjectDefaults.Copy(_obj.XmlChildObjectDefaults);
	if not ifnil(_obj.XmlChildExtraClrSchemeLst) then
		ifnil({self.}XmlChildExtraClrSchemeLst) ? {self.}ExtraClrSchemeLst.Copy(_obj.XmlChildExtraClrSchemeLst) : {self.}XmlChildExtraClrSchemeLst.Copy(_obj.XmlChildExtraClrSchemeLst);
	if not ifnil(_obj.XmlChildExtLst) then
		{self.}ExtLst.Copy(_obj.XmlChildExtLst);
	tslassigning := tslassigning_backup;
end;

function Theme.ReadXmlAttrName();
begin
	return {self.}XmlAttrName.Value;
end;

function Theme.WriteXmlAttrName(_value);
begin
	if ifnil({self.}XmlAttrName) then
	begin
		{self.}XmlAttrName := new OpenXmlAttribute("", "name", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrName;
	end
	{self.}XmlAttrName.Value := _value;
end;

function Theme.ReadXmlChildObjectDefaults();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildObjectDefaults) then
		begin
			{self.}XmlChildObjectDefaults := new OpenXmlEmpty(self, {self.}Prefix, "objectDefaults");
			container_.Set({self.}XmlChildObjectDefaults);
		end
		return {self.}XmlChildObjectDefaults;
	end
	return ifnil({self.}XmlChildObjectDefaults) ? nil : {self.}XmlChildObjectDefaults.BoolValue();
end;

function Theme.WriteXmlChildObjectDefaults(_value);
begin
	if ifnil({self.}XmlChildObjectDefaults) then
	begin
		{self.}XmlChildObjectDefaults := new OpenXmlEmpty(self, {self.}Prefix, "objectDefaults");
		container_.Set({self.}XmlChildObjectDefaults);
	end
	{self.}XmlChildObjectDefaults.Value := _value;
end;

function Theme.ReadXmlChildExtraClrSchemeLst();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildExtraClrSchemeLst) then
		begin
			{self.}XmlChildExtraClrSchemeLst := new OpenXmlEmpty(self, {self.}Prefix, "extraClrSchemeLst");
			container_.Set({self.}XmlChildExtraClrSchemeLst);
		end
		return {self.}XmlChildExtraClrSchemeLst;
	end
	return ifnil({self.}XmlChildExtraClrSchemeLst) ? nil : {self.}XmlChildExtraClrSchemeLst.BoolValue();
end;

function Theme.WriteXmlChildExtraClrSchemeLst(_value);
begin
	if ifnil({self.}XmlChildExtraClrSchemeLst) then
	begin
		{self.}XmlChildExtraClrSchemeLst := new OpenXmlEmpty(self, {self.}Prefix, "extraClrSchemeLst");
		container_.Set({self.}XmlChildExtraClrSchemeLst);
	end
	{self.}XmlChildExtraClrSchemeLst.Value := _value;
end;

function Theme.ReadXmlChildThemeElements(): ThemeElements;
begin
	if tslassigning and ifnil({self.}XmlChildThemeElements) then
	begin
		{self.}XmlChildThemeElements := new ThemeElements(self, {self.}Prefix, "themeElements");
		container_.Set({self.}XmlChildThemeElements);
	end
	return {self.}XmlChildThemeElements;
end;

function Theme.ReadXmlChildExtLst(): ExtLst;
begin
	if tslassigning and ifnil({self.}XmlChildExtLst) then
	begin
		{self.}XmlChildExtLst := new ExtLst(self, {self.}Prefix, "extLst");
		container_.Set({self.}XmlChildExtLst);
	end
	return {self.}XmlChildExtLst;
end;

function ThemeElements.Create();overload;
begin
	{self.}Create(nil, "a", "themeElements");
end;

function ThemeElements.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function ThemeElements.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function ThemeElements.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"name": makeweakref(thisFunction(WriteXmlAttrName)),
	);
	sorted_child_ := array(
		pre + "clrScheme": array(0, makeweakref(thisFunction(ReadXmlChildClrScheme))),
		pre + "fontScheme": array(1, makeweakref(thisFunction(ReadXmlChildFontScheme))),
		pre + "fmtScheme": array(2, makeweakref(thisFunction(ReadXmlChildFmtScheme))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function ThemeElements.Copy(_obj: ThemeElements);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Name) then
		{self.}Name := _obj.Name;
	if not ifnil(_obj.XmlChildClrScheme) then
		{self.}ClrScheme.Copy(_obj.XmlChildClrScheme);
	if not ifnil(_obj.XmlChildFontScheme) then
		{self.}FontScheme.Copy(_obj.XmlChildFontScheme);
	if not ifnil(_obj.XmlChildFmtScheme) then
		{self.}FmtScheme.Copy(_obj.XmlChildFmtScheme);
	tslassigning := tslassigning_backup;
end;

function ThemeElements.ReadXmlAttrName();
begin
	return {self.}XmlAttrName.Value;
end;

function ThemeElements.WriteXmlAttrName(_value);
begin
	if ifnil({self.}XmlAttrName) then
	begin
		{self.}XmlAttrName := new OpenXmlAttribute("", "name", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrName;
	end
	{self.}XmlAttrName.Value := _value;
end;

function ThemeElements.ReadXmlChildClrScheme(): ClrScheme;
begin
	if tslassigning and ifnil({self.}XmlChildClrScheme) then
	begin
		{self.}XmlChildClrScheme := new ClrScheme(self, {self.}Prefix, "clrScheme");
		container_.Set({self.}XmlChildClrScheme);
	end
	return {self.}XmlChildClrScheme;
end;

function ThemeElements.ReadXmlChildFontScheme(): FontScheme;
begin
	if tslassigning and ifnil({self.}XmlChildFontScheme) then
	begin
		{self.}XmlChildFontScheme := new FontScheme(self, {self.}Prefix, "fontScheme");
		container_.Set({self.}XmlChildFontScheme);
	end
	return {self.}XmlChildFontScheme;
end;

function ThemeElements.ReadXmlChildFmtScheme(): FmtScheme;
begin
	if tslassigning and ifnil({self.}XmlChildFmtScheme) then
	begin
		{self.}XmlChildFmtScheme := new FmtScheme(self, {self.}Prefix, "fmtScheme");
		container_.Set({self.}XmlChildFmtScheme);
	end
	return {self.}XmlChildFmtScheme;
end;

function ClrScheme.Create();overload;
begin
	{self.}Create(nil, "a", "clrScheme");
end;

function ClrScheme.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function ClrScheme.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function ClrScheme.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"name": makeweakref(thisFunction(WriteXmlAttrName)),
	);
	sorted_child_ := array(
		pre + "dk1": array(0, makeweakref(thisFunction(ReadXmlChildDk1))),
		pre + "lt1": array(1, makeweakref(thisFunction(ReadXmlChildLt1))),
		pre + "dk2": array(2, makeweakref(thisFunction(ReadXmlChildDk2))),
		pre + "lt2": array(3, makeweakref(thisFunction(ReadXmlChildLt2))),
		pre + "accent1": array(4, makeweakref(thisFunction(ReadXmlChildAccent1))),
		pre + "accent2": array(5, makeweakref(thisFunction(ReadXmlChildAccent2))),
		pre + "accent3": array(6, makeweakref(thisFunction(ReadXmlChildAccent3))),
		pre + "accent4": array(7, makeweakref(thisFunction(ReadXmlChildAccent4))),
		pre + "accent5": array(8, makeweakref(thisFunction(ReadXmlChildAccent5))),
		pre + "accent6": array(9, makeweakref(thisFunction(ReadXmlChildAccent6))),
		pre + "hlink": array(10, makeweakref(thisFunction(ReadXmlChildHlink))),
		pre + "folHlink": array(11, makeweakref(thisFunction(ReadXmlChildFolHlink))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function ClrScheme.Copy(_obj: ClrScheme);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Name) then
		{self.}Name := _obj.Name;
	if not ifnil(_obj.XmlChildDk1) then
		{self.}Dk1.Copy(_obj.XmlChildDk1);
	if not ifnil(_obj.XmlChildLt1) then
		{self.}Lt1.Copy(_obj.XmlChildLt1);
	if not ifnil(_obj.XmlChildDk2) then
		{self.}Dk2.Copy(_obj.XmlChildDk2);
	if not ifnil(_obj.XmlChildLt2) then
		{self.}Lt2.Copy(_obj.XmlChildLt2);
	if not ifnil(_obj.XmlChildAccent1) then
		{self.}Accent1.Copy(_obj.XmlChildAccent1);
	if not ifnil(_obj.XmlChildAccent2) then
		{self.}Accent2.Copy(_obj.XmlChildAccent2);
	if not ifnil(_obj.XmlChildAccent3) then
		{self.}Accent3.Copy(_obj.XmlChildAccent3);
	if not ifnil(_obj.XmlChildAccent4) then
		{self.}Accent4.Copy(_obj.XmlChildAccent4);
	if not ifnil(_obj.XmlChildAccent5) then
		{self.}Accent5.Copy(_obj.XmlChildAccent5);
	if not ifnil(_obj.XmlChildAccent6) then
		{self.}Accent6.Copy(_obj.XmlChildAccent6);
	if not ifnil(_obj.XmlChildHlink) then
		{self.}Hlink.Copy(_obj.XmlChildHlink);
	if not ifnil(_obj.XmlChildFolHlink) then
		{self.}FolHlink.Copy(_obj.XmlChildFolHlink);
	tslassigning := tslassigning_backup;
end;

function ClrScheme.ReadXmlAttrName();
begin
	return {self.}XmlAttrName.Value;
end;

function ClrScheme.WriteXmlAttrName(_value);
begin
	if ifnil({self.}XmlAttrName) then
	begin
		{self.}XmlAttrName := new OpenXmlAttribute("", "name", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrName;
	end
	{self.}XmlAttrName.Value := _value;
end;

function ClrScheme.ReadXmlChildDk1(): Clr1;
begin
	if tslassigning and ifnil({self.}XmlChildDk1) then
	begin
		{self.}XmlChildDk1 := new Clr1(self, {self.}Prefix, "dk1");
		container_.Set({self.}XmlChildDk1);
	end
	return {self.}XmlChildDk1;
end;

function ClrScheme.ReadXmlChildLt1(): Clr1;
begin
	if tslassigning and ifnil({self.}XmlChildLt1) then
	begin
		{self.}XmlChildLt1 := new Clr1(self, {self.}Prefix, "lt1");
		container_.Set({self.}XmlChildLt1);
	end
	return {self.}XmlChildLt1;
end;

function ClrScheme.ReadXmlChildDk2(): Clr2;
begin
	if tslassigning and ifnil({self.}XmlChildDk2) then
	begin
		{self.}XmlChildDk2 := new Clr2(self, {self.}Prefix, "dk2");
		container_.Set({self.}XmlChildDk2);
	end
	return {self.}XmlChildDk2;
end;

function ClrScheme.ReadXmlChildLt2(): Clr2;
begin
	if tslassigning and ifnil({self.}XmlChildLt2) then
	begin
		{self.}XmlChildLt2 := new Clr2(self, {self.}Prefix, "lt2");
		container_.Set({self.}XmlChildLt2);
	end
	return {self.}XmlChildLt2;
end;

function ClrScheme.ReadXmlChildAccent1(): Clr2;
begin
	if tslassigning and ifnil({self.}XmlChildAccent1) then
	begin
		{self.}XmlChildAccent1 := new Clr2(self, {self.}Prefix, "accent1");
		container_.Set({self.}XmlChildAccent1);
	end
	return {self.}XmlChildAccent1;
end;

function ClrScheme.ReadXmlChildAccent2(): Clr2;
begin
	if tslassigning and ifnil({self.}XmlChildAccent2) then
	begin
		{self.}XmlChildAccent2 := new Clr2(self, {self.}Prefix, "accent2");
		container_.Set({self.}XmlChildAccent2);
	end
	return {self.}XmlChildAccent2;
end;

function ClrScheme.ReadXmlChildAccent3(): Clr2;
begin
	if tslassigning and ifnil({self.}XmlChildAccent3) then
	begin
		{self.}XmlChildAccent3 := new Clr2(self, {self.}Prefix, "accent3");
		container_.Set({self.}XmlChildAccent3);
	end
	return {self.}XmlChildAccent3;
end;

function ClrScheme.ReadXmlChildAccent4(): Clr2;
begin
	if tslassigning and ifnil({self.}XmlChildAccent4) then
	begin
		{self.}XmlChildAccent4 := new Clr2(self, {self.}Prefix, "accent4");
		container_.Set({self.}XmlChildAccent4);
	end
	return {self.}XmlChildAccent4;
end;

function ClrScheme.ReadXmlChildAccent5(): Clr2;
begin
	if tslassigning and ifnil({self.}XmlChildAccent5) then
	begin
		{self.}XmlChildAccent5 := new Clr2(self, {self.}Prefix, "accent5");
		container_.Set({self.}XmlChildAccent5);
	end
	return {self.}XmlChildAccent5;
end;

function ClrScheme.ReadXmlChildAccent6(): Clr2;
begin
	if tslassigning and ifnil({self.}XmlChildAccent6) then
	begin
		{self.}XmlChildAccent6 := new Clr2(self, {self.}Prefix, "accent6");
		container_.Set({self.}XmlChildAccent6);
	end
	return {self.}XmlChildAccent6;
end;

function ClrScheme.ReadXmlChildHlink(): Clr2;
begin
	if tslassigning and ifnil({self.}XmlChildHlink) then
	begin
		{self.}XmlChildHlink := new Clr2(self, {self.}Prefix, "hlink");
		container_.Set({self.}XmlChildHlink);
	end
	return {self.}XmlChildHlink;
end;

function ClrScheme.ReadXmlChildFolHlink(): Clr2;
begin
	if tslassigning and ifnil({self.}XmlChildFolHlink) then
	begin
		{self.}XmlChildFolHlink := new Clr2(self, {self.}Prefix, "folHlink");
		container_.Set({self.}XmlChildFolHlink);
	end
	return {self.}XmlChildFolHlink;
end;

function Clr1.Create();overload;
begin
	{self.}Create(nil, "a", "");
end;

function Clr1.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Clr1.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Clr1.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "sysClr": array(0, makeweakref(thisFunction(ReadXmlChildSysClr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Clr1.Copy(_obj: Clr1);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildSysClr) then
		{self.}SysClr.Copy(_obj.XmlChildSysClr);
	tslassigning := tslassigning_backup;
end;

function Clr1.ReadXmlChildSysClr(): SysClr;
begin
	if tslassigning and ifnil({self.}XmlChildSysClr) then
	begin
		{self.}XmlChildSysClr := new SysClr(self, {self.}Prefix, "sysClr");
		container_.Set({self.}XmlChildSysClr);
	end
	return {self.}XmlChildSysClr;
end;

function SysClr.Create();overload;
begin
	{self.}Create(nil, "a", "sysClr");
end;

function SysClr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function SysClr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function SysClr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"val": makeweakref(thisFunction(WriteXmlAttrVal)),
		"LastClr": makeweakref(thisFunction(WriteXmlAttrLastClr)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function SysClr.Copy(_obj: SysClr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Val) then
		{self.}Val := _obj.Val;
	if not ifnil(_obj.LastClr) then
		{self.}LastClr := _obj.LastClr;
	tslassigning := tslassigning_backup;
end;

function SysClr.ReadXmlAttrVal();
begin
	return {self.}XmlAttrVal.Value;
end;

function SysClr.WriteXmlAttrVal(_value);
begin
	if ifnil({self.}XmlAttrVal) then
	begin
		{self.}XmlAttrVal := new OpenXmlAttribute("", "val", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrVal;
	end
	{self.}XmlAttrVal.Value := _value;
end;

function SysClr.ReadXmlAttrLastClr();
begin
	return {self.}XmlAttrLastClr.Value;
end;

function SysClr.WriteXmlAttrLastClr(_value);
begin
	if ifnil({self.}XmlAttrLastClr) then
	begin
		{self.}XmlAttrLastClr := new OpenXmlAttribute("", "LastClr", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrLastClr;
	end
	{self.}XmlAttrLastClr.Value := _value;
end;

function Clr2.Create();overload;
begin
	{self.}Create(nil, "a", "");
end;

function Clr2.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Clr2.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Clr2.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "srgbClr": array(0, makeweakref(thisFunction(ReadXmlChildSrgbClr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Clr2.Copy(_obj: Clr2);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildSrgbClr) then
		{self.}SrgbClr.Copy(_obj.XmlChildSrgbClr);
	tslassigning := tslassigning_backup;
end;

function Clr2.ReadXmlChildSrgbClr(): SrgbClr;
begin
	if tslassigning and ifnil({self.}XmlChildSrgbClr) then
	begin
		{self.}XmlChildSrgbClr := new SrgbClr(self, {self.}Prefix, "srgbClr");
		container_.Set({self.}XmlChildSrgbClr);
	end
	return {self.}XmlChildSrgbClr;
end;

function SrgbClr.Create();overload;
begin
	{self.}Create(nil, "a", "srgbClr");
end;

function SrgbClr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function SrgbClr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function SrgbClr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"val": makeweakref(thisFunction(WriteXmlAttrVal)),
	);
	sorted_child_ := array(
		pre + "aplha": array(0, makeweakref(thisFunction(ReadXmlChildAlpha))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function SrgbClr.Copy(_obj: SrgbClr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Val) then
		{self.}Val := _obj.Val;
	if not ifnil(_obj.XmlChildAlpha) then
		{self.}Alpha.Copy(_obj.XmlChildAlpha);
	tslassigning := tslassigning_backup;
end;

function SrgbClr.ReadXmlAttrVal();
begin
	return {self.}XmlAttrVal.Value;
end;

function SrgbClr.WriteXmlAttrVal(_value);
begin
	if ifnil({self.}XmlAttrVal) then
	begin
		{self.}XmlAttrVal := new OpenXmlAttribute("", "val", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrVal;
	end
	{self.}XmlAttrVal.Value := _value;
end;

function SrgbClr.ReadXmlChildAlpha(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildAlpha) then
	begin
		{self.}XmlChildAlpha := new PureVal(self, {self.}Prefix, "aplha");
		container_.Set({self.}XmlChildAlpha);
	end
	return {self.}XmlChildAlpha;
end;

function PureVal.Create();overload;
begin
	{self.}Create(nil, "", "");
end;

function PureVal.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function PureVal.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function PureVal.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"val": makeweakref(thisFunction(WriteXmlAttrVal)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function PureVal.Copy(_obj: PureVal);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Val) then
		{self.}Val := _obj.Val;
	tslassigning := tslassigning_backup;
end;

function PureVal.ReadXmlAttrVal();
begin
	return {self.}XmlAttrVal.Value;
end;

function PureVal.WriteXmlAttrVal(_value);
begin
	if ifnil({self.}XmlAttrVal) then
	begin
		{self.}XmlAttrVal := new OpenXmlAttribute("", "val", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrVal;
	end
	{self.}XmlAttrVal.Value := _value;
end;

function FontScheme.Create();overload;
begin
	{self.}Create(nil, "a", "fontScheme");
end;

function FontScheme.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function FontScheme.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function FontScheme.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"name": makeweakref(thisFunction(WriteXmlAttrName)),
	);
	sorted_child_ := array(
		pre + "majorFont": array(0, makeweakref(thisFunction(ReadXmlChildMajorfont))),
		pre + "minorFont": array(1, makeweakref(thisFunction(ReadXmlChildMinorfont))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function FontScheme.Copy(_obj: FontScheme);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Name) then
		{self.}Name := _obj.Name;
	if not ifnil(_obj.XmlChildMajorfont) then
		{self.}Majorfont.Copy(_obj.XmlChildMajorfont);
	if not ifnil(_obj.XmlChildMinorfont) then
		{self.}Minorfont.Copy(_obj.XmlChildMinorfont);
	tslassigning := tslassigning_backup;
end;

function FontScheme.ReadXmlAttrName();
begin
	return {self.}XmlAttrName.Value;
end;

function FontScheme.WriteXmlAttrName(_value);
begin
	if ifnil({self.}XmlAttrName) then
	begin
		{self.}XmlAttrName := new OpenXmlAttribute("", "name", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrName;
	end
	{self.}XmlAttrName.Value := _value;
end;

function FontScheme.ReadXmlChildMajorfont(): Mfont;
begin
	if tslassigning and ifnil({self.}XmlChildMajorfont) then
	begin
		{self.}XmlChildMajorfont := new Mfont(self, {self.}Prefix, "majorFont");
		container_.Set({self.}XmlChildMajorfont);
	end
	return {self.}XmlChildMajorfont;
end;

function FontScheme.ReadXmlChildMinorfont(): Mfont;
begin
	if tslassigning and ifnil({self.}XmlChildMinorfont) then
	begin
		{self.}XmlChildMinorfont := new Mfont(self, {self.}Prefix, "minorFont");
		container_.Set({self.}XmlChildMinorfont);
	end
	return {self.}XmlChildMinorfont;
end;

function MFont.Create();overload;
begin
	{self.}Create(nil, "a", "");
end;

function MFont.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function MFont.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function MFont.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "latin": array(0, makeweakref(thisFunction(ReadXmlChildLatin))),
		pre + "ea": array(1, makeweakref(thisFunction(ReadXmlChildEa))),
		pre + "cs": array(2, makeweakref(thisFunction(ReadXmlChildCs))),
		pre + "font": array(3, makeweakref(thisFunction(AppendFont))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function MFont.Copy(_obj: MFont);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildLatin) then
		{self.}Latin.Copy(_obj.XmlChildLatin);
	if not ifnil(_obj.XmlChildEa) then
		{self.}Ea.Copy(_obj.XmlChildEa);
	if not ifnil(_obj.XmlChildCs) then
		{self.}Cs.Copy(_obj.XmlChildCs);
	tslassigning := tslassigning_backup;
end;

function MFont.ReadXmlChildLatin(): Latin;
begin
	if tslassigning and ifnil({self.}XmlChildLatin) then
	begin
		{self.}XmlChildLatin := new Latin(self, {self.}Prefix, "latin");
		container_.Set({self.}XmlChildLatin);
	end
	return {self.}XmlChildLatin;
end;

function MFont.ReadXmlChildEa(): Latin;
begin
	if tslassigning and ifnil({self.}XmlChildEa) then
	begin
		{self.}XmlChildEa := new Latin(self, {self.}Prefix, "ea");
		container_.Set({self.}XmlChildEa);
	end
	return {self.}XmlChildEa;
end;

function MFont.ReadXmlChildCs(): Latin;
begin
	if tslassigning and ifnil({self.}XmlChildCs) then
	begin
		{self.}XmlChildCs := new Latin(self, {self.}Prefix, "cs");
		container_.Set({self.}XmlChildCs);
	end
	return {self.}XmlChildCs;
end;

function MFont.ReadFonts(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get(pre + "font", ind);
end;

function MFont.AddFont(): Font;
begin
	obj := new Font(self, {self.}Prefix, "font");
	container_.Insert(obj);
	return obj;
end;

function MFont.AppendFont(): Font;
begin
	obj := new Font(self, {self.}Prefix, "font");
	container_.Append(obj);
	return obj;
end;

function Font.Create();overload;
begin
	{self.}Create(nil, "a", "font");
end;

function Font.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Font.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Font.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"script": makeweakref(thisFunction(WriteXmlAttrScript)),
		"typeface": makeweakref(thisFunction(WriteXmlAttrTypeface)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Font.Copy(_obj: Font);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Script) then
		{self.}Script := _obj.Script;
	if not ifnil(_obj.Typeface) then
		{self.}Typeface := _obj.Typeface;
	tslassigning := tslassigning_backup;
end;

function Font.ReadXmlAttrScript();
begin
	return {self.}XmlAttrScript.Value;
end;

function Font.WriteXmlAttrScript(_value);
begin
	if ifnil({self.}XmlAttrScript) then
	begin
		{self.}XmlAttrScript := new OpenXmlAttribute("", "script", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrScript;
	end
	{self.}XmlAttrScript.Value := _value;
end;

function Font.ReadXmlAttrTypeface();
begin
	return {self.}XmlAttrTypeface.Value;
end;

function Font.WriteXmlAttrTypeface(_value);
begin
	if ifnil({self.}XmlAttrTypeface) then
	begin
		{self.}XmlAttrTypeface := new OpenXmlAttribute("", "typeface", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrTypeface;
	end
	{self.}XmlAttrTypeface.Value := _value;
end;

function FmtScheme.Create();overload;
begin
	{self.}Create(nil, "a", "fmtScheme");
end;

function FmtScheme.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function FmtScheme.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function FmtScheme.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"name": makeweakref(thisFunction(WriteXmlAttrName)),
	);
	sorted_child_ := array(
		pre + "fillStyleLst": array(0, makeweakref(thisFunction(ReadXmlChildFillStyleLst))),
		pre + "lnStyleLst": array(1, makeweakref(thisFunction(ReadXmlChildLnStyleLst))),
		pre + "effectStyleLst": array(2, makeweakref(thisFunction(ReadXmlChildEffectStyleLst))),
		pre + "bgFillStyleLst": array(3, makeweakref(thisFunction(ReadXmlChildBgFillStyleLst))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function FmtScheme.Copy(_obj: FmtScheme);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Name) then
		{self.}Name := _obj.Name;
	if not ifnil(_obj.XmlChildFillStyleLst) then
		{self.}FillStyleLst.Copy(_obj.XmlChildFillStyleLst);
	if not ifnil(_obj.XmlChildLnStyleLst) then
		{self.}LnStyleLst.Copy(_obj.XmlChildLnStyleLst);
	if not ifnil(_obj.XmlChildEffectStyleLst) then
		{self.}EffectStyleLst.Copy(_obj.XmlChildEffectStyleLst);
	if not ifnil(_obj.XmlChildBgFillStyleLst) then
		{self.}BgFillStyleLst.Copy(_obj.XmlChildBgFillStyleLst);
	tslassigning := tslassigning_backup;
end;

function FmtScheme.ReadXmlAttrName();
begin
	return {self.}XmlAttrName.Value;
end;

function FmtScheme.WriteXmlAttrName(_value);
begin
	if ifnil({self.}XmlAttrName) then
	begin
		{self.}XmlAttrName := new OpenXmlAttribute("", "name", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrName;
	end
	{self.}XmlAttrName.Value := _value;
end;

function FmtScheme.ReadXmlChildFillStyleLst(): FillStyleLst;
begin
	if tslassigning and ifnil({self.}XmlChildFillStyleLst) then
	begin
		{self.}XmlChildFillStyleLst := new FillStyleLst(self, {self.}Prefix, "fillStyleLst");
		container_.Set({self.}XmlChildFillStyleLst);
	end
	return {self.}XmlChildFillStyleLst;
end;

function FmtScheme.ReadXmlChildLnStyleLst(): LnStyleLst;
begin
	if tslassigning and ifnil({self.}XmlChildLnStyleLst) then
	begin
		{self.}XmlChildLnStyleLst := new LnStyleLst(self, {self.}Prefix, "lnStyleLst");
		container_.Set({self.}XmlChildLnStyleLst);
	end
	return {self.}XmlChildLnStyleLst;
end;

function FmtScheme.ReadXmlChildEffectStyleLst(): EffectStyleLst;
begin
	if tslassigning and ifnil({self.}XmlChildEffectStyleLst) then
	begin
		{self.}XmlChildEffectStyleLst := new EffectStyleLst(self, {self.}Prefix, "effectStyleLst");
		container_.Set({self.}XmlChildEffectStyleLst);
	end
	return {self.}XmlChildEffectStyleLst;
end;

function FmtScheme.ReadXmlChildBgFillStyleLst(): FillStyleLst;
begin
	if tslassigning and ifnil({self.}XmlChildBgFillStyleLst) then
	begin
		{self.}XmlChildBgFillStyleLst := new FillStyleLst(self, {self.}Prefix, "bgFillStyleLst");
		container_.Set({self.}XmlChildBgFillStyleLst);
	end
	return {self.}XmlChildBgFillStyleLst;
end;

function FillStyleLst.Create();overload;
begin
	{self.}Create(nil, "a", "fillStyleLst");
end;

function FillStyleLst.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function FillStyleLst.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function FillStyleLst.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "solidFill": array(0, makeweakref(thisFunction(AppendSolidFill))),
		pre + "gradFill": array(1, makeweakref(thisFunction(AppendGradFill))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function FillStyleLst.Copy(_obj: FillStyleLst);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	tslassigning := tslassigning_backup;
end;

function FillStyleLst.ReadSolidFills(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get(pre + "solidFill", ind);
end;

function FillStyleLst.ReadGradFills(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get(pre + "gradFill", ind);
end;

function FillStyleLst.AddSolidFill(): SolidFill;
begin
	obj := new SolidFill(self, {self.}Prefix, "solidFill");
	container_.Insert(obj);
	return obj;
end;

function FillStyleLst.AddGradFill(): GradFill;
begin
	obj := new GradFill(self, {self.}Prefix, "gradFill");
	container_.Insert(obj);
	return obj;
end;

function FillStyleLst.AppendSolidFill(): SolidFill;
begin
	obj := new SolidFill(self, {self.}Prefix, "solidFill");
	container_.Append(obj);
	return obj;
end;

function FillStyleLst.AppendGradFill(): GradFill;
begin
	obj := new GradFill(self, {self.}Prefix, "gradFill");
	container_.Append(obj);
	return obj;
end;

function SolidFill.Create();overload;
begin
	{self.}Create(nil, "a", "solidFill");
end;

function SolidFill.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function SolidFill.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function SolidFill.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "schemeClr": array(0, makeweakref(thisFunction(ReadXmlChildSchemeClr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function SolidFill.Copy(_obj: SolidFill);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildSchemeClr) then
		{self.}SchemeClr.Copy(_obj.XmlChildSchemeClr);
	tslassigning := tslassigning_backup;
end;

function SolidFill.ReadXmlChildSchemeClr(): SchemeClr;
begin
	if tslassigning and ifnil({self.}XmlChildSchemeClr) then
	begin
		{self.}XmlChildSchemeClr := new SchemeClr(self, {self.}Prefix, "schemeClr");
		container_.Set({self.}XmlChildSchemeClr);
	end
	return {self.}XmlChildSchemeClr;
end;

function SchemeClr.Create();overload;
begin
	{self.}Create(nil, "a", "schemeClr");
end;

function SchemeClr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function SchemeClr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function SchemeClr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"val": makeweakref(thisFunction(WriteXmlAttrVal)),
	);
	sorted_child_ := array(
		pre + "lumMod": array(0, makeweakref(thisFunction(ReadXmlChildLumMod))),
		pre + "satMod": array(1, makeweakref(thisFunction(ReadXmlChildSatMod))),
		pre + "tint": array(2, makeweakref(thisFunction(ReadXmlChildTint))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function SchemeClr.Copy(_obj: SchemeClr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Val) then
		{self.}Val := _obj.Val;
	if not ifnil(_obj.XmlChildLumMod) then
		{self.}LumMod.Copy(_obj.XmlChildLumMod);
	if not ifnil(_obj.XmlChildSatMod) then
		{self.}SatMod.Copy(_obj.XmlChildSatMod);
	if not ifnil(_obj.XmlChildTint) then
		{self.}Tint.Copy(_obj.XmlChildTint);
	tslassigning := tslassigning_backup;
end;

function SchemeClr.ReadXmlAttrVal();
begin
	return {self.}XmlAttrVal.Value;
end;

function SchemeClr.WriteXmlAttrVal(_value);
begin
	if ifnil({self.}XmlAttrVal) then
	begin
		{self.}XmlAttrVal := new OpenXmlAttribute("", "val", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrVal;
	end
	{self.}XmlAttrVal.Value := _value;
end;

function SchemeClr.ReadXmlChildLumMod(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildLumMod) then
	begin
		{self.}XmlChildLumMod := new PureVal(self, {self.}Prefix, "lumMod");
		container_.Set({self.}XmlChildLumMod);
	end
	return {self.}XmlChildLumMod;
end;

function SchemeClr.ReadXmlChildSatMod(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildSatMod) then
	begin
		{self.}XmlChildSatMod := new PureVal(self, {self.}Prefix, "satMod");
		container_.Set({self.}XmlChildSatMod);
	end
	return {self.}XmlChildSatMod;
end;

function SchemeClr.ReadXmlChildTint(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildTint) then
	begin
		{self.}XmlChildTint := new PureVal(self, {self.}Prefix, "tint");
		container_.Set({self.}XmlChildTint);
	end
	return {self.}XmlChildTint;
end;

function GradFill.Create();overload;
begin
	{self.}Create(nil, "a", "gradFill");
end;

function GradFill.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function GradFill.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function GradFill.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"rotWithShape": makeweakref(thisFunction(WriteXmlAttrRotWithShape)),
	);
	sorted_child_ := array(
		pre + "gsLst": array(0, makeweakref(thisFunction(ReadXmlChildGsLst))),
		pre + "lin": array(1, makeweakref(thisFunction(ReadXmlChildLin))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function GradFill.Copy(_obj: GradFill);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.RotWithShape) then
		{self.}RotWithShape := _obj.RotWithShape;
	if not ifnil(_obj.XmlChildGsLst) then
		{self.}GsLst.Copy(_obj.XmlChildGsLst);
	if not ifnil(_obj.XmlChildLin) then
		{self.}Lin.Copy(_obj.XmlChildLin);
	tslassigning := tslassigning_backup;
end;

function GradFill.ReadXmlAttrRotWithShape();
begin
	return {self.}XmlAttrRotWithShape.Value;
end;

function GradFill.WriteXmlAttrRotWithShape(_value);
begin
	if ifnil({self.}XmlAttrRotWithShape) then
	begin
		{self.}XmlAttrRotWithShape := new OpenXmlAttribute("", "rotWithShape", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrRotWithShape;
	end
	{self.}XmlAttrRotWithShape.Value := _value;
end;

function GradFill.ReadXmlChildGsLst(): GsLst;
begin
	if tslassigning and ifnil({self.}XmlChildGsLst) then
	begin
		{self.}XmlChildGsLst := new GsLst(self, {self.}Prefix, "gsLst");
		container_.Set({self.}XmlChildGsLst);
	end
	return {self.}XmlChildGsLst;
end;

function GradFill.ReadXmlChildLin(): Lin;
begin
	if tslassigning and ifnil({self.}XmlChildLin) then
	begin
		{self.}XmlChildLin := new Lin(self, {self.}Prefix, "lin");
		container_.Set({self.}XmlChildLin);
	end
	return {self.}XmlChildLin;
end;

function GsLst.Create();overload;
begin
	{self.}Create(nil, "a", "gsLst");
end;

function GsLst.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function GsLst.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function GsLst.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "gs": array(0, makeweakref(thisFunction(AppendGs))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function GsLst.Copy(_obj: GsLst);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	tslassigning := tslassigning_backup;
end;

function GsLst.ReadGses(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get(pre + "gs", ind);
end;

function GsLst.AddGs(): Gs;
begin
	obj := new Gs(self, {self.}Prefix, "gs");
	container_.Insert(obj);
	return obj;
end;

function GsLst.AppendGs(): Gs;
begin
	obj := new Gs(self, {self.}Prefix, "gs");
	container_.Append(obj);
	return obj;
end;

function Gs.Create();overload;
begin
	{self.}Create(nil, "a", "gs");
end;

function Gs.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Gs.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Gs.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"pos": makeweakref(thisFunction(WriteXmlAttrPos)),
	);
	sorted_child_ := array(
		pre + "schemeClr": array(0, makeweakref(thisFunction(ReadXmlChildSchemeClr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Gs.Copy(_obj: Gs);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Pos) then
		{self.}Pos := _obj.Pos;
	if not ifnil(_obj.XmlChildSchemeClr) then
		{self.}SchemeClr.Copy(_obj.XmlChildSchemeClr);
	tslassigning := tslassigning_backup;
end;

function Gs.ReadXmlAttrPos();
begin
	return {self.}XmlAttrPos.Value;
end;

function Gs.WriteXmlAttrPos(_value);
begin
	if ifnil({self.}XmlAttrPos) then
	begin
		{self.}XmlAttrPos := new OpenXmlAttribute("", "pos", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrPos;
	end
	{self.}XmlAttrPos.Value := _value;
end;

function Gs.ReadXmlChildSchemeClr(): SchemeClr;
begin
	if tslassigning and ifnil({self.}XmlChildSchemeClr) then
	begin
		{self.}XmlChildSchemeClr := new SchemeClr(self, {self.}Prefix, "schemeClr");
		container_.Set({self.}XmlChildSchemeClr);
	end
	return {self.}XmlChildSchemeClr;
end;

function Lin.Create();overload;
begin
	{self.}Create(nil, "a", "lin");
end;

function Lin.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Lin.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Lin.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"ang": makeweakref(thisFunction(WriteXmlAttrAng)),
		"scaled": makeweakref(thisFunction(WriteXmlAttrScaled)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Lin.Copy(_obj: Lin);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Ang) then
		{self.}Ang := _obj.Ang;
	if not ifnil(_obj.Scaled) then
		{self.}Scaled := _obj.Scaled;
	tslassigning := tslassigning_backup;
end;

function Lin.ReadXmlAttrAng();
begin
	return {self.}XmlAttrAng.Value;
end;

function Lin.WriteXmlAttrAng(_value);
begin
	if ifnil({self.}XmlAttrAng) then
	begin
		{self.}XmlAttrAng := new OpenXmlAttribute("", "ang", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrAng;
	end
	{self.}XmlAttrAng.Value := _value;
end;

function Lin.ReadXmlAttrScaled();
begin
	return {self.}XmlAttrScaled.Value;
end;

function Lin.WriteXmlAttrScaled(_value);
begin
	if ifnil({self.}XmlAttrScaled) then
	begin
		{self.}XmlAttrScaled := new OpenXmlAttribute("", "scaled", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrScaled;
	end
	{self.}XmlAttrScaled.Value := _value;
end;

function LnStyleLst.Create();overload;
begin
	{self.}Create(nil, "a", "lnStyleLst");
end;

function LnStyleLst.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function LnStyleLst.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function LnStyleLst.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "ln": array(0, makeweakref(thisFunction(AppendLn))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function LnStyleLst.Copy(_obj: LnStyleLst);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	tslassigning := tslassigning_backup;
end;

function LnStyleLst.ReadLns(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get(pre + "ln", ind);
end;

function LnStyleLst.AddLn(): Ln;
begin
	obj := new Ln(self, {self.}Prefix, "ln");
	container_.Insert(obj);
	return obj;
end;

function LnStyleLst.AppendLn(): Ln;
begin
	obj := new Ln(self, {self.}Prefix, "ln");
	container_.Append(obj);
	return obj;
end;

function EffectStyleLst.Create();overload;
begin
	{self.}Create(nil, "a", "effectStyleLst");
end;

function EffectStyleLst.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function EffectStyleLst.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function EffectStyleLst.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "effectStyle": array(0, makeweakref(thisFunction(AppendEffectStyle))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function EffectStyleLst.Copy(_obj: EffectStyleLst);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	tslassigning := tslassigning_backup;
end;

function EffectStyleLst.ReadEffectStyles(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get(pre + "effectStyle", ind);
end;

function EffectStyleLst.AddEffectStyle(): EffectStyle;
begin
	obj := new EffectStyle(self, {self.}Prefix, "effectStyle");
	container_.Insert(obj);
	return obj;
end;

function EffectStyleLst.AppendEffectStyle(): EffectStyle;
begin
	obj := new EffectStyle(self, {self.}Prefix, "effectStyle");
	container_.Append(obj);
	return obj;
end;

function EffectStyle.Create();overload;
begin
	{self.}Create(nil, "a", "effectStyle");
end;

function EffectStyle.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function EffectStyle.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function EffectStyle.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "effectLst": array(0, makeweakref(thisFunction(ReadXmlChildEffectLst))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function EffectStyle.Copy(_obj: EffectStyle);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildEffectLst) then
		{self.}EffectLst.Copy(_obj.XmlChildEffectLst);
	tslassigning := tslassigning_backup;
end;

function EffectStyle.ReadXmlChildEffectLst(): EffectLst;
begin
	if tslassigning and ifnil({self.}XmlChildEffectLst) then
	begin
		{self.}XmlChildEffectLst := new EffectLst(self, {self.}Prefix, "effectLst");
		container_.Set({self.}XmlChildEffectLst);
	end
	return {self.}XmlChildEffectLst;
end;

function OuterShdw.Create();overload;
begin
	{self.}Create(nil, "a", "outerShdw");
end;

function OuterShdw.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function OuterShdw.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function OuterShdw.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"blurRad": makeweakref(thisFunction(WriteXmlAttrBlurRad)),
		"dist": makeweakref(thisFunction(WriteXmlAttrDist)),
		"dir": makeweakref(thisFunction(WriteXmlAttrDir)),
		"algn": makeweakref(thisFunction(WriteXmlAttrAlgn)),
		"rotWithShape": makeweakref(thisFunction(WriteXmlAttrRotWithShape)),
	);
	sorted_child_ := array(
		pre + "srgbClr": array(0, makeweakref(thisFunction(ReadXmlChildSrgbClr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function OuterShdw.Copy(_obj: OuterShdw);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.BlurRad) then
		{self.}BlurRad := _obj.BlurRad;
	if not ifnil(_obj.Dist) then
		{self.}Dist := _obj.Dist;
	if not ifnil(_obj.Dir) then
		{self.}Dir := _obj.Dir;
	if not ifnil(_obj.Algn) then
		{self.}Algn := _obj.Algn;
	if not ifnil(_obj.RotWithShape) then
		{self.}RotWithShape := _obj.RotWithShape;
	if not ifnil(_obj.XmlChildSrgbClr) then
		{self.}SrgbClr.Copy(_obj.XmlChildSrgbClr);
	tslassigning := tslassigning_backup;
end;

function OuterShdw.ReadXmlAttrBlurRad();
begin
	return {self.}XmlAttrBlurRad.Value;
end;

function OuterShdw.WriteXmlAttrBlurRad(_value);
begin
	if ifnil({self.}XmlAttrBlurRad) then
	begin
		{self.}XmlAttrBlurRad := new OpenXmlAttribute("", "blurRad", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrBlurRad;
	end
	{self.}XmlAttrBlurRad.Value := _value;
end;

function OuterShdw.ReadXmlAttrDist();
begin
	return {self.}XmlAttrDist.Value;
end;

function OuterShdw.WriteXmlAttrDist(_value);
begin
	if ifnil({self.}XmlAttrDist) then
	begin
		{self.}XmlAttrDist := new OpenXmlAttribute("", "dist", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDist;
	end
	{self.}XmlAttrDist.Value := _value;
end;

function OuterShdw.ReadXmlAttrDir();
begin
	return {self.}XmlAttrDir.Value;
end;

function OuterShdw.WriteXmlAttrDir(_value);
begin
	if ifnil({self.}XmlAttrDir) then
	begin
		{self.}XmlAttrDir := new OpenXmlAttribute("", "dir", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDir;
	end
	{self.}XmlAttrDir.Value := _value;
end;

function OuterShdw.ReadXmlAttrAlgn();
begin
	return {self.}XmlAttrAlgn.Value;
end;

function OuterShdw.WriteXmlAttrAlgn(_value);
begin
	if ifnil({self.}XmlAttrAlgn) then
	begin
		{self.}XmlAttrAlgn := new OpenXmlAttribute("", "algn", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrAlgn;
	end
	{self.}XmlAttrAlgn.Value := _value;
end;

function OuterShdw.ReadXmlAttrRotWithShape();
begin
	return {self.}XmlAttrRotWithShape.Value;
end;

function OuterShdw.WriteXmlAttrRotWithShape(_value);
begin
	if ifnil({self.}XmlAttrRotWithShape) then
	begin
		{self.}XmlAttrRotWithShape := new OpenXmlAttribute("", "rotWithShape", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrRotWithShape;
	end
	{self.}XmlAttrRotWithShape.Value := _value;
end;

function OuterShdw.ReadXmlChildSrgbClr(): SrgbClr;
begin
	if tslassigning and ifnil({self.}XmlChildSrgbClr) then
	begin
		{self.}XmlChildSrgbClr := new SrgbClr(self, {self.}Prefix, "srgbClr");
		container_.Set({self.}XmlChildSrgbClr);
	end
	return {self.}XmlChildSrgbClr;
end;

function ExtLst.Create();overload;
begin
	{self.}Create(nil, "a", "extLst");
end;

function ExtLst.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function ExtLst.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function ExtLst.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "ext": array(0, makeweakref(thisFunction(AppendExt))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function ExtLst.Copy(_obj: ExtLst);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	tslassigning := tslassigning_backup;
end;

function ExtLst.ReadExts(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get(pre + "ext", ind);
end;

function ExtLst.AddExt(): Ext;
begin
	obj := new Ext(self, {self.}Prefix, "ext");
	container_.Insert(obj);
	return obj;
end;

function ExtLst.AppendExt(): Ext;
begin
	obj := new Ext(self, {self.}Prefix, "ext");
	container_.Append(obj);
	return obj;
end;

function Ext.Create();overload;
begin
	{self.}Create(nil, "a", "ext");
end;

function Ext.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Ext.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Ext.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"uri": makeweakref(thisFunction(WriteXmlAttrUri)),
	);
	sorted_child_ := array(
		"thm15:themeFamily": array(0, makeweakref(thisFunction(ReadXmlChildThm15ThemeFamily))),
		"c16:uniquedId": array(1, makeweakref(thisFunction(ReadXmlChildUniqueId))),
		"x14:slicerStyles": array(2, makeweakref(thisFunction(ReadXmlChildSlicerStyles))),
		"x15:timelineStyles": array(3, makeweakref(thisFunction(ReadXmlChildTimelineStyles))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Ext.Copy(_obj: Ext);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Uri) then
		{self.}Uri := _obj.Uri;
	if not ifnil(_obj.XmlChildThm15ThemeFamily) then
		{self.}Thm15ThemeFamily.Copy(_obj.XmlChildThm15ThemeFamily);
	if not ifnil(_obj.XmlChildUniqueId) then
		{self.}UniqueId.Copy(_obj.XmlChildUniqueId);
	if not ifnil(_obj.XmlChildSlicerStyles) then
		{self.}SlicerStyles.Copy(_obj.XmlChildSlicerStyles);
	if not ifnil(_obj.XmlChildTimelineStyles) then
		{self.}TimelineStyles.Copy(_obj.XmlChildTimelineStyles);
	tslassigning := tslassigning_backup;
end;

function Ext.ReadXmlAttrUri();
begin
	return {self.}XmlAttrUri.Value;
end;

function Ext.WriteXmlAttrUri(_value);
begin
	if ifnil({self.}XmlAttrUri) then
	begin
		{self.}XmlAttrUri := new OpenXmlAttribute("", "uri", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrUri;
	end
	{self.}XmlAttrUri.Value := _value;
end;

function Ext.ReadXmlChildThm15ThemeFamily(): ThemeFamily;
begin
	if tslassigning and ifnil({self.}XmlChildThm15ThemeFamily) then
	begin
		{self.}XmlChildThm15ThemeFamily := new ThemeFamily(self, "thm15", "themeFamily");
		container_.Set({self.}XmlChildThm15ThemeFamily);
	end
	return {self.}XmlChildThm15ThemeFamily;
end;

function Ext.ReadXmlChildUniqueId(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildUniqueId) then
	begin
		{self.}XmlChildUniqueId := new PureVal(self, "c16", "uniquedId");
		container_.Set({self.}XmlChildUniqueId);
	end
	return {self.}XmlChildUniqueId;
end;

function Ext.ReadXmlChildSlicerStyles(): SlicerStyles;
begin
	if tslassigning and ifnil({self.}XmlChildSlicerStyles) then
	begin
		{self.}XmlChildSlicerStyles := new SlicerStyles(self, "x14", "slicerStyles");
		container_.Set({self.}XmlChildSlicerStyles);
	end
	return {self.}XmlChildSlicerStyles;
end;

function Ext.ReadXmlChildTimelineStyles(): TimelineStyles;
begin
	if tslassigning and ifnil({self.}XmlChildTimelineStyles) then
	begin
		{self.}XmlChildTimelineStyles := new TimelineStyles(self, "x15", "timelineStyles");
		container_.Set({self.}XmlChildTimelineStyles);
	end
	return {self.}XmlChildTimelineStyles;
end;

function SlicerStyles.Create();overload;
begin
	{self.}Create(nil, "", "slicerStyles");
end;

function SlicerStyles.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function SlicerStyles.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function SlicerStyles.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"defaultSlicerStyle": makeweakref(thisFunction(WriteXmlAttrDefaultSlicerStyle)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function SlicerStyles.Copy(_obj: SlicerStyles);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.DefaultSlicerStyle) then
		{self.}DefaultSlicerStyle := _obj.DefaultSlicerStyle;
	tslassigning := tslassigning_backup;
end;

function SlicerStyles.ReadXmlAttrDefaultSlicerStyle();
begin
	return {self.}XmlAttrDefaultSlicerStyle.Value;
end;

function SlicerStyles.WriteXmlAttrDefaultSlicerStyle(_value);
begin
	if ifnil({self.}XmlAttrDefaultSlicerStyle) then
	begin
		{self.}XmlAttrDefaultSlicerStyle := new OpenXmlAttribute("", "defaultSlicerStyle", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDefaultSlicerStyle;
	end
	{self.}XmlAttrDefaultSlicerStyle.Value := _value;
end;

function TimelineStyles.Create();overload;
begin
	{self.}Create(nil, "", "timelineStyles");
end;

function TimelineStyles.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function TimelineStyles.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function TimelineStyles.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"defaultTimelineStyle": makeweakref(thisFunction(WriteXmlAttrDefaultTimelineStyle)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function TimelineStyles.Copy(_obj: TimelineStyles);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.DefaultTimelineStyle) then
		{self.}DefaultTimelineStyle := _obj.DefaultTimelineStyle;
	tslassigning := tslassigning_backup;
end;

function TimelineStyles.ReadXmlAttrDefaultTimelineStyle();
begin
	return {self.}XmlAttrDefaultTimelineStyle.Value;
end;

function TimelineStyles.WriteXmlAttrDefaultTimelineStyle(_value);
begin
	if ifnil({self.}XmlAttrDefaultTimelineStyle) then
	begin
		{self.}XmlAttrDefaultTimelineStyle := new OpenXmlAttribute("", "defaultTimelineStyle", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDefaultTimelineStyle;
	end
	{self.}XmlAttrDefaultTimelineStyle.Value := _value;
end;

function ThemeFamily.Create();overload;
begin
	{self.}Create(nil, "thm15", "themeFamily");
end;

function ThemeFamily.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function ThemeFamily.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function ThemeFamily.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"name": makeweakref(thisFunction(WriteXmlAttrName)),
		"Id": makeweakref(thisFunction(WriteXmlAttrId)),
		"vid": makeweakref(thisFunction(WriteXmlAttrVid)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function ThemeFamily.Copy(_obj: ThemeFamily);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Name) then
		{self.}Name := _obj.Name;
	if not ifnil(_obj.Id) then
		{self.}Id := _obj.Id;
	if not ifnil(_obj.Vid) then
		{self.}Vid := _obj.Vid;
	tslassigning := tslassigning_backup;
end;

function ThemeFamily.ReadXmlAttrName();
begin
	return {self.}XmlAttrName.Value;
end;

function ThemeFamily.WriteXmlAttrName(_value);
begin
	if ifnil({self.}XmlAttrName) then
	begin
		{self.}XmlAttrName := new OpenXmlAttribute("", "name", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrName;
	end
	{self.}XmlAttrName.Value := _value;
end;

function ThemeFamily.ReadXmlAttrId();
begin
	return {self.}XmlAttrId.Value;
end;

function ThemeFamily.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 ThemeFamily.ReadXmlAttrVid();
begin
	return {self.}XmlAttrVid.Value;
end;

function ThemeFamily.WriteXmlAttrVid(_value);
begin
	if ifnil({self.}XmlAttrVid) then
	begin
		{self.}XmlAttrVid := new OpenXmlAttribute("", "vid", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrVid;
	end
	{self.}XmlAttrVid.Value := _value;
end;

function ChartSpace.Create();overload;
begin
	{self.}Create(nil, "c", "chartSpace");
end;

function ChartSpace.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function ChartSpace.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function ChartSpace.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "date1904": array(0, makeweakref(thisFunction(ReadXmlChildDate1904))),
		pre + "lang": array(1, makeweakref(thisFunction(ReadXmlChildLang))),
		"mc:AlternateContent": array(2, makeweakref(thisFunction(ReadXmlChildAlternateContent))),
		pre + "chart": array(3, makeweakref(thisFunction(ReadXmlChildChart))),
		pre + "spPr": array(4, makeweakref(thisFunction(ReadXmlChildSpPr))),
		pre + "externalData": array(5, makeweakref(thisFunction(ReadXmlChildExternalData))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function ChartSpace.Copy(_obj: ChartSpace);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildDate1904) then
		{self.}Date1904.Copy(_obj.XmlChildDate1904);
	if not ifnil(_obj.XmlChildLang) then
		ifnil({self.}XmlChildLang) ? {self.}Lang.Copy(_obj.XmlChildLang) : {self.}XmlChildLang.Copy(_obj.XmlChildLang);
	if not ifnil(_obj.XmlChildAlternateContent) then
		{self.}AlternateContent.Copy(_obj.XmlChildAlternateContent);
	if not ifnil(_obj.XmlChildChart) then
		{self.}Chart.Copy(_obj.XmlChildChart);
	if not ifnil(_obj.XmlChildSpPr) then
		{self.}SpPr.Copy(_obj.XmlChildSpPr);
	if not ifnil(_obj.XmlChildExternalData) then
		{self.}ExternalData.Copy(_obj.XmlChildExternalData);
	tslassigning := tslassigning_backup;
end;

function ChartSpace.ReadXmlChildLang();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildLang) then
		begin
			{self.}XmlChildLang := new OpenXmlEmpty(self, {self.}Prefix, "lang");
			container_.Set({self.}XmlChildLang);
		end
		return {self.}XmlChildLang;
	end
	return ifnil({self.}XmlChildLang) ? nil : {self.}XmlChildLang.BoolValue();
end;

function ChartSpace.WriteXmlChildLang(_value);
begin
	if ifnil({self.}XmlChildLang) then
	begin
		{self.}XmlChildLang := new OpenXmlEmpty(self, {self.}Prefix, "lang");
		container_.Set({self.}XmlChildLang);
	end
	{self.}XmlChildLang.Value := _value;
end;

function ChartSpace.ReadXmlChildDate1904(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildDate1904) then
	begin
		{self.}XmlChildDate1904 := new PureVal(self, {self.}Prefix, "date1904");
		container_.Set({self.}XmlChildDate1904);
	end
	return {self.}XmlChildDate1904;
end;

function ChartSpace.ReadXmlChildAlternateContent(): AlternateContent;
begin
	if tslassigning and ifnil({self.}XmlChildAlternateContent) then
	begin
		{self.}XmlChildAlternateContent := new AlternateContent(self, "mc", "AlternateContent");
		container_.Set({self.}XmlChildAlternateContent);
	end
	return {self.}XmlChildAlternateContent;
end;

function ChartSpace.ReadXmlChildChart(): Chart;
begin
	if tslassigning and ifnil({self.}XmlChildChart) then
	begin
		{self.}XmlChildChart := new Chart(self, {self.}Prefix, "chart");
		container_.Set({self.}XmlChildChart);
	end
	return {self.}XmlChildChart;
end;

function ChartSpace.ReadXmlChildSpPr(): SpPr;
begin
	if tslassigning and ifnil({self.}XmlChildSpPr) then
	begin
		{self.}XmlChildSpPr := new SpPr(self, {self.}Prefix, "spPr");
		container_.Set({self.}XmlChildSpPr);
	end
	return {self.}XmlChildSpPr;
end;

function ChartSpace.ReadXmlChildExternalData(): ExternalData;
begin
	if tslassigning and ifnil({self.}XmlChildExternalData) then
	begin
		{self.}XmlChildExternalData := new ExternalData(self, {self.}Prefix, "externalData");
		container_.Set({self.}XmlChildExternalData);
	end
	return {self.}XmlChildExternalData;
end;

function Chart.Create();overload;
begin
	{self.}Create(nil, "c", "chart");
end;

function Chart.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Chart.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Chart.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"r:id": makeweakref(thisFunction(WriteXmlAttrId)),
	);
	sorted_child_ := array(
		pre + "title": array(0, makeweakref(thisFunction(ReadXmlChildTitle))),
		pre + "autoTitleDeleted": array(1, makeweakref(thisFunction(ReadXmlChildAutoTitleDeleted))),
		pre + "view3D": array(2, makeweakref(thisFunction(ReadXmlChildView3D))),
		pre + "plotArea": array(3, makeweakref(thisFunction(ReadXmlChildPlotArea))),
		pre + "legend": array(4, makeweakref(thisFunction(ReadXmlChildLegend))),
		pre + "plotVisOnly": array(5, makeweakref(thisFunction(ReadXmlChildPlotVisOnly))),
		pre + "dispBlanksAs": array(6, makeweakref(thisFunction(ReadXmlChildDispBlanksAs))),
		pre + "showDLblsOverMax": array(7, makeweakref(thisFunction(ReadXmlChildShowDLblsOverMax))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Chart.Copy(_obj: Chart);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Id) then
		{self.}Id := _obj.Id;
	if not ifnil(_obj.XmlChildTitle) then
		{self.}Title.Copy(_obj.XmlChildTitle);
	if not ifnil(_obj.XmlChildAutoTitleDeleted) then
		{self.}AutoTitleDeleted.Copy(_obj.XmlChildAutoTitleDeleted);
	if not ifnil(_obj.XmlChildView3D) then
		{self.}View3D.Copy(_obj.XmlChildView3D);
	if not ifnil(_obj.XmlChildPlotArea) then
		{self.}PlotArea.Copy(_obj.XmlChildPlotArea);
	if not ifnil(_obj.XmlChildLegend) then
		{self.}Legend.Copy(_obj.XmlChildLegend);
	if not ifnil(_obj.XmlChildPlotVisOnly) then
		{self.}PlotVisOnly.Copy(_obj.XmlChildPlotVisOnly);
	if not ifnil(_obj.XmlChildDispBlanksAs) then
		{self.}DispBlanksAs.Copy(_obj.XmlChildDispBlanksAs);
	if not ifnil(_obj.XmlChildShowDLblsOverMax) then
		{self.}ShowDLblsOverMax.Copy(_obj.XmlChildShowDLblsOverMax);
	tslassigning := tslassigning_backup;
end;

function Chart.ReadXmlAttrId();
begin
	return {self.}XmlAttrId.Value;
end;

function Chart.WriteXmlAttrId(_value);
begin
	if ifnil({self.}XmlAttrId) then
	begin
		{self.}XmlAttrId := new OpenXmlAttribute("r", "id", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrId;
	end
	{self.}XmlAttrId.Value := _value;
end;

function Chart.ReadXmlChildTitle(): Title;
begin
	if tslassigning and ifnil({self.}XmlChildTitle) then
	begin
		{self.}XmlChildTitle := new Title(self, {self.}Prefix, "title");
		container_.Set({self.}XmlChildTitle);
	end
	return {self.}XmlChildTitle;
end;

function Chart.ReadXmlChildAutoTitleDeleted(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildAutoTitleDeleted) then
	begin
		{self.}XmlChildAutoTitleDeleted := new PureVal(self, {self.}Prefix, "autoTitleDeleted");
		container_.Set({self.}XmlChildAutoTitleDeleted);
	end
	return {self.}XmlChildAutoTitleDeleted;
end;

function Chart.ReadXmlChildView3D(): View3D;
begin
	if tslassigning and ifnil({self.}XmlChildView3D) then
	begin
		{self.}XmlChildView3D := new View3D(self, {self.}Prefix, "view3D");
		container_.Set({self.}XmlChildView3D);
	end
	return {self.}XmlChildView3D;
end;

function Chart.ReadXmlChildPlotArea(): PlotArea;
begin
	if tslassigning and ifnil({self.}XmlChildPlotArea) then
	begin
		{self.}XmlChildPlotArea := new PlotArea(self, {self.}Prefix, "plotArea");
		container_.Set({self.}XmlChildPlotArea);
	end
	return {self.}XmlChildPlotArea;
end;

function Chart.ReadXmlChildLegend(): Legend;
begin
	if tslassigning and ifnil({self.}XmlChildLegend) then
	begin
		{self.}XmlChildLegend := new Legend(self, {self.}Prefix, "legend");
		container_.Set({self.}XmlChildLegend);
	end
	return {self.}XmlChildLegend;
end;

function Chart.ReadXmlChildPlotVisOnly(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildPlotVisOnly) then
	begin
		{self.}XmlChildPlotVisOnly := new PureVal(self, {self.}Prefix, "plotVisOnly");
		container_.Set({self.}XmlChildPlotVisOnly);
	end
	return {self.}XmlChildPlotVisOnly;
end;

function Chart.ReadXmlChildDispBlanksAs(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildDispBlanksAs) then
	begin
		{self.}XmlChildDispBlanksAs := new PureVal(self, {self.}Prefix, "dispBlanksAs");
		container_.Set({self.}XmlChildDispBlanksAs);
	end
	return {self.}XmlChildDispBlanksAs;
end;

function Chart.ReadXmlChildShowDLblsOverMax(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildShowDLblsOverMax) then
	begin
		{self.}XmlChildShowDLblsOverMax := new PureVal(self, {self.}Prefix, "showDLblsOverMax");
		container_.Set({self.}XmlChildShowDLblsOverMax);
	end
	return {self.}XmlChildShowDLblsOverMax;
end;

function Legend.Create();overload;
begin
	{self.}Create(nil, "c", "legend");
end;

function Legend.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Legend.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Legend.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "legendPos": array(0, makeweakref(thisFunction(ReadXmlChildLegendPos))),
		pre + "layout": array(1, makeweakref(thisFunction(ReadXmlChildLayout))),
		pre + "overlay": array(2, makeweakref(thisFunction(ReadXmlChildOverlay))),
		pre + "txPr": array(3, makeweakref(thisFunction(ReadXmlChildTxPr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Legend.Copy(_obj: Legend);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildLegendPos) then
		{self.}LegendPos.Copy(_obj.XmlChildLegendPos);
	if not ifnil(_obj.XmlChildLayout) then
		ifnil({self.}XmlChildLayout) ? {self.}Layout.Copy(_obj.XmlChildLayout) : {self.}XmlChildLayout.Copy(_obj.XmlChildLayout);
	if not ifnil(_obj.XmlChildOverlay) then
		{self.}Overlay.Copy(_obj.XmlChildOverlay);
	if not ifnil(_obj.XmlChildTxPr) then
		{self.}TxPr.Copy(_obj.XmlChildTxPr);
	tslassigning := tslassigning_backup;
end;

function Legend.ReadXmlChildLayout();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildLayout) then
		begin
			{self.}XmlChildLayout := new OpenXmlEmpty(self, {self.}Prefix, "layout");
			container_.Set({self.}XmlChildLayout);
		end
		return {self.}XmlChildLayout;
	end
	return ifnil({self.}XmlChildLayout) ? nil : {self.}XmlChildLayout.BoolValue();
end;

function Legend.WriteXmlChildLayout(_value);
begin
	if ifnil({self.}XmlChildLayout) then
	begin
		{self.}XmlChildLayout := new OpenXmlEmpty(self, {self.}Prefix, "layout");
		container_.Set({self.}XmlChildLayout);
	end
	{self.}XmlChildLayout.Value := _value;
end;

function Legend.ReadXmlChildLegendPos(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildLegendPos) then
	begin
		{self.}XmlChildLegendPos := new PureVal(self, {self.}Prefix, "legendPos");
		container_.Set({self.}XmlChildLegendPos);
	end
	return {self.}XmlChildLegendPos;
end;

function Legend.ReadXmlChildOverlay(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildOverlay) then
	begin
		{self.}XmlChildOverlay := new PureVal(self, {self.}Prefix, "overlay");
		container_.Set({self.}XmlChildOverlay);
	end
	return {self.}XmlChildOverlay;
end;

function Legend.ReadXmlChildTxPr(): TxPr;
begin
	if tslassigning and ifnil({self.}XmlChildTxPr) then
	begin
		{self.}XmlChildTxPr := new TxPr(self, {self.}Prefix, "txPr");
		container_.Set({self.}XmlChildTxPr);
	end
	return {self.}XmlChildTxPr;
end;

function View3D.Create();overload;
begin
	{self.}Create(nil, "c", "view3D");
end;

function View3D.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function View3D.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function View3D.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "rotX": array(0, makeweakref(thisFunction(ReadXmlChildRotX))),
		pre + "rotY": array(1, makeweakref(thisFunction(ReadXmlChildRotY))),
		pre + "rAngAx": array(2, makeweakref(thisFunction(ReadXmlChildRAngAx))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function View3D.Copy(_obj: View3D);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildRotX) then
		{self.}RotX.Copy(_obj.XmlChildRotX);
	if not ifnil(_obj.XmlChildRotY) then
		{self.}RotY.Copy(_obj.XmlChildRotY);
	if not ifnil(_obj.XmlChildRAngAx) then
		{self.}RAngAx.Copy(_obj.XmlChildRAngAx);
	tslassigning := tslassigning_backup;
end;

function View3D.ReadXmlChildRotX(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildRotX) then
	begin
		{self.}XmlChildRotX := new PureVal(self, {self.}Prefix, "rotX");
		container_.Set({self.}XmlChildRotX);
	end
	return {self.}XmlChildRotX;
end;

function View3D.ReadXmlChildRotY(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildRotY) then
	begin
		{self.}XmlChildRotY := new PureVal(self, {self.}Prefix, "rotY");
		container_.Set({self.}XmlChildRotY);
	end
	return {self.}XmlChildRotY;
end;

function View3D.ReadXmlChildRAngAx(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildRAngAx) then
	begin
		{self.}XmlChildRAngAx := new PureVal(self, {self.}Prefix, "rAngAx");
		container_.Set({self.}XmlChildRAngAx);
	end
	return {self.}XmlChildRAngAx;
end;

function PlotArea.Create();overload;
begin
	{self.}Create(nil, "c", "plotArea");
end;

function PlotArea.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function PlotArea.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function PlotArea.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "layout": array(0, makeweakref(thisFunction(ReadXmlChildLayout))),
		pre + "barChart": array(1, makeweakref(thisFunction(ReadXmlChildBarChart))),
		pre + "catAx": array(2, makeweakref(thisFunction(ReadXmlChildCatAx))),
		pre + "ValAx": array(3, makeweakref(thisFunction(ReadXmlChildValAx))),
		pre + "dTable": array(4, makeweakref(thisFunction(ReadXmlChildDTable))),
		pre + "SpPr": array(5, makeweakref(thisFunction(ReadXmlChildSpPr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function PlotArea.Copy(_obj: PlotArea);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildLayout) then
		ifnil({self.}XmlChildLayout) ? {self.}Layout.Copy(_obj.XmlChildLayout) : {self.}XmlChildLayout.Copy(_obj.XmlChildLayout);
	if not ifnil(_obj.XmlChildBarChart) then
		{self.}BarChart.Copy(_obj.XmlChildBarChart);
	if not ifnil(_obj.XmlChildCatAx) then
		{self.}CatAx.Copy(_obj.XmlChildCatAx);
	if not ifnil(_obj.XmlChildValAx) then
		{self.}ValAx.Copy(_obj.XmlChildValAx);
	if not ifnil(_obj.XmlChildDTable) then
		{self.}DTable.Copy(_obj.XmlChildDTable);
	if not ifnil(_obj.XmlChildSpPr) then
		{self.}SpPr.Copy(_obj.XmlChildSpPr);
	tslassigning := tslassigning_backup;
end;

function PlotArea.ReadXmlChildLayout();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildLayout) then
		begin
			{self.}XmlChildLayout := new OpenXmlEmpty(self, {self.}Prefix, "layout");
			container_.Set({self.}XmlChildLayout);
		end
		return {self.}XmlChildLayout;
	end
	return ifnil({self.}XmlChildLayout) ? nil : {self.}XmlChildLayout.BoolValue();
end;

function PlotArea.WriteXmlChildLayout(_value);
begin
	if ifnil({self.}XmlChildLayout) then
	begin
		{self.}XmlChildLayout := new OpenXmlEmpty(self, {self.}Prefix, "layout");
		container_.Set({self.}XmlChildLayout);
	end
	{self.}XmlChildLayout.Value := _value;
end;

function PlotArea.ReadXmlChildBarChart(): BarChart;
begin
	if tslassigning and ifnil({self.}XmlChildBarChart) then
	begin
		{self.}XmlChildBarChart := new BarChart(self, {self.}Prefix, "barChart");
		container_.Set({self.}XmlChildBarChart);
	end
	return {self.}XmlChildBarChart;
end;

function PlotArea.ReadXmlChildCatAx(): Ax;
begin
	if tslassigning and ifnil({self.}XmlChildCatAx) then
	begin
		{self.}XmlChildCatAx := new Ax(self, {self.}Prefix, "catAx");
		container_.Set({self.}XmlChildCatAx);
	end
	return {self.}XmlChildCatAx;
end;

function PlotArea.ReadXmlChildValAx(): Ax;
begin
	if tslassigning and ifnil({self.}XmlChildValAx) then
	begin
		{self.}XmlChildValAx := new Ax(self, {self.}Prefix, "ValAx");
		container_.Set({self.}XmlChildValAx);
	end
	return {self.}XmlChildValAx;
end;

function PlotArea.ReadXmlChildDTable(): DTable;
begin
	if tslassigning and ifnil({self.}XmlChildDTable) then
	begin
		{self.}XmlChildDTable := new DTable(self, {self.}Prefix, "dTable");
		container_.Set({self.}XmlChildDTable);
	end
	return {self.}XmlChildDTable;
end;

function PlotArea.ReadXmlChildSpPr(): SpPr;
begin
	if tslassigning and ifnil({self.}XmlChildSpPr) then
	begin
		{self.}XmlChildSpPr := new SpPr(self, {self.}Prefix, "SpPr");
		container_.Set({self.}XmlChildSpPr);
	end
	return {self.}XmlChildSpPr;
end;

function BarChart.Create();overload;
begin
	{self.}Create(nil, "c", "barChart");
end;

function BarChart.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function BarChart.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function BarChart.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "barDir": array(0, makeweakref(thisFunction(ReadXmlChildBarDir))),
		pre + "grouping": array(1, makeweakref(thisFunction(ReadXmlChildGrouping))),
		pre + "varyColors": array(2, makeweakref(thisFunction(ReadXmlChildVaryColors))),
		pre + "ser": array(3, makeweakref(thisFunction(AppendSer))),
		pre + "gapWidth": array(4, makeweakref(thisFunction(ReadXmlChildGapWidth))),
		pre + "axId": array(5, makeweakref(thisFunction(AppendAxId))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function BarChart.Copy(_obj: BarChart);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildBarDir) then
		{self.}BarDir.Copy(_obj.XmlChildBarDir);
	if not ifnil(_obj.XmlChildGrouping) then
		{self.}Grouping.Copy(_obj.XmlChildGrouping);
	if not ifnil(_obj.XmlChildVaryColors) then
		{self.}VaryColors.Copy(_obj.XmlChildVaryColors);
	if not ifnil(_obj.XmlChildGapWidth) then
		{self.}GapWidth.Copy(_obj.XmlChildGapWidth);
	tslassigning := tslassigning_backup;
end;

function BarChart.ReadXmlChildBarDir(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildBarDir) then
	begin
		{self.}XmlChildBarDir := new PureVal(self, {self.}Prefix, "barDir");
		container_.Set({self.}XmlChildBarDir);
	end
	return {self.}XmlChildBarDir;
end;

function BarChart.ReadXmlChildGrouping(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildGrouping) then
	begin
		{self.}XmlChildGrouping := new PureVal(self, {self.}Prefix, "grouping");
		container_.Set({self.}XmlChildGrouping);
	end
	return {self.}XmlChildGrouping;
end;

function BarChart.ReadXmlChildVaryColors(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildVaryColors) then
	begin
		{self.}XmlChildVaryColors := new PureVal(self, {self.}Prefix, "varyColors");
		container_.Set({self.}XmlChildVaryColors);
	end
	return {self.}XmlChildVaryColors;
end;

function BarChart.ReadXmlChildGapWidth(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildGapWidth) then
	begin
		{self.}XmlChildGapWidth := new PureVal(self, {self.}Prefix, "gapWidth");
		container_.Set({self.}XmlChildGapWidth);
	end
	return {self.}XmlChildGapWidth;
end;

function BarChart.ReadSers(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get(pre + "ser", ind);
end;

function BarChart.ReadAxIds(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get(pre + "axId", ind);
end;

function BarChart.AddSer(): Ser;
begin
	obj := new Ser(self, {self.}Prefix, "ser");
	container_.Insert(obj);
	return obj;
end;

function BarChart.AddAxId(): PureVal;
begin
	obj := new PureVal(self, {self.}Prefix, "axId");
	container_.Insert(obj);
	return obj;
end;

function BarChart.AppendSer(): Ser;
begin
	obj := new Ser(self, {self.}Prefix, "ser");
	container_.Append(obj);
	return obj;
end;

function BarChart.AppendAxId(): PureVal;
begin
	obj := new PureVal(self, {self.}Prefix, "axId");
	container_.Append(obj);
	return obj;
end;

function Ser.Create();overload;
begin
	{self.}Create(nil, "c", "ser");
end;

function Ser.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Ser.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Ser.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "idx": array(0, makeweakref(thisFunction(ReadXmlChildIdx))),
		pre + "order": array(1, makeweakref(thisFunction(ReadXmlChild_Order))),
		pre + "tx": array(2, makeweakref(thisFunction(ReadXmlChildTx))),
		pre + "invertIfNegative": array(3, makeweakref(thisFunction(ReadXmlChildInvertIfNegative))),
		pre + "dLbls": array(4, makeweakref(thisFunction(ReadXmlChildDLbls))),
		pre + "cat": array(5, makeweakref(thisFunction(ReadXmlChildCat))),
		pre + "val": array(6, makeweakref(thisFunction(ReadXmlChildVal))),
		pre + "extLst": array(7, makeweakref(thisFunction(ReadXmlChildExtLst))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Ser.Copy(_obj: Ser);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildIdx) then
		{self.}Idx.Copy(_obj.XmlChildIdx);
	if not ifnil(_obj.XmlChild_Order) then
		{self.}_Order.Copy(_obj.XmlChild_Order);
	if not ifnil(_obj.XmlChildTx) then
		{self.}Tx.Copy(_obj.XmlChildTx);
	if not ifnil(_obj.XmlChildInvertIfNegative) then
		{self.}InvertIfNegative.Copy(_obj.XmlChildInvertIfNegative);
	if not ifnil(_obj.XmlChildDLbls) then
		{self.}DLbls.Copy(_obj.XmlChildDLbls);
	if not ifnil(_obj.XmlChildCat) then
		{self.}Cat.Copy(_obj.XmlChildCat);
	if not ifnil(_obj.XmlChildVal) then
		{self.}Val.Copy(_obj.XmlChildVal);
	if not ifnil(_obj.XmlChildExtLst) then
		{self.}ExtLst.Copy(_obj.XmlChildExtLst);
	tslassigning := tslassigning_backup;
end;

function Ser.ReadXmlChildIdx(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildIdx) then
	begin
		{self.}XmlChildIdx := new PureVal(self, {self.}Prefix, "idx");
		container_.Set({self.}XmlChildIdx);
	end
	return {self.}XmlChildIdx;
end;

function Ser.ReadXmlChild_Order(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChild_Order) then
	begin
		{self.}XmlChild_Order := new PureVal(self, {self.}Prefix, "order");
		container_.Set({self.}XmlChild_Order);
	end
	return {self.}XmlChild_Order;
end;

function Ser.ReadXmlChildTx(): Tx;
begin
	if tslassigning and ifnil({self.}XmlChildTx) then
	begin
		{self.}XmlChildTx := new Tx(self, {self.}Prefix, "tx");
		container_.Set({self.}XmlChildTx);
	end
	return {self.}XmlChildTx;
end;

function Ser.ReadXmlChildInvertIfNegative(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildInvertIfNegative) then
	begin
		{self.}XmlChildInvertIfNegative := new PureVal(self, {self.}Prefix, "invertIfNegative");
		container_.Set({self.}XmlChildInvertIfNegative);
	end
	return {self.}XmlChildInvertIfNegative;
end;

function Ser.ReadXmlChildDLbls(): DLbls;
begin
	if tslassigning and ifnil({self.}XmlChildDLbls) then
	begin
		{self.}XmlChildDLbls := new DLbls(self, {self.}Prefix, "dLbls");
		container_.Set({self.}XmlChildDLbls);
	end
	return {self.}XmlChildDLbls;
end;

function Ser.ReadXmlChildCat(): Cat;
begin
	if tslassigning and ifnil({self.}XmlChildCat) then
	begin
		{self.}XmlChildCat := new Cat(self, {self.}Prefix, "cat");
		container_.Set({self.}XmlChildCat);
	end
	return {self.}XmlChildCat;
end;

function Ser.ReadXmlChildVal(): Val;
begin
	if tslassigning and ifnil({self.}XmlChildVal) then
	begin
		{self.}XmlChildVal := new Val(self, {self.}Prefix, "val");
		container_.Set({self.}XmlChildVal);
	end
	return {self.}XmlChildVal;
end;

function Ser.ReadXmlChildExtLst(): ExtLst;
begin
	if tslassigning and ifnil({self.}XmlChildExtLst) then
	begin
		{self.}XmlChildExtLst := new ExtLst(self, {self.}Prefix, "extLst");
		container_.Set({self.}XmlChildExtLst);
	end
	return {self.}XmlChildExtLst;
end;

function DLbls.Create();overload;
begin
	{self.}Create(nil, "c", "dLbls");
end;

function DLbls.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function DLbls.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function DLbls.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "spPr": array(0, makeweakref(thisFunction(ReadXmlChildSpPr))),
		pre + "showLegendKey": array(1, makeweakref(thisFunction(ReadXmlChildShowLegendKey))),
		pre + "showVal": array(2, makeweakref(thisFunction(ReadXmlChildShowVal))),
		pre + "showCatName": array(3, makeweakref(thisFunction(ReadXmlChildShowCatName))),
		pre + "showSerName": array(4, makeweakref(thisFunction(ReadXmlChildShowSerName))),
		pre + "showPercent": array(5, makeweakref(thisFunction(ReadXmlChildShowPercent))),
		pre + "showBubbleSize": array(6, makeweakref(thisFunction(ReadXmlChildShowBubbleSize))),
		pre + "showLeaderLines": array(7, makeweakref(thisFunction(ReadXmlChildShowLeaderLines))),
		pre + "extLst": array(8, makeweakref(thisFunction(ReadXmlChildExtLst))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function DLbls.Copy(_obj: DLbls);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildSpPr) then
		{self.}SpPr.Copy(_obj.XmlChildSpPr);
	if not ifnil(_obj.XmlChildShowLegendKey) then
		{self.}ShowLegendKey.Copy(_obj.XmlChildShowLegendKey);
	if not ifnil(_obj.XmlChildShowVal) then
		{self.}ShowVal.Copy(_obj.XmlChildShowVal);
	if not ifnil(_obj.XmlChildShowCatName) then
		{self.}ShowCatName.Copy(_obj.XmlChildShowCatName);
	if not ifnil(_obj.XmlChildShowSerName) then
		{self.}ShowSerName.Copy(_obj.XmlChildShowSerName);
	if not ifnil(_obj.XmlChildShowPercent) then
		{self.}ShowPercent.Copy(_obj.XmlChildShowPercent);
	if not ifnil(_obj.XmlChildShowBubbleSize) then
		{self.}ShowBubbleSize.Copy(_obj.XmlChildShowBubbleSize);
	if not ifnil(_obj.XmlChildShowLeaderLines) then
		{self.}ShowLeaderLines.Copy(_obj.XmlChildShowLeaderLines);
	if not ifnil(_obj.XmlChildExtLst) then
		{self.}ExtLst.Copy(_obj.XmlChildExtLst);
	tslassigning := tslassigning_backup;
end;

function DLbls.ReadXmlChildSpPr(): SpPr;
begin
	if tslassigning and ifnil({self.}XmlChildSpPr) then
	begin
		{self.}XmlChildSpPr := new SpPr(self, {self.}Prefix, "spPr");
		container_.Set({self.}XmlChildSpPr);
	end
	return {self.}XmlChildSpPr;
end;

function DLbls.ReadXmlChildShowLegendKey(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildShowLegendKey) then
	begin
		{self.}XmlChildShowLegendKey := new PureVal(self, {self.}Prefix, "showLegendKey");
		container_.Set({self.}XmlChildShowLegendKey);
	end
	return {self.}XmlChildShowLegendKey;
end;

function DLbls.ReadXmlChildShowVal(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildShowVal) then
	begin
		{self.}XmlChildShowVal := new PureVal(self, {self.}Prefix, "showVal");
		container_.Set({self.}XmlChildShowVal);
	end
	return {self.}XmlChildShowVal;
end;

function DLbls.ReadXmlChildShowCatName(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildShowCatName) then
	begin
		{self.}XmlChildShowCatName := new PureVal(self, {self.}Prefix, "showCatName");
		container_.Set({self.}XmlChildShowCatName);
	end
	return {self.}XmlChildShowCatName;
end;

function DLbls.ReadXmlChildShowSerName(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildShowSerName) then
	begin
		{self.}XmlChildShowSerName := new PureVal(self, {self.}Prefix, "showSerName");
		container_.Set({self.}XmlChildShowSerName);
	end
	return {self.}XmlChildShowSerName;
end;

function DLbls.ReadXmlChildShowPercent(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildShowPercent) then
	begin
		{self.}XmlChildShowPercent := new PureVal(self, {self.}Prefix, "showPercent");
		container_.Set({self.}XmlChildShowPercent);
	end
	return {self.}XmlChildShowPercent;
end;

function DLbls.ReadXmlChildShowBubbleSize(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildShowBubbleSize) then
	begin
		{self.}XmlChildShowBubbleSize := new PureVal(self, {self.}Prefix, "showBubbleSize");
		container_.Set({self.}XmlChildShowBubbleSize);
	end
	return {self.}XmlChildShowBubbleSize;
end;

function DLbls.ReadXmlChildShowLeaderLines(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildShowLeaderLines) then
	begin
		{self.}XmlChildShowLeaderLines := new PureVal(self, {self.}Prefix, "showLeaderLines");
		container_.Set({self.}XmlChildShowLeaderLines);
	end
	return {self.}XmlChildShowLeaderLines;
end;

function DLbls.ReadXmlChildExtLst(): ExtLst;
begin
	if tslassigning and ifnil({self.}XmlChildExtLst) then
	begin
		{self.}XmlChildExtLst := new ExtLst(self, {self.}Prefix, "extLst");
		container_.Set({self.}XmlChildExtLst);
	end
	return {self.}XmlChildExtLst;
end;

function Cat.Create();overload;
begin
	{self.}Create(nil, "c", "cat");
end;

function Cat.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Cat.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Cat.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "strRef": array(0, makeweakref(thisFunction(ReadXmlChildStrRef))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Cat.Copy(_obj: Cat);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildStrRef) then
		{self.}StrRef.Copy(_obj.XmlChildStrRef);
	tslassigning := tslassigning_backup;
end;

function Cat.ReadXmlChildStrRef(): StrRef;
begin
	if tslassigning and ifnil({self.}XmlChildStrRef) then
	begin
		{self.}XmlChildStrRef := new StrRef(self, {self.}Prefix, "strRef");
		container_.Set({self.}XmlChildStrRef);
	end
	return {self.}XmlChildStrRef;
end;

function StrRef.Create();overload;
begin
	{self.}Create(nil, "c", "strRef");
end;

function StrRef.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function StrRef.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function StrRef.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "f": array(0, makeweakref(thisFunction(ReadXmlChildF))),
		pre + "strCache": array(1, makeweakref(thisFunction(ReadXmlChildStrCache))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function StrRef.Copy(_obj: StrRef);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildF) then
		{self.}F.Copy(_obj.XmlChildF);
	if not ifnil(_obj.XmlChildStrCache) then
		{self.}StrCache.Copy(_obj.XmlChildStrCache);
	tslassigning := tslassigning_backup;
end;

function StrRef.ReadXmlChildF();
begin
	if tslassigning and ifnil({self.}XmlChildF) then
	begin
		{self.}XmlChildF := new OpenXmlPcdata(self, {self.}Prefix, "f");
		container_.Set({self.}XmlChildF);
	end
	return {self.}XmlChildF;
end;

function StrRef.ReadXmlChildStrCache(): StrCache;
begin
	if tslassigning and ifnil({self.}XmlChildStrCache) then
	begin
		{self.}XmlChildStrCache := new StrCache(self, {self.}Prefix, "strCache");
		container_.Set({self.}XmlChildStrCache);
	end
	return {self.}XmlChildStrCache;
end;

function Val.Create();overload;
begin
	{self.}Create(nil, "c", "val");
end;

function Val.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Val.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Val.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "numRef": array(0, makeweakref(thisFunction(ReadXmlChildNumRef))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Val.Copy(_obj: Val);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildNumRef) then
		{self.}NumRef.Copy(_obj.XmlChildNumRef);
	tslassigning := tslassigning_backup;
end;

function Val.ReadXmlChildNumRef(): NumRef;
begin
	if tslassigning and ifnil({self.}XmlChildNumRef) then
	begin
		{self.}XmlChildNumRef := new NumRef(self, {self.}Prefix, "numRef");
		container_.Set({self.}XmlChildNumRef);
	end
	return {self.}XmlChildNumRef;
end;

function NumRef.Create();overload;
begin
	{self.}Create(nil, "c", "numRef");
end;

function NumRef.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function NumRef.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function NumRef.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "f": array(0, makeweakref(thisFunction(ReadXmlChildF))),
		pre + "numCache": array(1, makeweakref(thisFunction(ReadXmlChildNumCache))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function NumRef.Copy(_obj: NumRef);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildF) then
		{self.}F.Copy(_obj.XmlChildF);
	if not ifnil(_obj.XmlChildNumCache) then
		{self.}NumCache.Copy(_obj.XmlChildNumCache);
	tslassigning := tslassigning_backup;
end;

function NumRef.ReadXmlChildF();
begin
	if tslassigning and ifnil({self.}XmlChildF) then
	begin
		{self.}XmlChildF := new OpenXmlPcdata(self, {self.}Prefix, "f");
		container_.Set({self.}XmlChildF);
	end
	return {self.}XmlChildF;
end;

function NumRef.ReadXmlChildNumCache(): NumCache;
begin
	if tslassigning and ifnil({self.}XmlChildNumCache) then
	begin
		{self.}XmlChildNumCache := new NumCache(self, {self.}Prefix, "numCache");
		container_.Set({self.}XmlChildNumCache);
	end
	return {self.}XmlChildNumCache;
end;

function StrCache.Create();overload;
begin
	{self.}Create(nil, "c", "");
end;

function StrCache.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function StrCache.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function StrCache.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "ptCount": array(0, makeweakref(thisFunction(ReadXmlChildPtCount))),
		pre + "pt": array(1, makeweakref(thisFunction(AppendPt))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function StrCache.Copy(_obj: StrCache);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildPtCount) then
		{self.}PtCount.Copy(_obj.XmlChildPtCount);
	tslassigning := tslassigning_backup;
end;

function StrCache.ReadXmlChildPtCount(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildPtCount) then
	begin
		{self.}XmlChildPtCount := new PureVal(self, {self.}Prefix, "ptCount");
		container_.Set({self.}XmlChildPtCount);
	end
	return {self.}XmlChildPtCount;
end;

function StrCache.ReadPts(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get(pre + "pt", ind);
end;

function StrCache.AddPt(): Pt;
begin
	obj := new Pt(self, {self.}Prefix, "pt");
	container_.Insert(obj);
	return obj;
end;

function StrCache.AppendPt(): Pt;
begin
	obj := new Pt(self, {self.}Prefix, "pt");
	container_.Append(obj);
	return obj;
end;

function NumCache.Create();overload;
begin
	{self.}Create(nil, "c", "");
end;

function NumCache.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function NumCache.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function NumCache.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "formatCode": array(0, makeweakref(thisFunction(ReadXmlChildFormatCode))),
		pre + "ptCount": array(1, makeweakref(thisFunction(ReadXmlChildPtCount))),
		pre + "pt": array(2, makeweakref(thisFunction(AppendPt))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function NumCache.Copy(_obj: NumCache);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildFormatCode) then
		{self.}FormatCode.Copy(_obj.XmlChildFormatCode);
	if not ifnil(_obj.XmlChildPtCount) then
		{self.}PtCount.Copy(_obj.XmlChildPtCount);
	tslassigning := tslassigning_backup;
end;

function NumCache.ReadXmlChildFormatCode();
begin
	if tslassigning and ifnil({self.}XmlChildFormatCode) then
	begin
		{self.}XmlChildFormatCode := new OpenXmlPcdata(self, {self.}Prefix, "formatCode");
		container_.Set({self.}XmlChildFormatCode);
	end
	return {self.}XmlChildFormatCode;
end;

function NumCache.ReadXmlChildPtCount(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildPtCount) then
	begin
		{self.}XmlChildPtCount := new PureVal(self, {self.}Prefix, "ptCount");
		container_.Set({self.}XmlChildPtCount);
	end
	return {self.}XmlChildPtCount;
end;

function NumCache.ReadPts(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get(pre + "pt", ind);
end;

function NumCache.AddPt(): Pt;
begin
	obj := new Pt(self, {self.}Prefix, "pt");
	container_.Insert(obj);
	return obj;
end;

function NumCache.AppendPt(): Pt;
begin
	obj := new Pt(self, {self.}Prefix, "pt");
	container_.Append(obj);
	return obj;
end;

function Pt.Create();overload;
begin
	{self.}Create(nil, "c", "pt");
end;

function Pt.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Pt.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Pt.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"idx": makeweakref(thisFunction(WriteXmlAttrIdx)),
	);
	sorted_child_ := array(
		pre + "v": array(0, makeweakref(thisFunction(ReadXmlChildV))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Pt.Copy(_obj: Pt);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Idx) then
		{self.}Idx := _obj.Idx;
	if not ifnil(_obj.XmlChildV) then
		{self.}V.Copy(_obj.XmlChildV);
	tslassigning := tslassigning_backup;
end;

function Pt.ReadXmlAttrIdx();
begin
	return {self.}XmlAttrIdx.Value;
end;

function Pt.WriteXmlAttrIdx(_value);
begin
	if ifnil({self.}XmlAttrIdx) then
	begin
		{self.}XmlAttrIdx := new OpenXmlAttribute("", "idx", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrIdx;
	end
	{self.}XmlAttrIdx.Value := _value;
end;

function Pt.ReadXmlChildV();
begin
	if tslassigning and ifnil({self.}XmlChildV) then
	begin
		{self.}XmlChildV := new OpenXmlPcdata(self, {self.}Prefix, "v");
		container_.Set({self.}XmlChildV);
	end
	return {self.}XmlChildV;
end;

function Ax.Create();overload;
begin
	{self.}Create(nil, "c", "");
end;

function Ax.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Ax.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Ax.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "axId": array(0, makeweakref(thisFunction(ReadXmlChildAxId))),
		pre + "scaling": array(1, makeweakref(thisFunction(ReadXmlChildScaling))),
		pre + "delete": array(2, makeweakref(thisFunction(ReadXmlChild_Delete))),
		pre + "axPos": array(3, makeweakref(thisFunction(ReadXmlChildAxPos))),
		pre + "numFmt": array(4, makeweakref(thisFunction(ReadXmlChildNumFmt))),
		pre + "majorTickMark": array(5, makeweakref(thisFunction(ReadXmlChildMajorTickMark))),
		pre + "minorTickMark": array(6, makeweakref(thisFunction(ReadXmlChildMinorTickMark))),
		pre + "tickLblPos": array(7, makeweakref(thisFunction(ReadXmlChildTickLblPos))),
		pre + "spPr": array(8, makeweakref(thisFunction(ReadXmlChildSpPr))),
		pre + "txPr": array(9, makeweakref(thisFunction(ReadXmlChildTxPr))),
		pre + "crossAx": array(10, makeweakref(thisFunction(ReadXmlChildCrossAx))),
		pre + "crosses": array(11, makeweakref(thisFunction(ReadXmlChildCrosses))),
		pre + "crossBetween": array(12, makeweakref(thisFunction(ReadXmlChildCrossBetween))),
		pre + "auto": array(13, makeweakref(thisFunction(ReadXmlChildAuto))),
		pre + "lblAlgn": array(14, makeweakref(thisFunction(ReadXmlChildLblAlgn))),
		pre + "lblOffset": array(15, makeweakref(thisFunction(ReadXmlChildLblOffset))),
		pre + "noMultiLvlLbl": array(16, makeweakref(thisFunction(ReadXmlChildNoMultiLvlLbl))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Ax.Copy(_obj: Ax);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildAxId) then
		{self.}AxId.Copy(_obj.XmlChildAxId);
	if not ifnil(_obj.XmlChildScaling) then
		{self.}Scaling.Copy(_obj.XmlChildScaling);
	if not ifnil(_obj.XmlChild_Delete) then
		{self.}_Delete.Copy(_obj.XmlChild_Delete);
	if not ifnil(_obj.XmlChildAxPos) then
		{self.}AxPos.Copy(_obj.XmlChildAxPos);
	if not ifnil(_obj.XmlChildNumFmt) then
		{self.}NumFmt.Copy(_obj.XmlChildNumFmt);
	if not ifnil(_obj.XmlChildMajorTickMark) then
		{self.}MajorTickMark.Copy(_obj.XmlChildMajorTickMark);
	if not ifnil(_obj.XmlChildMinorTickMark) then
		{self.}MinorTickMark.Copy(_obj.XmlChildMinorTickMark);
	if not ifnil(_obj.XmlChildTickLblPos) then
		{self.}TickLblPos.Copy(_obj.XmlChildTickLblPos);
	if not ifnil(_obj.XmlChildSpPr) then
		{self.}SpPr.Copy(_obj.XmlChildSpPr);
	if not ifnil(_obj.XmlChildTxPr) then
		{self.}TxPr.Copy(_obj.XmlChildTxPr);
	if not ifnil(_obj.XmlChildCrossAx) then
		{self.}CrossAx.Copy(_obj.XmlChildCrossAx);
	if not ifnil(_obj.XmlChildCrosses) then
		{self.}Crosses.Copy(_obj.XmlChildCrosses);
	if not ifnil(_obj.XmlChildCrossBetween) then
		{self.}CrossBetween.Copy(_obj.XmlChildCrossBetween);
	if not ifnil(_obj.XmlChildAuto) then
		{self.}Auto.Copy(_obj.XmlChildAuto);
	if not ifnil(_obj.XmlChildLblAlgn) then
		{self.}LblAlgn.Copy(_obj.XmlChildLblAlgn);
	if not ifnil(_obj.XmlChildLblOffset) then
		{self.}LblOffset.Copy(_obj.XmlChildLblOffset);
	if not ifnil(_obj.XmlChildNoMultiLvlLbl) then
		{self.}NoMultiLvlLbl.Copy(_obj.XmlChildNoMultiLvlLbl);
	tslassigning := tslassigning_backup;
end;

function Ax.ReadXmlChildAxId(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildAxId) then
	begin
		{self.}XmlChildAxId := new PureVal(self, {self.}Prefix, "axId");
		container_.Set({self.}XmlChildAxId);
	end
	return {self.}XmlChildAxId;
end;

function Ax.ReadXmlChildScaling(): Scaling;
begin
	if tslassigning and ifnil({self.}XmlChildScaling) then
	begin
		{self.}XmlChildScaling := new Scaling(self, {self.}Prefix, "scaling");
		container_.Set({self.}XmlChildScaling);
	end
	return {self.}XmlChildScaling;
end;

function Ax.ReadXmlChild_Delete(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChild_Delete) then
	begin
		{self.}XmlChild_Delete := new PureVal(self, {self.}Prefix, "delete");
		container_.Set({self.}XmlChild_Delete);
	end
	return {self.}XmlChild_Delete;
end;

function Ax.ReadXmlChildAxPos(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildAxPos) then
	begin
		{self.}XmlChildAxPos := new PureVal(self, {self.}Prefix, "axPos");
		container_.Set({self.}XmlChildAxPos);
	end
	return {self.}XmlChildAxPos;
end;

function Ax.ReadXmlChildNumFmt(): NumFmt;
begin
	if tslassigning and ifnil({self.}XmlChildNumFmt) then
	begin
		{self.}XmlChildNumFmt := new NumFmt(self, {self.}Prefix, "numFmt");
		container_.Set({self.}XmlChildNumFmt);
	end
	return {self.}XmlChildNumFmt;
end;

function Ax.ReadXmlChildMajorTickMark(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildMajorTickMark) then
	begin
		{self.}XmlChildMajorTickMark := new PureVal(self, {self.}Prefix, "majorTickMark");
		container_.Set({self.}XmlChildMajorTickMark);
	end
	return {self.}XmlChildMajorTickMark;
end;

function Ax.ReadXmlChildMinorTickMark(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildMinorTickMark) then
	begin
		{self.}XmlChildMinorTickMark := new PureVal(self, {self.}Prefix, "minorTickMark");
		container_.Set({self.}XmlChildMinorTickMark);
	end
	return {self.}XmlChildMinorTickMark;
end;

function Ax.ReadXmlChildTickLblPos(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildTickLblPos) then
	begin
		{self.}XmlChildTickLblPos := new PureVal(self, {self.}Prefix, "tickLblPos");
		container_.Set({self.}XmlChildTickLblPos);
	end
	return {self.}XmlChildTickLblPos;
end;

function Ax.ReadXmlChildSpPr(): SpPr;
begin
	if tslassigning and ifnil({self.}XmlChildSpPr) then
	begin
		{self.}XmlChildSpPr := new SpPr(self, {self.}Prefix, "spPr");
		container_.Set({self.}XmlChildSpPr);
	end
	return {self.}XmlChildSpPr;
end;

function Ax.ReadXmlChildTxPr(): TxPr;
begin
	if tslassigning and ifnil({self.}XmlChildTxPr) then
	begin
		{self.}XmlChildTxPr := new TxPr(self, {self.}Prefix, "txPr");
		container_.Set({self.}XmlChildTxPr);
	end
	return {self.}XmlChildTxPr;
end;

function Ax.ReadXmlChildCrossAx(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildCrossAx) then
	begin
		{self.}XmlChildCrossAx := new PureVal(self, {self.}Prefix, "crossAx");
		container_.Set({self.}XmlChildCrossAx);
	end
	return {self.}XmlChildCrossAx;
end;

function Ax.ReadXmlChildCrosses(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildCrosses) then
	begin
		{self.}XmlChildCrosses := new PureVal(self, {self.}Prefix, "crosses");
		container_.Set({self.}XmlChildCrosses);
	end
	return {self.}XmlChildCrosses;
end;

function Ax.ReadXmlChildCrossBetween(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildCrossBetween) then
	begin
		{self.}XmlChildCrossBetween := new PureVal(self, {self.}Prefix, "crossBetween");
		container_.Set({self.}XmlChildCrossBetween);
	end
	return {self.}XmlChildCrossBetween;
end;

function Ax.ReadXmlChildAuto(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildAuto) then
	begin
		{self.}XmlChildAuto := new PureVal(self, {self.}Prefix, "auto");
		container_.Set({self.}XmlChildAuto);
	end
	return {self.}XmlChildAuto;
end;

function Ax.ReadXmlChildLblAlgn(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildLblAlgn) then
	begin
		{self.}XmlChildLblAlgn := new PureVal(self, {self.}Prefix, "lblAlgn");
		container_.Set({self.}XmlChildLblAlgn);
	end
	return {self.}XmlChildLblAlgn;
end;

function Ax.ReadXmlChildLblOffset(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildLblOffset) then
	begin
		{self.}XmlChildLblOffset := new PureVal(self, {self.}Prefix, "lblOffset");
		container_.Set({self.}XmlChildLblOffset);
	end
	return {self.}XmlChildLblOffset;
end;

function Ax.ReadXmlChildNoMultiLvlLbl(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildNoMultiLvlLbl) then
	begin
		{self.}XmlChildNoMultiLvlLbl := new PureVal(self, {self.}Prefix, "noMultiLvlLbl");
		container_.Set({self.}XmlChildNoMultiLvlLbl);
	end
	return {self.}XmlChildNoMultiLvlLbl;
end;

function NumFmt.Create();overload;
begin
	{self.}Create(nil, "c", "numFmt");
end;

function NumFmt.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function NumFmt.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function NumFmt.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"formatCode": makeweakref(thisFunction(WriteXmlAttrFormatCode)),
		"sourceLinked": makeweakref(thisFunction(WriteXmlAttrSourceLinked)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function NumFmt.Copy(_obj: NumFmt);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.FormatCode) then
		{self.}FormatCode := _obj.FormatCode;
	if not ifnil(_obj.SourceLinked) then
		{self.}SourceLinked := _obj.SourceLinked;
	tslassigning := tslassigning_backup;
end;

function NumFmt.ReadXmlAttrFormatCode();
begin
	return {self.}XmlAttrFormatCode.Value;
end;

function NumFmt.WriteXmlAttrFormatCode(_value);
begin
	if ifnil({self.}XmlAttrFormatCode) then
	begin
		{self.}XmlAttrFormatCode := new OpenXmlAttribute("", "formatCode", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrFormatCode;
	end
	{self.}XmlAttrFormatCode.Value := _value;
end;

function NumFmt.ReadXmlAttrSourceLinked();
begin
	return {self.}XmlAttrSourceLinked.Value;
end;

function NumFmt.WriteXmlAttrSourceLinked(_value);
begin
	if ifnil({self.}XmlAttrSourceLinked) then
	begin
		{self.}XmlAttrSourceLinked := new OpenXmlAttribute("", "sourceLinked", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrSourceLinked;
	end
	{self.}XmlAttrSourceLinked.Value := _value;
end;

function Scaling.Create();overload;
begin
	{self.}Create(nil, "c", "scaling");
end;

function Scaling.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Scaling.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Scaling.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "orientation": array(0, makeweakref(thisFunction(ReadXmlChildOrientation))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Scaling.Copy(_obj: Scaling);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildOrientation) then
		ifnil({self.}XmlChildOrientation) ? {self.}Orientation.Copy(_obj.XmlChildOrientation) : {self.}XmlChildOrientation.Copy(_obj.XmlChildOrientation);
	tslassigning := tslassigning_backup;
end;

function Scaling.ReadXmlChildOrientation();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildOrientation) then
		begin
			{self.}XmlChildOrientation := new OpenXmlEmpty(self, {self.}Prefix, "orientation");
			container_.Set({self.}XmlChildOrientation);
		end
		return {self.}XmlChildOrientation;
	end
	return ifnil({self.}XmlChildOrientation) ? nil : {self.}XmlChildOrientation.BoolValue();
end;

function Scaling.WriteXmlChildOrientation(_value);
begin
	if ifnil({self.}XmlChildOrientation) then
	begin
		{self.}XmlChildOrientation := new OpenXmlEmpty(self, {self.}Prefix, "orientation");
		container_.Set({self.}XmlChildOrientation);
	end
	{self.}XmlChildOrientation.Value := _value;
end;

function DTable.Create();overload;
begin
	{self.}Create(nil, "c", "dTable");
end;

function DTable.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function DTable.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function DTable.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "showHorzBorder": array(0, makeweakref(thisFunction(ReadXmlChildShowHorzBorder))),
		pre + "showVertBorder": array(1, makeweakref(thisFunction(ReadXmlChildShowVertBorder))),
		pre + "showOutline": array(2, makeweakref(thisFunction(ReadXmlChildShowOutline))),
		pre + "showKeys": array(3, makeweakref(thisFunction(ReadXmlChildShowKeys))),
		pre + "txPr": array(4, makeweakref(thisFunction(ReadXmlChildTxPr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function DTable.Copy(_obj: DTable);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildShowHorzBorder) then
		{self.}ShowHorzBorder.Copy(_obj.XmlChildShowHorzBorder);
	if not ifnil(_obj.XmlChildShowVertBorder) then
		{self.}ShowVertBorder.Copy(_obj.XmlChildShowVertBorder);
	if not ifnil(_obj.XmlChildShowOutline) then
		{self.}ShowOutline.Copy(_obj.XmlChildShowOutline);
	if not ifnil(_obj.XmlChildShowKeys) then
		{self.}ShowKeys.Copy(_obj.XmlChildShowKeys);
	if not ifnil(_obj.XmlChildTxPr) then
		{self.}TxPr.Copy(_obj.XmlChildTxPr);
	tslassigning := tslassigning_backup;
end;

function DTable.ReadXmlChildShowHorzBorder(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildShowHorzBorder) then
	begin
		{self.}XmlChildShowHorzBorder := new PureVal(self, {self.}Prefix, "showHorzBorder");
		container_.Set({self.}XmlChildShowHorzBorder);
	end
	return {self.}XmlChildShowHorzBorder;
end;

function DTable.ReadXmlChildShowVertBorder(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildShowVertBorder) then
	begin
		{self.}XmlChildShowVertBorder := new PureVal(self, {self.}Prefix, "showVertBorder");
		container_.Set({self.}XmlChildShowVertBorder);
	end
	return {self.}XmlChildShowVertBorder;
end;

function DTable.ReadXmlChildShowOutline(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildShowOutline) then
	begin
		{self.}XmlChildShowOutline := new PureVal(self, {self.}Prefix, "showOutline");
		container_.Set({self.}XmlChildShowOutline);
	end
	return {self.}XmlChildShowOutline;
end;

function DTable.ReadXmlChildShowKeys(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildShowKeys) then
	begin
		{self.}XmlChildShowKeys := new PureVal(self, {self.}Prefix, "showKeys");
		container_.Set({self.}XmlChildShowKeys);
	end
	return {self.}XmlChildShowKeys;
end;

function DTable.ReadXmlChildTxPr(): TxPr;
begin
	if tslassigning and ifnil({self.}XmlChildTxPr) then
	begin
		{self.}XmlChildTxPr := new TxPr(self, {self.}Prefix, "txPr");
		container_.Set({self.}XmlChildTxPr);
	end
	return {self.}XmlChildTxPr;
end;

function TxPr.Create();overload;
begin
	{self.}Create(nil, "c", "txPr");
end;

function TxPr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function TxPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function TxPr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		"a:bodyPr": array(0, makeweakref(thisFunction(ReadXmlChildBodyPr))),
		"a:lstStyle": array(1, makeweakref(thisFunction(ReadXmlChildLstStyle))),
		"a:p": array(2, makeweakref(thisFunction(AppendP))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function TxPr.Copy(_obj: TxPr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildBodyPr) then
		{self.}BodyPr.Copy(_obj.XmlChildBodyPr);
	if not ifnil(_obj.XmlChildLstStyle) then
		ifnil({self.}XmlChildLstStyle) ? {self.}LstStyle.Copy(_obj.XmlChildLstStyle) : {self.}XmlChildLstStyle.Copy(_obj.XmlChildLstStyle);
	tslassigning := tslassigning_backup;
end;

function TxPr.ReadXmlChildLstStyle();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildLstStyle) then
		begin
			{self.}XmlChildLstStyle := new OpenXmlEmpty(self, "a", "lstStyle");
			container_.Set({self.}XmlChildLstStyle);
		end
		return {self.}XmlChildLstStyle;
	end
	return ifnil({self.}XmlChildLstStyle) ? nil : {self.}XmlChildLstStyle.BoolValue();
end;

function TxPr.WriteXmlChildLstStyle(_value);
begin
	if ifnil({self.}XmlChildLstStyle) then
	begin
		{self.}XmlChildLstStyle := new OpenXmlEmpty(self, "a", "lstStyle");
		container_.Set({self.}XmlChildLstStyle);
	end
	{self.}XmlChildLstStyle.Value := _value;
end;

function TxPr.ReadXmlChildBodyPr(): BodyPr;
begin
	if tslassigning and ifnil({self.}XmlChildBodyPr) then
	begin
		{self.}XmlChildBodyPr := new BodyPr(self, "a", "bodyPr");
		container_.Set({self.}XmlChildBodyPr);
	end
	return {self.}XmlChildBodyPr;
end;

function TxPr.ReadPs(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get("a:p", ind);
end;

function TxPr.AddP(): P;
begin
	obj := new P(self, "a", "p");
	container_.Insert(obj);
	return obj;
end;

function TxPr.AppendP(): P;
begin
	obj := new P(self, "a", "p");
	container_.Append(obj);
	return obj;
end;

function Title.Create();overload;
begin
	{self.}Create(nil, "c", "title");
end;

function Title.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Title.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Title.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "tx": array(0, makeweakref(thisFunction(ReadXmlChildTx))),
		pre + "layout": array(1, makeweakref(thisFunction(ReadXmlChildLayout))),
		pre + "overlay": array(2, makeweakref(thisFunction(ReadXmlChildOverlay))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Title.Copy(_obj: Title);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildTx) then
		{self.}Tx.Copy(_obj.XmlChildTx);
	if not ifnil(_obj.XmlChildLayout) then
		ifnil({self.}XmlChildLayout) ? {self.}Layout.Copy(_obj.XmlChildLayout) : {self.}XmlChildLayout.Copy(_obj.XmlChildLayout);
	if not ifnil(_obj.XmlChildOverlay) then
		{self.}Overlay.Copy(_obj.XmlChildOverlay);
	tslassigning := tslassigning_backup;
end;

function Title.ReadXmlChildLayout();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildLayout) then
		begin
			{self.}XmlChildLayout := new OpenXmlEmpty(self, {self.}Prefix, "layout");
			container_.Set({self.}XmlChildLayout);
		end
		return {self.}XmlChildLayout;
	end
	return ifnil({self.}XmlChildLayout) ? nil : {self.}XmlChildLayout.BoolValue();
end;

function Title.WriteXmlChildLayout(_value);
begin
	if ifnil({self.}XmlChildLayout) then
	begin
		{self.}XmlChildLayout := new OpenXmlEmpty(self, {self.}Prefix, "layout");
		container_.Set({self.}XmlChildLayout);
	end
	{self.}XmlChildLayout.Value := _value;
end;

function Title.ReadXmlChildTx(): Tx;
begin
	if tslassigning and ifnil({self.}XmlChildTx) then
	begin
		{self.}XmlChildTx := new Tx(self, {self.}Prefix, "tx");
		container_.Set({self.}XmlChildTx);
	end
	return {self.}XmlChildTx;
end;

function Title.ReadXmlChildOverlay(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildOverlay) then
	begin
		{self.}XmlChildOverlay := new PureVal(self, {self.}Prefix, "overlay");
		container_.Set({self.}XmlChildOverlay);
	end
	return {self.}XmlChildOverlay;
end;

function Tx.Create();overload;
begin
	{self.}Create(nil, "c", "tx");
end;

function Tx.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Tx.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Tx.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "strRef": array(0, makeweakref(thisFunction(ReadXmlChildStrRef))),
		pre + "rich": array(1, makeweakref(thisFunction(ReadXmlChildRich))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Tx.Copy(_obj: Tx);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildStrRef) then
		{self.}StrRef.Copy(_obj.XmlChildStrRef);
	if not ifnil(_obj.XmlChildRich) then
		{self.}Rich.Copy(_obj.XmlChildRich);
	tslassigning := tslassigning_backup;
end;

function Tx.ReadXmlChildStrRef(): StrRef;
begin
	if tslassigning and ifnil({self.}XmlChildStrRef) then
	begin
		{self.}XmlChildStrRef := new StrRef(self, {self.}Prefix, "strRef");
		container_.Set({self.}XmlChildStrRef);
	end
	return {self.}XmlChildStrRef;
end;

function Tx.ReadXmlChildRich(): Rich;
begin
	if tslassigning and ifnil({self.}XmlChildRich) then
	begin
		{self.}XmlChildRich := new Rich(self, {self.}Prefix, "rich");
		container_.Set({self.}XmlChildRich);
	end
	return {self.}XmlChildRich;
end;

function Rich.Create();overload;
begin
	{self.}Create(nil, "c", "rich");
end;

function Rich.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Rich.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Rich.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		"a:bodyPr": array(0, makeweakref(thisFunction(ReadXmlChildBodyPr))),
		"a:lstStyle": array(1, makeweakref(thisFunction(ReadXmlChildLstStyle))),
		"a:p": array(2, makeweakref(thisFunction(AppendP))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Rich.Copy(_obj: Rich);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildBodyPr) then
		{self.}BodyPr.Copy(_obj.XmlChildBodyPr);
	if not ifnil(_obj.XmlChildLstStyle) then
		ifnil({self.}XmlChildLstStyle) ? {self.}LstStyle.Copy(_obj.XmlChildLstStyle) : {self.}XmlChildLstStyle.Copy(_obj.XmlChildLstStyle);
	tslassigning := tslassigning_backup;
end;

function Rich.ReadXmlChildLstStyle();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildLstStyle) then
		begin
			{self.}XmlChildLstStyle := new OpenXmlEmpty(self, "a", "lstStyle");
			container_.Set({self.}XmlChildLstStyle);
		end
		return {self.}XmlChildLstStyle;
	end
	return ifnil({self.}XmlChildLstStyle) ? nil : {self.}XmlChildLstStyle.BoolValue();
end;

function Rich.WriteXmlChildLstStyle(_value);
begin
	if ifnil({self.}XmlChildLstStyle) then
	begin
		{self.}XmlChildLstStyle := new OpenXmlEmpty(self, "a", "lstStyle");
		container_.Set({self.}XmlChildLstStyle);
	end
	{self.}XmlChildLstStyle.Value := _value;
end;

function Rich.ReadXmlChildBodyPr(): BodyPr;
begin
	if tslassigning and ifnil({self.}XmlChildBodyPr) then
	begin
		{self.}XmlChildBodyPr := new BodyPr(self, "a", "bodyPr");
		container_.Set({self.}XmlChildBodyPr);
	end
	return {self.}XmlChildBodyPr;
end;

function Rich.ReadPs(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get("a:p", ind);
end;

function Rich.AddP(): P;
begin
	obj := new P(self, "a", "p");
	container_.Insert(obj);
	return obj;
end;

function Rich.AppendP(): P;
begin
	obj := new P(self, "a", "p");
	container_.Append(obj);
	return obj;
end;

function BodyPr.Create();overload;
begin
	{self.}Create(nil, "a", "bodyPr");
end;

function BodyPr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function BodyPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function BodyPr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"rot": makeweakref(thisFunction(WriteXmlAttrRot)),
		"spcFirstLastPara": makeweakref(thisFunction(WriteXmlAttrSpcFirstLastPara)),
		"vertOverflow": makeweakref(thisFunction(WriteXmlAttrVertOverflow)),
		"horzOverflow": makeweakref(thisFunction(WriteXmlAttrHorzOverflow)),
		"vert": makeweakref(thisFunction(WriteXmlAttrVert)),
		"wrap": makeweakref(thisFunction(WriteXmlAttrWrap)),
		"lIns": makeweakref(thisFunction(WriteXmlAttrLIns)),
		"TIns": makeweakref(thisFunction(WriteXmlAttrTIns)),
		"rIns": makeweakref(thisFunction(WriteXmlAttrRIns)),
		"bIns": makeweakref(thisFunction(WriteXmlAttrBIns)),
		"numCol": makeweakref(thisFunction(WriteXmlAttrNumCol)),
		"spcCol": makeweakref(thisFunction(WriteXmlAttrSpcCol)),
		"rtlCol": makeweakref(thisFunction(WriteXmlAttrRtlCol)),
		"fromWordArt": makeweakref(thisFunction(WriteXmlAttrFromWordArt)),
		"anchor": makeweakref(thisFunction(WriteXmlAttrAnchor)),
		"anchorCtr": makeweakref(thisFunction(WriteXmlAttrAnchorCtr)),
		"forceAA": makeweakref(thisFunction(WriteXmlAttrForceAA)),
		"compatLnSpc": makeweakref(thisFunction(WriteXmlAttrCompatLnSpc)),
	);
	sorted_child_ := array(
		"a:prstTxWrap": array(0, makeweakref(thisFunction(ReadXmlChildPrstTxWrap))),
		"a:noAutofit": array(1, makeweakref(thisFunction(ReadXmlChildNoAutofit))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function BodyPr.Copy(_obj: BodyPr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Rot) then
		{self.}Rot := _obj.Rot;
	if not ifnil(_obj.SpcFirstLastPara) then
		{self.}SpcFirstLastPara := _obj.SpcFirstLastPara;
	if not ifnil(_obj.VertOverflow) then
		{self.}VertOverflow := _obj.VertOverflow;
	if not ifnil(_obj.HorzOverflow) then
		{self.}HorzOverflow := _obj.HorzOverflow;
	if not ifnil(_obj.Vert) then
		{self.}Vert := _obj.Vert;
	if not ifnil(_obj.Wrap) then
		{self.}Wrap := _obj.Wrap;
	if not ifnil(_obj.LIns) then
		{self.}LIns := _obj.LIns;
	if not ifnil(_obj.TIns) then
		{self.}TIns := _obj.TIns;
	if not ifnil(_obj.RIns) then
		{self.}RIns := _obj.RIns;
	if not ifnil(_obj.BIns) then
		{self.}BIns := _obj.BIns;
	if not ifnil(_obj.NumCol) then
		{self.}NumCol := _obj.NumCol;
	if not ifnil(_obj.SpcCol) then
		{self.}SpcCol := _obj.SpcCol;
	if not ifnil(_obj.RtlCol) then
		{self.}RtlCol := _obj.RtlCol;
	if not ifnil(_obj.FromWordArt) then
		{self.}FromWordArt := _obj.FromWordArt;
	if not ifnil(_obj.Anchor) then
		{self.}Anchor := _obj.Anchor;
	if not ifnil(_obj.AnchorCtr) then
		{self.}AnchorCtr := _obj.AnchorCtr;
	if not ifnil(_obj.ForceAA) then
		{self.}ForceAA := _obj.ForceAA;
	if not ifnil(_obj.CompatLnSpc) then
		{self.}CompatLnSpc := _obj.CompatLnSpc;
	if not ifnil(_obj.XmlChildPrstTxWrap) then
		{self.}PrstTxWrap.Copy(_obj.XmlChildPrstTxWrap);
	if not ifnil(_obj.XmlChildNoAutofit) then
		ifnil({self.}XmlChildNoAutofit) ? {self.}NoAutofit.Copy(_obj.XmlChildNoAutofit) : {self.}XmlChildNoAutofit.Copy(_obj.XmlChildNoAutofit);
	tslassigning := tslassigning_backup;
end;

function BodyPr.ReadXmlAttrRot();
begin
	return {self.}XmlAttrRot.Value;
end;

function BodyPr.WriteXmlAttrRot(_value);
begin
	if ifnil({self.}XmlAttrRot) then
	begin
		{self.}XmlAttrRot := new OpenXmlAttribute("", "rot", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrRot;
	end
	{self.}XmlAttrRot.Value := _value;
end;

function BodyPr.ReadXmlAttrSpcFirstLastPara();
begin
	return {self.}XmlAttrSpcFirstLastPara.Value;
end;

function BodyPr.WriteXmlAttrSpcFirstLastPara(_value);
begin
	if ifnil({self.}XmlAttrSpcFirstLastPara) then
	begin
		{self.}XmlAttrSpcFirstLastPara := new OpenXmlAttribute("", "spcFirstLastPara", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrSpcFirstLastPara;
	end
	{self.}XmlAttrSpcFirstLastPara.Value := _value;
end;

function BodyPr.ReadXmlAttrVertOverflow();
begin
	return {self.}XmlAttrVertOverflow.Value;
end;

function BodyPr.WriteXmlAttrVertOverflow(_value);
begin
	if ifnil({self.}XmlAttrVertOverflow) then
	begin
		{self.}XmlAttrVertOverflow := new OpenXmlAttribute("", "vertOverflow", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrVertOverflow;
	end
	{self.}XmlAttrVertOverflow.Value := _value;
end;

function BodyPr.ReadXmlAttrHorzOverflow();
begin
	return {self.}XmlAttrHorzOverflow.Value;
end;

function BodyPr.WriteXmlAttrHorzOverflow(_value);
begin
	if ifnil({self.}XmlAttrHorzOverflow) then
	begin
		{self.}XmlAttrHorzOverflow := new OpenXmlAttribute("", "horzOverflow", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrHorzOverflow;
	end
	{self.}XmlAttrHorzOverflow.Value := _value;
end;

function BodyPr.ReadXmlAttrVert();
begin
	return {self.}XmlAttrVert.Value;
end;

function BodyPr.WriteXmlAttrVert(_value);
begin
	if ifnil({self.}XmlAttrVert) then
	begin
		{self.}XmlAttrVert := new OpenXmlAttribute("", "vert", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrVert;
	end
	{self.}XmlAttrVert.Value := _value;
end;

function BodyPr.ReadXmlAttrWrap();
begin
	return {self.}XmlAttrWrap.Value;
end;

function BodyPr.WriteXmlAttrWrap(_value);
begin
	if ifnil({self.}XmlAttrWrap) then
	begin
		{self.}XmlAttrWrap := new OpenXmlAttribute("", "wrap", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrWrap;
	end
	{self.}XmlAttrWrap.Value := _value;
end;

function BodyPr.ReadXmlAttrLIns();
begin
	return {self.}XmlAttrLIns.Value;
end;

function BodyPr.WriteXmlAttrLIns(_value);
begin
	if ifnil({self.}XmlAttrLIns) then
	begin
		{self.}XmlAttrLIns := new OpenXmlAttribute("", "lIns", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrLIns;
	end
	{self.}XmlAttrLIns.Value := _value;
end;

function BodyPr.ReadXmlAttrTIns();
begin
	return {self.}XmlAttrTIns.Value;
end;

function BodyPr.WriteXmlAttrTIns(_value);
begin
	if ifnil({self.}XmlAttrTIns) then
	begin
		{self.}XmlAttrTIns := new OpenXmlAttribute("", "TIns", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrTIns;
	end
	{self.}XmlAttrTIns.Value := _value;
end;

function BodyPr.ReadXmlAttrRIns();
begin
	return {self.}XmlAttrRIns.Value;
end;

function BodyPr.WriteXmlAttrRIns(_value);
begin
	if ifnil({self.}XmlAttrRIns) then
	begin
		{self.}XmlAttrRIns := new OpenXmlAttribute("", "rIns", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrRIns;
	end
	{self.}XmlAttrRIns.Value := _value;
end;

function BodyPr.ReadXmlAttrBIns();
begin
	return {self.}XmlAttrBIns.Value;
end;

function BodyPr.WriteXmlAttrBIns(_value);
begin
	if ifnil({self.}XmlAttrBIns) then
	begin
		{self.}XmlAttrBIns := new OpenXmlAttribute("", "bIns", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrBIns;
	end
	{self.}XmlAttrBIns.Value := _value;
end;

function BodyPr.ReadXmlAttrNumCol();
begin
	return {self.}XmlAttrNumCol.Value;
end;

function BodyPr.WriteXmlAttrNumCol(_value);
begin
	if ifnil({self.}XmlAttrNumCol) then
	begin
		{self.}XmlAttrNumCol := new OpenXmlAttribute("", "numCol", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrNumCol;
	end
	{self.}XmlAttrNumCol.Value := _value;
end;

function BodyPr.ReadXmlAttrSpcCol();
begin
	return {self.}XmlAttrSpcCol.Value;
end;

function BodyPr.WriteXmlAttrSpcCol(_value);
begin
	if ifnil({self.}XmlAttrSpcCol) then
	begin
		{self.}XmlAttrSpcCol := new OpenXmlAttribute("", "spcCol", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrSpcCol;
	end
	{self.}XmlAttrSpcCol.Value := _value;
end;

function BodyPr.ReadXmlAttrRtlCol();
begin
	return {self.}XmlAttrRtlCol.Value;
end;

function BodyPr.WriteXmlAttrRtlCol(_value);
begin
	if ifnil({self.}XmlAttrRtlCol) then
	begin
		{self.}XmlAttrRtlCol := new OpenXmlAttribute("", "rtlCol", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrRtlCol;
	end
	{self.}XmlAttrRtlCol.Value := _value;
end;

function BodyPr.ReadXmlAttrFromWordArt();
begin
	return {self.}XmlAttrFromWordArt.Value;
end;

function BodyPr.WriteXmlAttrFromWordArt(_value);
begin
	if ifnil({self.}XmlAttrFromWordArt) then
	begin
		{self.}XmlAttrFromWordArt := new OpenXmlAttribute("", "fromWordArt", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrFromWordArt;
	end
	{self.}XmlAttrFromWordArt.Value := _value;
end;

function BodyPr.ReadXmlAttrAnchor();
begin
	return {self.}XmlAttrAnchor.Value;
end;

function BodyPr.WriteXmlAttrAnchor(_value);
begin
	if ifnil({self.}XmlAttrAnchor) then
	begin
		{self.}XmlAttrAnchor := new OpenXmlAttribute("", "anchor", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrAnchor;
	end
	{self.}XmlAttrAnchor.Value := _value;
end;

function BodyPr.ReadXmlAttrAnchorCtr();
begin
	return {self.}XmlAttrAnchorCtr.Value;
end;

function BodyPr.WriteXmlAttrAnchorCtr(_value);
begin
	if ifnil({self.}XmlAttrAnchorCtr) then
	begin
		{self.}XmlAttrAnchorCtr := new OpenXmlAttribute("", "anchorCtr", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrAnchorCtr;
	end
	{self.}XmlAttrAnchorCtr.Value := _value;
end;

function BodyPr.ReadXmlAttrForceAA();
begin
	return {self.}XmlAttrForceAA.Value;
end;

function BodyPr.WriteXmlAttrForceAA(_value);
begin
	if ifnil({self.}XmlAttrForceAA) then
	begin
		{self.}XmlAttrForceAA := new OpenXmlAttribute("", "forceAA", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrForceAA;
	end
	{self.}XmlAttrForceAA.Value := _value;
end;

function BodyPr.ReadXmlAttrCompatLnSpc();
begin
	return {self.}XmlAttrCompatLnSpc.Value;
end;

function BodyPr.WriteXmlAttrCompatLnSpc(_value);
begin
	if ifnil({self.}XmlAttrCompatLnSpc) then
	begin
		{self.}XmlAttrCompatLnSpc := new OpenXmlAttribute("", "compatLnSpc", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrCompatLnSpc;
	end
	{self.}XmlAttrCompatLnSpc.Value := _value;
end;

function BodyPr.ReadXmlChildNoAutofit();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildNoAutofit) then
		begin
			{self.}XmlChildNoAutofit := new OpenXmlEmpty(self, "a", "noAutofit");
			container_.Set({self.}XmlChildNoAutofit);
		end
		return {self.}XmlChildNoAutofit;
	end
	return ifnil({self.}XmlChildNoAutofit) ? nil : {self.}XmlChildNoAutofit.BoolValue();
end;

function BodyPr.WriteXmlChildNoAutofit(_value);
begin
	if ifnil({self.}XmlChildNoAutofit) then
	begin
		{self.}XmlChildNoAutofit := new OpenXmlEmpty(self, "a", "noAutofit");
		container_.Set({self.}XmlChildNoAutofit);
	end
	{self.}XmlChildNoAutofit.Value := _value;
end;

function BodyPr.ReadXmlChildPrstTxWrap(): PrstTxWrap;
begin
	if tslassigning and ifnil({self.}XmlChildPrstTxWrap) then
	begin
		{self.}XmlChildPrstTxWrap := new PrstTxWrap(self, "a", "prstTxWrap");
		container_.Set({self.}XmlChildPrstTxWrap);
	end
	return {self.}XmlChildPrstTxWrap;
end;

function PrstTxWrap.Create();overload;
begin
	{self.}Create(nil, "a", "prstTxWrap");
end;

function PrstTxWrap.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function PrstTxWrap.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function PrstTxWrap.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"prst": makeweakref(thisFunction(WriteXmlAttrPrst)),
	);
	sorted_child_ := array(
		"a:avLst": array(0, makeweakref(thisFunction(ReadXmlChildAvLst))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function PrstTxWrap.Copy(_obj: PrstTxWrap);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Prst) then
		{self.}Prst := _obj.Prst;
	if not ifnil(_obj.XmlChildAvLst) then
		ifnil({self.}XmlChildAvLst) ? {self.}AvLst.Copy(_obj.XmlChildAvLst) : {self.}XmlChildAvLst.Copy(_obj.XmlChildAvLst);
	tslassigning := tslassigning_backup;
end;

function PrstTxWrap.ReadXmlAttrPrst();
begin
	return {self.}XmlAttrPrst.Value;
end;

function PrstTxWrap.WriteXmlAttrPrst(_value);
begin
	if ifnil({self.}XmlAttrPrst) then
	begin
		{self.}XmlAttrPrst := new OpenXmlAttribute("", "prst", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrPrst;
	end
	{self.}XmlAttrPrst.Value := _value;
end;

function PrstTxWrap.ReadXmlChildAvLst();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildAvLst) then
		begin
			{self.}XmlChildAvLst := new OpenXmlEmpty(self, "a", "avLst");
			container_.Set({self.}XmlChildAvLst);
		end
		return {self.}XmlChildAvLst;
	end
	return ifnil({self.}XmlChildAvLst) ? nil : {self.}XmlChildAvLst.BoolValue();
end;

function PrstTxWrap.WriteXmlChildAvLst(_value);
begin
	if ifnil({self.}XmlChildAvLst) then
	begin
		{self.}XmlChildAvLst := new OpenXmlEmpty(self, "a", "avLst");
		container_.Set({self.}XmlChildAvLst);
	end
	{self.}XmlChildAvLst.Value := _value;
end;

function P.Create();overload;
begin
	{self.}Create(nil, "a", "p");
end;

function P.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function P.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function P.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "pPr": array(0, makeweakref(thisFunction(ReadXmlChildPPr))),
		pre + "endParaRPr": array(1, makeweakref(thisFunction(ReadXmlChildEndParaRPr))),
		pre + "r": array(2, makeweakref(thisFunction(AppendR))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function P.Copy(_obj: P);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildPPr) then
		{self.}PPr.Copy(_obj.XmlChildPPr);
	if not ifnil(_obj.XmlChildEndParaRPr) then
		{self.}EndParaRPr.Copy(_obj.XmlChildEndParaRPr);
	tslassigning := tslassigning_backup;
end;

function P.ReadXmlChildPPr(): PPr;
begin
	if tslassigning and ifnil({self.}XmlChildPPr) then
	begin
		{self.}XmlChildPPr := new PPr(self, {self.}Prefix, "pPr");
		container_.Set({self.}XmlChildPPr);
	end
	return {self.}XmlChildPPr;
end;

function P.ReadXmlChildEndParaRPr(): RPr;
begin
	if tslassigning and ifnil({self.}XmlChildEndParaRPr) then
	begin
		{self.}XmlChildEndParaRPr := new RPr(self, {self.}Prefix, "endParaRPr");
		container_.Set({self.}XmlChildEndParaRPr);
	end
	return {self.}XmlChildEndParaRPr;
end;

function P.ReadRs(_index);
begin
	ind := ifnil(_index) ? -2 : _index;
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	return container_.Get(pre + "r", ind);
end;

function P.AddR(): R;
begin
	obj := new R(self, {self.}Prefix, "r");
	container_.Insert(obj);
	return obj;
end;

function P.AppendR(): R;
begin
	obj := new R(self, {self.}Prefix, "r");
	container_.Append(obj);
	return obj;
end;

function RPr.Create();overload;
begin
	{self.}Create(nil, "a", "rPr");
end;

function RPr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function RPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function RPr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"lang": makeweakref(thisFunction(WriteXmlAttrLang)),
		"altLang": makeweakref(thisFunction(WriteXmlAttrAltLang)),
		"b": makeweakref(thisFunction(WriteXmlAttrB)),
		"baseline": makeweakref(thisFunction(WriteXmlAttrBaseline)),
		"i": makeweakref(thisFunction(WriteXmlAttrI)),
		"kern": makeweakref(thisFunction(WriteXmlAttrKern)),
		"spc": makeweakref(thisFunction(WriteXmlAttrSpc)),
		"strike": makeweakref(thisFunction(WriteXmlAttrStrike)),
		"sz": makeweakref(thisFunction(WriteXmlAttrSz)),
		"u": makeweakref(thisFunction(WriteXmlAttrU)),
	);
	sorted_child_ := array(
		pre + "solidFill": array(0, makeweakref(thisFunction(ReadXmlChildSolidFill))),
		pre + "latin": array(1, makeweakref(thisFunction(ReadXmlChildLatin))),
		pre + "ea": array(2, makeweakref(thisFunction(ReadXmlChildEa))),
		pre + "cs": array(3, makeweakref(thisFunction(ReadXmlChildCs))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function RPr.Copy(_obj: RPr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Lang) then
		{self.}Lang := _obj.Lang;
	if not ifnil(_obj.AltLang) then
		{self.}AltLang := _obj.AltLang;
	if not ifnil(_obj.B) then
		{self.}B := _obj.B;
	if not ifnil(_obj.Baseline) then
		{self.}Baseline := _obj.Baseline;
	if not ifnil(_obj.I) then
		{self.}I := _obj.I;
	if not ifnil(_obj.Kern) then
		{self.}Kern := _obj.Kern;
	if not ifnil(_obj.Spc) then
		{self.}Spc := _obj.Spc;
	if not ifnil(_obj.Strike) then
		{self.}Strike := _obj.Strike;
	if not ifnil(_obj.Sz) then
		{self.}Sz := _obj.Sz;
	if not ifnil(_obj.U) then
		{self.}U := _obj.U;
	if not ifnil(_obj.XmlChildSolidFill) then
		{self.}SolidFill.Copy(_obj.XmlChildSolidFill);
	if not ifnil(_obj.XmlChildLatin) then
		{self.}Latin.Copy(_obj.XmlChildLatin);
	if not ifnil(_obj.XmlChildEa) then
		{self.}Ea.Copy(_obj.XmlChildEa);
	if not ifnil(_obj.XmlChildCs) then
		{self.}Cs.Copy(_obj.XmlChildCs);
	tslassigning := tslassigning_backup;
end;

function RPr.ReadXmlAttrLang();
begin
	return {self.}XmlAttrLang.Value;
end;

function RPr.WriteXmlAttrLang(_value);
begin
	if ifnil({self.}XmlAttrLang) then
	begin
		{self.}XmlAttrLang := new OpenXmlAttribute("", "lang", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrLang;
	end
	{self.}XmlAttrLang.Value := _value;
end;

function RPr.ReadXmlAttrAltLang();
begin
	return {self.}XmlAttrAltLang.Value;
end;

function RPr.WriteXmlAttrAltLang(_value);
begin
	if ifnil({self.}XmlAttrAltLang) then
	begin
		{self.}XmlAttrAltLang := new OpenXmlAttribute("", "altLang", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrAltLang;
	end
	{self.}XmlAttrAltLang.Value := _value;
end;

function RPr.ReadXmlAttrB();
begin
	return {self.}XmlAttrB.Value;
end;

function RPr.WriteXmlAttrB(_value);
begin
	if ifnil({self.}XmlAttrB) then
	begin
		{self.}XmlAttrB := new OpenXmlAttribute("", "b", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrB;
	end
	{self.}XmlAttrB.Value := _value;
end;

function RPr.ReadXmlAttrBaseline();
begin
	return {self.}XmlAttrBaseline.Value;
end;

function RPr.WriteXmlAttrBaseline(_value);
begin
	if ifnil({self.}XmlAttrBaseline) then
	begin
		{self.}XmlAttrBaseline := new OpenXmlAttribute("", "baseline", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrBaseline;
	end
	{self.}XmlAttrBaseline.Value := _value;
end;

function RPr.ReadXmlAttrI();
begin
	return {self.}XmlAttrI.Value;
end;

function RPr.WriteXmlAttrI(_value);
begin
	if ifnil({self.}XmlAttrI) then
	begin
		{self.}XmlAttrI := new OpenXmlAttribute("", "i", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrI;
	end
	{self.}XmlAttrI.Value := _value;
end;

function RPr.ReadXmlAttrKern();
begin
	return {self.}XmlAttrKern.Value;
end;

function RPr.WriteXmlAttrKern(_value);
begin
	if ifnil({self.}XmlAttrKern) then
	begin
		{self.}XmlAttrKern := new OpenXmlAttribute("", "kern", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrKern;
	end
	{self.}XmlAttrKern.Value := _value;
end;

function RPr.ReadXmlAttrSpc();
begin
	return {self.}XmlAttrSpc.Value;
end;

function RPr.WriteXmlAttrSpc(_value);
begin
	if ifnil({self.}XmlAttrSpc) then
	begin
		{self.}XmlAttrSpc := new OpenXmlAttribute("", "spc", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrSpc;
	end
	{self.}XmlAttrSpc.Value := _value;
end;

function RPr.ReadXmlAttrStrike();
begin
	return {self.}XmlAttrStrike.Value;
end;

function RPr.WriteXmlAttrStrike(_value);
begin
	if ifnil({self.}XmlAttrStrike) then
	begin
		{self.}XmlAttrStrike := new OpenXmlAttribute("", "strike", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrStrike;
	end
	{self.}XmlAttrStrike.Value := _value;
end;

function RPr.ReadXmlAttrSz();
begin
	return {self.}XmlAttrSz.Value;
end;

function RPr.WriteXmlAttrSz(_value);
begin
	if ifnil({self.}XmlAttrSz) then
	begin
		{self.}XmlAttrSz := new OpenXmlAttribute("", "sz", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrSz;
	end
	{self.}XmlAttrSz.Value := _value;
end;

function RPr.ReadXmlAttrU();
begin
	return {self.}XmlAttrU.Value;
end;

function RPr.WriteXmlAttrU(_value);
begin
	if ifnil({self.}XmlAttrU) then
	begin
		{self.}XmlAttrU := new OpenXmlAttribute("", "u", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrU;
	end
	{self.}XmlAttrU.Value := _value;
end;

function RPr.ReadXmlChildSolidFill(): SolidFill;
begin
	if tslassigning and ifnil({self.}XmlChildSolidFill) then
	begin
		{self.}XmlChildSolidFill := new SolidFill(self, {self.}Prefix, "solidFill");
		container_.Set({self.}XmlChildSolidFill);
	end
	return {self.}XmlChildSolidFill;
end;

function RPr.ReadXmlChildLatin(): Latin;
begin
	if tslassigning and ifnil({self.}XmlChildLatin) then
	begin
		{self.}XmlChildLatin := new Latin(self, {self.}Prefix, "latin");
		container_.Set({self.}XmlChildLatin);
	end
	return {self.}XmlChildLatin;
end;

function RPr.ReadXmlChildEa(): Latin;
begin
	if tslassigning and ifnil({self.}XmlChildEa) then
	begin
		{self.}XmlChildEa := new Latin(self, {self.}Prefix, "ea");
		container_.Set({self.}XmlChildEa);
	end
	return {self.}XmlChildEa;
end;

function RPr.ReadXmlChildCs(): Latin;
begin
	if tslassigning and ifnil({self.}XmlChildCs) then
	begin
		{self.}XmlChildCs := new Latin(self, {self.}Prefix, "cs");
		container_.Set({self.}XmlChildCs);
	end
	return {self.}XmlChildCs;
end;

function PPr.Create();overload;
begin
	{self.}Create(nil, "a", "pPr");
end;

function PPr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function PPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function PPr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "defRPr": array(0, makeweakref(thisFunction(ReadXmlChildDefRPr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function PPr.Copy(_obj: PPr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildDefRPr) then
		{self.}DefRPr.Copy(_obj.XmlChildDefRPr);
	tslassigning := tslassigning_backup;
end;

function PPr.ReadXmlChildDefRPr(): RPr;
begin
	if tslassigning and ifnil({self.}XmlChildDefRPr) then
	begin
		{self.}XmlChildDefRPr := new RPr(self, {self.}Prefix, "defRPr");
		container_.Set({self.}XmlChildDefRPr);
	end
	return {self.}XmlChildDefRPr;
end;

function Latin.Create();overload;
begin
	{self.}Create(nil, "a", "latin");
end;

function Latin.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Latin.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Latin.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"typeface": makeweakref(thisFunction(WriteXmlAttrTypeface)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Latin.Copy(_obj: Latin);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Typeface) then
		{self.}Typeface := _obj.Typeface;
	tslassigning := tslassigning_backup;
end;

function Latin.ReadXmlAttrTypeface();
begin
	return {self.}XmlAttrTypeface.Value;
end;

function Latin.WriteXmlAttrTypeface(_value);
begin
	if ifnil({self.}XmlAttrTypeface) then
	begin
		{self.}XmlAttrTypeface := new OpenXmlAttribute("", "typeface", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrTypeface;
	end
	{self.}XmlAttrTypeface.Value := _value;
end;

function R.Create();overload;
begin
	{self.}Create(nil, "a", "r");
end;

function R.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function R.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function R.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "rPr": array(0, makeweakref(thisFunction(ReadXmlChildRPr))),
		pre + "t": array(1, makeweakref(thisFunction(ReadXmlChildT))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function R.Copy(_obj: R);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildRPr) then
		{self.}RPr.Copy(_obj.XmlChildRPr);
	if not ifnil(_obj.XmlChildT) then
		{self.}T.Copy(_obj.XmlChildT);
	tslassigning := tslassigning_backup;
end;

function R.ReadXmlChildRPr(): RPr;
begin
	if tslassigning and ifnil({self.}XmlChildRPr) then
	begin
		{self.}XmlChildRPr := new RPr(self, {self.}Prefix, "rPr");
		container_.Set({self.}XmlChildRPr);
	end
	return {self.}XmlChildRPr;
end;

function R.ReadXmlChildT(): T;
begin
	if tslassigning and ifnil({self.}XmlChildT) then
	begin
		{self.}XmlChildT := new T(self, {self.}Prefix, "t");
		container_.Set({self.}XmlChildT);
	end
	return {self.}XmlChildT;
end;

function ExternalData.Create();overload;
begin
	{self.}Create(nil, "c", "externalData");
end;

function ExternalData.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function ExternalData.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function ExternalData.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"r:id": makeweakref(thisFunction(WriteXmlAttrId)),
	);
	sorted_child_ := array(
		pre + "autoUpdate": array(0, makeweakref(thisFunction(ReadXmlChildAutoUpdate))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function ExternalData.Copy(_obj: ExternalData);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Id) then
		{self.}Id := _obj.Id;
	if not ifnil(_obj.XmlChildAutoUpdate) then
		{self.}AutoUpdate.Copy(_obj.XmlChildAutoUpdate);
	tslassigning := tslassigning_backup;
end;

function ExternalData.ReadXmlAttrId();
begin
	return {self.}XmlAttrId.Value;
end;

function ExternalData.WriteXmlAttrId(_value);
begin
	if ifnil({self.}XmlAttrId) then
	begin
		{self.}XmlAttrId := new OpenXmlAttribute("r", "id", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrId;
	end
	{self.}XmlAttrId.Value := _value;
end;

function ExternalData.ReadXmlChildAutoUpdate(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildAutoUpdate) then
	begin
		{self.}XmlChildAutoUpdate := new PureVal(self, {self.}Prefix, "autoUpdate");
		container_.Set({self.}XmlChildAutoUpdate);
	end
	return {self.}XmlChildAutoUpdate;
end;

function _Inline.Create();overload;
begin
	{self.}Create(nil, "wp", "inline");
end;

function _Inline.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function _Inline.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function _Inline.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"distT": makeweakref(thisFunction(WriteXmlAttrDistT)),
		"distB": makeweakref(thisFunction(WriteXmlAttrDistB)),
		"distL": makeweakref(thisFunction(WriteXmlAttrDistL)),
		"distR": makeweakref(thisFunction(WriteXmlAttrDistR)),
		"wp14:anchorId": makeweakref(thisFunction(WriteXmlAttrAnchorId)),
		"wp14:editId": makeweakref(thisFunction(WriteXmlAttrEditId)),
	);
	sorted_child_ := array(
		pre + "extent": array(0, makeweakref(thisFunction(ReadXmlChildExtent))),
		pre + "effectExtent": array(1, makeweakref(thisFunction(ReadXmlChildEffectExtent))),
		pre + "docPr": array(2, makeweakref(thisFunction(ReadXmlChildDocPr))),
		pre + "cNvGraphicFramePr": array(3, makeweakref(thisFunction(ReadXmlChildCNvGraphicFramePr))),
		"a:graphic": array(4, makeweakref(thisFunction(ReadXmlChildGraphic))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function _Inline.Copy(_obj: _Inline);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.DistT) then
		{self.}DistT := _obj.DistT;
	if not ifnil(_obj.DistB) then
		{self.}DistB := _obj.DistB;
	if not ifnil(_obj.DistL) then
		{self.}DistL := _obj.DistL;
	if not ifnil(_obj.DistR) then
		{self.}DistR := _obj.DistR;
	if not ifnil(_obj.AnchorId) then
		{self.}AnchorId := _obj.AnchorId;
	if not ifnil(_obj.EditId) then
		{self.}EditId := _obj.EditId;
	if not ifnil(_obj.XmlChildExtent) then
		{self.}Extent.Copy(_obj.XmlChildExtent);
	if not ifnil(_obj.XmlChildEffectExtent) then
		{self.}EffectExtent.Copy(_obj.XmlChildEffectExtent);
	if not ifnil(_obj.XmlChildDocPr) then
		{self.}DocPr.Copy(_obj.XmlChildDocPr);
	if not ifnil(_obj.XmlChildCNvGraphicFramePr) then
		{self.}CNvGraphicFramePr.Copy(_obj.XmlChildCNvGraphicFramePr);
	if not ifnil(_obj.XmlChildGraphic) then
		{self.}Graphic.Copy(_obj.XmlChildGraphic);
	tslassigning := tslassigning_backup;
end;

function _Inline.ReadXmlAttrDistT();
begin
	return {self.}XmlAttrDistT.Value;
end;

function _Inline.WriteXmlAttrDistT(_value);
begin
	if ifnil({self.}XmlAttrDistT) then
	begin
		{self.}XmlAttrDistT := new OpenXmlAttribute("", "distT", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDistT;
	end
	{self.}XmlAttrDistT.Value := _value;
end;

function _Inline.ReadXmlAttrDistB();
begin
	return {self.}XmlAttrDistB.Value;
end;

function _Inline.WriteXmlAttrDistB(_value);
begin
	if ifnil({self.}XmlAttrDistB) then
	begin
		{self.}XmlAttrDistB := new OpenXmlAttribute("", "distB", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDistB;
	end
	{self.}XmlAttrDistB.Value := _value;
end;

function _Inline.ReadXmlAttrDistL();
begin
	return {self.}XmlAttrDistL.Value;
end;

function _Inline.WriteXmlAttrDistL(_value);
begin
	if ifnil({self.}XmlAttrDistL) then
	begin
		{self.}XmlAttrDistL := new OpenXmlAttribute("", "distL", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDistL;
	end
	{self.}XmlAttrDistL.Value := _value;
end;

function _Inline.ReadXmlAttrDistR();
begin
	return {self.}XmlAttrDistR.Value;
end;

function _Inline.WriteXmlAttrDistR(_value);
begin
	if ifnil({self.}XmlAttrDistR) then
	begin
		{self.}XmlAttrDistR := new OpenXmlAttribute("", "distR", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDistR;
	end
	{self.}XmlAttrDistR.Value := _value;
end;

function _Inline.ReadXmlAttrAnchorId();
begin
	return {self.}XmlAttrAnchorId.Value;
end;

function _Inline.WriteXmlAttrAnchorId(_value);
begin
	if ifnil({self.}XmlAttrAnchorId) then
	begin
		{self.}XmlAttrAnchorId := new OpenXmlAttribute("wp14", "anchorId", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrAnchorId;
	end
	{self.}XmlAttrAnchorId.Value := _value;
end;

function _Inline.ReadXmlAttrEditId();
begin
	return {self.}XmlAttrEditId.Value;
end;

function _Inline.WriteXmlAttrEditId(_value);
begin
	if ifnil({self.}XmlAttrEditId) then
	begin
		{self.}XmlAttrEditId := new OpenXmlAttribute("wp14", "editId", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrEditId;
	end
	{self.}XmlAttrEditId.Value := _value;
end;

function _Inline.ReadXmlChildExtent(): CXY;
begin
	if tslassigning and ifnil({self.}XmlChildExtent) then
	begin
		{self.}XmlChildExtent := new CXY(self, {self.}Prefix, "extent");
		container_.Set({self.}XmlChildExtent);
	end
	return {self.}XmlChildExtent;
end;

function _Inline.ReadXmlChildEffectExtent(): EffectExtent;
begin
	if tslassigning and ifnil({self.}XmlChildEffectExtent) then
	begin
		{self.}XmlChildEffectExtent := new EffectExtent(self, {self.}Prefix, "effectExtent");
		container_.Set({self.}XmlChildEffectExtent);
	end
	return {self.}XmlChildEffectExtent;
end;

function _Inline.ReadXmlChildDocPr(): DocPr;
begin
	if tslassigning and ifnil({self.}XmlChildDocPr) then
	begin
		{self.}XmlChildDocPr := new DocPr(self, {self.}Prefix, "docPr");
		container_.Set({self.}XmlChildDocPr);
	end
	return {self.}XmlChildDocPr;
end;

function _Inline.ReadXmlChildCNvGraphicFramePr(): CNvGraphicFramePr;
begin
	if tslassigning and ifnil({self.}XmlChildCNvGraphicFramePr) then
	begin
		{self.}XmlChildCNvGraphicFramePr := new CNvGraphicFramePr(self, {self.}Prefix, "cNvGraphicFramePr");
		container_.Set({self.}XmlChildCNvGraphicFramePr);
	end
	return {self.}XmlChildCNvGraphicFramePr;
end;

function _Inline.ReadXmlChildGraphic(): Graphic;
begin
	if tslassigning and ifnil({self.}XmlChildGraphic) then
	begin
		{self.}XmlChildGraphic := new Graphic(self, "a", "graphic");
		container_.Set({self.}XmlChildGraphic);
	end
	return {self.}XmlChildGraphic;
end;

function EffectExtent.Create();overload;
begin
	{self.}Create(nil, "wp", "effectExtent");
end;

function EffectExtent.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function EffectExtent.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function EffectExtent.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"l": makeweakref(thisFunction(WriteXmlAttrL)),
		"t": makeweakref(thisFunction(WriteXmlAttrT)),
		"r": makeweakref(thisFunction(WriteXmlAttrR)),
		"b": makeweakref(thisFunction(WriteXmlAttrB)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function EffectExtent.Copy(_obj: EffectExtent);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.L) then
		{self.}L := _obj.L;
	if not ifnil(_obj.T) then
		{self.}T := _obj.T;
	if not ifnil(_obj.R) then
		{self.}R := _obj.R;
	if not ifnil(_obj.B) then
		{self.}B := _obj.B;
	tslassigning := tslassigning_backup;
end;

function EffectExtent.ReadXmlAttrL();
begin
	return {self.}XmlAttrL.Value;
end;

function EffectExtent.WriteXmlAttrL(_value);
begin
	if ifnil({self.}XmlAttrL) then
	begin
		{self.}XmlAttrL := new OpenXmlAttribute("", "l", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrL;
	end
	{self.}XmlAttrL.Value := _value;
end;

function EffectExtent.ReadXmlAttrT();
begin
	return {self.}XmlAttrT.Value;
end;

function EffectExtent.WriteXmlAttrT(_value);
begin
	if ifnil({self.}XmlAttrT) then
	begin
		{self.}XmlAttrT := new OpenXmlAttribute("", "t", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrT;
	end
	{self.}XmlAttrT.Value := _value;
end;

function EffectExtent.ReadXmlAttrR();
begin
	return {self.}XmlAttrR.Value;
end;

function EffectExtent.WriteXmlAttrR(_value);
begin
	if ifnil({self.}XmlAttrR) then
	begin
		{self.}XmlAttrR := new OpenXmlAttribute("", "r", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrR;
	end
	{self.}XmlAttrR.Value := _value;
end;

function EffectExtent.ReadXmlAttrB();
begin
	return {self.}XmlAttrB.Value;
end;

function EffectExtent.WriteXmlAttrB(_value);
begin
	if ifnil({self.}XmlAttrB) then
	begin
		{self.}XmlAttrB := new OpenXmlAttribute("", "b", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrB;
	end
	{self.}XmlAttrB.Value := _value;
end;

function DocPr.Create();overload;
begin
	{self.}Create(nil, "wp", "docPr");
end;

function DocPr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function DocPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function DocPr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"id": makeweakref(thisFunction(WriteXmlAttrId)),
		"name": makeweakref(thisFunction(WriteXmlAttrName)),
		"descr": makeweakref(thisFunction(WriteXmlAttrDescr)),
	);
	sorted_child_ := array(
		pre + "extLst": array(0, makeweakref(thisFunction(ReadXmlChildExtLst))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function DocPr.Copy(_obj: DocPr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Id) then
		{self.}Id := _obj.Id;
	if not ifnil(_obj.Name) then
		{self.}Name := _obj.Name;
	if not ifnil(_obj.Descr) then
		{self.}Descr := _obj.Descr;
	if not ifnil(_obj.XmlChildExtLst) then
		{self.}ExtLst.Copy(_obj.XmlChildExtLst);
	tslassigning := tslassigning_backup;
end;

function DocPr.ReadXmlAttrId();
begin
	return {self.}XmlAttrId.Value;
end;

function DocPr.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 DocPr.ReadXmlAttrName();
begin
	return {self.}XmlAttrName.Value;
end;

function DocPr.WriteXmlAttrName(_value);
begin
	if ifnil({self.}XmlAttrName) then
	begin
		{self.}XmlAttrName := new OpenXmlAttribute("", "name", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrName;
	end
	{self.}XmlAttrName.Value := _value;
end;

function DocPr.ReadXmlAttrDescr();
begin
	return {self.}XmlAttrDescr.Value;
end;

function DocPr.WriteXmlAttrDescr(_value);
begin
	if ifnil({self.}XmlAttrDescr) then
	begin
		{self.}XmlAttrDescr := new OpenXmlAttribute("", "descr", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDescr;
	end
	{self.}XmlAttrDescr.Value := _value;
end;

function DocPr.ReadXmlChildExtLst(): ExtLst;
begin
	if tslassigning and ifnil({self.}XmlChildExtLst) then
	begin
		{self.}XmlChildExtLst := new DrawingML.ExtLst(self, {self.}Prefix, "extLst");
		container_.Set({self.}XmlChildExtLst);
	end
	return {self.}XmlChildExtLst;
end;

function CNvGraphicFramePr.Create();overload;
begin
	{self.}Create(nil, "w", "cNvGraphicFramePr");
end;

function CNvGraphicFramePr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function CNvGraphicFramePr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function CNvGraphicFramePr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "graphicFrameLocks": array(0, makeweakref(thisFunction(ReadXmlChildGraphicFrameLocks))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function CNvGraphicFramePr.Copy(_obj: CNvGraphicFramePr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildGraphicFrameLocks) then
		{self.}GraphicFrameLocks.Copy(_obj.XmlChildGraphicFrameLocks);
	tslassigning := tslassigning_backup;
end;

function CNvGraphicFramePr.ReadXmlChildGraphicFrameLocks(): GraphicFrameLocks;
begin
	if tslassigning and ifnil({self.}XmlChildGraphicFrameLocks) then
	begin
		{self.}XmlChildGraphicFrameLocks := new GraphicFrameLocks(self, {self.}Prefix, "graphicFrameLocks");
		container_.Set({self.}XmlChildGraphicFrameLocks);
	end
	return {self.}XmlChildGraphicFrameLocks;
end;

function GraphicFrameLocks.Create();overload;
begin
	{self.}Create(nil, "", "");
end;

function GraphicFrameLocks.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function GraphicFrameLocks.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function GraphicFrameLocks.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"noChangeAspect": makeweakref(thisFunction(WriteXmlAttrNoChangeAspect)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function GraphicFrameLocks.Copy(_obj: GraphicFrameLocks);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.NoChangeAspect) then
		{self.}NoChangeAspect := _obj.NoChangeAspect;
	tslassigning := tslassigning_backup;
end;

function GraphicFrameLocks.ReadXmlAttrNoChangeAspect();
begin
	return {self.}XmlAttrNoChangeAspect.Value;
end;

function GraphicFrameLocks.WriteXmlAttrNoChangeAspect(_value);
begin
	if ifnil({self.}XmlAttrNoChangeAspect) then
	begin
		{self.}XmlAttrNoChangeAspect := new OpenXmlAttribute("", "noChangeAspect", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrNoChangeAspect;
	end
	{self.}XmlAttrNoChangeAspect.Value := _value;
end;

function Graphic.Create();overload;
begin
	{self.}Create(nil, "a", "graphic");
end;

function Graphic.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Graphic.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Graphic.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		"a:graphicData": array(0, makeweakref(thisFunction(ReadXmlChildGraphicData))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Graphic.Copy(_obj: Graphic);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildGraphicData) then
		{self.}GraphicData.Copy(_obj.XmlChildGraphicData);
	tslassigning := tslassigning_backup;
end;

function Graphic.ReadXmlChildGraphicData(): GraphicData;
begin
	if tslassigning and ifnil({self.}XmlChildGraphicData) then
	begin
		{self.}XmlChildGraphicData := new GraphicData(self, "a", "graphicData");
		container_.Set({self.}XmlChildGraphicData);
	end
	return {self.}XmlChildGraphicData;
end;

function GraphicData.Create();overload;
begin
	{self.}Create(nil, "a", "graphicData");
end;

function GraphicData.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function GraphicData.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function GraphicData.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"uri": makeweakref(thisFunction(WriteXmlAttrUri)),
	);
	sorted_child_ := array(
		"pic:pic": array(0, makeweakref(thisFunction(ReadXmlChildPic))),
		"c:chart": array(1, makeweakref(thisFunction(ReadXmlChildChart))),
		"wps:wsp": array(2, makeweakref(thisFunction(ReadXmlChildWsp))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function GraphicData.Copy(_obj: GraphicData);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Uri) then
		{self.}Uri := _obj.Uri;
	if not ifnil(_obj.XmlChildPic) then
		{self.}Pic.Copy(_obj.XmlChildPic);
	if not ifnil(_obj.XmlChildChart) then
		{self.}Chart.Copy(_obj.XmlChildChart);
	if not ifnil(_obj.XmlChildWsp) then
		{self.}Wsp.Copy(_obj.XmlChildWsp);
	tslassigning := tslassigning_backup;
end;

function GraphicData.ReadXmlAttrUri();
begin
	return {self.}XmlAttrUri.Value;
end;

function GraphicData.WriteXmlAttrUri(_value);
begin
	if ifnil({self.}XmlAttrUri) then
	begin
		{self.}XmlAttrUri := new OpenXmlAttribute("", "uri", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrUri;
	end
	{self.}XmlAttrUri.Value := _value;
end;

function GraphicData.ReadXmlChildPic(): Pic;
begin
	if tslassigning and ifnil({self.}XmlChildPic) then
	begin
		{self.}XmlChildPic := new Pic(self, "pic", "pic");
		container_.Set({self.}XmlChildPic);
	end
	return {self.}XmlChildPic;
end;

function GraphicData.ReadXmlChildChart(): Chart;
begin
	if tslassigning and ifnil({self.}XmlChildChart) then
	begin
		{self.}XmlChildChart := new Chart(self, "c", "chart");
		container_.Set({self.}XmlChildChart);
	end
	return {self.}XmlChildChart;
end;

function GraphicData.ReadXmlChildWsp(): Wsp;
begin
	if tslassigning and ifnil({self.}XmlChildWsp) then
	begin
		{self.}XmlChildWsp := new Wsp(self, "wps", "wsp");
		container_.Set({self.}XmlChildWsp);
	end
	return {self.}XmlChildWsp;
end;

function Wsp.Create();overload;
begin
	{self.}Create(nil, "wps", "wsp");
end;

function Wsp.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Wsp.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Wsp.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "cNvSpPr": array(0, makeweakref(thisFunction(ReadXmlChildCNvSpPr))),
		pre + "spPr": array(1, makeweakref(thisFunction(ReadXmlChildSpPr))),
		pre + "txbx": array(2, makeweakref(thisFunction(ReadXmlChildTxbx))),
		pre + "style": array(3, makeweakref(thisFunction(ReadXmlChildStyle))),
		pre + "bodyPr": array(4, makeweakref(thisFunction(ReadXmlChildBodyPr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Wsp.Copy(_obj: Wsp);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildCNvSpPr) then
		{self.}CNvSpPr.Copy(_obj.XmlChildCNvSpPr);
	if not ifnil(_obj.XmlChildSpPr) then
		{self.}SpPr.Copy(_obj.XmlChildSpPr);
	if not ifnil(_obj.XmlChildTxbx) then
		{self.}Txbx.Copy(_obj.XmlChildTxbx);
	if not ifnil(_obj.XmlChildStyle) then
		{self.}Style.Copy(_obj.XmlChildStyle);
	if not ifnil(_obj.XmlChildBodyPr) then
		{self.}BodyPr.Copy(_obj.XmlChildBodyPr);
	tslassigning := tslassigning_backup;
end;

function Wsp.ReadXmlChildCNvSpPr(): CNvSpPr;
begin
	if tslassigning and ifnil({self.}XmlChildCNvSpPr) then
	begin
		{self.}XmlChildCNvSpPr := new CNvSpPr(self, {self.}Prefix, "cNvSpPr");
		container_.Set({self.}XmlChildCNvSpPr);
	end
	return {self.}XmlChildCNvSpPr;
end;

function Wsp.ReadXmlChildSpPr(): SpPr;
begin
	if tslassigning and ifnil({self.}XmlChildSpPr) then
	begin
		{self.}XmlChildSpPr := new SpPr(self, {self.}Prefix, "spPr");
		container_.Set({self.}XmlChildSpPr);
	end
	return {self.}XmlChildSpPr;
end;

function Wsp.ReadXmlChildTxbx(): Txbx;
begin
	if tslassigning and ifnil({self.}XmlChildTxbx) then
	begin
		{self.}XmlChildTxbx := new Txbx(self, {self.}Prefix, "txbx");
		container_.Set({self.}XmlChildTxbx);
	end
	return {self.}XmlChildTxbx;
end;

function Wsp.ReadXmlChildStyle(): WpsStyle;
begin
	if tslassigning and ifnil({self.}XmlChildStyle) then
	begin
		{self.}XmlChildStyle := new WpsStyle(self, {self.}Prefix, "style");
		container_.Set({self.}XmlChildStyle);
	end
	return {self.}XmlChildStyle;
end;

function Wsp.ReadXmlChildBodyPr(): BodyPr;
begin
	if tslassigning and ifnil({self.}XmlChildBodyPr) then
	begin
		{self.}XmlChildBodyPr := new BodyPr(self, {self.}Prefix, "bodyPr");
		container_.Set({self.}XmlChildBodyPr);
	end
	return {self.}XmlChildBodyPr;
end;

function WpsStyle.Create();overload;
begin
	{self.}Create(nil, "wps", "style");
end;

function WpsStyle.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function WpsStyle.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function WpsStyle.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		"a:lnRef": array(0, makeweakref(thisFunction(ReadXmlChildLnRef))),
		"a:fillRef": array(1, makeweakref(thisFunction(ReadXmlChildFillRef))),
		"a:effectRef": array(2, makeweakref(thisFunction(ReadXmlChildEffectRef))),
		"a:fontRef": array(3, makeweakref(thisFunction(ReadXmlChildFontRef))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function WpsStyle.Copy(_obj: WpsStyle);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildLnRef) then
		{self.}LnRef.Copy(_obj.XmlChildLnRef);
	if not ifnil(_obj.XmlChildFillRef) then
		{self.}FillRef.Copy(_obj.XmlChildFillRef);
	if not ifnil(_obj.XmlChildEffectRef) then
		{self.}EffectRef.Copy(_obj.XmlChildEffectRef);
	if not ifnil(_obj.XmlChildFontRef) then
		{self.}FontRef.Copy(_obj.XmlChildFontRef);
	tslassigning := tslassigning_backup;
end;

function WpsStyle.ReadXmlChildLnRef(): XRef;
begin
	if tslassigning and ifnil({self.}XmlChildLnRef) then
	begin
		{self.}XmlChildLnRef := new XRef(self, "a", "lnRef");
		container_.Set({self.}XmlChildLnRef);
	end
	return {self.}XmlChildLnRef;
end;

function WpsStyle.ReadXmlChildFillRef(): XRef;
begin
	if tslassigning and ifnil({self.}XmlChildFillRef) then
	begin
		{self.}XmlChildFillRef := new XRef(self, "a", "fillRef");
		container_.Set({self.}XmlChildFillRef);
	end
	return {self.}XmlChildFillRef;
end;

function WpsStyle.ReadXmlChildEffectRef(): XRef;
begin
	if tslassigning and ifnil({self.}XmlChildEffectRef) then
	begin
		{self.}XmlChildEffectRef := new XRef(self, "a", "effectRef");
		container_.Set({self.}XmlChildEffectRef);
	end
	return {self.}XmlChildEffectRef;
end;

function WpsStyle.ReadXmlChildFontRef(): XRef;
begin
	if tslassigning and ifnil({self.}XmlChildFontRef) then
	begin
		{self.}XmlChildFontRef := new XRef(self, "a", "fontRef");
		container_.Set({self.}XmlChildFontRef);
	end
	return {self.}XmlChildFontRef;
end;

function XRef.Create();overload;
begin
	{self.}Create(nil, "a", "lnRef");
end;

function XRef.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function XRef.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function XRef.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"idx": makeweakref(thisFunction(WriteXmlAttrIdx)),
	);
	sorted_child_ := array(
		"a:schemeClr": array(0, makeweakref(thisFunction(ReadXmlChildSchemeClr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function XRef.Copy(_obj: XRef);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Idx) then
		{self.}Idx := _obj.Idx;
	if not ifnil(_obj.XmlChildSchemeClr) then
		{self.}SchemeClr.Copy(_obj.XmlChildSchemeClr);
	tslassigning := tslassigning_backup;
end;

function XRef.ReadXmlAttrIdx();
begin
	return {self.}XmlAttrIdx.Value;
end;

function XRef.WriteXmlAttrIdx(_value);
begin
	if ifnil({self.}XmlAttrIdx) then
	begin
		{self.}XmlAttrIdx := new OpenXmlAttribute("", "idx", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrIdx;
	end
	{self.}XmlAttrIdx.Value := _value;
end;

function XRef.ReadXmlChildSchemeClr(): SchemeClr;
begin
	if tslassigning and ifnil({self.}XmlChildSchemeClr) then
	begin
		{self.}XmlChildSchemeClr := new SchemeClr(self, "a", "schemeClr");
		container_.Set({self.}XmlChildSchemeClr);
	end
	return {self.}XmlChildSchemeClr;
end;

function Txbx.Create();overload;
begin
	{self.}Create(nil, "wps", "txbx");
end;

function Txbx.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Txbx.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Txbx.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		"w:txbxContent": array(0, makeweakref(thisFunction(ReadXmlChildTxbxContent))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Txbx.Copy(_obj: Txbx);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildTxbxContent) then
		{self.}TxbxContent.Copy(_obj.XmlChildTxbxContent);
	tslassigning := tslassigning_backup;
end;

function Txbx.ReadXmlChildTxbxContent(): TxbxContent;
begin
	if tslassigning and ifnil({self.}XmlChildTxbxContent) then
	begin
		{self.}XmlChildTxbxContent := new TxbxContent(self, "w", "txbxContent");
		container_.Set({self.}XmlChildTxbxContent);
	end
	return {self.}XmlChildTxbxContent;
end;

function CNvSpPr.Create();overload;
begin
	{self.}Create(nil, "wps", "cNvSpPr");
end;

function CNvSpPr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function CNvSpPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function CNvSpPr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"txBox": makeweakref(thisFunction(WriteXmlAttrTxBox)),
	);
	sorted_child_ := array(
		"a:spLocks": array(0, makeweakref(thisFunction(ReadXmlChildSpLocks))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function CNvSpPr.Copy(_obj: CNvSpPr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.TxBox) then
		{self.}TxBox := _obj.TxBox;
	if not ifnil(_obj.XmlChildSpLocks) then
		{self.}SpLocks.Copy(_obj.XmlChildSpLocks);
	tslassigning := tslassigning_backup;
end;

function CNvSpPr.ReadXmlAttrTxBox();
begin
	return {self.}XmlAttrTxBox.Value;
end;

function CNvSpPr.WriteXmlAttrTxBox(_value);
begin
	if ifnil({self.}XmlAttrTxBox) then
	begin
		{self.}XmlAttrTxBox := new OpenXmlAttribute("", "txBox", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrTxBox;
	end
	{self.}XmlAttrTxBox.Value := _value;
end;

function CNvSpPr.ReadXmlChildSpLocks(): SpLocks;
begin
	if tslassigning and ifnil({self.}XmlChildSpLocks) then
	begin
		{self.}XmlChildSpLocks := new SpLocks(self, "a", "spLocks");
		container_.Set({self.}XmlChildSpLocks);
	end
	return {self.}XmlChildSpLocks;
end;

function SpLocks.Create();overload;
begin
	{self.}Create(nil, "a", "spLocks");
end;

function SpLocks.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function SpLocks.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function SpLocks.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"noChangeArrowheads": makeweakref(thisFunction(WriteXmlAttrNoChangeArrowheads)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function SpLocks.Copy(_obj: SpLocks);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.NoChangeArrowheads) then
		{self.}NoChangeArrowheads := _obj.NoChangeArrowheads;
	tslassigning := tslassigning_backup;
end;

function SpLocks.ReadXmlAttrNoChangeArrowheads();
begin
	return {self.}XmlAttrNoChangeArrowheads.Value;
end;

function SpLocks.WriteXmlAttrNoChangeArrowheads(_value);
begin
	if ifnil({self.}XmlAttrNoChangeArrowheads) then
	begin
		{self.}XmlAttrNoChangeArrowheads := new OpenXmlAttribute("", "noChangeArrowheads", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrNoChangeArrowheads;
	end
	{self.}XmlAttrNoChangeArrowheads.Value := _value;
end;

function Pic.Create();overload;
begin
	{self.}Create(nil, "pic", "pic");
end;

function Pic.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Pic.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Pic.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "nvPicPr": array(0, makeweakref(thisFunction(ReadXmlChildNvPicPr))),
		pre + "blipFill": array(1, makeweakref(thisFunction(ReadXmlChildBlipFill))),
		pre + "spPr": array(2, makeweakref(thisFunction(ReadXmlChildSpPr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Pic.Copy(_obj: Pic);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildNvPicPr) then
		{self.}NvPicPr.Copy(_obj.XmlChildNvPicPr);
	if not ifnil(_obj.XmlChildBlipFill) then
		{self.}BlipFill.Copy(_obj.XmlChildBlipFill);
	if not ifnil(_obj.XmlChildSpPr) then
		{self.}SpPr.Copy(_obj.XmlChildSpPr);
	tslassigning := tslassigning_backup;
end;

function Pic.ReadXmlChildNvPicPr(): NvPicPr;
begin
	if tslassigning and ifnil({self.}XmlChildNvPicPr) then
	begin
		{self.}XmlChildNvPicPr := new NvPicPr(self, {self.}Prefix, "nvPicPr");
		container_.Set({self.}XmlChildNvPicPr);
	end
	return {self.}XmlChildNvPicPr;
end;

function Pic.ReadXmlChildBlipFill(): BlipFill;
begin
	if tslassigning and ifnil({self.}XmlChildBlipFill) then
	begin
		{self.}XmlChildBlipFill := new BlipFill(self, {self.}Prefix, "blipFill");
		container_.Set({self.}XmlChildBlipFill);
	end
	return {self.}XmlChildBlipFill;
end;

function Pic.ReadXmlChildSpPr(): SpPr;
begin
	if tslassigning and ifnil({self.}XmlChildSpPr) then
	begin
		{self.}XmlChildSpPr := new SpPr(self, {self.}Prefix, "spPr");
		container_.Set({self.}XmlChildSpPr);
	end
	return {self.}XmlChildSpPr;
end;

function NvPicPr.Create();overload;
begin
	{self.}Create(nil, "pic", "nvPicPr");
end;

function NvPicPr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function NvPicPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function NvPicPr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		"pic:cNvPr": array(0, makeweakref(thisFunction(ReadXmlChildCNvPr))),
		"pic:cNvPicPr": array(1, makeweakref(thisFunction(ReadXmlChildCNvPicPr))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function NvPicPr.Copy(_obj: NvPicPr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildCNvPr) then
		{self.}CNvPr.Copy(_obj.XmlChildCNvPr);
	if not ifnil(_obj.XmlChildCNvPicPr) then
		{self.}CNvPicPr.Copy(_obj.XmlChildCNvPicPr);
	tslassigning := tslassigning_backup;
end;

function NvPicPr.ReadXmlChildCNvPr(): CNvPr;
begin
	if tslassigning and ifnil({self.}XmlChildCNvPr) then
	begin
		{self.}XmlChildCNvPr := new CNvPr(self, "pic", "cNvPr");
		container_.Set({self.}XmlChildCNvPr);
	end
	return {self.}XmlChildCNvPr;
end;

function NvPicPr.ReadXmlChildCNvPicPr(): CNvPicPr;
begin
	if tslassigning and ifnil({self.}XmlChildCNvPicPr) then
	begin
		{self.}XmlChildCNvPicPr := new CNvPicPr(self, "pic", "cNvPicPr");
		container_.Set({self.}XmlChildCNvPicPr);
	end
	return {self.}XmlChildCNvPicPr;
end;

function CNvPr.Create();overload;
begin
	{self.}Create(nil, "pic", "cNvPr");
end;

function CNvPr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function CNvPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function CNvPr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"id": makeweakref(thisFunction(WriteXmlAttrId)),
		"name": makeweakref(thisFunction(WriteXmlAttrName)),
		"descr": makeweakref(thisFunction(WriteXmlAttrDescr)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function CNvPr.Copy(_obj: CNvPr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Id) then
		{self.}Id := _obj.Id;
	if not ifnil(_obj.Name) then
		{self.}Name := _obj.Name;
	if not ifnil(_obj.Descr) then
		{self.}Descr := _obj.Descr;
	tslassigning := tslassigning_backup;
end;

function CNvPr.ReadXmlAttrId();
begin
	return {self.}XmlAttrId.Value;
end;

function CNvPr.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 CNvPr.ReadXmlAttrName();
begin
	return {self.}XmlAttrName.Value;
end;

function CNvPr.WriteXmlAttrName(_value);
begin
	if ifnil({self.}XmlAttrName) then
	begin
		{self.}XmlAttrName := new OpenXmlAttribute("", "name", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrName;
	end
	{self.}XmlAttrName.Value := _value;
end;

function CNvPr.ReadXmlAttrDescr();
begin
	return {self.}XmlAttrDescr.Value;
end;

function CNvPr.WriteXmlAttrDescr(_value);
begin
	if ifnil({self.}XmlAttrDescr) then
	begin
		{self.}XmlAttrDescr := new OpenXmlAttribute("", "descr", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDescr;
	end
	{self.}XmlAttrDescr.Value := _value;
end;

function CNvPicPr.Create();overload;
begin
	{self.}Create(nil, "pic", "cNvPicPr");
end;

function CNvPicPr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function CNvPicPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function CNvPicPr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		"a:picLocks": array(0, makeweakref(thisFunction(ReadXmlChildPicLocks))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function CNvPicPr.Copy(_obj: CNvPicPr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildPicLocks) then
		{self.}PicLocks.Copy(_obj.XmlChildPicLocks);
	tslassigning := tslassigning_backup;
end;

function CNvPicPr.ReadXmlChildPicLocks(): PicLocks;
begin
	if tslassigning and ifnil({self.}XmlChildPicLocks) then
	begin
		{self.}XmlChildPicLocks := new PicLocks(self, "a", "picLocks");
		container_.Set({self.}XmlChildPicLocks);
	end
	return {self.}XmlChildPicLocks;
end;

function PicLocks.Create();overload;
begin
	{self.}Create(nil, "a", "picLocks");
end;

function PicLocks.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function PicLocks.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function PicLocks.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"noChangeAspect": makeweakref(thisFunction(WriteXmlAttrNoChangeAspect)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function PicLocks.Copy(_obj: PicLocks);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.NoChangeAspect) then
		{self.}NoChangeAspect := _obj.NoChangeAspect;
	tslassigning := tslassigning_backup;
end;

function PicLocks.ReadXmlAttrNoChangeAspect();
begin
	return {self.}XmlAttrNoChangeAspect.Value;
end;

function PicLocks.WriteXmlAttrNoChangeAspect(_value);
begin
	if ifnil({self.}XmlAttrNoChangeAspect) then
	begin
		{self.}XmlAttrNoChangeAspect := new OpenXmlAttribute("", "noChangeAspect", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrNoChangeAspect;
	end
	{self.}XmlAttrNoChangeAspect.Value := _value;
end;

function BlipFill.Create();overload;
begin
	{self.}Create(nil, "pic", "blipFill");
end;

function BlipFill.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function BlipFill.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function BlipFill.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		"a:blip": array(0, makeweakref(thisFunction(ReadXmlChildBlip))),
		"a:stretch": array(1, makeweakref(thisFunction(ReadXmlChildStretch))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function BlipFill.Copy(_obj: BlipFill);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildBlip) then
		{self.}Blip.Copy(_obj.XmlChildBlip);
	if not ifnil(_obj.XmlChildStretch) then
		{self.}Stretch.Copy(_obj.XmlChildStretch);
	tslassigning := tslassigning_backup;
end;

function BlipFill.ReadXmlChildBlip(): Blip;
begin
	if tslassigning and ifnil({self.}XmlChildBlip) then
	begin
		{self.}XmlChildBlip := new Blip(self, "a", "blip");
		container_.Set({self.}XmlChildBlip);
	end
	return {self.}XmlChildBlip;
end;

function BlipFill.ReadXmlChildStretch(): Stretch;
begin
	if tslassigning and ifnil({self.}XmlChildStretch) then
	begin
		{self.}XmlChildStretch := new Stretch(self, "a", "stretch");
		container_.Set({self.}XmlChildStretch);
	end
	return {self.}XmlChildStretch;
end;

function Blip.Create();overload;
begin
	{self.}Create(nil, "a", "blip");
end;

function Blip.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Blip.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Blip.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"r:embed": makeweakref(thisFunction(WriteXmlAttrEmbed)),
		"cstate": makeweakref(thisFunction(WriteXmlAttrCstate)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Blip.Copy(_obj: Blip);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Embed) then
		{self.}Embed := _obj.Embed;
	if not ifnil(_obj.Cstate) then
		{self.}Cstate := _obj.Cstate;
	tslassigning := tslassigning_backup;
end;

function Blip.ReadXmlAttrEmbed();
begin
	return {self.}XmlAttrEmbed.Value;
end;

function Blip.WriteXmlAttrEmbed(_value);
begin
	if ifnil({self.}XmlAttrEmbed) then
	begin
		{self.}XmlAttrEmbed := new OpenXmlAttribute("r", "embed", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrEmbed;
	end
	{self.}XmlAttrEmbed.Value := _value;
end;

function Blip.ReadXmlAttrCstate();
begin
	return {self.}XmlAttrCstate.Value;
end;

function Blip.WriteXmlAttrCstate(_value);
begin
	if ifnil({self.}XmlAttrCstate) then
	begin
		{self.}XmlAttrCstate := new OpenXmlAttribute("", "cstate", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrCstate;
	end
	{self.}XmlAttrCstate.Value := _value;
end;

function Stretch.Create();overload;
begin
	{self.}Create(nil, "a", "stretch");
end;

function Stretch.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Stretch.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Stretch.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		"a:fillRect": array(0, makeweakref(thisFunction(ReadXmlChildFillRect))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Stretch.Copy(_obj: Stretch);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildFillRect) then
		{self.}FillRect.Copy(_obj.XmlChildFillRect);
	tslassigning := tslassigning_backup;
end;

function Stretch.ReadXmlChildFillRect(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildFillRect) then
	begin
		{self.}XmlChildFillRect := new PureVal(self, "a", "fillRect");
		container_.Set({self.}XmlChildFillRect);
	end
	return {self.}XmlChildFillRect;
end;

function SpPr.Create();overload;
begin
	{self.}Create(nil, "pic", "spPr");
end;

function SpPr.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function SpPr.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function SpPr.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"bwMode": makeweakref(thisFunction(WriteXmlAttrBwMode)),
	);
	sorted_child_ := array(
		"a:xfrm": array(0, makeweakref(thisFunction(ReadXmlChildXfrm))),
		"a:prstGeom": array(1, makeweakref(thisFunction(ReadXmlChildPrstGeom))),
		"a:noFill": array(2, makeweakref(thisFunction(ReadXmlChildNoFill))),
		"a:solidFill": array(3, makeweakref(thisFunction(ReadXmlChildSolidFill))),
		"a:ln": array(4, makeweakref(thisFunction(ReadXmlChildLn))),
		"a:effectLst": array(5, makeweakref(thisFunction(ReadXmlChildEffectLst))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function SpPr.Copy(_obj: SpPr);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.BwMode) then
		{self.}BwMode := _obj.BwMode;
	if not ifnil(_obj.XmlChildXfrm) then
		{self.}Xfrm.Copy(_obj.XmlChildXfrm);
	if not ifnil(_obj.XmlChildPrstGeom) then
		{self.}PrstGeom.Copy(_obj.XmlChildPrstGeom);
	if not ifnil(_obj.XmlChildNoFill) then
		ifnil({self.}XmlChildNoFill) ? {self.}NoFill.Copy(_obj.XmlChildNoFill) : {self.}XmlChildNoFill.Copy(_obj.XmlChildNoFill);
	if not ifnil(_obj.XmlChildSolidFill) then
		{self.}SolidFill.Copy(_obj.XmlChildSolidFill);
	if not ifnil(_obj.XmlChildLn) then
		{self.}Ln.Copy(_obj.XmlChildLn);
	if not ifnil(_obj.XmlChildEffectLst) then
		{self.}EffectLst.Copy(_obj.XmlChildEffectLst);
	tslassigning := tslassigning_backup;
end;

function SpPr.ReadXmlAttrBwMode();
begin
	return {self.}XmlAttrBwMode.Value;
end;

function SpPr.WriteXmlAttrBwMode(_value);
begin
	if ifnil({self.}XmlAttrBwMode) then
	begin
		{self.}XmlAttrBwMode := new OpenXmlAttribute("", "bwMode", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrBwMode;
	end
	{self.}XmlAttrBwMode.Value := _value;
end;

function SpPr.ReadXmlChildNoFill();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildNoFill) then
		begin
			{self.}XmlChildNoFill := new OpenXmlEmpty(self, "a", "noFill");
			container_.Set({self.}XmlChildNoFill);
		end
		return {self.}XmlChildNoFill;
	end
	return ifnil({self.}XmlChildNoFill) ? nil : {self.}XmlChildNoFill.BoolValue();
end;

function SpPr.WriteXmlChildNoFill(_value);
begin
	if ifnil({self.}XmlChildNoFill) then
	begin
		{self.}XmlChildNoFill := new OpenXmlEmpty(self, "a", "noFill");
		container_.Set({self.}XmlChildNoFill);
	end
	{self.}XmlChildNoFill.Value := _value;
end;

function SpPr.ReadXmlChildXfrm(): Xfrm;
begin
	if tslassigning and ifnil({self.}XmlChildXfrm) then
	begin
		{self.}XmlChildXfrm := new Xfrm(self, "a", "xfrm");
		container_.Set({self.}XmlChildXfrm);
	end
	return {self.}XmlChildXfrm;
end;

function SpPr.ReadXmlChildPrstGeom(): PrstGeom;
begin
	if tslassigning and ifnil({self.}XmlChildPrstGeom) then
	begin
		{self.}XmlChildPrstGeom := new PrstGeom(self, "a", "prstGeom");
		container_.Set({self.}XmlChildPrstGeom);
	end
	return {self.}XmlChildPrstGeom;
end;

function SpPr.ReadXmlChildSolidFill(): SolidFill;
begin
	if tslassigning and ifnil({self.}XmlChildSolidFill) then
	begin
		{self.}XmlChildSolidFill := new SolidFill(self, "a", "solidFill");
		container_.Set({self.}XmlChildSolidFill);
	end
	return {self.}XmlChildSolidFill;
end;

function SpPr.ReadXmlChildLn(): Ln;
begin
	if tslassigning and ifnil({self.}XmlChildLn) then
	begin
		{self.}XmlChildLn := new Ln(self, "a", "ln");
		container_.Set({self.}XmlChildLn);
	end
	return {self.}XmlChildLn;
end;

function SpPr.ReadXmlChildEffectLst(): EffectLst;
begin
	if tslassigning and ifnil({self.}XmlChildEffectLst) then
	begin
		{self.}XmlChildEffectLst := new EffectLst(self, "a", "effectLst");
		container_.Set({self.}XmlChildEffectLst);
	end
	return {self.}XmlChildEffectLst;
end;

function EffectLst.Create();overload;
begin
	{self.}Create(nil, "a", "effectLst");
end;

function EffectLst.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function EffectLst.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function EffectLst.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "outerShdw": array(0, makeweakref(thisFunction(ReadXmlChildOuterShdw))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function EffectLst.Copy(_obj: EffectLst);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildOuterShdw) then
		{self.}OuterShdw.Copy(_obj.XmlChildOuterShdw);
	tslassigning := tslassigning_backup;
end;

function EffectLst.ReadXmlChildOuterShdw(): OuterShdw;
begin
	if tslassigning and ifnil({self.}XmlChildOuterShdw) then
	begin
		{self.}XmlChildOuterShdw := new OuterShdw(self, {self.}Prefix, "outerShdw");
		container_.Set({self.}XmlChildOuterShdw);
	end
	return {self.}XmlChildOuterShdw;
end;

function Ln.Create();overload;
begin
	{self.}Create(nil, "a", "ln");
end;

function Ln.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Ln.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Ln.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"w": makeweakref(thisFunction(WriteXmlAttrW)),
		"cap": makeweakref(thisFunction(WriteXmlAttrCap)),
		"cmpd": makeweakref(thisFunction(WriteXmlAttrCmpd)),
		"algn": makeweakref(thisFunction(WriteXmlAttrAlgn)),
	);
	sorted_child_ := array(
		pre + "noFill": array(0, makeweakref(thisFunction(ReadXmlChildNoFill))),
		pre + "solidFill": array(1, makeweakref(thisFunction(ReadXmlChildSolidFill))),
		pre + "prstDash": array(2, makeweakref(thisFunction(ReadXmlChildPrstDash))),
		pre + "miter": array(3, makeweakref(thisFunction(ReadXmlChildMiter))),
		pre + "headEnd": array(4, makeweakref(thisFunction(ReadXmlChildHeadEnd))),
		pre + "tailEnd": array(5, makeweakref(thisFunction(ReadXmlChildTailEnd))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Ln.Copy(_obj: Ln);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.W) then
		{self.}W := _obj.W;
	if not ifnil(_obj.Cap) then
		{self.}Cap := _obj.Cap;
	if not ifnil(_obj.Cmpd) then
		{self.}Cmpd := _obj.Cmpd;
	if not ifnil(_obj.Algn) then
		{self.}Algn := _obj.Algn;
	if not ifnil(_obj.XmlChildNoFill) then
		ifnil({self.}XmlChildNoFill) ? {self.}NoFill.Copy(_obj.XmlChildNoFill) : {self.}XmlChildNoFill.Copy(_obj.XmlChildNoFill);
	if not ifnil(_obj.XmlChildSolidFill) then
		{self.}SolidFill.Copy(_obj.XmlChildSolidFill);
	if not ifnil(_obj.XmlChildPrstDash) then
		{self.}PrstDash.Copy(_obj.XmlChildPrstDash);
	if not ifnil(_obj.XmlChildMiter) then
		{self.}Miter.Copy(_obj.XmlChildMiter);
	if not ifnil(_obj.XmlChildHeadEnd) then
		ifnil({self.}XmlChildHeadEnd) ? {self.}HeadEnd.Copy(_obj.XmlChildHeadEnd) : {self.}XmlChildHeadEnd.Copy(_obj.XmlChildHeadEnd);
	if not ifnil(_obj.XmlChildTailEnd) then
		ifnil({self.}XmlChildTailEnd) ? {self.}TailEnd.Copy(_obj.XmlChildTailEnd) : {self.}XmlChildTailEnd.Copy(_obj.XmlChildTailEnd);
	tslassigning := tslassigning_backup;
end;

function Ln.ReadXmlAttrW();
begin
	return {self.}XmlAttrW.Value;
end;

function Ln.WriteXmlAttrW(_value);
begin
	if ifnil({self.}XmlAttrW) then
	begin
		{self.}XmlAttrW := new OpenXmlAttribute("", "w", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrW;
	end
	{self.}XmlAttrW.Value := _value;
end;

function Ln.ReadXmlAttrCap();
begin
	return {self.}XmlAttrCap.Value;
end;

function Ln.WriteXmlAttrCap(_value);
begin
	if ifnil({self.}XmlAttrCap) then
	begin
		{self.}XmlAttrCap := new OpenXmlAttribute("", "cap", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrCap;
	end
	{self.}XmlAttrCap.Value := _value;
end;

function Ln.ReadXmlAttrCmpd();
begin
	return {self.}XmlAttrCmpd.Value;
end;

function Ln.WriteXmlAttrCmpd(_value);
begin
	if ifnil({self.}XmlAttrCmpd) then
	begin
		{self.}XmlAttrCmpd := new OpenXmlAttribute("", "cmpd", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrCmpd;
	end
	{self.}XmlAttrCmpd.Value := _value;
end;

function Ln.ReadXmlAttrAlgn();
begin
	return {self.}XmlAttrAlgn.Value;
end;

function Ln.WriteXmlAttrAlgn(_value);
begin
	if ifnil({self.}XmlAttrAlgn) then
	begin
		{self.}XmlAttrAlgn := new OpenXmlAttribute("", "algn", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrAlgn;
	end
	{self.}XmlAttrAlgn.Value := _value;
end;

function Ln.ReadXmlChildNoFill();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildNoFill) then
		begin
			{self.}XmlChildNoFill := new OpenXmlEmpty(self, {self.}Prefix, "noFill");
			container_.Set({self.}XmlChildNoFill);
		end
		return {self.}XmlChildNoFill;
	end
	return ifnil({self.}XmlChildNoFill) ? nil : {self.}XmlChildNoFill.BoolValue();
end;

function Ln.WriteXmlChildNoFill(_value);
begin
	if ifnil({self.}XmlChildNoFill) then
	begin
		{self.}XmlChildNoFill := new OpenXmlEmpty(self, {self.}Prefix, "noFill");
		container_.Set({self.}XmlChildNoFill);
	end
	{self.}XmlChildNoFill.Value := _value;
end;

function Ln.ReadXmlChildHeadEnd();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildHeadEnd) then
		begin
			{self.}XmlChildHeadEnd := new OpenXmlEmpty(self, {self.}Prefix, "headEnd");
			container_.Set({self.}XmlChildHeadEnd);
		end
		return {self.}XmlChildHeadEnd;
	end
	return ifnil({self.}XmlChildHeadEnd) ? nil : {self.}XmlChildHeadEnd.BoolValue();
end;

function Ln.WriteXmlChildHeadEnd(_value);
begin
	if ifnil({self.}XmlChildHeadEnd) then
	begin
		{self.}XmlChildHeadEnd := new OpenXmlEmpty(self, {self.}Prefix, "headEnd");
		container_.Set({self.}XmlChildHeadEnd);
	end
	{self.}XmlChildHeadEnd.Value := _value;
end;

function Ln.ReadXmlChildTailEnd();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildTailEnd) then
		begin
			{self.}XmlChildTailEnd := new OpenXmlEmpty(self, {self.}Prefix, "tailEnd");
			container_.Set({self.}XmlChildTailEnd);
		end
		return {self.}XmlChildTailEnd;
	end
	return ifnil({self.}XmlChildTailEnd) ? nil : {self.}XmlChildTailEnd.BoolValue();
end;

function Ln.WriteXmlChildTailEnd(_value);
begin
	if ifnil({self.}XmlChildTailEnd) then
	begin
		{self.}XmlChildTailEnd := new OpenXmlEmpty(self, {self.}Prefix, "tailEnd");
		container_.Set({self.}XmlChildTailEnd);
	end
	{self.}XmlChildTailEnd.Value := _value;
end;

function Ln.ReadXmlChildSolidFill(): SolidFill;
begin
	if tslassigning and ifnil({self.}XmlChildSolidFill) then
	begin
		{self.}XmlChildSolidFill := new SolidFill(self, {self.}Prefix, "solidFill");
		container_.Set({self.}XmlChildSolidFill);
	end
	return {self.}XmlChildSolidFill;
end;

function Ln.ReadXmlChildPrstDash(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildPrstDash) then
	begin
		{self.}XmlChildPrstDash := new PureVal(self, {self.}Prefix, "prstDash");
		container_.Set({self.}XmlChildPrstDash);
	end
	return {self.}XmlChildPrstDash;
end;

function Ln.ReadXmlChildMiter(): Miter;
begin
	if tslassigning and ifnil({self.}XmlChildMiter) then
	begin
		{self.}XmlChildMiter := new Miter(self, {self.}Prefix, "miter");
		container_.Set({self.}XmlChildMiter);
	end
	return {self.}XmlChildMiter;
end;

function Miter.Create();overload;
begin
	{self.}Create(nil, "a", "miter");
end;

function Miter.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Miter.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Miter.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"lim": makeweakref(thisFunction(WriteXmlAttrLim)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Miter.Copy(_obj: Miter);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Lim) then
		{self.}Lim := _obj.Lim;
	tslassigning := tslassigning_backup;
end;

function Miter.ReadXmlAttrLim();
begin
	return {self.}XmlAttrLim.Value;
end;

function Miter.WriteXmlAttrLim(_value);
begin
	if ifnil({self.}XmlAttrLim) then
	begin
		{self.}XmlAttrLim := new OpenXmlAttribute("", "lim", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrLim;
	end
	{self.}XmlAttrLim.Value := _value;
end;

function Xfrm.Create();overload;
begin
	{self.}Create(nil, "a", "xfrm");
end;

function Xfrm.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Xfrm.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Xfrm.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
	);
	sorted_child_ := array(
		pre + "off": array(0, makeweakref(thisFunction(ReadXmlChildOff))),
		pre + "ext": array(1, makeweakref(thisFunction(ReadXmlChildExt))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Xfrm.Copy(_obj: Xfrm);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.XmlChildOff) then
		{self.}Off.Copy(_obj.XmlChildOff);
	if not ifnil(_obj.XmlChildExt) then
		{self.}Ext.Copy(_obj.XmlChildExt);
	tslassigning := tslassigning_backup;
end;

function Xfrm.ReadXmlChildOff(): XY;
begin
	if tslassigning and ifnil({self.}XmlChildOff) then
	begin
		{self.}XmlChildOff := new XY(self, {self.}Prefix, "off");
		container_.Set({self.}XmlChildOff);
	end
	return {self.}XmlChildOff;
end;

function Xfrm.ReadXmlChildExt(): CXY;
begin
	if tslassigning and ifnil({self.}XmlChildExt) then
	begin
		{self.}XmlChildExt := new CXY(self, {self.}Prefix, "ext");
		container_.Set({self.}XmlChildExt);
	end
	return {self.}XmlChildExt;
end;

function XY.Create();overload;
begin
	{self.}Create(nil, "", "");
end;

function XY.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function XY.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function XY.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"x": makeweakref(thisFunction(WriteXmlAttrX)),
		"y": makeweakref(thisFunction(WriteXmlAttrY)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function XY.Copy(_obj: XY);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.X) then
		{self.}X := _obj.X;
	if not ifnil(_obj.Y) then
		{self.}Y := _obj.Y;
	tslassigning := tslassigning_backup;
end;

function XY.ReadXmlAttrX();
begin
	return {self.}XmlAttrX.Value;
end;

function XY.WriteXmlAttrX(_value);
begin
	if ifnil({self.}XmlAttrX) then
	begin
		{self.}XmlAttrX := new OpenXmlAttribute("", "x", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrX;
	end
	{self.}XmlAttrX.Value := _value;
end;

function XY.ReadXmlAttrY();
begin
	return {self.}XmlAttrY.Value;
end;

function XY.WriteXmlAttrY(_value);
begin
	if ifnil({self.}XmlAttrY) then
	begin
		{self.}XmlAttrY := new OpenXmlAttribute("", "y", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrY;
	end
	{self.}XmlAttrY.Value := _value;
end;

function CXY.Create();overload;
begin
	{self.}Create(nil, "", "");
end;

function CXY.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function CXY.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function CXY.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"cx": makeweakref(thisFunction(WriteXmlAttrCx)),
		"cy": makeweakref(thisFunction(WriteXmlAttrCy)),
	);
	sorted_child_ := array(
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function CXY.Copy(_obj: CXY);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Cx) then
		{self.}Cx := _obj.Cx;
	if not ifnil(_obj.Cy) then
		{self.}Cy := _obj.Cy;
	tslassigning := tslassigning_backup;
end;

function CXY.ReadXmlAttrCx();
begin
	return {self.}XmlAttrCx.Value;
end;

function CXY.WriteXmlAttrCx(_value);
begin
	if ifnil({self.}XmlAttrCx) then
	begin
		{self.}XmlAttrCx := new OpenXmlAttribute("", "cx", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrCx;
	end
	{self.}XmlAttrCx.Value := _value;
end;

function CXY.ReadXmlAttrCy();
begin
	return {self.}XmlAttrCy.Value;
end;

function CXY.WriteXmlAttrCy(_value);
begin
	if ifnil({self.}XmlAttrCy) then
	begin
		{self.}XmlAttrCy := new OpenXmlAttribute("", "cy", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrCy;
	end
	{self.}XmlAttrCy.Value := _value;
end;

function PrstGeom.Create();overload;
begin
	{self.}Create(nil, "a", "prstGeom");
end;

function PrstGeom.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function PrstGeom.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function PrstGeom.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"prst": makeweakref(thisFunction(WriteXmlAttrPrst)),
	);
	sorted_child_ := array(
		pre + "avLst": array(0, makeweakref(thisFunction(ReadXmlChildAvLst))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function PrstGeom.Copy(_obj: PrstGeom);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.Prst) then
		{self.}Prst := _obj.Prst;
	if not ifnil(_obj.XmlChildAvLst) then
		{self.}AvLst.Copy(_obj.XmlChildAvLst);
	tslassigning := tslassigning_backup;
end;

function PrstGeom.ReadXmlAttrPrst();
begin
	return {self.}XmlAttrPrst.Value;
end;

function PrstGeom.WriteXmlAttrPrst(_value);
begin
	if ifnil({self.}XmlAttrPrst) then
	begin
		{self.}XmlAttrPrst := new OpenXmlAttribute("", "prst", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrPrst;
	end
	{self.}XmlAttrPrst.Value := _value;
end;

function PrstGeom.ReadXmlChildAvLst(): PureVal;
begin
	if tslassigning and ifnil({self.}XmlChildAvLst) then
	begin
		{self.}XmlChildAvLst := new PureVal(self, {self.}Prefix, "avLst");
		container_.Set({self.}XmlChildAvLst);
	end
	return {self.}XmlChildAvLst;
end;

function Anchor.Create();overload;
begin
	{self.}Create(nil, "wp", "anchor");
end;

function Anchor.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function Anchor.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function Anchor.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"distT": makeweakref(thisFunction(WriteXmlAttrDistT)),
		"distB": makeweakref(thisFunction(WriteXmlAttrDistB)),
		"distL": makeweakref(thisFunction(WriteXmlAttrDistL)),
		"distR": makeweakref(thisFunction(WriteXmlAttrDistR)),
		"simplePos": makeweakref(thisFunction(WriteXmlAttrSimplePos)),
		"relativeHeight": makeweakref(thisFunction(WriteXmlAttrRelativeHeight)),
		"behindDoc": makeweakref(thisFunction(WriteXmlAttrBehindDoc)),
		"locked": makeweakref(thisFunction(WriteXmlAttrLocked)),
		"hidden": makeweakref(thisFunction(WriteXmlAttrHidden)),
		"layoutInCell": makeweakref(thisFunction(WriteXmlAttrLayoutInCell)),
		"allowOverlap": makeweakref(thisFunction(WriteXmlAttrAllowOverlap)),
		"wp14:anchorId": makeweakref(thisFunction(WriteXmlAttrAnchorId)),
		"wp14:editId": makeweakref(thisFunction(WriteXmlAttrEditId)),
	);
	sorted_child_ := array(
		pre + "simplePos": array(0, makeweakref(thisFunction(ReadXmlChildSimplePos))),
		pre + "positionH": array(1, makeweakref(thisFunction(ReadXmlChildPositionH))),
		pre + "positionV": array(2, makeweakref(thisFunction(ReadXmlChildPositionV))),
		pre + "extent": array(3, makeweakref(thisFunction(ReadXmlChildExtent))),
		pre + "effectExtent": array(4, makeweakref(thisFunction(ReadXmlChildEffectExtent))),
		pre + "wrapNone": array(5, makeweakref(thisFunction(ReadXmlChildWrapNone))),
		pre + "docPr": array(6, makeweakref(thisFunction(ReadXmlChildDocPr))),
		pre + "cNvGraphicFramePr": array(7, makeweakref(thisFunction(ReadXmlChildCNvGraphicFramePr))),
		"a:graphic": array(8, makeweakref(thisFunction(ReadXmlChildGraphic))),
		"wp14:sizeRelH": array(9, makeweakref(thisFunction(ReadXmlChildSizeRelH))),
		"wp14:sizeRelV": array(10, makeweakref(thisFunction(ReadXmlChildSizeRelV))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function Anchor.Copy(_obj: Anchor);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.DistT) then
		{self.}DistT := _obj.DistT;
	if not ifnil(_obj.DistB) then
		{self.}DistB := _obj.DistB;
	if not ifnil(_obj.DistL) then
		{self.}DistL := _obj.DistL;
	if not ifnil(_obj.DistR) then
		{self.}DistR := _obj.DistR;
	if not ifnil(_obj.SimplePos) then
		{self.}SimplePos := _obj.SimplePos;
	if not ifnil(_obj.RelativeHeight) then
		{self.}RelativeHeight := _obj.RelativeHeight;
	if not ifnil(_obj.BehindDoc) then
		{self.}BehindDoc := _obj.BehindDoc;
	if not ifnil(_obj.Locked) then
		{self.}Locked := _obj.Locked;
	if not ifnil(_obj.Hidden) then
		{self.}Hidden := _obj.Hidden;
	if not ifnil(_obj.LayoutInCell) then
		{self.}LayoutInCell := _obj.LayoutInCell;
	if not ifnil(_obj.AllowOverlap) then
		{self.}AllowOverlap := _obj.AllowOverlap;
	if not ifnil(_obj.AnchorId) then
		{self.}AnchorId := _obj.AnchorId;
	if not ifnil(_obj.EditId) then
		{self.}EditId := _obj.EditId;
	if not ifnil(_obj.XmlChildSimplePos) then
		{self.}SimplePos.Copy(_obj.XmlChildSimplePos);
	if not ifnil(_obj.XmlChildPositionH) then
		{self.}PositionH.Copy(_obj.XmlChildPositionH);
	if not ifnil(_obj.XmlChildPositionV) then
		{self.}PositionV.Copy(_obj.XmlChildPositionV);
	if not ifnil(_obj.XmlChildExtent) then
		{self.}Extent.Copy(_obj.XmlChildExtent);
	if not ifnil(_obj.XmlChildEffectExtent) then
		{self.}EffectExtent.Copy(_obj.XmlChildEffectExtent);
	if not ifnil(_obj.XmlChildWrapNone) then
		ifnil({self.}XmlChildWrapNone) ? {self.}WrapNone.Copy(_obj.XmlChildWrapNone) : {self.}XmlChildWrapNone.Copy(_obj.XmlChildWrapNone);
	if not ifnil(_obj.XmlChildDocPr) then
		{self.}DocPr.Copy(_obj.XmlChildDocPr);
	if not ifnil(_obj.XmlChildCNvGraphicFramePr) then
		{self.}CNvGraphicFramePr.Copy(_obj.XmlChildCNvGraphicFramePr);
	if not ifnil(_obj.XmlChildGraphic) then
		{self.}Graphic.Copy(_obj.XmlChildGraphic);
	if not ifnil(_obj.XmlChildSizeRelH) then
		{self.}SizeRelH.Copy(_obj.XmlChildSizeRelH);
	if not ifnil(_obj.XmlChildSizeRelV) then
		{self.}SizeRelV.Copy(_obj.XmlChildSizeRelV);
	tslassigning := tslassigning_backup;
end;

function Anchor.ReadXmlAttrDistT();
begin
	return {self.}XmlAttrDistT.Value;
end;

function Anchor.WriteXmlAttrDistT(_value);
begin
	if ifnil({self.}XmlAttrDistT) then
	begin
		{self.}XmlAttrDistT := new OpenXmlAttribute("", "distT", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDistT;
	end
	{self.}XmlAttrDistT.Value := _value;
end;

function Anchor.ReadXmlAttrDistB();
begin
	return {self.}XmlAttrDistB.Value;
end;

function Anchor.WriteXmlAttrDistB(_value);
begin
	if ifnil({self.}XmlAttrDistB) then
	begin
		{self.}XmlAttrDistB := new OpenXmlAttribute("", "distB", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDistB;
	end
	{self.}XmlAttrDistB.Value := _value;
end;

function Anchor.ReadXmlAttrDistL();
begin
	return {self.}XmlAttrDistL.Value;
end;

function Anchor.WriteXmlAttrDistL(_value);
begin
	if ifnil({self.}XmlAttrDistL) then
	begin
		{self.}XmlAttrDistL := new OpenXmlAttribute("", "distL", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDistL;
	end
	{self.}XmlAttrDistL.Value := _value;
end;

function Anchor.ReadXmlAttrDistR();
begin
	return {self.}XmlAttrDistR.Value;
end;

function Anchor.WriteXmlAttrDistR(_value);
begin
	if ifnil({self.}XmlAttrDistR) then
	begin
		{self.}XmlAttrDistR := new OpenXmlAttribute("", "distR", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrDistR;
	end
	{self.}XmlAttrDistR.Value := _value;
end;

function Anchor.ReadXmlAttrSimplePos();
begin
	return {self.}XmlAttrSimplePos.Value;
end;

function Anchor.WriteXmlAttrSimplePos(_value);
begin
	if ifnil({self.}XmlAttrSimplePos) then
	begin
		{self.}XmlAttrSimplePos := new OpenXmlAttribute("", "simplePos", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrSimplePos;
	end
	{self.}XmlAttrSimplePos.Value := _value;
end;

function Anchor.ReadXmlAttrRelativeHeight();
begin
	return {self.}XmlAttrRelativeHeight.Value;
end;

function Anchor.WriteXmlAttrRelativeHeight(_value);
begin
	if ifnil({self.}XmlAttrRelativeHeight) then
	begin
		{self.}XmlAttrRelativeHeight := new OpenXmlAttribute("", "relativeHeight", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrRelativeHeight;
	end
	{self.}XmlAttrRelativeHeight.Value := _value;
end;

function Anchor.ReadXmlAttrBehindDoc();
begin
	return {self.}XmlAttrBehindDoc.Value;
end;

function Anchor.WriteXmlAttrBehindDoc(_value);
begin
	if ifnil({self.}XmlAttrBehindDoc) then
	begin
		{self.}XmlAttrBehindDoc := new OpenXmlAttribute("", "behindDoc", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrBehindDoc;
	end
	{self.}XmlAttrBehindDoc.Value := _value;
end;

function Anchor.ReadXmlAttrLocked();
begin
	return {self.}XmlAttrLocked.Value;
end;

function Anchor.WriteXmlAttrLocked(_value);
begin
	if ifnil({self.}XmlAttrLocked) then
	begin
		{self.}XmlAttrLocked := new OpenXmlAttribute("", "locked", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrLocked;
	end
	{self.}XmlAttrLocked.Value := _value;
end;

function Anchor.ReadXmlAttrHidden();
begin
	return {self.}XmlAttrHidden.Value;
end;

function Anchor.WriteXmlAttrHidden(_value);
begin
	if ifnil({self.}XmlAttrHidden) then
	begin
		{self.}XmlAttrHidden := new OpenXmlAttribute("", "hidden", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrHidden;
	end
	{self.}XmlAttrHidden.Value := _value;
end;

function Anchor.ReadXmlAttrLayoutInCell();
begin
	return {self.}XmlAttrLayoutInCell.Value;
end;

function Anchor.WriteXmlAttrLayoutInCell(_value);
begin
	if ifnil({self.}XmlAttrLayoutInCell) then
	begin
		{self.}XmlAttrLayoutInCell := new OpenXmlAttribute("", "layoutInCell", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrLayoutInCell;
	end
	{self.}XmlAttrLayoutInCell.Value := _value;
end;

function Anchor.ReadXmlAttrAllowOverlap();
begin
	return {self.}XmlAttrAllowOverlap.Value;
end;

function Anchor.WriteXmlAttrAllowOverlap(_value);
begin
	if ifnil({self.}XmlAttrAllowOverlap) then
	begin
		{self.}XmlAttrAllowOverlap := new OpenXmlAttribute("", "allowOverlap", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrAllowOverlap;
	end
	{self.}XmlAttrAllowOverlap.Value := _value;
end;

function Anchor.ReadXmlAttrAnchorId();
begin
	return {self.}XmlAttrAnchorId.Value;
end;

function Anchor.WriteXmlAttrAnchorId(_value);
begin
	if ifnil({self.}XmlAttrAnchorId) then
	begin
		{self.}XmlAttrAnchorId := new OpenXmlAttribute("wp14", "anchorId", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrAnchorId;
	end
	{self.}XmlAttrAnchorId.Value := _value;
end;

function Anchor.ReadXmlAttrEditId();
begin
	return {self.}XmlAttrEditId.Value;
end;

function Anchor.WriteXmlAttrEditId(_value);
begin
	if ifnil({self.}XmlAttrEditId) then
	begin
		{self.}XmlAttrEditId := new OpenXmlAttribute("wp14", "editId", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrEditId;
	end
	{self.}XmlAttrEditId.Value := _value;
end;

function Anchor.ReadXmlChildWrapNone();
begin
	if tslassigning then
	begin
		if ifnil({self.}XmlChildWrapNone) then
		begin
			{self.}XmlChildWrapNone := new OpenXmlEmpty(self, {self.}Prefix, "wrapNone");
			container_.Set({self.}XmlChildWrapNone);
		end
		return {self.}XmlChildWrapNone;
	end
	return ifnil({self.}XmlChildWrapNone) ? nil : {self.}XmlChildWrapNone.BoolValue();
end;

function Anchor.WriteXmlChildWrapNone(_value);
begin
	if ifnil({self.}XmlChildWrapNone) then
	begin
		{self.}XmlChildWrapNone := new OpenXmlEmpty(self, {self.}Prefix, "wrapNone");
		container_.Set({self.}XmlChildWrapNone);
	end
	{self.}XmlChildWrapNone.Value := _value;
end;

function Anchor.ReadXmlChildSimplePos(): XY;
begin
	if tslassigning and ifnil({self.}XmlChildSimplePos) then
	begin
		{self.}XmlChildSimplePos := new XY(self, {self.}Prefix, "simplePos");
		container_.Set({self.}XmlChildSimplePos);
	end
	return {self.}XmlChildSimplePos;
end;

function Anchor.ReadXmlChildPositionH(): PositionH;
begin
	if tslassigning and ifnil({self.}XmlChildPositionH) then
	begin
		{self.}XmlChildPositionH := new PositionH(self, {self.}Prefix, "positionH");
		container_.Set({self.}XmlChildPositionH);
	end
	return {self.}XmlChildPositionH;
end;

function Anchor.ReadXmlChildPositionV(): PositionV;
begin
	if tslassigning and ifnil({self.}XmlChildPositionV) then
	begin
		{self.}XmlChildPositionV := new PositionV(self, {self.}Prefix, "positionV");
		container_.Set({self.}XmlChildPositionV);
	end
	return {self.}XmlChildPositionV;
end;

function Anchor.ReadXmlChildExtent(): CXY;
begin
	if tslassigning and ifnil({self.}XmlChildExtent) then
	begin
		{self.}XmlChildExtent := new CXY(self, {self.}Prefix, "extent");
		container_.Set({self.}XmlChildExtent);
	end
	return {self.}XmlChildExtent;
end;

function Anchor.ReadXmlChildEffectExtent(): EffectExtent;
begin
	if tslassigning and ifnil({self.}XmlChildEffectExtent) then
	begin
		{self.}XmlChildEffectExtent := new EffectExtent(self, {self.}Prefix, "effectExtent");
		container_.Set({self.}XmlChildEffectExtent);
	end
	return {self.}XmlChildEffectExtent;
end;

function Anchor.ReadXmlChildDocPr(): DocPr;
begin
	if tslassigning and ifnil({self.}XmlChildDocPr) then
	begin
		{self.}XmlChildDocPr := new DocPr(self, {self.}Prefix, "docPr");
		container_.Set({self.}XmlChildDocPr);
	end
	return {self.}XmlChildDocPr;
end;

function Anchor.ReadXmlChildCNvGraphicFramePr(): CNvGraphicFramePr;
begin
	if tslassigning and ifnil({self.}XmlChildCNvGraphicFramePr) then
	begin
		{self.}XmlChildCNvGraphicFramePr := new CNvGraphicFramePr(self, {self.}Prefix, "cNvGraphicFramePr");
		container_.Set({self.}XmlChildCNvGraphicFramePr);
	end
	return {self.}XmlChildCNvGraphicFramePr;
end;

function Anchor.ReadXmlChildGraphic(): Graphic;
begin
	if tslassigning and ifnil({self.}XmlChildGraphic) then
	begin
		{self.}XmlChildGraphic := new Graphic(self, "a", "graphic");
		container_.Set({self.}XmlChildGraphic);
	end
	return {self.}XmlChildGraphic;
end;

function Anchor.ReadXmlChildSizeRelH(): SizeRelH;
begin
	if tslassigning and ifnil({self.}XmlChildSizeRelH) then
	begin
		{self.}XmlChildSizeRelH := new SizeRelH(self, "wp14", "sizeRelH");
		container_.Set({self.}XmlChildSizeRelH);
	end
	return {self.}XmlChildSizeRelH;
end;

function Anchor.ReadXmlChildSizeRelV(): SizeRelV;
begin
	if tslassigning and ifnil({self.}XmlChildSizeRelV) then
	begin
		{self.}XmlChildSizeRelV := new SizeRelV(self, "wp14", "sizeRelV");
		container_.Set({self.}XmlChildSizeRelV);
	end
	return {self.}XmlChildSizeRelV;
end;

function PositionV.Create();overload;
begin
	{self.}Create(nil, "wp", "positionV");
end;

function PositionV.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function PositionV.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function PositionV.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"relativeFrom": makeweakref(thisFunction(WriteXmlAttrRelativeFrom)),
	);
	sorted_child_ := array(
		pre + "posOffset": array(0, makeweakref(thisFunction(ReadXmlChildPosOffset))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function PositionV.Copy(_obj: PositionV);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.RelativeFrom) then
		{self.}RelativeFrom := _obj.RelativeFrom;
	if not ifnil(_obj.XmlChildPosOffset) then
		{self.}PosOffset.Copy(_obj.XmlChildPosOffset);
	tslassigning := tslassigning_backup;
end;

function PositionV.ReadXmlAttrRelativeFrom();
begin
	return {self.}XmlAttrRelativeFrom.Value;
end;

function PositionV.WriteXmlAttrRelativeFrom(_value);
begin
	if ifnil({self.}XmlAttrRelativeFrom) then
	begin
		{self.}XmlAttrRelativeFrom := new OpenXmlAttribute("", "relativeFrom", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrRelativeFrom;
	end
	{self.}XmlAttrRelativeFrom.Value := _value;
end;

function PositionV.ReadXmlChildPosOffset();
begin
	if tslassigning and ifnil({self.}XmlChildPosOffset) then
	begin
		{self.}XmlChildPosOffset := new OpenXmlPcdata(self, {self.}Prefix, "posOffset");
		container_.Set({self.}XmlChildPosOffset);
	end
	return {self.}XmlChildPosOffset;
end;

function PositionH.Create();overload;
begin
	{self.}Create(nil, "wp", "positionH");
end;

function PositionH.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function PositionH.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function PositionH.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"relativeFrom": makeweakref(thisFunction(WriteXmlAttrRelativeFrom)),
	);
	sorted_child_ := array(
		pre + "posOffset": array(0, makeweakref(thisFunction(ReadXmlChildPosOffset))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function PositionH.Copy(_obj: PositionH);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.RelativeFrom) then
		{self.}RelativeFrom := _obj.RelativeFrom;
	if not ifnil(_obj.XmlChildPosOffset) then
		{self.}PosOffset.Copy(_obj.XmlChildPosOffset);
	tslassigning := tslassigning_backup;
end;

function PositionH.ReadXmlAttrRelativeFrom();
begin
	return {self.}XmlAttrRelativeFrom.Value;
end;

function PositionH.WriteXmlAttrRelativeFrom(_value);
begin
	if ifnil({self.}XmlAttrRelativeFrom) then
	begin
		{self.}XmlAttrRelativeFrom := new OpenXmlAttribute("", "relativeFrom", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrRelativeFrom;
	end
	{self.}XmlAttrRelativeFrom.Value := _value;
end;

function PositionH.ReadXmlChildPosOffset();
begin
	if tslassigning and ifnil({self.}XmlChildPosOffset) then
	begin
		{self.}XmlChildPosOffset := new OpenXmlPcdata(self, {self.}Prefix, "posOffset");
		container_.Set({self.}XmlChildPosOffset);
	end
	return {self.}XmlChildPosOffset;
end;

function SizeRelH.Create();overload;
begin
	{self.}Create(nil, "wp14", "sizeRelH");
end;

function SizeRelH.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function SizeRelH.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function SizeRelH.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"relativeFrom": makeweakref(thisFunction(WriteXmlAttrRelativeFrom)),
	);
	sorted_child_ := array(
		pre + "pctWidth": array(0, makeweakref(thisFunction(ReadXmlChildPctWidth))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function SizeRelH.Copy(_obj: SizeRelH);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.RelativeFrom) then
		{self.}RelativeFrom := _obj.RelativeFrom;
	if not ifnil(_obj.XmlChildPctWidth) then
		{self.}PctWidth.Copy(_obj.XmlChildPctWidth);
	tslassigning := tslassigning_backup;
end;

function SizeRelH.ReadXmlAttrRelativeFrom();
begin
	return {self.}XmlAttrRelativeFrom.Value;
end;

function SizeRelH.WriteXmlAttrRelativeFrom(_value);
begin
	if ifnil({self.}XmlAttrRelativeFrom) then
	begin
		{self.}XmlAttrRelativeFrom := new OpenXmlAttribute("", "relativeFrom", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrRelativeFrom;
	end
	{self.}XmlAttrRelativeFrom.Value := _value;
end;

function SizeRelH.ReadXmlChildPctWidth();
begin
	if tslassigning and ifnil({self.}XmlChildPctWidth) then
	begin
		{self.}XmlChildPctWidth := new OpenXmlPcdata(self, {self.}Prefix, "pctWidth");
		container_.Set({self.}XmlChildPctWidth);
	end
	return {self.}XmlChildPctWidth;
end;

function SizeRelV.Create();overload;
begin
	{self.}Create(nil, "wp14", "sizeRelV");
end;

function SizeRelV.Create(_node: XmlNode);overload;
begin
	class(OpenXmlElement).Create(_node: XmlNode);
end;

function SizeRelV.Create(_parent: tslobj; _prefix: string; _local_name: string);overload;
begin
	setsysparam(pn_calcctrlword(), getsysparam(pn_calcctrlword()) .| 0x200);
	class(OpenXmlElement).Create(_parent, _prefix, _local_name);
end;

function SizeRelV.Init();override;
begin
	pre := {self.}Prefix ? {self.}Prefix + ":" : "";
	attributes_ := array();
	attributes_pf_ := array(
		"relativeFrom": makeweakref(thisFunction(WriteXmlAttrRelativeFrom)),
	);
	sorted_child_ := array(
		pre + "pctHeight": array(0, makeweakref(thisFunction(ReadXmlChildPctHeight))),
	);
	container_ := new TSOfficeContainer(sorted_child_);
end;

function SizeRelV.Copy(_obj: SizeRelV);override;
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	class(OpenXmlElement).Copy(_obj);
	if not ifnil(_obj.RelativeFrom) then
		{self.}RelativeFrom := _obj.RelativeFrom;
	if not ifnil(_obj.XmlChildPctHeight) then
		{self.}PctHeight.Copy(_obj.XmlChildPctHeight);
	tslassigning := tslassigning_backup;
end;

function SizeRelV.ReadXmlAttrRelativeFrom();
begin
	return {self.}XmlAttrRelativeFrom.Value;
end;

function SizeRelV.WriteXmlAttrRelativeFrom(_value);
begin
	if ifnil({self.}XmlAttrRelativeFrom) then
	begin
		{self.}XmlAttrRelativeFrom := new OpenXmlAttribute("", "relativeFrom", nil);
		attributes_[length(attributes_)] := {self.}XmlAttrRelativeFrom;
	end
	{self.}XmlAttrRelativeFrom.Value := _value;
end;

function SizeRelV.ReadXmlChildPctHeight();
begin
	if tslassigning and ifnil({self.}XmlChildPctHeight) then
	begin
		{self.}XmlChildPctHeight := new OpenXmlPcdata(self, {self.}Prefix, "pctHeight");
		container_.Set({self.}XmlChildPctHeight);
	end
	return {self.}XmlChildPctHeight;
end;

end.