unit DrawingMLUnitDecorator;
interface
uses DrawingML, TSSafeUnitConverter;

type ThemeUnitDecorator = class(Theme)
public
	function Create(_obj: Theme);
	function GetObject();
	function Convert();
private
	object_: Theme;
end;

type ThemeElementsUnitDecorator = class(ThemeElements)
public
	function Create(_obj: ThemeElements);
	function GetObject();
	function Convert();
private
	object_: ThemeElements;
end;

type ClrSchemeUnitDecorator = class(ClrScheme)
public
	function Create(_obj: ClrScheme);
	function GetObject();
	function Convert();
private
	object_: ClrScheme;
end;

type Clr1UnitDecorator = class(Clr1)
public
	function Create(_obj: Clr1);
	function GetObject();
	function Convert();
private
	object_: Clr1;
end;

type SysClrUnitDecorator = class(SysClr)
public
	function Create(_obj: SysClr);
	function GetObject();
	function Convert();
private
	object_: SysClr;
end;

type Clr2UnitDecorator = class(Clr2)
public
	function Create(_obj: Clr2);
	function GetObject();
	function Convert();
private
	object_: Clr2;
end;

type SrgbClrUnitDecorator = class(SrgbClr)
public
	function Create(_obj: SrgbClr);
	function GetObject();
	function Convert();
private
	object_: SrgbClr;
end;

type PureValUnitDecorator = class(PureVal)
public
	function Create(_obj: PureVal);
	function GetObject();
	function Convert();
private
	object_: PureVal;
end;

type FontSchemeUnitDecorator = class(FontScheme)
public
	function Create(_obj: FontScheme);
	function GetObject();
	function Convert();
private
	object_: FontScheme;
end;

type MFontUnitDecorator = class(MFont)
public
	function Create(_obj: MFont);
	function GetObject();
	function Convert();
private
	object_: MFont;
end;

type FontUnitDecorator = class(Font)
public
	function Create(_obj: Font);
	function GetObject();
	function Convert();
private
	object_: Font;
end;

type FmtSchemeUnitDecorator = class(FmtScheme)
public
	function Create(_obj: FmtScheme);
	function GetObject();
	function Convert();
private
	object_: FmtScheme;
end;

type FillStyleLstUnitDecorator = class(FillStyleLst)
public
	function Create(_obj: FillStyleLst);
	function GetObject();
	function Convert();
private
	object_: FillStyleLst;
end;

type SolidFillUnitDecorator = class(SolidFill)
public
	function Create(_obj: SolidFill);
	function GetObject();
	function Convert();
private
	object_: SolidFill;
end;

type SchemeClrUnitDecorator = class(SchemeClr)
public
	function Create(_obj: SchemeClr);
	function GetObject();
	function Convert();
private
	object_: SchemeClr;
end;

type GradFillUnitDecorator = class(GradFill)
public
	function Create(_obj: GradFill);
	function GetObject();
	function Convert();
private
	object_: GradFill;
end;

type GsLstUnitDecorator = class(GsLst)
public
	function Create(_obj: GsLst);
	function GetObject();
	function Convert();
private
	object_: GsLst;
end;

type GsUnitDecorator = class(Gs)
public
	function Create(_obj: Gs);
	function GetObject();
	function Convert();
private
	object_: Gs;
end;

type LinUnitDecorator = class(Lin)
public
	function Create(_obj: Lin);
	function GetObject();
	function Convert();
private
	object_: Lin;
end;

type LnStyleLstUnitDecorator = class(LnStyleLst)
public
	function Create(_obj: LnStyleLst);
	function GetObject();
	function Convert();
private
	object_: LnStyleLst;
end;

type EffectStyleLstUnitDecorator = class(EffectStyleLst)
public
	function Create(_obj: EffectStyleLst);
	function GetObject();
	function Convert();
private
	object_: EffectStyleLst;
end;

type EffectStyleUnitDecorator = class(EffectStyle)
public
	function Create(_obj: EffectStyle);
	function GetObject();
	function Convert();
private
	object_: EffectStyle;
end;

type OuterShdwUnitDecorator = class(OuterShdw)
public
	function Create(_obj: OuterShdw);
	function GetObject();
	function Convert();
private
	object_: OuterShdw;
end;

type ExtLstUnitDecorator = class(ExtLst)
public
	function Create(_obj: ExtLst);
	function GetObject();
	function Convert();
private
	object_: ExtLst;
end;

type ExtUnitDecorator = class(Ext)
public
	function Create(_obj: Ext);
	function GetObject();
	function Convert();
private
	object_: Ext;
end;

type SlicerStylesUnitDecorator = class(SlicerStyles)
public
	function Create(_obj: SlicerStyles);
	function GetObject();
	function Convert();
private
	object_: SlicerStyles;
end;

type TimelineStylesUnitDecorator = class(TimelineStyles)
public
	function Create(_obj: TimelineStyles);
	function GetObject();
	function Convert();
private
	object_: TimelineStyles;
end;

type ThemeFamilyUnitDecorator = class(ThemeFamily)
public
	function Create(_obj: ThemeFamily);
	function GetObject();
	function Convert();
private
	object_: ThemeFamily;
end;

type ChartSpaceUnitDecorator = class(ChartSpace)
public
	function Create(_obj: ChartSpace);
	function GetObject();
	function Convert();
private
	object_: ChartSpace;
end;

type ChartUnitDecorator = class(Chart)
public
	function Create(_obj: Chart);
	function GetObject();
	function Convert();
private
	object_: Chart;
end;

type LegendUnitDecorator = class(Legend)
public
	function Create(_obj: Legend);
	function GetObject();
	function Convert();
private
	object_: Legend;
end;

type View3DUnitDecorator = class(View3D)
public
	function Create(_obj: View3D);
	function GetObject();
	function Convert();
private
	object_: View3D;
end;

type PlotAreaUnitDecorator = class(PlotArea)
public
	function Create(_obj: PlotArea);
	function GetObject();
	function Convert();
private
	object_: PlotArea;
end;

type BarChartUnitDecorator = class(BarChart)
public
	function Create(_obj: BarChart);
	function GetObject();
	function Convert();
private
	object_: BarChart;
end;

type SerUnitDecorator = class(Ser)
public
	function Create(_obj: Ser);
	function GetObject();
	function Convert();
private
	object_: Ser;
end;

type DLblsUnitDecorator = class(DLbls)
public
	function Create(_obj: DLbls);
	function GetObject();
	function Convert();
private
	object_: DLbls;
end;

type CatUnitDecorator = class(Cat)
public
	function Create(_obj: Cat);
	function GetObject();
	function Convert();
private
	object_: Cat;
end;

type StrRefUnitDecorator = class(StrRef)
public
	function Create(_obj: StrRef);
	function GetObject();
	function Convert();
private
	object_: StrRef;
end;

type ValUnitDecorator = class(Val)
public
	function Create(_obj: Val);
	function GetObject();
	function Convert();
private
	object_: Val;
end;

type NumRefUnitDecorator = class(NumRef)
public
	function Create(_obj: NumRef);
	function GetObject();
	function Convert();
private
	object_: NumRef;
end;

type StrCacheUnitDecorator = class(StrCache)
public
	function Create(_obj: StrCache);
	function GetObject();
	function Convert();
private
	object_: StrCache;
end;

type NumCacheUnitDecorator = class(NumCache)
public
	function Create(_obj: NumCache);
	function GetObject();
	function Convert();
private
	object_: NumCache;
end;

type PtUnitDecorator = class(Pt)
public
	function Create(_obj: Pt);
	function GetObject();
	function Convert();
private
	object_: Pt;
end;

type AxUnitDecorator = class(Ax)
public
	function Create(_obj: Ax);
	function GetObject();
	function Convert();
private
	object_: Ax;
end;

type NumFmtUnitDecorator = class(NumFmt)
public
	function Create(_obj: NumFmt);
	function GetObject();
	function Convert();
private
	object_: NumFmt;
end;

type ScalingUnitDecorator = class(Scaling)
public
	function Create(_obj: Scaling);
	function GetObject();
	function Convert();
private
	object_: Scaling;
end;

type DTableUnitDecorator = class(DTable)
public
	function Create(_obj: DTable);
	function GetObject();
	function Convert();
private
	object_: DTable;
end;

type TxPrUnitDecorator = class(TxPr)
public
	function Create(_obj: TxPr);
	function GetObject();
	function Convert();
private
	object_: TxPr;
end;

type TitleUnitDecorator = class(Title)
public
	function Create(_obj: Title);
	function GetObject();
	function Convert();
private
	object_: Title;
end;

type TxUnitDecorator = class(Tx)
public
	function Create(_obj: Tx);
	function GetObject();
	function Convert();
private
	object_: Tx;
end;

type RichUnitDecorator = class(Rich)
public
	function Create(_obj: Rich);
	function GetObject();
	function Convert();
private
	object_: Rich;
end;

type BodyPrUnitDecorator = class(BodyPr)
public
	function Create(_obj: BodyPr);
	function GetObject();
	function Convert();
private
	object_: BodyPr;
end;

type PrstTxWrapUnitDecorator = class(PrstTxWrap)
public
	function Create(_obj: PrstTxWrap);
	function GetObject();
	function Convert();
private
	object_: PrstTxWrap;
end;

type PUnitDecorator = class(P)
public
	function Create(_obj: P);
	function GetObject();
	function Convert();
private
	object_: P;
end;

type RPrUnitDecorator = class(RPr)
public
	function Create(_obj: RPr);
	function GetObject();
	function Convert();
private
	object_: RPr;
end;

type PPrUnitDecorator = class(PPr)
public
	function Create(_obj: PPr);
	function GetObject();
	function Convert();
private
	object_: PPr;
end;

type LatinUnitDecorator = class(Latin)
public
	function Create(_obj: Latin);
	function GetObject();
	function Convert();
private
	object_: Latin;
end;

type RUnitDecorator = class(R)
public
	function Create(_obj: R);
	function GetObject();
	function Convert();
private
	object_: R;
end;

type ExternalDataUnitDecorator = class(ExternalData)
public
	function Create(_obj: ExternalData);
	function GetObject();
	function Convert();
private
	object_: ExternalData;
end;

type _InlineUnitDecorator = class(_Inline)
public
	function Create(_obj: _Inline);
	function GetObject();
	function Convert();
private
	object_: _Inline;
end;

type EffectExtentUnitDecorator = class(EffectExtent)
public
	function Create(_obj: EffectExtent);
	function GetObject();
	function Convert();
private
	object_: EffectExtent;
end;

type DocPrUnitDecorator = class(DocPr)
public
	function Create(_obj: DocPr);
	function GetObject();
	function Convert();
private
	object_: DocPr;
end;

type CNvGraphicFramePrUnitDecorator = class(CNvGraphicFramePr)
public
	function Create(_obj: CNvGraphicFramePr);
	function GetObject();
	function Convert();
private
	object_: CNvGraphicFramePr;
end;

type GraphicFrameLocksUnitDecorator = class(GraphicFrameLocks)
public
	function Create(_obj: GraphicFrameLocks);
	function GetObject();
	function Convert();
private
	object_: GraphicFrameLocks;
end;

type GraphicUnitDecorator = class(Graphic)
public
	function Create(_obj: Graphic);
	function GetObject();
	function Convert();
private
	object_: Graphic;
end;

type GraphicDataUnitDecorator = class(GraphicData)
public
	function Create(_obj: GraphicData);
	function GetObject();
	function Convert();
private
	object_: GraphicData;
end;

type WspUnitDecorator = class(Wsp)
public
	function Create(_obj: Wsp);
	function GetObject();
	function Convert();
private
	object_: Wsp;
end;

type WpsStyleUnitDecorator = class(WpsStyle)
public
	function Create(_obj: WpsStyle);
	function GetObject();
	function Convert();
private
	object_: WpsStyle;
end;

type XRefUnitDecorator = class(XRef)
public
	function Create(_obj: XRef);
	function GetObject();
	function Convert();
private
	object_: XRef;
end;

type TxbxUnitDecorator = class(Txbx)
public
	function Create(_obj: Txbx);
	function GetObject();
	function Convert();
private
	object_: Txbx;
end;

type CNvSpPrUnitDecorator = class(CNvSpPr)
public
	function Create(_obj: CNvSpPr);
	function GetObject();
	function Convert();
private
	object_: CNvSpPr;
end;

type SpLocksUnitDecorator = class(SpLocks)
public
	function Create(_obj: SpLocks);
	function GetObject();
	function Convert();
private
	object_: SpLocks;
end;

type PicUnitDecorator = class(Pic)
public
	function Create(_obj: Pic);
	function GetObject();
	function Convert();
private
	object_: Pic;
end;

type NvPicPrUnitDecorator = class(NvPicPr)
public
	function Create(_obj: NvPicPr);
	function GetObject();
	function Convert();
private
	object_: NvPicPr;
end;

type CNvPrUnitDecorator = class(CNvPr)
public
	function Create(_obj: CNvPr);
	function GetObject();
	function Convert();
private
	object_: CNvPr;
end;

type CNvPicPrUnitDecorator = class(CNvPicPr)
public
	function Create(_obj: CNvPicPr);
	function GetObject();
	function Convert();
private
	object_: CNvPicPr;
end;

type PicLocksUnitDecorator = class(PicLocks)
public
	function Create(_obj: PicLocks);
	function GetObject();
	function Convert();
private
	object_: PicLocks;
end;

type BlipFillUnitDecorator = class(BlipFill)
public
	function Create(_obj: BlipFill);
	function GetObject();
	function Convert();
private
	object_: BlipFill;
end;

type BlipUnitDecorator = class(Blip)
public
	function Create(_obj: Blip);
	function GetObject();
	function Convert();
private
	object_: Blip;
end;

type StretchUnitDecorator = class(Stretch)
public
	function Create(_obj: Stretch);
	function GetObject();
	function Convert();
private
	object_: Stretch;
end;

type SpPrUnitDecorator = class(SpPr)
public
	function Create(_obj: SpPr);
	function GetObject();
	function Convert();
private
	object_: SpPr;
end;

type EffectLstUnitDecorator = class(EffectLst)
public
	function Create(_obj: EffectLst);
	function GetObject();
	function Convert();
private
	object_: EffectLst;
end;

type LnUnitDecorator = class(Ln)
public
	function Create(_obj: Ln);
	function GetObject();
	function Convert();
private
	object_: Ln;
end;

type MiterUnitDecorator = class(Miter)
public
	function Create(_obj: Miter);
	function GetObject();
	function Convert();
private
	object_: Miter;
end;

type XfrmUnitDecorator = class(Xfrm)
public
	function Create(_obj: Xfrm);
	function GetObject();
	function Convert();
private
	object_: Xfrm;
end;

type XYUnitDecorator = class(XY)
public
	function Create(_obj: XY);
	function GetObject();
	function Convert();
private
	object_: XY;
end;

type CXYUnitDecorator = class(CXY)
public
	function Create(_obj: CXY);
	function GetObject();
	function Convert();
private
	object_: CXY;
end;

type PrstGeomUnitDecorator = class(PrstGeom)
public
	function Create(_obj: PrstGeom);
	function GetObject();
	function Convert();
private
	object_: PrstGeom;
end;

type AnchorUnitDecorator = class(Anchor)
public
	function Create(_obj: Anchor);
	function GetObject();
	function Convert();
private
	object_: Anchor;
end;

type PositionVUnitDecorator = class(PositionV)
public
	function Create(_obj: PositionV);
	function GetObject();
	function Convert();
private
	object_: PositionV;
end;

type PositionHUnitDecorator = class(PositionH)
public
	function Create(_obj: PositionH);
	function GetObject();
	function Convert();
private
	object_: PositionH;
end;

type SizeRelHUnitDecorator = class(SizeRelH)
public
	function Create(_obj: SizeRelH);
	function GetObject();
	function Convert();
private
	object_: SizeRelH;
end;

type SizeRelVUnitDecorator = class(SizeRelV)
public
	function Create(_obj: SizeRelV);
	function GetObject();
	function Convert();
private
	object_: SizeRelV;
end;

implementation

function ThemeUnitDecorator.Create(_obj: Theme);
begin
	class(Theme).Create();
	object_ := _obj;
	{self.}Convert();
end;

function ThemeUnitDecorator.GetObject();
begin
	return object_;
end;

function ThemeUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrName) then
		{self.}Name := object_.XmlAttrName.Value;
	if not ifnil(object_.XmlChildThemeElements) then
		{self.}XmlChildThemeElements := new ThemeElementsUnitDecorator(object_.XmlChildThemeElements);
	if not ifnil(object_.XmlChildObjectDefaults) then
		{self.}ObjectDefaults.Copy(object_.XmlChildObjectDefaults);
	if not ifnil(object_.XmlChildExtraClrSchemeLst) then
		{self.}ExtraClrSchemeLst.Copy(object_.XmlChildExtraClrSchemeLst);
	if not ifnil(object_.XmlChildExtLst) then
		{self.}XmlChildExtLst := new ExtLstUnitDecorator(object_.XmlChildExtLst);
	tslassigning := tslassigning_backup;
end;

function ThemeElementsUnitDecorator.Create(_obj: ThemeElements);
begin
	class(ThemeElements).Create();
	object_ := _obj;
	{self.}Convert();
end;

function ThemeElementsUnitDecorator.GetObject();
begin
	return object_;
end;

function ThemeElementsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrName) then
		{self.}Name := object_.XmlAttrName.Value;
	if not ifnil(object_.XmlChildClrScheme) then
		{self.}XmlChildClrScheme := new ClrSchemeUnitDecorator(object_.XmlChildClrScheme);
	if not ifnil(object_.XmlChildFontScheme) then
		{self.}XmlChildFontScheme := new FontSchemeUnitDecorator(object_.XmlChildFontScheme);
	if not ifnil(object_.XmlChildFmtScheme) then
		{self.}XmlChildFmtScheme := new FmtSchemeUnitDecorator(object_.XmlChildFmtScheme);
	tslassigning := tslassigning_backup;
end;

function ClrSchemeUnitDecorator.Create(_obj: ClrScheme);
begin
	class(ClrScheme).Create();
	object_ := _obj;
	{self.}Convert();
end;

function ClrSchemeUnitDecorator.GetObject();
begin
	return object_;
end;

function ClrSchemeUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrName) then
		{self.}Name := object_.XmlAttrName.Value;
	if not ifnil(object_.XmlChildDk1) then
		{self.}XmlChildDk1 := new Clr1UnitDecorator(object_.XmlChildDk1);
	if not ifnil(object_.XmlChildLt1) then
		{self.}XmlChildLt1 := new Clr1UnitDecorator(object_.XmlChildLt1);
	if not ifnil(object_.XmlChildDk2) then
		{self.}XmlChildDk2 := new Clr2UnitDecorator(object_.XmlChildDk2);
	if not ifnil(object_.XmlChildLt2) then
		{self.}XmlChildLt2 := new Clr2UnitDecorator(object_.XmlChildLt2);
	if not ifnil(object_.XmlChildAccent1) then
		{self.}XmlChildAccent1 := new Clr2UnitDecorator(object_.XmlChildAccent1);
	if not ifnil(object_.XmlChildAccent2) then
		{self.}XmlChildAccent2 := new Clr2UnitDecorator(object_.XmlChildAccent2);
	if not ifnil(object_.XmlChildAccent3) then
		{self.}XmlChildAccent3 := new Clr2UnitDecorator(object_.XmlChildAccent3);
	if not ifnil(object_.XmlChildAccent4) then
		{self.}XmlChildAccent4 := new Clr2UnitDecorator(object_.XmlChildAccent4);
	if not ifnil(object_.XmlChildAccent5) then
		{self.}XmlChildAccent5 := new Clr2UnitDecorator(object_.XmlChildAccent5);
	if not ifnil(object_.XmlChildAccent6) then
		{self.}XmlChildAccent6 := new Clr2UnitDecorator(object_.XmlChildAccent6);
	if not ifnil(object_.XmlChildHlink) then
		{self.}XmlChildHlink := new Clr2UnitDecorator(object_.XmlChildHlink);
	if not ifnil(object_.XmlChildFolHlink) then
		{self.}XmlChildFolHlink := new Clr2UnitDecorator(object_.XmlChildFolHlink);
	tslassigning := tslassigning_backup;
end;

function Clr1UnitDecorator.Create(_obj: Clr1);
begin
	class(Clr1).Create();
	object_ := _obj;
	{self.}Convert();
end;

function Clr1UnitDecorator.GetObject();
begin
	return object_;
end;

function Clr1UnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildSysClr) then
		{self.}XmlChildSysClr := new SysClrUnitDecorator(object_.XmlChildSysClr);
	tslassigning := tslassigning_backup;
end;

function SysClrUnitDecorator.Create(_obj: SysClr);
begin
	class(SysClr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SysClrUnitDecorator.GetObject();
begin
	return object_;
end;

function SysClrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrVal) then
		{self.}Val := object_.XmlAttrVal.Value;
	if not ifnil(object_.XmlAttrLastClr) then
		{self.}LastClr := object_.XmlAttrLastClr.Value;
	tslassigning := tslassigning_backup;
end;

function Clr2UnitDecorator.Create(_obj: Clr2);
begin
	class(Clr2).Create();
	object_ := _obj;
	{self.}Convert();
end;

function Clr2UnitDecorator.GetObject();
begin
	return object_;
end;

function Clr2UnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildSrgbClr) then
		{self.}XmlChildSrgbClr := new SrgbClrUnitDecorator(object_.XmlChildSrgbClr);
	tslassigning := tslassigning_backup;
end;

function SrgbClrUnitDecorator.Create(_obj: SrgbClr);
begin
	class(SrgbClr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SrgbClrUnitDecorator.GetObject();
begin
	return object_;
end;

function SrgbClrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrVal) then
		{self.}Val := object_.XmlAttrVal.Value;
	if not ifnil(object_.XmlChildAlpha) then
		{self.}XmlChildAlpha := new PureValUnitDecorator(object_.XmlChildAlpha);
	tslassigning := tslassigning_backup;
end;

function PureValUnitDecorator.Create(_obj: PureVal);
begin
	class(PureVal).Create();
	object_ := _obj;
	{self.}Convert();
end;

function PureValUnitDecorator.GetObject();
begin
	return object_;
end;

function PureValUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrVal) then
		{self.}Val := object_.XmlAttrVal.Value;
	tslassigning := tslassigning_backup;
end;

function FontSchemeUnitDecorator.Create(_obj: FontScheme);
begin
	class(FontScheme).Create();
	object_ := _obj;
	{self.}Convert();
end;

function FontSchemeUnitDecorator.GetObject();
begin
	return object_;
end;

function FontSchemeUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrName) then
		{self.}Name := object_.XmlAttrName.Value;
	if not ifnil(object_.XmlChildMajorfont) then
		{self.}XmlChildMajorfont := new MfontUnitDecorator(object_.XmlChildMajorfont);
	if not ifnil(object_.XmlChildMinorfont) then
		{self.}XmlChildMinorfont := new MfontUnitDecorator(object_.XmlChildMinorfont);
	tslassigning := tslassigning_backup;
end;

function MFontUnitDecorator.Create(_obj: MFont);
begin
	class(MFont).Create();
	object_ := _obj;
	{self.}Convert();
end;

function MFontUnitDecorator.GetObject();
begin
	return object_;
end;

function MFontUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildLatin) then
		{self.}XmlChildLatin := new LatinUnitDecorator(object_.XmlChildLatin);
	if not ifnil(object_.XmlChildEa) then
		{self.}XmlChildEa := new LatinUnitDecorator(object_.XmlChildEa);
	if not ifnil(object_.XmlChildCs) then
		{self.}XmlChildCs := new LatinUnitDecorator(object_.XmlChildCs);
	elems := object_.Fonts();
	for _,elem in elems do
		{self.}AppendChild(new FontUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function FontUnitDecorator.Create(_obj: Font);
begin
	class(Font).Create();
	object_ := _obj;
	{self.}Convert();
end;

function FontUnitDecorator.GetObject();
begin
	return object_;
end;

function FontUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrScript) then
		{self.}Script := object_.XmlAttrScript.Value;
	if not ifnil(object_.XmlAttrTypeface) then
		{self.}Typeface := object_.XmlAttrTypeface.Value;
	tslassigning := tslassigning_backup;
end;

function FmtSchemeUnitDecorator.Create(_obj: FmtScheme);
begin
	class(FmtScheme).Create();
	object_ := _obj;
	{self.}Convert();
end;

function FmtSchemeUnitDecorator.GetObject();
begin
	return object_;
end;

function FmtSchemeUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrName) then
		{self.}Name := object_.XmlAttrName.Value;
	if not ifnil(object_.XmlChildFillStyleLst) then
		{self.}XmlChildFillStyleLst := new FillStyleLstUnitDecorator(object_.XmlChildFillStyleLst);
	if not ifnil(object_.XmlChildLnStyleLst) then
		{self.}XmlChildLnStyleLst := new LnStyleLstUnitDecorator(object_.XmlChildLnStyleLst);
	if not ifnil(object_.XmlChildEffectStyleLst) then
		{self.}XmlChildEffectStyleLst := new EffectStyleLstUnitDecorator(object_.XmlChildEffectStyleLst);
	if not ifnil(object_.XmlChildBgFillStyleLst) then
		{self.}XmlChildBgFillStyleLst := new FillStyleLstUnitDecorator(object_.XmlChildBgFillStyleLst);
	tslassigning := tslassigning_backup;
end;

function FillStyleLstUnitDecorator.Create(_obj: FillStyleLst);
begin
	class(FillStyleLst).Create();
	object_ := _obj;
	{self.}Convert();
end;

function FillStyleLstUnitDecorator.GetObject();
begin
	return object_;
end;

function FillStyleLstUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.SolidFills();
	for _,elem in elems do
		{self.}AppendChild(new SolidFillUnitDecorator(elem));
	elems := object_.GradFills();
	for _,elem in elems do
		{self.}AppendChild(new GradFillUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function SolidFillUnitDecorator.Create(_obj: SolidFill);
begin
	class(SolidFill).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SolidFillUnitDecorator.GetObject();
begin
	return object_;
end;

function SolidFillUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildSchemeClr) then
		{self.}XmlChildSchemeClr := new SchemeClrUnitDecorator(object_.XmlChildSchemeClr);
	tslassigning := tslassigning_backup;
end;

function SchemeClrUnitDecorator.Create(_obj: SchemeClr);
begin
	class(SchemeClr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SchemeClrUnitDecorator.GetObject();
begin
	return object_;
end;

function SchemeClrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrVal) then
		{self.}Val := object_.XmlAttrVal.Value;
	if not ifnil(object_.XmlChildLumMod) then
		{self.}XmlChildLumMod := new PureValUnitDecorator(object_.XmlChildLumMod);
	if not ifnil(object_.XmlChildSatMod) then
		{self.}XmlChildSatMod := new PureValUnitDecorator(object_.XmlChildSatMod);
	if not ifnil(object_.XmlChildTint) then
		{self.}XmlChildTint := new PureValUnitDecorator(object_.XmlChildTint);
	tslassigning := tslassigning_backup;
end;

function GradFillUnitDecorator.Create(_obj: GradFill);
begin
	class(GradFill).Create();
	object_ := _obj;
	{self.}Convert();
end;

function GradFillUnitDecorator.GetObject();
begin
	return object_;
end;

function GradFillUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrRotWithShape) then
		{self.}RotWithShape := object_.XmlAttrRotWithShape.Value;
	if not ifnil(object_.XmlChildGsLst) then
		{self.}XmlChildGsLst := new GsLstUnitDecorator(object_.XmlChildGsLst);
	if not ifnil(object_.XmlChildLin) then
		{self.}XmlChildLin := new LinUnitDecorator(object_.XmlChildLin);
	tslassigning := tslassigning_backup;
end;

function GsLstUnitDecorator.Create(_obj: GsLst);
begin
	class(GsLst).Create();
	object_ := _obj;
	{self.}Convert();
end;

function GsLstUnitDecorator.GetObject();
begin
	return object_;
end;

function GsLstUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Gses();
	for _,elem in elems do
		{self.}AppendChild(new GsUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function GsUnitDecorator.Create(_obj: Gs);
begin
	class(Gs).Create();
	object_ := _obj;
	{self.}Convert();
end;

function GsUnitDecorator.GetObject();
begin
	return object_;
end;

function GsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrPos) then
		{self.}Pos := object_.XmlAttrPos.Value;
	if not ifnil(object_.XmlChildSchemeClr) then
		{self.}XmlChildSchemeClr := new SchemeClrUnitDecorator(object_.XmlChildSchemeClr);
	tslassigning := tslassigning_backup;
end;

function LinUnitDecorator.Create(_obj: Lin);
begin
	class(Lin).Create();
	object_ := _obj;
	{self.}Convert();
end;

function LinUnitDecorator.GetObject();
begin
	return object_;
end;

function LinUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrAng) then
		{self.}Ang := object_.XmlAttrAng.Value;
	if not ifnil(object_.XmlAttrScaled) then
		{self.}Scaled := object_.XmlAttrScaled.Value;
	tslassigning := tslassigning_backup;
end;

function LnStyleLstUnitDecorator.Create(_obj: LnStyleLst);
begin
	class(LnStyleLst).Create();
	object_ := _obj;
	{self.}Convert();
end;

function LnStyleLstUnitDecorator.GetObject();
begin
	return object_;
end;

function LnStyleLstUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Lns();
	for _,elem in elems do
		{self.}AppendChild(new LnUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function EffectStyleLstUnitDecorator.Create(_obj: EffectStyleLst);
begin
	class(EffectStyleLst).Create();
	object_ := _obj;
	{self.}Convert();
end;

function EffectStyleLstUnitDecorator.GetObject();
begin
	return object_;
end;

function EffectStyleLstUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.EffectStyles();
	for _,elem in elems do
		{self.}AppendChild(new EffectStyleUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function EffectStyleUnitDecorator.Create(_obj: EffectStyle);
begin
	class(EffectStyle).Create();
	object_ := _obj;
	{self.}Convert();
end;

function EffectStyleUnitDecorator.GetObject();
begin
	return object_;
end;

function EffectStyleUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildEffectLst) then
		{self.}XmlChildEffectLst := new EffectLstUnitDecorator(object_.XmlChildEffectLst);
	tslassigning := tslassigning_backup;
end;

function OuterShdwUnitDecorator.Create(_obj: OuterShdw);
begin
	class(OuterShdw).Create();
	object_ := _obj;
	{self.}Convert();
end;

function OuterShdwUnitDecorator.GetObject();
begin
	return object_;
end;

function OuterShdwUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrBlurRad) then
		{self.}BlurRad := object_.XmlAttrBlurRad.Value;
	if not ifnil(object_.XmlAttrDist) then
		{self.}Dist := object_.XmlAttrDist.Value;
	if not ifnil(object_.XmlAttrDir) then
		{self.}Dir := object_.XmlAttrDir.Value;
	if not ifnil(object_.XmlAttrAlgn) then
		{self.}Algn := object_.XmlAttrAlgn.Value;
	if not ifnil(object_.XmlAttrRotWithShape) then
		{self.}RotWithShape := object_.XmlAttrRotWithShape.Value;
	if not ifnil(object_.XmlChildSrgbClr) then
		{self.}XmlChildSrgbClr := new SrgbClrUnitDecorator(object_.XmlChildSrgbClr);
	tslassigning := tslassigning_backup;
end;

function ExtLstUnitDecorator.Create(_obj: ExtLst);
begin
	class(ExtLst).Create();
	object_ := _obj;
	{self.}Convert();
end;

function ExtLstUnitDecorator.GetObject();
begin
	return object_;
end;

function ExtLstUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Exts();
	for _,elem in elems do
		{self.}AppendChild(new ExtUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function ExtUnitDecorator.Create(_obj: Ext);
begin
	class(Ext).Create();
	object_ := _obj;
	{self.}Convert();
end;

function ExtUnitDecorator.GetObject();
begin
	return object_;
end;

function ExtUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrUri) then
		{self.}Uri := object_.XmlAttrUri.Value;
	if not ifnil(object_.XmlChildThm15ThemeFamily) then
		{self.}XmlChildThm15ThemeFamily := new ThemeFamilyUnitDecorator(object_.XmlChildThm15ThemeFamily);
	if not ifnil(object_.XmlChildUniqueId) then
		{self.}XmlChildUniqueId := new PureValUnitDecorator(object_.XmlChildUniqueId);
	if not ifnil(object_.XmlChildSlicerStyles) then
		{self.}XmlChildSlicerStyles := new SlicerStylesUnitDecorator(object_.XmlChildSlicerStyles);
	if not ifnil(object_.XmlChildTimelineStyles) then
		{self.}XmlChildTimelineStyles := new TimelineStylesUnitDecorator(object_.XmlChildTimelineStyles);
	tslassigning := tslassigning_backup;
end;

function SlicerStylesUnitDecorator.Create(_obj: SlicerStyles);
begin
	class(SlicerStyles).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SlicerStylesUnitDecorator.GetObject();
begin
	return object_;
end;

function SlicerStylesUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrDefaultSlicerStyle) then
		{self.}DefaultSlicerStyle := object_.XmlAttrDefaultSlicerStyle.Value;
	tslassigning := tslassigning_backup;
end;

function TimelineStylesUnitDecorator.Create(_obj: TimelineStyles);
begin
	class(TimelineStyles).Create();
	object_ := _obj;
	{self.}Convert();
end;

function TimelineStylesUnitDecorator.GetObject();
begin
	return object_;
end;

function TimelineStylesUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrDefaultTimelineStyle) then
		{self.}DefaultTimelineStyle := object_.XmlAttrDefaultTimelineStyle.Value;
	tslassigning := tslassigning_backup;
end;

function ThemeFamilyUnitDecorator.Create(_obj: ThemeFamily);
begin
	class(ThemeFamily).Create();
	object_ := _obj;
	{self.}Convert();
end;

function ThemeFamilyUnitDecorator.GetObject();
begin
	return object_;
end;

function ThemeFamilyUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrName) then
		{self.}Name := object_.XmlAttrName.Value;
	if not ifnil(object_.XmlAttrId) then
		{self.}Id := object_.XmlAttrId.Value;
	if not ifnil(object_.XmlAttrVid) then
		{self.}Vid := object_.XmlAttrVid.Value;
	tslassigning := tslassigning_backup;
end;

function ChartSpaceUnitDecorator.Create(_obj: ChartSpace);
begin
	class(ChartSpace).Create();
	object_ := _obj;
	{self.}Convert();
end;

function ChartSpaceUnitDecorator.GetObject();
begin
	return object_;
end;

function ChartSpaceUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildDate1904) then
		{self.}XmlChildDate1904 := new PureValUnitDecorator(object_.XmlChildDate1904);
	if not ifnil(object_.XmlChildLang) then
		{self.}XmlChildLang := new PureValUnitDecorator(object_.XmlChildLang);
	if not ifnil(object_.XmlChildAlternateContent) then
		{self.}XmlChildAlternateContent := new AlternateContentUnitDecorator(object_.XmlChildAlternateContent);
	if not ifnil(object_.XmlChildChart) then
		{self.}XmlChildChart := new ChartUnitDecorator(object_.XmlChildChart);
	if not ifnil(object_.XmlChildSpPr) then
		{self.}XmlChildSpPr := new SpPrUnitDecorator(object_.XmlChildSpPr);
	if not ifnil(object_.XmlChildExternalData) then
		{self.}XmlChildExternalData := new ExternalDataUnitDecorator(object_.XmlChildExternalData);
	tslassigning := tslassigning_backup;
end;

function ChartUnitDecorator.Create(_obj: Chart);
begin
	class(Chart).Create();
	object_ := _obj;
	{self.}Convert();
end;

function ChartUnitDecorator.GetObject();
begin
	return object_;
end;

function ChartUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrId) then
		{self.}Id := object_.XmlAttrId.Value;
	if not ifnil(object_.XmlChildTitle) then
		{self.}XmlChildTitle := new TitleUnitDecorator(object_.XmlChildTitle);
	if not ifnil(object_.XmlChildAutoTitleDeleted) then
		{self.}XmlChildAutoTitleDeleted := new PureValUnitDecorator(object_.XmlChildAutoTitleDeleted);
	if not ifnil(object_.XmlChildView3D) then
		{self.}XmlChildView3D := new View3DUnitDecorator(object_.XmlChildView3D);
	if not ifnil(object_.XmlChildPlotArea) then
		{self.}XmlChildPlotArea := new PlotAreaUnitDecorator(object_.XmlChildPlotArea);
	if not ifnil(object_.XmlChildLegend) then
		{self.}XmlChildLegend := new LegendUnitDecorator(object_.XmlChildLegend);
	if not ifnil(object_.XmlChildPlotVisOnly) then
		{self.}XmlChildPlotVisOnly := new PureValUnitDecorator(object_.XmlChildPlotVisOnly);
	if not ifnil(object_.XmlChildDispBlanksAs) then
		{self.}XmlChildDispBlanksAs := new PureValUnitDecorator(object_.XmlChildDispBlanksAs);
	if not ifnil(object_.XmlChildShowDLblsOverMax) then
		{self.}XmlChildShowDLblsOverMax := new PureValUnitDecorator(object_.XmlChildShowDLblsOverMax);
	tslassigning := tslassigning_backup;
end;

function LegendUnitDecorator.Create(_obj: Legend);
begin
	class(Legend).Create();
	object_ := _obj;
	{self.}Convert();
end;

function LegendUnitDecorator.GetObject();
begin
	return object_;
end;

function LegendUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildLegendPos) then
		{self.}XmlChildLegendPos := new PureValUnitDecorator(object_.XmlChildLegendPos);
	if not ifnil(object_.XmlChildLayout) then
		{self.}Layout.Copy(object_.XmlChildLayout);
	if not ifnil(object_.XmlChildOverlay) then
		{self.}XmlChildOverlay := new PureValUnitDecorator(object_.XmlChildOverlay);
	if not ifnil(object_.XmlChildTxPr) then
		{self.}XmlChildTxPr := new TxPrUnitDecorator(object_.XmlChildTxPr);
	tslassigning := tslassigning_backup;
end;

function View3DUnitDecorator.Create(_obj: View3D);
begin
	class(View3D).Create();
	object_ := _obj;
	{self.}Convert();
end;

function View3DUnitDecorator.GetObject();
begin
	return object_;
end;

function View3DUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildRotX) then
		{self.}XmlChildRotX := new PureValUnitDecorator(object_.XmlChildRotX);
	if not ifnil(object_.XmlChildRotY) then
		{self.}XmlChildRotY := new PureValUnitDecorator(object_.XmlChildRotY);
	if not ifnil(object_.XmlChildRAngAx) then
		{self.}XmlChildRAngAx := new PureValUnitDecorator(object_.XmlChildRAngAx);
	tslassigning := tslassigning_backup;
end;

function PlotAreaUnitDecorator.Create(_obj: PlotArea);
begin
	class(PlotArea).Create();
	object_ := _obj;
	{self.}Convert();
end;

function PlotAreaUnitDecorator.GetObject();
begin
	return object_;
end;

function PlotAreaUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildLayout) then
		{self.}Layout.Copy(object_.XmlChildLayout);
	if not ifnil(object_.XmlChildBarChart) then
		{self.}XmlChildBarChart := new BarChartUnitDecorator(object_.XmlChildBarChart);
	if not ifnil(object_.XmlChildCatAx) then
		{self.}XmlChildCatAx := new AxUnitDecorator(object_.XmlChildCatAx);
	if not ifnil(object_.XmlChildValAx) then
		{self.}XmlChildValAx := new AxUnitDecorator(object_.XmlChildValAx);
	if not ifnil(object_.XmlChildDTable) then
		{self.}XmlChildDTable := new DTableUnitDecorator(object_.XmlChildDTable);
	if not ifnil(object_.XmlChildSpPr) then
		{self.}XmlChildSpPr := new SpPrUnitDecorator(object_.XmlChildSpPr);
	tslassigning := tslassigning_backup;
end;

function BarChartUnitDecorator.Create(_obj: BarChart);
begin
	class(BarChart).Create();
	object_ := _obj;
	{self.}Convert();
end;

function BarChartUnitDecorator.GetObject();
begin
	return object_;
end;

function BarChartUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildBarDir) then
		{self.}XmlChildBarDir := new PureValUnitDecorator(object_.XmlChildBarDir);
	if not ifnil(object_.XmlChildGrouping) then
		{self.}XmlChildGrouping := new PureValUnitDecorator(object_.XmlChildGrouping);
	if not ifnil(object_.XmlChildVaryColors) then
		{self.}XmlChildVaryColors := new PureValUnitDecorator(object_.XmlChildVaryColors);
	elems := object_.Sers();
	for _,elem in elems do
		{self.}AppendChild(new SerUnitDecorator(elem));
	if not ifnil(object_.XmlChildGapWidth) then
		{self.}XmlChildGapWidth := new PureValUnitDecorator(object_.XmlChildGapWidth);
	elems := object_.AxIds();
	for _,elem in elems do
		{self.}AppendChild(new PureValUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function SerUnitDecorator.Create(_obj: Ser);
begin
	class(Ser).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SerUnitDecorator.GetObject();
begin
	return object_;
end;

function SerUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildIdx) then
		{self.}XmlChildIdx := new PureValUnitDecorator(object_.XmlChildIdx);
	if not ifnil(object_.XmlChild_Order) then
		{self.}XmlChild_Order := new PureValUnitDecorator(object_.XmlChild_Order);
	if not ifnil(object_.XmlChildTx) then
		{self.}XmlChildTx := new TxUnitDecorator(object_.XmlChildTx);
	if not ifnil(object_.XmlChildInvertIfNegative) then
		{self.}XmlChildInvertIfNegative := new PureValUnitDecorator(object_.XmlChildInvertIfNegative);
	if not ifnil(object_.XmlChildDLbls) then
		{self.}XmlChildDLbls := new DLblsUnitDecorator(object_.XmlChildDLbls);
	if not ifnil(object_.XmlChildCat) then
		{self.}XmlChildCat := new CatUnitDecorator(object_.XmlChildCat);
	if not ifnil(object_.XmlChildVal) then
		{self.}XmlChildVal := new ValUnitDecorator(object_.XmlChildVal);
	if not ifnil(object_.XmlChildExtLst) then
		{self.}XmlChildExtLst := new ExtLstUnitDecorator(object_.XmlChildExtLst);
	tslassigning := tslassigning_backup;
end;

function DLblsUnitDecorator.Create(_obj: DLbls);
begin
	class(DLbls).Create();
	object_ := _obj;
	{self.}Convert();
end;

function DLblsUnitDecorator.GetObject();
begin
	return object_;
end;

function DLblsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildSpPr) then
		{self.}XmlChildSpPr := new SpPrUnitDecorator(object_.XmlChildSpPr);
	if not ifnil(object_.XmlChildShowLegendKey) then
		{self.}XmlChildShowLegendKey := new PureValUnitDecorator(object_.XmlChildShowLegendKey);
	if not ifnil(object_.XmlChildShowVal) then
		{self.}XmlChildShowVal := new PureValUnitDecorator(object_.XmlChildShowVal);
	if not ifnil(object_.XmlChildShowCatName) then
		{self.}XmlChildShowCatName := new PureValUnitDecorator(object_.XmlChildShowCatName);
	if not ifnil(object_.XmlChildShowSerName) then
		{self.}XmlChildShowSerName := new PureValUnitDecorator(object_.XmlChildShowSerName);
	if not ifnil(object_.XmlChildShowPercent) then
		{self.}XmlChildShowPercent := new PureValUnitDecorator(object_.XmlChildShowPercent);
	if not ifnil(object_.XmlChildShowBubbleSize) then
		{self.}XmlChildShowBubbleSize := new PureValUnitDecorator(object_.XmlChildShowBubbleSize);
	if not ifnil(object_.XmlChildShowLeaderLines) then
		{self.}XmlChildShowLeaderLines := new PureValUnitDecorator(object_.XmlChildShowLeaderLines);
	if not ifnil(object_.XmlChildExtLst) then
		{self.}XmlChildExtLst := new ExtLstUnitDecorator(object_.XmlChildExtLst);
	tslassigning := tslassigning_backup;
end;

function CatUnitDecorator.Create(_obj: Cat);
begin
	class(Cat).Create();
	object_ := _obj;
	{self.}Convert();
end;

function CatUnitDecorator.GetObject();
begin
	return object_;
end;

function CatUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildStrRef) then
		{self.}XmlChildStrRef := new StrRefUnitDecorator(object_.XmlChildStrRef);
	tslassigning := tslassigning_backup;
end;

function StrRefUnitDecorator.Create(_obj: StrRef);
begin
	class(StrRef).Create();
	object_ := _obj;
	{self.}Convert();
end;

function StrRefUnitDecorator.GetObject();
begin
	return object_;
end;

function StrRefUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildF) then
	if not ifnil(object_.XmlChildStrCache) then
		{self.}XmlChildStrCache := new StrCacheUnitDecorator(object_.XmlChildStrCache);
	tslassigning := tslassigning_backup;
end;

function ValUnitDecorator.Create(_obj: Val);
begin
	class(Val).Create();
	object_ := _obj;
	{self.}Convert();
end;

function ValUnitDecorator.GetObject();
begin
	return object_;
end;

function ValUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildNumRef) then
		{self.}XmlChildNumRef := new NumRefUnitDecorator(object_.XmlChildNumRef);
	tslassigning := tslassigning_backup;
end;

function NumRefUnitDecorator.Create(_obj: NumRef);
begin
	class(NumRef).Create();
	object_ := _obj;
	{self.}Convert();
end;

function NumRefUnitDecorator.GetObject();
begin
	return object_;
end;

function NumRefUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildF) then
	if not ifnil(object_.XmlChildNumCache) then
		{self.}XmlChildNumCache := new NumCacheUnitDecorator(object_.XmlChildNumCache);
	tslassigning := tslassigning_backup;
end;

function StrCacheUnitDecorator.Create(_obj: StrCache);
begin
	class(StrCache).Create();
	object_ := _obj;
	{self.}Convert();
end;

function StrCacheUnitDecorator.GetObject();
begin
	return object_;
end;

function StrCacheUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildPtCount) then
		{self.}XmlChildPtCount := new PureValUnitDecorator(object_.XmlChildPtCount);
	elems := object_.Pts();
	for _,elem in elems do
		{self.}AppendChild(new PtUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function NumCacheUnitDecorator.Create(_obj: NumCache);
begin
	class(NumCache).Create();
	object_ := _obj;
	{self.}Convert();
end;

function NumCacheUnitDecorator.GetObject();
begin
	return object_;
end;

function NumCacheUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildFormatCode) then
	if not ifnil(object_.XmlChildPtCount) then
		{self.}XmlChildPtCount := new PureValUnitDecorator(object_.XmlChildPtCount);
	elems := object_.Pts();
	for _,elem in elems do
		{self.}AppendChild(new PtUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function PtUnitDecorator.Create(_obj: Pt);
begin
	class(Pt).Create();
	object_ := _obj;
	{self.}Convert();
end;

function PtUnitDecorator.GetObject();
begin
	return object_;
end;

function PtUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrIdx) then
		{self.}Idx := object_.XmlAttrIdx.Value;
	if not ifnil(object_.XmlChildV) then
	tslassigning := tslassigning_backup;
end;

function AxUnitDecorator.Create(_obj: Ax);
begin
	class(Ax).Create();
	object_ := _obj;
	{self.}Convert();
end;

function AxUnitDecorator.GetObject();
begin
	return object_;
end;

function AxUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildAxId) then
		{self.}XmlChildAxId := new PureValUnitDecorator(object_.XmlChildAxId);
	if not ifnil(object_.XmlChildScaling) then
		{self.}XmlChildScaling := new ScalingUnitDecorator(object_.XmlChildScaling);
	if not ifnil(object_.XmlChild_Delete) then
		{self.}XmlChild_Delete := new PureValUnitDecorator(object_.XmlChild_Delete);
	if not ifnil(object_.XmlChildAxPos) then
		{self.}XmlChildAxPos := new PureValUnitDecorator(object_.XmlChildAxPos);
	if not ifnil(object_.XmlChildNumFmt) then
		{self.}XmlChildNumFmt := new NumFmtUnitDecorator(object_.XmlChildNumFmt);
	if not ifnil(object_.XmlChildMajorTickMark) then
		{self.}XmlChildMajorTickMark := new PureValUnitDecorator(object_.XmlChildMajorTickMark);
	if not ifnil(object_.XmlChildMinorTickMark) then
		{self.}XmlChildMinorTickMark := new PureValUnitDecorator(object_.XmlChildMinorTickMark);
	if not ifnil(object_.XmlChildTickLblPos) then
		{self.}XmlChildTickLblPos := new PureValUnitDecorator(object_.XmlChildTickLblPos);
	if not ifnil(object_.XmlChildSpPr) then
		{self.}XmlChildSpPr := new SpPrUnitDecorator(object_.XmlChildSpPr);
	if not ifnil(object_.XmlChildTxPr) then
		{self.}XmlChildTxPr := new TxPrUnitDecorator(object_.XmlChildTxPr);
	if not ifnil(object_.XmlChildCrossAx) then
		{self.}XmlChildCrossAx := new PureValUnitDecorator(object_.XmlChildCrossAx);
	if not ifnil(object_.XmlChildCrosses) then
		{self.}XmlChildCrosses := new PureValUnitDecorator(object_.XmlChildCrosses);
	if not ifnil(object_.XmlChildCrossBetween) then
		{self.}XmlChildCrossBetween := new PureValUnitDecorator(object_.XmlChildCrossBetween);
	if not ifnil(object_.XmlChildAuto) then
		{self.}XmlChildAuto := new PureValUnitDecorator(object_.XmlChildAuto);
	if not ifnil(object_.XmlChildLblAlgn) then
		{self.}XmlChildLblAlgn := new PureValUnitDecorator(object_.XmlChildLblAlgn);
	if not ifnil(object_.XmlChildLblOffset) then
		{self.}XmlChildLblOffset := new PureValUnitDecorator(object_.XmlChildLblOffset);
	if not ifnil(object_.XmlChildNoMultiLvlLbl) then
		{self.}XmlChildNoMultiLvlLbl := new PureValUnitDecorator(object_.XmlChildNoMultiLvlLbl);
	tslassigning := tslassigning_backup;
end;

function NumFmtUnitDecorator.Create(_obj: NumFmt);
begin
	class(NumFmt).Create();
	object_ := _obj;
	{self.}Convert();
end;

function NumFmtUnitDecorator.GetObject();
begin
	return object_;
end;

function NumFmtUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrFormatCode) then
		{self.}FormatCode := object_.XmlAttrFormatCode.Value;
	if not ifnil(object_.XmlAttrSourceLinked) then
		{self.}SourceLinked := object_.XmlAttrSourceLinked.Value;
	tslassigning := tslassigning_backup;
end;

function ScalingUnitDecorator.Create(_obj: Scaling);
begin
	class(Scaling).Create();
	object_ := _obj;
	{self.}Convert();
end;

function ScalingUnitDecorator.GetObject();
begin
	return object_;
end;

function ScalingUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildOrientation) then
		{self.}XmlChildOrientation := new PureValUnitDecorator(object_.XmlChildOrientation);
	tslassigning := tslassigning_backup;
end;

function DTableUnitDecorator.Create(_obj: DTable);
begin
	class(DTable).Create();
	object_ := _obj;
	{self.}Convert();
end;

function DTableUnitDecorator.GetObject();
begin
	return object_;
end;

function DTableUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildShowHorzBorder) then
		{self.}XmlChildShowHorzBorder := new PureValUnitDecorator(object_.XmlChildShowHorzBorder);
	if not ifnil(object_.XmlChildShowVertBorder) then
		{self.}XmlChildShowVertBorder := new PureValUnitDecorator(object_.XmlChildShowVertBorder);
	if not ifnil(object_.XmlChildShowOutline) then
		{self.}XmlChildShowOutline := new PureValUnitDecorator(object_.XmlChildShowOutline);
	if not ifnil(object_.XmlChildShowKeys) then
		{self.}XmlChildShowKeys := new PureValUnitDecorator(object_.XmlChildShowKeys);
	if not ifnil(object_.XmlChildTxPr) then
		{self.}XmlChildTxPr := new TxPrUnitDecorator(object_.XmlChildTxPr);
	tslassigning := tslassigning_backup;
end;

function TxPrUnitDecorator.Create(_obj: TxPr);
begin
	class(TxPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function TxPrUnitDecorator.GetObject();
begin
	return object_;
end;

function TxPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildBodyPr) then
		{self.}XmlChildBodyPr := new BodyPrUnitDecorator(object_.XmlChildBodyPr);
	if not ifnil(object_.XmlChildLstStyle) then
		{self.}LstStyle.Copy(object_.XmlChildLstStyle);
	elems := object_.Ps();
	for _,elem in elems do
		{self.}AppendChild(new PUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function TitleUnitDecorator.Create(_obj: Title);
begin
	class(Title).Create();
	object_ := _obj;
	{self.}Convert();
end;

function TitleUnitDecorator.GetObject();
begin
	return object_;
end;

function TitleUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildTx) then
		{self.}XmlChildTx := new TxUnitDecorator(object_.XmlChildTx);
	if not ifnil(object_.XmlChildLayout) then
		{self.}Layout.Copy(object_.XmlChildLayout);
	if not ifnil(object_.XmlChildOverlay) then
		{self.}XmlChildOverlay := new PureValUnitDecorator(object_.XmlChildOverlay);
	tslassigning := tslassigning_backup;
end;

function TxUnitDecorator.Create(_obj: Tx);
begin
	class(Tx).Create();
	object_ := _obj;
	{self.}Convert();
end;

function TxUnitDecorator.GetObject();
begin
	return object_;
end;

function TxUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildStrRef) then
		{self.}XmlChildStrRef := new StrRefUnitDecorator(object_.XmlChildStrRef);
	if not ifnil(object_.XmlChildRich) then
		{self.}XmlChildRich := new RichUnitDecorator(object_.XmlChildRich);
	tslassigning := tslassigning_backup;
end;

function RichUnitDecorator.Create(_obj: Rich);
begin
	class(Rich).Create();
	object_ := _obj;
	{self.}Convert();
end;

function RichUnitDecorator.GetObject();
begin
	return object_;
end;

function RichUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildBodyPr) then
		{self.}XmlChildBodyPr := new BodyPrUnitDecorator(object_.XmlChildBodyPr);
	if not ifnil(object_.XmlChildLstStyle) then
		{self.}LstStyle.Copy(object_.XmlChildLstStyle);
	elems := object_.Ps();
	for _,elem in elems do
		{self.}AppendChild(new PUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function BodyPrUnitDecorator.Create(_obj: BodyPr);
begin
	class(BodyPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function BodyPrUnitDecorator.GetObject();
begin
	return object_;
end;

function BodyPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrRot) then
		{self.}Rot := object_.XmlAttrRot.Value;
	if not ifnil(object_.XmlAttrSpcFirstLastPara) then
		{self.}SpcFirstLastPara := object_.XmlAttrSpcFirstLastPara.Value;
	if not ifnil(object_.XmlAttrVertOverflow) then
		{self.}VertOverflow := object_.XmlAttrVertOverflow.Value;
	if not ifnil(object_.XmlAttrHorzOverflow) then
		{self.}HorzOverflow := object_.XmlAttrHorzOverflow.Value;
	if not ifnil(object_.XmlAttrVert) then
		{self.}Vert := object_.XmlAttrVert.Value;
	if not ifnil(object_.XmlAttrWrap) then
		{self.}Wrap := object_.XmlAttrWrap.Value;
	if not ifnil(object_.XmlAttrLIns) then
		{self.}LIns := TSSafeUnitConverter.EmusToPoints(object_.XmlAttrLIns.Value);
	if not ifnil(object_.XmlAttrTIns) then
		{self.}TIns := TSSafeUnitConverter.EmusToPoints(object_.XmlAttrTIns.Value);
	if not ifnil(object_.XmlAttrRIns) then
		{self.}RIns := TSSafeUnitConverter.EmusToPoints(object_.XmlAttrRIns.Value);
	if not ifnil(object_.XmlAttrBIns) then
		{self.}BIns := TSSafeUnitConverter.EmusToPoints(object_.XmlAttrBIns.Value);
	if not ifnil(object_.XmlAttrNumCol) then
		{self.}NumCol := object_.XmlAttrNumCol.Value;
	if not ifnil(object_.XmlAttrSpcCol) then
		{self.}SpcCol := object_.XmlAttrSpcCol.Value;
	if not ifnil(object_.XmlAttrRtlCol) then
		{self.}RtlCol := object_.XmlAttrRtlCol.Value;
	if not ifnil(object_.XmlAttrFromWordArt) then
		{self.}FromWordArt := object_.XmlAttrFromWordArt.Value;
	if not ifnil(object_.XmlAttrAnchor) then
		{self.}Anchor := object_.XmlAttrAnchor.Value;
	if not ifnil(object_.XmlAttrAnchorCtr) then
		{self.}AnchorCtr := object_.XmlAttrAnchorCtr.Value;
	if not ifnil(object_.XmlAttrForceAA) then
		{self.}ForceAA := object_.XmlAttrForceAA.Value;
	if not ifnil(object_.XmlAttrCompatLnSpc) then
		{self.}CompatLnSpc := object_.XmlAttrCompatLnSpc.Value;
	if not ifnil(object_.XmlChildPrstTxWrap) then
		{self.}XmlChildPrstTxWrap := new PrstTxWrapUnitDecorator(object_.XmlChildPrstTxWrap);
	if not ifnil(object_.XmlChildNoAutofit) then
		{self.}NoAutofit.Copy(object_.XmlChildNoAutofit);
	tslassigning := tslassigning_backup;
end;

function PrstTxWrapUnitDecorator.Create(_obj: PrstTxWrap);
begin
	class(PrstTxWrap).Create();
	object_ := _obj;
	{self.}Convert();
end;

function PrstTxWrapUnitDecorator.GetObject();
begin
	return object_;
end;

function PrstTxWrapUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrPrst) then
		{self.}Prst := object_.XmlAttrPrst.Value;
	if not ifnil(object_.XmlChildAvLst) then
		{self.}AvLst.Copy(object_.XmlChildAvLst);
	tslassigning := tslassigning_backup;
end;

function PUnitDecorator.Create(_obj: P);
begin
	class(P).Create();
	object_ := _obj;
	{self.}Convert();
end;

function PUnitDecorator.GetObject();
begin
	return object_;
end;

function PUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildPPr) then
		{self.}XmlChildPPr := new PPrUnitDecorator(object_.XmlChildPPr);
	if not ifnil(object_.XmlChildEndParaRPr) then
		{self.}XmlChildEndParaRPr := new RPrUnitDecorator(object_.XmlChildEndParaRPr);
	elems := object_.Rs();
	for _,elem in elems do
		{self.}AppendChild(new RUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

function RPrUnitDecorator.Create(_obj: RPr);
begin
	class(RPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function RPrUnitDecorator.GetObject();
begin
	return object_;
end;

function RPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrLang) then
		{self.}Lang := object_.XmlAttrLang.Value;
	if not ifnil(object_.XmlAttrAltLang) then
		{self.}AltLang := object_.XmlAttrAltLang.Value;
	if not ifnil(object_.XmlAttrB) then
		{self.}B := object_.XmlAttrB.Value;
	if not ifnil(object_.XmlAttrBaseline) then
		{self.}Baseline := object_.XmlAttrBaseline.Value;
	if not ifnil(object_.XmlAttrI) then
		{self.}I := object_.XmlAttrI.Value;
	if not ifnil(object_.XmlAttrKern) then
		{self.}Kern := object_.XmlAttrKern.Value;
	if not ifnil(object_.XmlAttrSpc) then
		{self.}Spc := object_.XmlAttrSpc.Value;
	if not ifnil(object_.XmlAttrStrike) then
		{self.}Strike := object_.XmlAttrStrike.Value;
	if not ifnil(object_.XmlAttrSz) then
		{self.}Sz := object_.XmlAttrSz.Value;
	if not ifnil(object_.XmlAttrU) then
		{self.}U := object_.XmlAttrU.Value;
	if not ifnil(object_.XmlChildSolidFill) then
		{self.}XmlChildSolidFill := new SolidFillUnitDecorator(object_.XmlChildSolidFill);
	if not ifnil(object_.XmlChildLatin) then
		{self.}XmlChildLatin := new LatinUnitDecorator(object_.XmlChildLatin);
	if not ifnil(object_.XmlChildEa) then
		{self.}XmlChildEa := new LatinUnitDecorator(object_.XmlChildEa);
	if not ifnil(object_.XmlChildCs) then
		{self.}XmlChildCs := new LatinUnitDecorator(object_.XmlChildCs);
	tslassigning := tslassigning_backup;
end;

function PPrUnitDecorator.Create(_obj: PPr);
begin
	class(PPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function PPrUnitDecorator.GetObject();
begin
	return object_;
end;

function PPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildDefRPr) then
		{self.}XmlChildDefRPr := new RPrUnitDecorator(object_.XmlChildDefRPr);
	tslassigning := tslassigning_backup;
end;

function LatinUnitDecorator.Create(_obj: Latin);
begin
	class(Latin).Create();
	object_ := _obj;
	{self.}Convert();
end;

function LatinUnitDecorator.GetObject();
begin
	return object_;
end;

function LatinUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrTypeface) then
		{self.}Typeface := object_.XmlAttrTypeface.Value;
	tslassigning := tslassigning_backup;
end;

function RUnitDecorator.Create(_obj: R);
begin
	class(R).Create();
	object_ := _obj;
	{self.}Convert();
end;

function RUnitDecorator.GetObject();
begin
	return object_;
end;

function RUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildRPr) then
		{self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
	if not ifnil(object_.XmlChildT) then
		{self.}XmlChildT := new TUnitDecorator(object_.XmlChildT);
	tslassigning := tslassigning_backup;
end;

function ExternalDataUnitDecorator.Create(_obj: ExternalData);
begin
	class(ExternalData).Create();
	object_ := _obj;
	{self.}Convert();
end;

function ExternalDataUnitDecorator.GetObject();
begin
	return object_;
end;

function ExternalDataUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrId) then
		{self.}Id := object_.XmlAttrId.Value;
	if not ifnil(object_.XmlChildAutoUpdate) then
		{self.}XmlChildAutoUpdate := new PureValUnitDecorator(object_.XmlChildAutoUpdate);
	tslassigning := tslassigning_backup;
end;

function _InlineUnitDecorator.Create(_obj: _Inline);
begin
	class(_Inline).Create();
	object_ := _obj;
	{self.}Convert();
end;

function _InlineUnitDecorator.GetObject();
begin
	return object_;
end;

function _InlineUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrDistT) then
		{self.}DistT := object_.XmlAttrDistT.Value;
	if not ifnil(object_.XmlAttrDistB) then
		{self.}DistB := object_.XmlAttrDistB.Value;
	if not ifnil(object_.XmlAttrDistL) then
		{self.}DistL := object_.XmlAttrDistL.Value;
	if not ifnil(object_.XmlAttrDistR) then
		{self.}DistR := object_.XmlAttrDistR.Value;
	if not ifnil(object_.XmlAttrAnchorId) then
		{self.}AnchorId := object_.XmlAttrAnchorId.Value;
	if not ifnil(object_.XmlAttrEditId) then
		{self.}EditId := object_.XmlAttrEditId.Value;
	if not ifnil(object_.XmlChildExtent) then
		{self.}XmlChildExtent := new CXYUnitDecorator(object_.XmlChildExtent);
	if not ifnil(object_.XmlChildEffectExtent) then
		{self.}XmlChildEffectExtent := new EffectExtentUnitDecorator(object_.XmlChildEffectExtent);
	if not ifnil(object_.XmlChildDocPr) then
		{self.}XmlChildDocPr := new DocPrUnitDecorator(object_.XmlChildDocPr);
	if not ifnil(object_.XmlChildCNvGraphicFramePr) then
		{self.}XmlChildCNvGraphicFramePr := new CNvGraphicFramePrUnitDecorator(object_.XmlChildCNvGraphicFramePr);
	if not ifnil(object_.XmlChildGraphic) then
		{self.}XmlChildGraphic := new GraphicUnitDecorator(object_.XmlChildGraphic);
	tslassigning := tslassigning_backup;
end;

function EffectExtentUnitDecorator.Create(_obj: EffectExtent);
begin
	class(EffectExtent).Create();
	object_ := _obj;
	{self.}Convert();
end;

function EffectExtentUnitDecorator.GetObject();
begin
	return object_;
end;

function EffectExtentUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrL) then
		{self.}L := object_.XmlAttrL.Value;
	if not ifnil(object_.XmlAttrT) then
		{self.}T := object_.XmlAttrT.Value;
	if not ifnil(object_.XmlAttrR) then
		{self.}R := object_.XmlAttrR.Value;
	if not ifnil(object_.XmlAttrB) then
		{self.}B := object_.XmlAttrB.Value;
	tslassigning := tslassigning_backup;
end;

function DocPrUnitDecorator.Create(_obj: DocPr);
begin
	class(DocPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function DocPrUnitDecorator.GetObject();
begin
	return object_;
end;

function DocPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrId) then
		{self.}Id := object_.XmlAttrId.Value;
	if not ifnil(object_.XmlAttrName) then
		{self.}Name := object_.XmlAttrName.Value;
	if not ifnil(object_.XmlAttrDescr) then
		{self.}Descr := object_.XmlAttrDescr.Value;
	if not ifnil(object_.XmlChildExtLst) then
		{self.}XmlChildExtLst := new ExtLstUnitDecorator(object_.XmlChildExtLst);
	tslassigning := tslassigning_backup;
end;

function CNvGraphicFramePrUnitDecorator.Create(_obj: CNvGraphicFramePr);
begin
	class(CNvGraphicFramePr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function CNvGraphicFramePrUnitDecorator.GetObject();
begin
	return object_;
end;

function CNvGraphicFramePrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildGraphicFrameLocks) then
		{self.}XmlChildGraphicFrameLocks := new GraphicFrameLocksUnitDecorator(object_.XmlChildGraphicFrameLocks);
	tslassigning := tslassigning_backup;
end;

function GraphicFrameLocksUnitDecorator.Create(_obj: GraphicFrameLocks);
begin
	class(GraphicFrameLocks).Create();
	object_ := _obj;
	{self.}Convert();
end;

function GraphicFrameLocksUnitDecorator.GetObject();
begin
	return object_;
end;

function GraphicFrameLocksUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrNoChangeAspect) then
		{self.}NoChangeAspect := object_.XmlAttrNoChangeAspect.Value;
	tslassigning := tslassigning_backup;
end;

function GraphicUnitDecorator.Create(_obj: Graphic);
begin
	class(Graphic).Create();
	object_ := _obj;
	{self.}Convert();
end;

function GraphicUnitDecorator.GetObject();
begin
	return object_;
end;

function GraphicUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildGraphicData) then
		{self.}XmlChildGraphicData := new GraphicDataUnitDecorator(object_.XmlChildGraphicData);
	tslassigning := tslassigning_backup;
end;

function GraphicDataUnitDecorator.Create(_obj: GraphicData);
begin
	class(GraphicData).Create();
	object_ := _obj;
	{self.}Convert();
end;

function GraphicDataUnitDecorator.GetObject();
begin
	return object_;
end;

function GraphicDataUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrUri) then
		{self.}Uri := object_.XmlAttrUri.Value;
	if not ifnil(object_.XmlChildPic) then
		{self.}XmlChildPic := new PicUnitDecorator(object_.XmlChildPic);
	if not ifnil(object_.XmlChildChart) then
		{self.}XmlChildChart := new ChartUnitDecorator(object_.XmlChildChart);
	if not ifnil(object_.XmlChildWsp) then
		{self.}XmlChildWsp := new WspUnitDecorator(object_.XmlChildWsp);
	tslassigning := tslassigning_backup;
end;

function WspUnitDecorator.Create(_obj: Wsp);
begin
	class(Wsp).Create();
	object_ := _obj;
	{self.}Convert();
end;

function WspUnitDecorator.GetObject();
begin
	return object_;
end;

function WspUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildCNvSpPr) then
		{self.}XmlChildCNvSpPr := new CNvSpPrUnitDecorator(object_.XmlChildCNvSpPr);
	if not ifnil(object_.XmlChildSpPr) then
		{self.}XmlChildSpPr := new SpPrUnitDecorator(object_.XmlChildSpPr);
	if not ifnil(object_.XmlChildTxbx) then
		{self.}XmlChildTxbx := new TxbxUnitDecorator(object_.XmlChildTxbx);
	if not ifnil(object_.XmlChildStyle) then
		{self.}XmlChildStyle := new WpsStyleUnitDecorator(object_.XmlChildStyle);
	if not ifnil(object_.XmlChildBodyPr) then
		{self.}XmlChildBodyPr := new BodyPrUnitDecorator(object_.XmlChildBodyPr);
	tslassigning := tslassigning_backup;
end;

function WpsStyleUnitDecorator.Create(_obj: WpsStyle);
begin
	class(WpsStyle).Create();
	object_ := _obj;
	{self.}Convert();
end;

function WpsStyleUnitDecorator.GetObject();
begin
	return object_;
end;

function WpsStyleUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildLnRef) then
		{self.}XmlChildLnRef := new XRefUnitDecorator(object_.XmlChildLnRef);
	if not ifnil(object_.XmlChildFillRef) then
		{self.}XmlChildFillRef := new XRefUnitDecorator(object_.XmlChildFillRef);
	if not ifnil(object_.XmlChildEffectRef) then
		{self.}XmlChildEffectRef := new XRefUnitDecorator(object_.XmlChildEffectRef);
	if not ifnil(object_.XmlChildFontRef) then
		{self.}XmlChildFontRef := new XRefUnitDecorator(object_.XmlChildFontRef);
	tslassigning := tslassigning_backup;
end;

function XRefUnitDecorator.Create(_obj: XRef);
begin
	class(XRef).Create();
	object_ := _obj;
	{self.}Convert();
end;

function XRefUnitDecorator.GetObject();
begin
	return object_;
end;

function XRefUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrIdx) then
		{self.}Idx := object_.XmlAttrIdx.Value;
	if not ifnil(object_.XmlChildSchemeClr) then
		{self.}XmlChildSchemeClr := new SchemeClrUnitDecorator(object_.XmlChildSchemeClr);
	tslassigning := tslassigning_backup;
end;

function TxbxUnitDecorator.Create(_obj: Txbx);
begin
	class(Txbx).Create();
	object_ := _obj;
	{self.}Convert();
end;

function TxbxUnitDecorator.GetObject();
begin
	return object_;
end;

function TxbxUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildTxbxContent) then
		{self.}XmlChildTxbxContent := new TxbxContentUnitDecorator(object_.XmlChildTxbxContent);
	tslassigning := tslassigning_backup;
end;

function CNvSpPrUnitDecorator.Create(_obj: CNvSpPr);
begin
	class(CNvSpPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function CNvSpPrUnitDecorator.GetObject();
begin
	return object_;
end;

function CNvSpPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrTxBox) then
		{self.}TxBox := object_.XmlAttrTxBox.Value;
	if not ifnil(object_.XmlChildSpLocks) then
		{self.}XmlChildSpLocks := new SpLocksUnitDecorator(object_.XmlChildSpLocks);
	tslassigning := tslassigning_backup;
end;

function SpLocksUnitDecorator.Create(_obj: SpLocks);
begin
	class(SpLocks).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SpLocksUnitDecorator.GetObject();
begin
	return object_;
end;

function SpLocksUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrNoChangeArrowheads) then
		{self.}NoChangeArrowheads := object_.XmlAttrNoChangeArrowheads.Value;
	tslassigning := tslassigning_backup;
end;

function PicUnitDecorator.Create(_obj: Pic);
begin
	class(Pic).Create();
	object_ := _obj;
	{self.}Convert();
end;

function PicUnitDecorator.GetObject();
begin
	return object_;
end;

function PicUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildNvPicPr) then
		{self.}XmlChildNvPicPr := new NvPicPrUnitDecorator(object_.XmlChildNvPicPr);
	if not ifnil(object_.XmlChildBlipFill) then
		{self.}XmlChildBlipFill := new BlipFillUnitDecorator(object_.XmlChildBlipFill);
	if not ifnil(object_.XmlChildSpPr) then
		{self.}XmlChildSpPr := new SpPrUnitDecorator(object_.XmlChildSpPr);
	tslassigning := tslassigning_backup;
end;

function NvPicPrUnitDecorator.Create(_obj: NvPicPr);
begin
	class(NvPicPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function NvPicPrUnitDecorator.GetObject();
begin
	return object_;
end;

function NvPicPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildCNvPr) then
		{self.}XmlChildCNvPr := new CNvPrUnitDecorator(object_.XmlChildCNvPr);
	if not ifnil(object_.XmlChildCNvPicPr) then
		{self.}XmlChildCNvPicPr := new CNvPicPrUnitDecorator(object_.XmlChildCNvPicPr);
	tslassigning := tslassigning_backup;
end;

function CNvPrUnitDecorator.Create(_obj: CNvPr);
begin
	class(CNvPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function CNvPrUnitDecorator.GetObject();
begin
	return object_;
end;

function CNvPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrId) then
		{self.}Id := object_.XmlAttrId.Value;
	if not ifnil(object_.XmlAttrName) then
		{self.}Name := object_.XmlAttrName.Value;
	if not ifnil(object_.XmlAttrDescr) then
		{self.}Descr := object_.XmlAttrDescr.Value;
	tslassigning := tslassigning_backup;
end;

function CNvPicPrUnitDecorator.Create(_obj: CNvPicPr);
begin
	class(CNvPicPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function CNvPicPrUnitDecorator.GetObject();
begin
	return object_;
end;

function CNvPicPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildPicLocks) then
		{self.}XmlChildPicLocks := new PicLocksUnitDecorator(object_.XmlChildPicLocks);
	tslassigning := tslassigning_backup;
end;

function PicLocksUnitDecorator.Create(_obj: PicLocks);
begin
	class(PicLocks).Create();
	object_ := _obj;
	{self.}Convert();
end;

function PicLocksUnitDecorator.GetObject();
begin
	return object_;
end;

function PicLocksUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrNoChangeAspect) then
		{self.}NoChangeAspect := object_.XmlAttrNoChangeAspect.Value;
	tslassigning := tslassigning_backup;
end;

function BlipFillUnitDecorator.Create(_obj: BlipFill);
begin
	class(BlipFill).Create();
	object_ := _obj;
	{self.}Convert();
end;

function BlipFillUnitDecorator.GetObject();
begin
	return object_;
end;

function BlipFillUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildBlip) then
		{self.}XmlChildBlip := new BlipUnitDecorator(object_.XmlChildBlip);
	if not ifnil(object_.XmlChildStretch) then
		{self.}XmlChildStretch := new StretchUnitDecorator(object_.XmlChildStretch);
	tslassigning := tslassigning_backup;
end;

function BlipUnitDecorator.Create(_obj: Blip);
begin
	class(Blip).Create();
	object_ := _obj;
	{self.}Convert();
end;

function BlipUnitDecorator.GetObject();
begin
	return object_;
end;

function BlipUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrEmbed) then
		{self.}Embed := object_.XmlAttrEmbed.Value;
	if not ifnil(object_.XmlAttrCstate) then
		{self.}Cstate := object_.XmlAttrCstate.Value;
	tslassigning := tslassigning_backup;
end;

function StretchUnitDecorator.Create(_obj: Stretch);
begin
	class(Stretch).Create();
	object_ := _obj;
	{self.}Convert();
end;

function StretchUnitDecorator.GetObject();
begin
	return object_;
end;

function StretchUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildFillRect) then
		{self.}XmlChildFillRect := new PureValUnitDecorator(object_.XmlChildFillRect);
	tslassigning := tslassigning_backup;
end;

function SpPrUnitDecorator.Create(_obj: SpPr);
begin
	class(SpPr).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SpPrUnitDecorator.GetObject();
begin
	return object_;
end;

function SpPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrBwMode) then
		{self.}BwMode := object_.XmlAttrBwMode.Value;
	if not ifnil(object_.XmlChildXfrm) then
		{self.}XmlChildXfrm := new XfrmUnitDecorator(object_.XmlChildXfrm);
	if not ifnil(object_.XmlChildPrstGeom) then
		{self.}XmlChildPrstGeom := new PrstGeomUnitDecorator(object_.XmlChildPrstGeom);
	if not ifnil(object_.XmlChildNoFill) then
		{self.}NoFill.Copy(object_.XmlChildNoFill);
	if not ifnil(object_.XmlChildSolidFill) then
		{self.}XmlChildSolidFill := new SolidFillUnitDecorator(object_.XmlChildSolidFill);
	if not ifnil(object_.XmlChildLn) then
		{self.}XmlChildLn := new LnUnitDecorator(object_.XmlChildLn);
	if not ifnil(object_.XmlChildEffectLst) then
		{self.}XmlChildEffectLst := new EffectLstUnitDecorator(object_.XmlChildEffectLst);
	tslassigning := tslassigning_backup;
end;

function EffectLstUnitDecorator.Create(_obj: EffectLst);
begin
	class(EffectLst).Create();
	object_ := _obj;
	{self.}Convert();
end;

function EffectLstUnitDecorator.GetObject();
begin
	return object_;
end;

function EffectLstUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildOuterShdw) then
		{self.}XmlChildOuterShdw := new OuterShdwUnitDecorator(object_.XmlChildOuterShdw);
	tslassigning := tslassigning_backup;
end;

function LnUnitDecorator.Create(_obj: Ln);
begin
	class(Ln).Create();
	object_ := _obj;
	{self.}Convert();
end;

function LnUnitDecorator.GetObject();
begin
	return object_;
end;

function LnUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrW) then
		{self.}W := object_.XmlAttrW.Value;
	if not ifnil(object_.XmlAttrCap) then
		{self.}Cap := object_.XmlAttrCap.Value;
	if not ifnil(object_.XmlAttrCmpd) then
		{self.}Cmpd := object_.XmlAttrCmpd.Value;
	if not ifnil(object_.XmlAttrAlgn) then
		{self.}Algn := object_.XmlAttrAlgn.Value;
	if not ifnil(object_.XmlChildNoFill) then
		{self.}NoFill.Copy(object_.XmlChildNoFill);
	if not ifnil(object_.XmlChildSolidFill) then
		{self.}XmlChildSolidFill := new SolidFillUnitDecorator(object_.XmlChildSolidFill);
	if not ifnil(object_.XmlChildPrstDash) then
		{self.}XmlChildPrstDash := new PureValUnitDecorator(object_.XmlChildPrstDash);
	if not ifnil(object_.XmlChildMiter) then
		{self.}XmlChildMiter := new MiterUnitDecorator(object_.XmlChildMiter);
	if not ifnil(object_.XmlChildHeadEnd) then
		{self.}HeadEnd.Copy(object_.XmlChildHeadEnd);
	if not ifnil(object_.XmlChildTailEnd) then
		{self.}TailEnd.Copy(object_.XmlChildTailEnd);
	tslassigning := tslassigning_backup;
end;

function MiterUnitDecorator.Create(_obj: Miter);
begin
	class(Miter).Create();
	object_ := _obj;
	{self.}Convert();
end;

function MiterUnitDecorator.GetObject();
begin
	return object_;
end;

function MiterUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrLim) then
		{self.}Lim := object_.XmlAttrLim.Value;
	tslassigning := tslassigning_backup;
end;

function XfrmUnitDecorator.Create(_obj: Xfrm);
begin
	class(Xfrm).Create();
	object_ := _obj;
	{self.}Convert();
end;

function XfrmUnitDecorator.GetObject();
begin
	return object_;
end;

function XfrmUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrFlipH) then
		{self.}FlipH := object_.XmlAttrFlipH.Value;
	if not ifnil(object_.XmlAttrFlipV) then
		{self.}FlipV := object_.XmlAttrFlipV.Value;
	if not ifnil(object_.XmlAttrRot) then
		{self.}Rot := object_.XmlAttrRot.Value;
	if not ifnil(object_.XmlChildOff) then
		{self.}XmlChildOff := new XYUnitDecorator(object_.XmlChildOff);
	if not ifnil(object_.XmlChildExt) then
		{self.}XmlChildExt := new CXYUnitDecorator(object_.XmlChildExt);
	tslassigning := tslassigning_backup;
end;

function XYUnitDecorator.Create(_obj: XY);
begin
	class(XY).Create();
	object_ := _obj;
	{self.}Convert();
end;

function XYUnitDecorator.GetObject();
begin
	return object_;
end;

function XYUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrX) then
		{self.}X := TSSafeUnitConverter.EmusToPoints(object_.XmlAttrX.Value);
	if not ifnil(object_.XmlAttrY) then
		{self.}Y := TSSafeUnitConverter.EmusToPoints(object_.XmlAttrY.Value);
	tslassigning := tslassigning_backup;
end;

function CXYUnitDecorator.Create(_obj: CXY);
begin
	class(CXY).Create();
	object_ := _obj;
	{self.}Convert();
end;

function CXYUnitDecorator.GetObject();
begin
	return object_;
end;

function CXYUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrCx) then
		{self.}Cx := TSSafeUnitConverter.EmusToPoints(object_.XmlAttrCx.Value);
	if not ifnil(object_.XmlAttrCy) then
		{self.}Cy := TSSafeUnitConverter.EmusToPoints(object_.XmlAttrCy.Value);
	tslassigning := tslassigning_backup;
end;

function PrstGeomUnitDecorator.Create(_obj: PrstGeom);
begin
	class(PrstGeom).Create();
	object_ := _obj;
	{self.}Convert();
end;

function PrstGeomUnitDecorator.GetObject();
begin
	return object_;
end;

function PrstGeomUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrPrst) then
		{self.}Prst := object_.XmlAttrPrst.Value;
	if not ifnil(object_.XmlChildAvLst) then
		{self.}XmlChildAvLst := new PureValUnitDecorator(object_.XmlChildAvLst);
	tslassigning := tslassigning_backup;
end;

function AnchorUnitDecorator.Create(_obj: Anchor);
begin
	class(Anchor).Create();
	object_ := _obj;
	{self.}Convert();
end;

function AnchorUnitDecorator.GetObject();
begin
	return object_;
end;

function AnchorUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrDistT) then
		{self.}DistT := object_.XmlAttrDistT.Value;
	if not ifnil(object_.XmlAttrDistB) then
		{self.}DistB := object_.XmlAttrDistB.Value;
	if not ifnil(object_.XmlAttrDistL) then
		{self.}DistL := object_.XmlAttrDistL.Value;
	if not ifnil(object_.XmlAttrDistR) then
		{self.}DistR := object_.XmlAttrDistR.Value;
	if not ifnil(object_.XmlAttrSimplePos) then
		{self.}SimplePos := object_.XmlAttrSimplePos.Value;
	if not ifnil(object_.XmlAttrRelativeHeight) then
		{self.}RelativeHeight := object_.XmlAttrRelativeHeight.Value;
	if not ifnil(object_.XmlAttrBehindDoc) then
		{self.}BehindDoc := object_.XmlAttrBehindDoc.Value;
	if not ifnil(object_.XmlAttrLocked) then
		{self.}Locked := object_.XmlAttrLocked.Value;
	if not ifnil(object_.XmlAttrHidden) then
		{self.}Hidden := object_.XmlAttrHidden.Value;
	if not ifnil(object_.XmlAttrLayoutInCell) then
		{self.}LayoutInCell := object_.XmlAttrLayoutInCell.Value;
	if not ifnil(object_.XmlAttrAllowOverlap) then
		{self.}AllowOverlap := object_.XmlAttrAllowOverlap.Value;
	if not ifnil(object_.XmlAttrAnchorId) then
		{self.}AnchorId := object_.XmlAttrAnchorId.Value;
	if not ifnil(object_.XmlAttrEditId) then
		{self.}EditId := object_.XmlAttrEditId.Value;
	if not ifnil(object_.XmlChildSimplePos) then
		{self.}XmlChildSimplePos := new XYUnitDecorator(object_.XmlChildSimplePos);
	if not ifnil(object_.XmlChildPositionH) then
		{self.}XmlChildPositionH := new PositionHUnitDecorator(object_.XmlChildPositionH);
	if not ifnil(object_.XmlChildPositionV) then
		{self.}XmlChildPositionV := new PositionVUnitDecorator(object_.XmlChildPositionV);
	if not ifnil(object_.XmlChildExtent) then
		{self.}XmlChildExtent := new CXYUnitDecorator(object_.XmlChildExtent);
	if not ifnil(object_.XmlChildEffectExtent) then
		{self.}XmlChildEffectExtent := new EffectExtentUnitDecorator(object_.XmlChildEffectExtent);
	if not ifnil(object_.XmlChildWrapNone) then
		{self.}WrapNone.Copy(object_.XmlChildWrapNone);
	if not ifnil(object_.XmlChildDocPr) then
		{self.}XmlChildDocPr := new DocPrUnitDecorator(object_.XmlChildDocPr);
	if not ifnil(object_.XmlChildCNvGraphicFramePr) then
		{self.}XmlChildCNvGraphicFramePr := new CNvGraphicFramePrUnitDecorator(object_.XmlChildCNvGraphicFramePr);
	if not ifnil(object_.XmlChildGraphic) then
		{self.}XmlChildGraphic := new GraphicUnitDecorator(object_.XmlChildGraphic);
	if not ifnil(object_.XmlChildSizeRelH) then
		{self.}XmlChildSizeRelH := new SizeRelHUnitDecorator(object_.XmlChildSizeRelH);
	if not ifnil(object_.XmlChildSizeRelV) then
		{self.}XmlChildSizeRelV := new SizeRelVUnitDecorator(object_.XmlChildSizeRelV);
	tslassigning := tslassigning_backup;
end;

function PositionVUnitDecorator.Create(_obj: PositionV);
begin
	class(PositionV).Create();
	object_ := _obj;
	{self.}Convert();
end;

function PositionVUnitDecorator.GetObject();
begin
	return object_;
end;

function PositionVUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrRelativeFrom) then
		{self.}RelativeFrom := object_.XmlAttrRelativeFrom.Value;
	if not ifnil(object_.XmlChildPosOffset) then
		{self.}PosOffset.Text := TSSafeUnitConverter.EmusToPoints(object_.XmlChildPosOffset.Text);
	tslassigning := tslassigning_backup;
end;

function PositionHUnitDecorator.Create(_obj: PositionH);
begin
	class(PositionH).Create();
	object_ := _obj;
	{self.}Convert();
end;

function PositionHUnitDecorator.GetObject();
begin
	return object_;
end;

function PositionHUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrRelativeFrom) then
		{self.}RelativeFrom := object_.XmlAttrRelativeFrom.Value;
	if not ifnil(object_.XmlChildPosOffset) then
		{self.}PosOffset.Text := TSSafeUnitConverter.EmusToPoints(object_.XmlChildPosOffset.Text);
	tslassigning := tslassigning_backup;
end;

function SizeRelHUnitDecorator.Create(_obj: SizeRelH);
begin
	class(SizeRelH).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SizeRelHUnitDecorator.GetObject();
begin
	return object_;
end;

function SizeRelHUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrRelativeFrom) then
		{self.}RelativeFrom := object_.XmlAttrRelativeFrom.Value;
	if not ifnil(object_.XmlChildPctWidth) then
		{self.}PctWidth.Text := TSSafeUnitConverter.EmusToPoints(object_.XmlChildPctWidth.Text);
	tslassigning := tslassigning_backup;
end;

function SizeRelVUnitDecorator.Create(_obj: SizeRelV);
begin
	class(SizeRelV).Create();
	object_ := _obj;
	{self.}Convert();
end;

function SizeRelVUnitDecorator.GetObject();
begin
	return object_;
end;

function SizeRelVUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrRelativeFrom) then
		{self.}RelativeFrom := object_.XmlAttrRelativeFrom.Value;
	if not ifnil(object_.XmlChildPctHeight) then
		{self.}PctHeight.Text := TSSafeUnitConverter.EmusToPoints(object_.XmlChildPctHeight.Text);
	tslassigning := tslassigning_backup;
end;

end.