OfficeXml/autounit/DocxMLUnitDecorator.tsf

unit DocxMLUnitDecorator;
interface
uses DocxML, TSSafeUnitConverter;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

implementation

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

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

function PropertiesUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildTemplate) then
	if not ifnil(object_.XmlChildTotalTime) then
	if not ifnil(object_.XmlChildPages) then
	if not ifnil(object_.XmlChildWords) then
	if not ifnil(object_.XmlChildCharacters) then
	if not ifnil(object_.XmlChildApplication) then
	if not ifnil(object_.XmlChildDocSecurity) then
	if not ifnil(object_.XmlChildLines) then
	if not ifnil(object_.XmlChildParagraphs) then
	if not ifnil(object_.XmlChildScaleCrop) then
	if not ifnil(object_.XmlChildCompany) then
	if not ifnil(object_.XmlChildLinksUpToDate) then
	if not ifnil(object_.XmlChildCharactersWithSpaces) then
	if not ifnil(object_.XmlChildSharedDoc) then
	if not ifnil(object_.XmlChildHyperlinksChanged) then
	if not ifnil(object_.XmlChildAppVersion) then
	tslassigning := tslassigning_backup;
end;

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

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

function DocumentUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrMcIgnorable) then
		{self.}McIgnorable := object_.XmlAttrMcIgnorable.Value;
	if not ifnil(object_.XmlChildBody) then
		{self.}XmlChildBody := new BodyUnitDecorator(object_.XmlChildBody);
	tslassigning := tslassigning_backup;
end;

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

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

function BodyUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	elems := object_.Ps();
	for _,elem in elems do
		{self.}AppendChild(new PUnitDecorator(elem));
	elems := object_.Tbls();
	for _,elem in elems do
		{self.}AppendChild(new TblUnitDecorator(elem));
	elems := object_.Sdts();
	for _,elem in elems do
		{self.}AppendChild(new SdtUnitDecorator(elem));
	if not ifnil(object_.XmlChildSectPr) then
		{self.}XmlChildSectPr := new SectPrUnitDecorator(object_.XmlChildSectPr);
	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_.XmlAttrParaId) then
		{self.}ParaId := object_.XmlAttrParaId.Value;
	if not ifnil(object_.XmlAttrTextId) then
		{self.}TextId := object_.XmlAttrTextId.Value;
	if not ifnil(object_.XmlAttrRsidR) then
		{self.}RsidR := object_.XmlAttrRsidR.Value;
	if not ifnil(object_.XmlAttrRsidRPr) then
		{self.}RsidRPr := object_.XmlAttrRsidRPr.Value;
	if not ifnil(object_.XmlAttrRsidRDefault) then
		{self.}RsidRDefault := object_.XmlAttrRsidRDefault.Value;
	if not ifnil(object_.XmlAttrRsidP) then
		{self.}RsidP := object_.XmlAttrRsidP.Value;
	if not ifnil(object_.XmlChildPPr) then
		{self.}XmlChildPPr := new PPrUnitDecorator(object_.XmlChildPPr);
	if not ifnil(object_.XmlChildOMathPara) then
		{self.}XmlChildOMathPara := new OMathParaUnitDecorator(object_.XmlChildOMathPara);
	if not ifnil(object_.XmlChildIns) then
		{self.}XmlChildIns := new InsUnitDecorator(object_.XmlChildIns);
	elems := object_.Rs();
	for _,elem in elems do
		{self.}AppendChild(new RUnitDecorator(elem));
	elems := object_.CommentRangeStarts();
	for _,elem in elems do
		{self.}AppendChild(new CommentRangeUnitDecorator(elem));
	elems := object_.CommentRangeEnds();
	for _,elem in elems do
		{self.}AppendChild(new CommentRangeUnitDecorator(elem));
	elems := object_.BookmarkStarts();
	for _,elem in elems do
		{self.}AppendChild(new BookmarkUnitDecorator(elem));
	elems := object_.BookmarkEnds();
	for _,elem in elems do
		{self.}AppendChild(new BookmarkUnitDecorator(elem));
	elems := object_.Hyperlinks();
	for _,elem in elems do
		{self.}AppendChild(new HyperLinkUnitDecorator(elem));
	elems := object_.FldSimples();
	for _,elem in elems do
		{self.}AppendChild(new FldSimpleUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function FldSimpleUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrInstr) then
		{self.}Instr := object_.XmlAttrInstr.Value;
	elems := object_.Rs();
	for _,elem in elems do
		{self.}AppendChild(new RUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

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

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

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

function HyperLinkUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrAnchor) then
		{self.}Anchor := object_.XmlAttrAnchor.Value;
	if not ifnil(object_.XmlAttrId) then
		{self.}Id := object_.XmlAttrId.Value;
	if not ifnil(object_.XmlAttrHistory) then
		{self.}History := object_.XmlAttrHistory.Value;
	elems := object_.Rs();
	for _,elem in elems do
		{self.}AppendChild(new RUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function BookmarkUnitDecorator.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;
	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_.XmlChildSectPr) then
		{self.}XmlChildSectPr := new SectPrUnitDecorator(object_.XmlChildSectPr);
	if not ifnil(object_.XmlChildTabs) then
		{self.}XmlChildTabs := new TabsUnitDecorator(object_.XmlChildTabs);
	if not ifnil(object_.XmlChildWidowControl) then
		{self.}WidowControl.Copy(object_.XmlChildWidowControl);
	if not ifnil(object_.XmlChildSnapToGrid) then
		{self.}SnapToGrid.Copy(object_.XmlChildSnapToGrid);
	if not ifnil(object_.XmlChildPStyle) then
		{self.}XmlChildPStyle := new PureWValUnitDecorator(object_.XmlChildPStyle);
	if not ifnil(object_.XmlChildNumPr) then
		{self.}XmlChildNumPr := new NumPrUnitDecorator(object_.XmlChildNumPr);
	if not ifnil(object_.XmlChildJc) then
		{self.}XmlChildJc := new PureWValUnitDecorator(object_.XmlChildJc);
	if not ifnil(object_.XmlChildInd) then
		{self.}XmlChildInd := new IndUnitDecorator(object_.XmlChildInd);
	if not ifnil(object_.XmlChildKeepNext) then
		{self.}KeepNext.Copy(object_.XmlChildKeepNext);
	if not ifnil(object_.XmlChildKeepLines) then
		{self.}KeepLines.Copy(object_.XmlChildKeepLines);
	if not ifnil(object_.XmlChildPageBreakBefore) then
		{self.}PageBreakBefore.Copy(object_.XmlChildPageBreakBefore);
	if not ifnil(object_.XmlChildAdjustRightInd) then
		{self.}XmlChildAdjustRightInd := new PureWValUnitDecorator(object_.XmlChildAdjustRightInd);
	if not ifnil(object_.XmlChildSpacing) then
		{self.}XmlChildSpacing := new SpacingUnitDecorator(object_.XmlChildSpacing);
	if not ifnil(object_.XmlChildOutlineLvl) then
		{self.}XmlChildOutlineLvl := new PureWValUnitDecorator(object_.XmlChildOutlineLvl);
	if not ifnil(object_.XmlChildAutoSpaceDE) then
		{self.}XmlChildAutoSpaceDE := new PureWValUnitDecorator(object_.XmlChildAutoSpaceDE);
	if not ifnil(object_.XmlChildAutoSpaceDN) then
		{self.}XmlChildAutoSpaceDN := new PureWValUnitDecorator(object_.XmlChildAutoSpaceDN);
	if not ifnil(object_.XmlChildRPr) then
		{self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
	if not ifnil(object_.XmlChildPBdr) then
		{self.}XmlChildPBdr := new PBdrUnitDecorator(object_.XmlChildPBdr);
	if not ifnil(object_.XmlChildContextualSpacing) then
		{self.}ContextualSpacing.Copy(object_.XmlChildContextualSpacing);
	if not ifnil(object_.XmlChildShd) then
		{self.}XmlChildShd := new ShdUnitDecorator(object_.XmlChildShd);
	if not ifnil(object_.XmlChildWordWrap) then
		{self.}XmlChildWordWrap := new PureWValUnitDecorator(object_.XmlChildWordWrap);
	if not ifnil(object_.XmlChildTextboxTightWrap) then
		{self.}XmlChildTextboxTightWrap := new PureWValUnitDecorator(object_.XmlChildTextboxTightWrap);
	tslassigning := tslassigning_backup;
end;

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

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

function PBdrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildTop) then
		{self.}XmlChildTop := new PBorderUnitDecorator(object_.XmlChildTop);
	if not ifnil(object_.XmlChildBottom) then
		{self.}XmlChildBottom := new PBorderUnitDecorator(object_.XmlChildBottom);
	tslassigning := tslassigning_backup;
end;

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

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

function PBorderUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrVal) then
		{self.}Val := object_.XmlAttrVal.Value;
	if not ifnil(object_.XmlAttrColor) then
		{self.}Color := object_.XmlAttrColor.Value;
	if not ifnil(object_.XmlAttrSpace) then
		{self.}Space := object_.XmlAttrSpace.Value;
	if not ifnil(object_.XmlAttrThemeColor) then
		{self.}ThemeColor := object_.XmlAttrThemeColor.Value;
	if not ifnil(object_.XmlAttrThemeTint) then
		{self.}ThemeTint := object_.XmlAttrThemeTint.Value;
	if not ifnil(object_.XmlAttrSz) then
		{self.}Sz := TSSafeUnitConverter.HalfPointToPoints(object_.XmlAttrSz.Value);
	tslassigning := tslassigning_backup;
end;

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

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

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

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

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

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

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

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

function NumPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildIlvl) then
		{self.}XmlChildIlvl := new PureWValUnitDecorator(object_.XmlChildIlvl);
	if not ifnil(object_.XmlChildNumId) then
		{self.}XmlChildNumId := new PureWValUnitDecorator(object_.XmlChildNumId);
	tslassigning := tslassigning_backup;
end;

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

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

function IndUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrFirstLineChars) then
		{self.}FirstLineChars := TSSafeUnitConverter.PercentToNumber(object_.XmlAttrFirstLineChars.Value);
	if not ifnil(object_.XmlAttrFirstLine) then
		{self.}FirstLine := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrFirstLine.Value);
	if not ifnil(object_.XmlAttrRightChars) then
		{self.}RightChars := TSSafeUnitConverter.PercentToNumber(object_.XmlAttrRightChars.Value);
	if not ifnil(object_.XmlAttrRight) then
		{self.}Right := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrRight.Value);
	if not ifnil(object_.XmlAttrLeftChars) then
		{self.}LeftChars := TSSafeUnitConverter.PercentToNumber(object_.XmlAttrLeftChars.Value);
	if not ifnil(object_.XmlAttrLeft) then
		{self.}Left := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrLeft.Value);
	if not ifnil(object_.XmlAttrHanging) then
		{self.}Hanging := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrHanging.Value);
	if not ifnil(object_.XmlAttrHangingChars) then
		{self.}HangingChars := TSSafeUnitConverter.PercentToNumber(object_.XmlAttrHangingChars.Value);
	tslassigning := tslassigning_backup;
end;

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

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

function SpacingUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrBefore) then
		{self.}Before := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrBefore.Value);
	if not ifnil(object_.XmlAttrBeforeLines) then
		{self.}BeforeLines := TSSafeUnitConverter.PercentToNumber(object_.XmlAttrBeforeLines.Value);
	if not ifnil(object_.XmlAttrBeforeAutospacing) then
		{self.}BeforeAutospacing := object_.XmlAttrBeforeAutospacing.Value;
	if not ifnil(object_.XmlAttrAfter) then
		{self.}After := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrAfter.Value);
	if not ifnil(object_.XmlAttrAfterLines) then
		{self.}AfterLines := TSSafeUnitConverter.PercentToNumber(object_.XmlAttrAfterLines.Value);
	if not ifnil(object_.XmlAttrAfterAutospacing) then
		{self.}AfterAutospacing := object_.XmlAttrAfterAutospacing.Value;
	if not ifnil(object_.XmlAttrLine) then
		{self.}Line := TSSafeUnitConverter.ToInt(object_.XmlAttrLine.Value);
	if not ifnil(object_.XmlAttrLineRule) then
		{self.}LineRule := object_.XmlAttrLineRule.Value;
	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_.XmlChildNoProof) then
		{self.}XmlChildNoProof := new PureValUnitDecorator(object_.XmlChildNoProof);
	if not ifnil(object_.XmlChildPosition) then
		{self.}XmlChildPosition := new PureValUnitDecorator(object_.XmlChildPosition);
	if not ifnil(object_.XmlChildWebHidden) then
		{self.}XmlChildWebHidden := new PureWValUnitDecorator(object_.XmlChildWebHidden);
	if not ifnil(object_.XmlChildRStyle) then
		{self.}XmlChildRStyle := new PureWValUnitDecorator(object_.XmlChildRStyle);
	if not ifnil(object_.XmlChildIns) then
		{self.}XmlChildIns := new InsUnitDecorator(object_.XmlChildIns);
	if not ifnil(object_.XmlChildRFonts) then
		{self.}XmlChildRFonts := new RFontsUnitDecorator(object_.XmlChildRFonts);
	if not ifnil(object_.XmlChildKern) then
		{self.}XmlChildKern := new PureWValUnitDecorator(object_.XmlChildKern);
	if not ifnil(object_.XmlChildI) then
		{self.}I.Copy(object_.XmlChildI);
	if not ifnil(object_.XmlChildICs) then
		{self.}ICs.Copy(object_.XmlChildICs);
	if not ifnil(object_.XmlChildB) then
		{self.}B.Copy(object_.XmlChildB);
	if not ifnil(object_.XmlChildBCs) then
		{self.}BCs.Copy(object_.XmlChildBCs);
	if not ifnil(object_.XmlChildStrike) then
		{self.}Strike.Copy(object_.XmlChildStrike);
	if not ifnil(object_.XmlChildColor) then
		{self.}XmlChildColor := new ColorUnitDecorator(object_.XmlChildColor);
	if not ifnil(object_.XmlChildSz) then
		{self.}XmlChildSz := new SzUnitDecorator(object_.XmlChildSz);
	if not ifnil(object_.XmlChildSzCs) then
		{self.}XmlChildSzCs := new SzCsUnitDecorator(object_.XmlChildSzCs);
	if not ifnil(object_.XmlChildU) then
		{self.}U.Copy(object_.XmlChildU);
	if not ifnil(object_.XmlChildLang) then
		{self.}XmlChildLang := new LangUnitDecorator(object_.XmlChildLang);
	if not ifnil(object_.XmlChildVertAlign) then
		{self.}XmlChildVertAlign := new PureWValUnitDecorator(object_.XmlChildVertAlign);
	if not ifnil(object_.XmlChildLigatures) then
		{self.}XmlChildLigatures := new PureWValUnitDecorator(object_.XmlChildLigatures);
	tslassigning := tslassigning_backup;
end;

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

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

function RFontsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrAscii) then
		{self.}Ascii := object_.XmlAttrAscii.Value;
	if not ifnil(object_.XmlAttrAsciiTheme) then
		{self.}AsciiTheme := object_.XmlAttrAsciiTheme.Value;
	if not ifnil(object_.XmlAttrEastAsia) then
		{self.}EastAsia := object_.XmlAttrEastAsia.Value;
	if not ifnil(object_.XmlAttrEastAsiaTheme) then
		{self.}EastAsiaTheme := object_.XmlAttrEastAsiaTheme.Value;
	if not ifnil(object_.XmlAttrHAnsi) then
		{self.}HAnsi := object_.XmlAttrHAnsi.Value;
	if not ifnil(object_.XmlAttrHAnsiTheme) then
		{self.}HAnsiTheme := object_.XmlAttrHAnsiTheme.Value;
	if not ifnil(object_.XmlAttrHint) then
		{self.}Hint := object_.XmlAttrHint.Value;
	if not ifnil(object_.XmlAttrCs) then
		{self.}Cs := object_.XmlAttrCs.Value;
	if not ifnil(object_.XmlAttrCsTheme) then
		{self.}CsTheme := object_.XmlAttrCsTheme.Value;
	tslassigning := tslassigning_backup;
end;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

function LangUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrVal) then
		{self.}Val := object_.XmlAttrVal.Value;
	if not ifnil(object_.XmlAttrEastAsia) then
		{self.}EastAsia := object_.XmlAttrEastAsia.Value;
	if not ifnil(object_.XmlAttrBidi) then
		{self.}Bidi := object_.XmlAttrBidi.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_.XmlAttrWRsidRPr) then
		{self.}WRsidRPr := object_.XmlAttrWRsidRPr.Value;
	if not ifnil(object_.XmlAttrAnchor) then
		{self.}Anchor := object_.XmlAttrAnchor.Value;
	if not ifnil(object_.XmlAttrHistory) then
		{self.}History := object_.XmlAttrHistory.Value;
	if not ifnil(object_.XmlChildRPr) then
		{self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
	if not ifnil(object_.XmlChildBr) then
		{self.}XmlChildBr := new BrUnitDecorator(object_.XmlChildBr);
	if not ifnil(object_.XmlChildFldChar) then
		{self.}XmlChildFldChar := new FldCharUnitDecorator(object_.XmlChildFldChar);
	if not ifnil(object_.XmlChildInstrText) then
		{self.}XmlChildInstrText := new InstrTextUnitDecorator(object_.XmlChildInstrText);
	if not ifnil(object_.XmlChildSeparator) then
		{self.}Separator.Copy(object_.XmlChildSeparator);
	if not ifnil(object_.XmlChildContinuationSeparator) then
		{self.}ContinuationSeparator.Copy(object_.XmlChildContinuationSeparator);
	if not ifnil(object_.XmlChildLastRenderedPageBreak) then
		{self.}LastRenderedPageBreak.Copy(object_.XmlChildLastRenderedPageBreak);
	if not ifnil(object_.XmlChildAlternateContent) then
		{self.}XmlChildAlternateContent := new AlternateContentUnitDecorator(object_.XmlChildAlternateContent);
	if not ifnil(object_.XmlChildDrawing) then
		{self.}XmlChildDrawing := new DrawingUnitDecorator(object_.XmlChildDrawing);
	if not ifnil(object_.XmlChildT) then
		{self.}XmlChildT := new TUnitDecorator(object_.XmlChildT);
	if not ifnil(object_.XmlChildObject) then
		{self.}XmlChildObject := new ObjectUnitDecorator(object_.XmlChildObject);
	if not ifnil(object_.XmlChildFootnoteReference) then
		{self.}XmlChildFootnoteReference := new FootnoteReferenceUnitDecorator(object_.XmlChildFootnoteReference);
	if not ifnil(object_.XmlChildFootnoteRef) then
		{self.}FootnoteRef.Copy(object_.XmlChildFootnoteRef);
	tslassigning := tslassigning_backup;
end;

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

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

function ObjectUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrDxaOrig) then
		{self.}DxaOrig := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrDxaOrig.Value);
	if not ifnil(object_.XmlAttrDyaOrig) then
		{self.}DyaOrig := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrDyaOrig.Value);
	if not ifnil(object_.XmlAttrAnchorId) then
		{self.}AnchorId := object_.XmlAttrAnchorId.Value;
	if not ifnil(object_.XmlChildShapetype) then
		{self.}XmlChildShapetype := new ShapetypeUnitDecorator(object_.XmlChildShapetype);
	if not ifnil(object_.XmlChildShape) then
		{self.}XmlChildShape := new ShapeUnitDecorator(object_.XmlChildShape);
	if not ifnil(object_.XmlChildOLEObject) then
		{self.}XmlChildOLEObject := new OLEObjectUnitDecorator(object_.XmlChildOLEObject);
	tslassigning := tslassigning_backup;
end;

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

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

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

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

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

function FldCharUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrFldCharType) then
		{self.}FldCharType := object_.XmlAttrFldCharType.Value;
	if not ifnil(object_.XmlAttrFldLock) then
		{self.}FldLock := object_.XmlAttrFldLock.Value;
	if not ifnil(object_.XmlAttrDirty) then
		{self.}Dirty := object_.XmlAttrDirty.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function InstrTextUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrSpace) then
		{self.}Space := object_.XmlAttrSpace.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function BrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	tslassigning := tslassigning_backup;
end;

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

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

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

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

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

function DrawingUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChild_Inline) then
		{self.}XmlChild_Inline := new _InlineUnitDecorator(object_.XmlChild_Inline);
	if not ifnil(object_.XmlChildAnchor) then
		{self.}XmlChildAnchor := new AnchorUnitDecorator(object_.XmlChildAnchor);
	tslassigning := tslassigning_backup;
end;

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

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

function TUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrSpace) then
		{self.}Space := object_.XmlAttrSpace.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function TblUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildTblPr) then
		{self.}XmlChildTblPr := new TblPrUnitDecorator(object_.XmlChildTblPr);
	if not ifnil(object_.XmlChildTblGrid) then
		{self.}XmlChildTblGrid := new TblGridUnitDecorator(object_.XmlChildTblGrid);
	elems := object_.Trs();
	for _,elem in elems do
		{self.}AppendChild(new TrUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function TblPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildJc) then
		{self.}XmlChildJc := new PureWValUnitDecorator(object_.XmlChildJc);
	if not ifnil(object_.XmlChildShd) then
		{self.}XmlChildShd := new ShdUnitDecorator(object_.XmlChildShd);
	if not ifnil(object_.XmlChildTblStyle) then
		{self.}XmlChildTblStyle := new PureWValUnitDecorator(object_.XmlChildTblStyle);
	if not ifnil(object_.XmlChildTblW) then
		{self.}XmlChildTblW := new TblWUnitDecorator(object_.XmlChildTblW);
	if not ifnil(object_.XmlChildTblInd) then
		{self.}XmlChildTblInd := new TblWUnitDecorator(object_.XmlChildTblInd);
	if not ifnil(object_.XmlChildTblLayout) then
		{self.}XmlChildTblLayout := new TblLayoutUnitDecorator(object_.XmlChildTblLayout);
	if not ifnil(object_.XmlChildTblLook) then
		{self.}XmlChildTblLook := new TblLookUnitDecorator(object_.XmlChildTblLook);
	if not ifnil(object_.XmlChildTblBorders) then
		{self.}XmlChildTblBorders := new TblBordersUnitDecorator(object_.XmlChildTblBorders);
	if not ifnil(object_.XmlChildTblCellMar) then
		{self.}XmlChildTblCellMar := new TblCellMarUnitDecorator(object_.XmlChildTblCellMar);
	if not ifnil(object_.XmlChildTblCellSpacing) then
		{self.}XmlChildTblCellSpacing := new TblCellSpacingUnitDecorator(object_.XmlChildTblCellSpacing);
	if not ifnil(object_.XmlChildTblCaption) then
		{self.}XmlChildTblCaption := new PureWValUnitDecorator(object_.XmlChildTblCaption);
	if not ifnil(object_.XmlChildTblDescription) then
		{self.}XmlChildTblDescription := new PureWValUnitDecorator(object_.XmlChildTblDescription);
	if not ifnil(object_.XmlChildTblStyleRowBandSize) then
		{self.}XmlChildTblStyleRowBandSize := new PureWValUnitDecorator(object_.XmlChildTblStyleRowBandSize);
	if not ifnil(object_.XmlChildTblStyleColBandSize) then
		{self.}XmlChildTblStyleColBandSize := new PureWValUnitDecorator(object_.XmlChildTblStyleColBandSize);
	tslassigning := tslassigning_backup;
end;

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

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

function TblCellSpacingUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrW) then
		{self.}W := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrW.Value);
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function TblWUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrW) then
		{self.}W := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrW.Value);
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function TblLayoutUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function TblLookUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrVal) then
		{self.}Val := object_.XmlAttrVal.Value;
	if not ifnil(object_.XmlAttrFirstRow) then
		{self.}FirstRow := object_.XmlAttrFirstRow.Value;
	if not ifnil(object_.XmlAttrLastRow) then
		{self.}LastRow := object_.XmlAttrLastRow.Value;
	if not ifnil(object_.XmlAttrFirstColumn) then
		{self.}FirstColumn := object_.XmlAttrFirstColumn.Value;
	if not ifnil(object_.XmlAttrLastColumn) then
		{self.}LastColumn := object_.XmlAttrLastColumn.Value;
	if not ifnil(object_.XmlAttrNoHBand) then
		{self.}NoHBand := object_.XmlAttrNoHBand.Value;
	if not ifnil(object_.XmlAttrNoVBand) then
		{self.}NoVBand := object_.XmlAttrNoVBand.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function TblBordersUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildTop) then
		{self.}XmlChildTop := new TblBorderUnitDecorator(object_.XmlChildTop);
	if not ifnil(object_.XmlChildLeft) then
		{self.}XmlChildLeft := new TblBorderUnitDecorator(object_.XmlChildLeft);
	if not ifnil(object_.XmlChildBottom) then
		{self.}XmlChildBottom := new TblBorderUnitDecorator(object_.XmlChildBottom);
	if not ifnil(object_.XmlChildRight) then
		{self.}XmlChildRight := new TblBorderUnitDecorator(object_.XmlChildRight);
	if not ifnil(object_.XmlChildInsideH) then
		{self.}XmlChildInsideH := new TblBorderUnitDecorator(object_.XmlChildInsideH);
	if not ifnil(object_.XmlChildInsideV) then
		{self.}XmlChildInsideV := new TblBorderUnitDecorator(object_.XmlChildInsideV);
	tslassigning := tslassigning_backup;
end;

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

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

function TblBorderUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrVal) then
		{self.}Val := object_.XmlAttrVal.Value;
	if not ifnil(object_.XmlAttrColor) then
		{self.}Color := object_.XmlAttrColor.Value;
	if not ifnil(object_.XmlAttrSpace) then
		{self.}Space := object_.XmlAttrSpace.Value;
	if not ifnil(object_.XmlAttrThemeColor) then
		{self.}ThemeColor := object_.XmlAttrThemeColor.Value;
	if not ifnil(object_.XmlAttrThemeTint) then
		{self.}ThemeTint := object_.XmlAttrThemeTint.Value;
	if not ifnil(object_.XmlAttrSz) then
		{self.}Sz := TSSafeUnitConverter.EighthPointToPoints(object_.XmlAttrSz.Value);
	tslassigning := tslassigning_backup;
end;

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

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

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

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

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

function GridColUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrw) then
		{self.}w := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrw.Value);
	tslassigning := tslassigning_backup;
end;

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

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

function TrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrRsidR) then
		{self.}RsidR := object_.XmlAttrRsidR.Value;
	if not ifnil(object_.XmlAttrParaId) then
		{self.}ParaId := object_.XmlAttrParaId.Value;
	if not ifnil(object_.XmlAttrTextId) then
		{self.}TextId := object_.XmlAttrTextId.Value;
	if not ifnil(object_.XmlAttrRsidTr) then
		{self.}RsidTr := object_.XmlAttrRsidTr.Value;
	if not ifnil(object_.XmlChildTrPr) then
		{self.}XmlChildTrPr := new TrPrUnitDecorator(object_.XmlChildTrPr);
	elems := object_.Tcs();
	for _,elem in elems do
		{self.}AppendChild(new TcUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function TrPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildTrHeight) then
		{self.}XmlChildTrHeight := new TrHeightUnitDecorator(object_.XmlChildTrHeight);
	if not ifnil(object_.XmlChildTblHeader) then
		{self.}XmlChildTblHeader := new PureWValUnitDecorator(object_.XmlChildTblHeader);
	if not ifnil(object_.XmlChildJc) then
		{self.}XmlChildJc := new PureWValUnitDecorator(object_.XmlChildJc);
	if not ifnil(object_.XmlChildCantSplit) then
		{self.}CantSplit.Copy(object_.XmlChildCantSplit);
	if not ifnil(object_.XmlChildCnfStyle) then
		{self.}XmlChildCnfStyle := new CnfStyleUnitDecorator(object_.XmlChildCnfStyle);
	if not ifnil(object_.XmlChildIns) then
		{self.}XmlChildIns := new InsUnitDecorator(object_.XmlChildIns);
	tslassigning := tslassigning_backup;
end;

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

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

function InsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrId) then
		{self.}Id := object_.XmlAttrId.Value;
	if not ifnil(object_.XmlAttrAuthor) then
		{self.}Author := object_.XmlAttrAuthor.Value;
	if not ifnil(object_.XmlAttrDate) then
		{self.}Date := object_.XmlAttrDate.Value;
	if not ifnil(object_.XmlAttrDateUtc) then
		{self.}DateUtc := object_.XmlAttrDateUtc.Value;
	elems := object_.Rs();
	for _,elem in elems do
		{self.}AppendChild(new RUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function CnfStyleUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrVal) then
		{self.}Val := object_.XmlAttrVal.Value;
	if not ifnil(object_.XmlAttrFirstRow) then
		{self.}FirstRow := object_.XmlAttrFirstRow.Value;
	if not ifnil(object_.XmlAttrLastRow) then
		{self.}LastRow := object_.XmlAttrLastRow.Value;
	if not ifnil(object_.XmlAttrFirstColumn) then
		{self.}FirstColumn := object_.XmlAttrFirstColumn.Value;
	if not ifnil(object_.XmlAttrLastColumn) then
		{self.}LastColumn := object_.XmlAttrLastColumn.Value;
	if not ifnil(object_.XmlAttrOddVBand) then
		{self.}OddVBand := object_.XmlAttrOddVBand.Value;
	if not ifnil(object_.XmlAttrEvenVBand) then
		{self.}EvenVBand := object_.XmlAttrEvenVBand.Value;
	if not ifnil(object_.XmlAttrOddHBand) then
		{self.}OddHBand := object_.XmlAttrOddHBand.Value;
	if not ifnil(object_.XmlAttrEvenHBand) then
		{self.}EvenHBand := object_.XmlAttrEvenHBand.Value;
	if not ifnil(object_.XmlAttrFirstRowFirstColumn) then
		{self.}FirstRowFirstColumn := object_.XmlAttrFirstRowFirstColumn.Value;
	if not ifnil(object_.XmlAttrFirstRowLastColumn) then
		{self.}FirstRowLastColumn := object_.XmlAttrFirstRowLastColumn.Value;
	if not ifnil(object_.XmlAttrLastRowFirstColumn) then
		{self.}LastRowFirstColumn := object_.XmlAttrLastRowFirstColumn.Value;
	if not ifnil(object_.XmlAttrLastRowLastColumn) then
		{self.}LastRowLastColumn := object_.XmlAttrLastRowLastColumn.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function TrHeightUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrHRule) then
		{self.}HRule := object_.XmlAttrHRule.Value;
	if not ifnil(object_.XmlAttrval) then
		{self.}val := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrval.Value);
	tslassigning := tslassigning_backup;
end;

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

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

function TcUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildTcPr) then
		{self.}XmlChildTcPr := new TcPrUnitDecorator(object_.XmlChildTcPr);
	elems := object_.Ps();
	for _,elem in elems do
		{self.}AppendChild(new PUnitDecorator(elem));
	elems := object_.Tbls();
	for _,elem in elems do
		{self.}AppendChild(new TblUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function TcPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildTcW) then
		{self.}XmlChildTcW := new TblWUnitDecorator(object_.XmlChildTcW);
	if not ifnil(object_.XmlChildGridSpan) then
		{self.}XmlChildGridSpan := new GridSpanUnitDecorator(object_.XmlChildGridSpan);
	if not ifnil(object_.XmlChildVMerge) then
		{self.}VMerge.Copy(object_.XmlChildVMerge);
	if not ifnil(object_.XmlChildVAlign) then
		{self.}XmlChildVAlign := new PureWValUnitDecorator(object_.XmlChildVAlign);
	if not ifnil(object_.XmlChildHideMark) then
		{self.}HideMark.Copy(object_.XmlChildHideMark);
	if not ifnil(object_.XmlChildShd) then
		{self.}XmlChildShd := new ShdUnitDecorator(object_.XmlChildShd);
	if not ifnil(object_.XmlChildTcBorders) then
		{self.}XmlChildTcBorders := new TcBordersUnitDecorator(object_.XmlChildTcBorders);
	tslassigning := tslassigning_backup;
end;

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

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

function TcBordersUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildTop) then
		{self.}XmlChildTop := new TcBorderUnitDecorator(object_.XmlChildTop);
	if not ifnil(object_.XmlChildLeft) then
		{self.}XmlChildLeft := new TcBorderUnitDecorator(object_.XmlChildLeft);
	if not ifnil(object_.XmlChildBottom) then
		{self.}XmlChildBottom := new TcBorderUnitDecorator(object_.XmlChildBottom);
	if not ifnil(object_.XmlChildRight) then
		{self.}XmlChildRight := new TcBorderUnitDecorator(object_.XmlChildRight);
	if not ifnil(object_.XmlChildTl2Br) then
		{self.}XmlChildTl2Br := new TcBorderUnitDecorator(object_.XmlChildTl2Br);
	if not ifnil(object_.XmlChildTr2Bl) then
		{self.}XmlChildTr2Bl := new TcBorderUnitDecorator(object_.XmlChildTr2Bl);
	if not ifnil(object_.XmlChildInsideH) then
		{self.}XmlChildInsideH := new TcBorderUnitDecorator(object_.XmlChildInsideH);
	if not ifnil(object_.XmlChildInsideV) then
		{self.}XmlChildInsideV := new TcBorderUnitDecorator(object_.XmlChildInsideV);
	tslassigning := tslassigning_backup;
end;

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

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

function TcBorderUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrVal) then
		{self.}Val := object_.XmlAttrVal.Value;
	if not ifnil(object_.XmlAttrColor) then
		{self.}Color := object_.XmlAttrColor.Value;
	if not ifnil(object_.XmlAttrSpace) then
		{self.}Space := object_.XmlAttrSpace.Value;
	if not ifnil(object_.XmlAttrThemeColor) then
		{self.}ThemeColor := object_.XmlAttrThemeColor.Value;
	if not ifnil(object_.XmlAttrThemeTint) then
		{self.}ThemeTint := object_.XmlAttrThemeTint.Value;
	if not ifnil(object_.XmlAttrSz) then
		{self.}Sz := TSSafeUnitConverter.EighthPointToPoints(object_.XmlAttrSz.Value);
	tslassigning := tslassigning_backup;
end;

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

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

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

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

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

function ShdUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrVal) then
		{self.}Val := object_.XmlAttrVal.Value;
	if not ifnil(object_.XmlAttrColor) then
		{self.}Color := object_.XmlAttrColor.Value;
	if not ifnil(object_.XmlAttrFill) then
		{self.}Fill := object_.XmlAttrFill.Value;
	if not ifnil(object_.XmlAttrThemeFill) then
		{self.}ThemeFill := object_.XmlAttrThemeFill.Value;
	if not ifnil(object_.XmlAttrThemeFillTint) then
		{self.}ThemeFillTint := object_.XmlAttrThemeFillTint.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function SdtUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildSdtPr) then
		{self.}XmlChildSdtPr := new SdtPrUnitDecorator(object_.XmlChildSdtPr);
	if not ifnil(object_.XmlChildSdtEndPr) then
		{self.}XmlChildSdtEndPr := new SdtEndPrUnitDecorator(object_.XmlChildSdtEndPr);
	if not ifnil(object_.XmlChildSdtContent) then
		{self.}XmlChildSdtContent := new SdtContentUnitDecorator(object_.XmlChildSdtContent);
	tslassigning := tslassigning_backup;
end;

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

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

function SdtPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildRPr) then
		{self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
	if not ifnil(object_.XmlChildId) then
		{self.}XmlChildId := new PureWValUnitDecorator(object_.XmlChildId);
	if not ifnil(object_.XmlChildDocPartObj) then
		{self.}XmlChildDocPartObj := new DocPartObjUnitDecorator(object_.XmlChildDocPartObj);
	tslassigning := tslassigning_backup;
end;

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

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

function DocPartObjUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildDocPartGallery) then
		{self.}XmlChildDocPartGallery := new PureWValUnitDecorator(object_.XmlChildDocPartGallery);
	if not ifnil(object_.XmlChildDocPartUnique) then
		{self.}XmlChildDocPartUnique := new PureValUnitDecorator(object_.XmlChildDocPartUnique);
	tslassigning := tslassigning_backup;
end;

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

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

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

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

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

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

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

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

function SectPrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrRsidR) then
		{self.}RsidR := object_.XmlAttrRsidR.Value;
	if not ifnil(object_.XmlAttrRsidSect) then
		{self.}RsidSect := object_.XmlAttrRsidSect.Value;
	elems := object_.HeaderReferences();
	for _,elem in elems do
		{self.}AppendChild(new ReferenceUnitDecorator(elem));
	elems := object_.FooterReferences();
	for _,elem in elems do
		{self.}AppendChild(new ReferenceUnitDecorator(elem));
	if not ifnil(object_.XmlChildFootnotePr) then
		{self.}XmlChildFootnotePr := new FootnotePrUnitDecorator(object_.XmlChildFootnotePr);
	if not ifnil(object_.XmlChildEndnotePr) then
		{self.}XmlChildEndnotePr := new EndnotePrUnitDecorator(object_.XmlChildEndnotePr);
	if not ifnil(object_.XmlChildType) then
		{self.}XmlChildType := new PureWValUnitDecorator(object_.XmlChildType);
	if not ifnil(object_.XmlChildPgSz) then
		{self.}XmlChildPgSz := new PgSzUnitDecorator(object_.XmlChildPgSz);
	if not ifnil(object_.XmlChildPgMar) then
		{self.}XmlChildPgMar := new PgMarUnitDecorator(object_.XmlChildPgMar);
	if not ifnil(object_.XmlChildPgNumType) then
		{self.}XmlChildPgNumType := new PgNumTypeUnitDecorator(object_.XmlChildPgNumType);
	if not ifnil(object_.XmlChildCols) then
		{self.}XmlChildCols := new ColsUnitDecorator(object_.XmlChildCols);
	if not ifnil(object_.XmlChildTitlePg) then
		{self.}TitlePg.Copy(object_.XmlChildTitlePg);
	if not ifnil(object_.XmlChildDocGrid) then
		{self.}XmlChildDocGrid := new DocGridUnitDecorator(object_.XmlChildDocGrid);
	tslassigning := tslassigning_backup;
end;

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

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

function ReferenceUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	if not ifnil(object_.XmlAttrId) then
		{self.}Id := object_.XmlAttrId.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function PgNumTypeUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrStart) then
		{self.}Start := TSSafeUnitConverter.ToInt(object_.XmlAttrStart.Value);
	tslassigning := tslassigning_backup;
end;

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

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

function PgSzUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrW) then
		{self.}W := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrW.Value);
	if not ifnil(object_.XmlAttrH) then
		{self.}H := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrH.Value);
	if not ifnil(object_.XmlAttrOrient) then
		{self.}Orient := object_.XmlAttrOrient.Value;
	if not ifnil(object_.XmlAttrCode) then
		{self.}Code := object_.XmlAttrCode.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function PgMarUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrTop) then
		{self.}Top := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrTop.Value);
	if not ifnil(object_.XmlAttrRight) then
		{self.}Right := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrRight.Value);
	if not ifnil(object_.XmlAttrBottom) then
		{self.}Bottom := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrBottom.Value);
	if not ifnil(object_.XmlAttrLeft) then
		{self.}Left := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrLeft.Value);
	if not ifnil(object_.XmlAttrHeader) then
		{self.}Header := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrHeader.Value);
	if not ifnil(object_.XmlAttrFooter) then
		{self.}Footer := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrFooter.Value);
	if not ifnil(object_.XmlAttrGutter) then
		{self.}Gutter := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrGutter.Value);
	tslassigning := tslassigning_backup;
end;

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

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

function ColsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrNum) then
		{self.}Num := TSSafeUnitConverter.ToInt(object_.XmlAttrNum.Value);
	if not ifnil(object_.XmlAttrSpace) then
		{self.}Space := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrSpace.Value);
	if not ifnil(object_.XmlAttrEqualWidth) then
		{self.}EqualWidth := object_.XmlAttrEqualWidth.Value;
	elems := object_.Cols();
	for _,elem in elems do
		{self.}AppendChild(new ColUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function ColUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrW) then
		{self.}W := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrW.Value);
	if not ifnil(object_.XmlAttrSpace) then
		{self.}Space := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrSpace.Value);
	tslassigning := tslassigning_backup;
end;

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

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

function DocGridUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	if not ifnil(object_.XmlAttrLinePitch) then
		{self.}LinePitch := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrLinePitch.Value);
	tslassigning := tslassigning_backup;
end;

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

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

function EndnotesUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrIgnorable) then
		{self.}Ignorable := object_.XmlAttrIgnorable.Value;
	elems := object_.Endnotes();
	for _,elem in elems do
		{self.}AppendChild(new EndnoteUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function EndnoteUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	if not ifnil(object_.XmlAttrId) then
		{self.}Id := object_.XmlAttrId.Value;
	elems := object_.Ps();
	for _,elem in elems do
		{self.}AppendChild(new PUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function FootnotesUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrIgnorable) then
		{self.}Ignorable := object_.XmlAttrIgnorable.Value;
	elems := object_.Footnotes();
	for _,elem in elems do
		{self.}AppendChild(new FootnoteUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function FootnoteUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	if not ifnil(object_.XmlAttrId) then
		{self.}Id := object_.XmlAttrId.Value;
	elems := object_.Ps();
	for _,elem in elems do
		{self.}AppendChild(new PUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function FontsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrIgnorable) then
		{self.}Ignorable := object_.XmlAttrIgnorable.Value;
	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_.XmlAttrName) then
		{self.}Name := object_.XmlAttrName.Value;
	if not ifnil(object_.XmlChildAltName) then
		{self.}XmlChildAltName := new PureWValUnitDecorator(object_.XmlChildAltName);
	if not ifnil(object_.XmlChildPanosel) then
		{self.}XmlChildPanosel := new PureWValUnitDecorator(object_.XmlChildPanosel);
	if not ifnil(object_.XmlChildCharset) then
		{self.}XmlChildCharset := new PureWValUnitDecorator(object_.XmlChildCharset);
	if not ifnil(object_.XmlChildFamily) then
		{self.}XmlChildFamily := new PureWValUnitDecorator(object_.XmlChildFamily);
	if not ifnil(object_.XmlChildPitch) then
		{self.}XmlChildPitch := new PureWValUnitDecorator(object_.XmlChildPitch);
	if not ifnil(object_.XmlChildSig) then
		{self.}XmlChildSig := new SigUnitDecorator(object_.XmlChildSig);
	tslassigning := tslassigning_backup;
end;

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

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

function SigUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrUsb0) then
		{self.}Usb0 := object_.XmlAttrUsb0.Value;
	if not ifnil(object_.XmlAttrUsb1) then
		{self.}Usb1 := object_.XmlAttrUsb1.Value;
	if not ifnil(object_.XmlAttrUsb2) then
		{self.}Usb2 := object_.XmlAttrUsb2.Value;
	if not ifnil(object_.XmlAttrUsb3) then
		{self.}Usb3 := object_.XmlAttrUsb3.Value;
	if not ifnil(object_.XmlAttrcsb0) then
		{self.}csb0 := object_.XmlAttrcsb0.Value;
	if not ifnil(object_.XmlAttrcsb1) then
		{self.}csb1 := object_.XmlAttrcsb1.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function SettingsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrIgnorable) then
		{self.}Ignorable := object_.XmlAttrIgnorable.Value;
	if not ifnil(object_.XmlChildZoom) then
		{self.}XmlChildZoom := new ZoomUnitDecorator(object_.XmlChildZoom);
	if not ifnil(object_.XmlChildBordersDoNotSurroundHeader) then
		{self.}BordersDoNotSurroundHeader.Copy(object_.XmlChildBordersDoNotSurroundHeader);
	if not ifnil(object_.XmlChildBordersDoNotSurroundFooter) then
		{self.}BordersDoNotSurroundFooter.Copy(object_.XmlChildBordersDoNotSurroundFooter);
	if not ifnil(object_.XmlChildDefaultTabStop) then
		{self.}XmlChildDefaultTabStop := new PureWValUnitDecorator(object_.XmlChildDefaultTabStop);
	if not ifnil(object_.XmlChildEvenAndOddHeaders) then
		{self.}EvenAndOddHeaders.Copy(object_.XmlChildEvenAndOddHeaders);
	if not ifnil(object_.XmlChildDrawingGridVerticalSpacing) then
		{self.}XmlChildDrawingGridVerticalSpacing := new PureWValUnitDecorator(object_.XmlChildDrawingGridVerticalSpacing);
	if not ifnil(object_.XmlChildDisplayHorizontalDrawingGridEvery) then
		{self.}XmlChildDisplayHorizontalDrawingGridEvery := new PureWValUnitDecorator(object_.XmlChildDisplayHorizontalDrawingGridEvery);
	if not ifnil(object_.XmlChildDisplayVerticalDrawingGridEvery) then
		{self.}XmlChildDisplayVerticalDrawingGridEvery := new PureWValUnitDecorator(object_.XmlChildDisplayVerticalDrawingGridEvery);
	if not ifnil(object_.XmlChildCharacterSpacingControl) then
		{self.}XmlChildCharacterSpacingControl := new PureWValUnitDecorator(object_.XmlChildCharacterSpacingControl);
	if not ifnil(object_.XmlChildHdrShapeDefaults) then
		{self.}XmlChildHdrShapeDefaults := new HdrShapeDefaultsUnitDecorator(object_.XmlChildHdrShapeDefaults);
	if not ifnil(object_.XmlChildFootnotePr) then
		{self.}XmlChildFootnotePr := new FootnotePrUnitDecorator(object_.XmlChildFootnotePr);
	if not ifnil(object_.XmlChildEndnotePr) then
		{self.}XmlChildEndnotePr := new EndnotePrUnitDecorator(object_.XmlChildEndnotePr);
	if not ifnil(object_.XmlChildCompat) then
		{self.}XmlChildCompat := new CompatUnitDecorator(object_.XmlChildCompat);
	if not ifnil(object_.XmlChildRsids) then
		{self.}XmlChildRsids := new RsidsUnitDecorator(object_.XmlChildRsids);
	if not ifnil(object_.XmlChildMathPr) then
		{self.}XmlChildMathPr := new MathPrUnitDecorator(object_.XmlChildMathPr);
	if not ifnil(object_.XmlChildThemeFontLang) then
		{self.}XmlChildThemeFontLang := new ThemeFontLangUnitDecorator(object_.XmlChildThemeFontLang);
	if not ifnil(object_.XmlChildClrSchemeMapping) then
		{self.}XmlChildClrSchemeMapping := new ClrSchemeMappingUnitDecorator(object_.XmlChildClrSchemeMapping);
	if not ifnil(object_.XmlChildDoNotIncludeSubdocsInStats) then
		{self.}DoNotIncludeSubdocsInStats.Copy(object_.XmlChildDoNotIncludeSubdocsInStats);
	if not ifnil(object_.XmlChildShapeDefaults) then
		{self.}XmlChildShapeDefaults := new ShapeDefaults2UnitDecorator(object_.XmlChildShapeDefaults);
	if not ifnil(object_.XmlChildDecimalSymbol) then
		{self.}XmlChildDecimalSymbol := new PureWValUnitDecorator(object_.XmlChildDecimalSymbol);
	if not ifnil(object_.XmlChildListSeparator) then
		{self.}XmlChildListSeparator := new PureWValUnitDecorator(object_.XmlChildListSeparator);
	if not ifnil(object_.XmlChildDocId) then
		{self.}XmlChildDocId := new PureWValUnitDecorator(object_.XmlChildDocId);
	if not ifnil(object_.XmlChildDocId) then
		{self.}XmlChildDocId := new PureWValUnitDecorator(object_.XmlChildDocId);
	if not ifnil(object_.XmlChildDocId) then
		{self.}XmlChildDocId := new PureWValUnitDecorator(object_.XmlChildDocId);
	if not ifnil(object_.XmlChildChartTrackingRefBased) then
		{self.}ChartTrackingRefBased.Copy(object_.XmlChildChartTrackingRefBased);
	tslassigning := tslassigning_backup;
end;

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

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

function ZoomUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrPercent) then
		{self.}Percent := object_.XmlAttrPercent.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function HdrShapeDefaultsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildShapeDefaults) then
		{self.}XmlChildShapeDefaults := new ShapeDefaultsUnitDecorator(object_.XmlChildShapeDefaults);
	tslassigning := tslassigning_backup;
end;

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

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

function ShapeDefaultsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrExt) then
		{self.}Ext := object_.XmlAttrExt.Value;
	if not ifnil(object_.XmlAttrSpidmax) then
		{self.}Spidmax := object_.XmlAttrSpidmax.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function FootnotePrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildPos) then
		{self.}XmlChildPos := new PureWValUnitDecorator(object_.XmlChildPos);
	if not ifnil(object_.XmlChildNumFmt) then
		{self.}XmlChildNumFmt := new PureWValUnitDecorator(object_.XmlChildNumFmt);
	if not ifnil(object_.XmlChildNumStart) then
		{self.}XmlChildNumStart := new PureWValUnitDecorator(object_.XmlChildNumStart);
	elems := object_.Footnotes();
	for _,elem in elems do
		{self.}AppendChild(new FootnoteUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function EndnotePrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildPos) then
		{self.}XmlChildPos := new PureWValUnitDecorator(object_.XmlChildPos);
	if not ifnil(object_.XmlChildNumFmt) then
		{self.}XmlChildNumFmt := new PureWValUnitDecorator(object_.XmlChildNumFmt);
	if not ifnil(object_.XmlChildNumStart) then
		{self.}XmlChildNumStart := new PureWValUnitDecorator(object_.XmlChildNumStart);
	elems := object_.Endnotes();
	for _,elem in elems do
		{self.}AppendChild(new EndnoteUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function CompatUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildSpaceForUL) then
		{self.}SpaceForUL.Copy(object_.XmlChildSpaceForUL);
	if not ifnil(object_.XmlChildBalanceSingleByteDoubleByteWidth) then
		{self.}BalanceSingleByteDoubleByteWidth.Copy(object_.XmlChildBalanceSingleByteDoubleByteWidth);
	if not ifnil(object_.XmlChildDoNotLeaveBackslashAlone) then
		{self.}DoNotLeaveBackslashAlone.Copy(object_.XmlChildDoNotLeaveBackslashAlone);
	if not ifnil(object_.XmlChildUlTrailSpace) then
		{self.}UlTrailSpace.Copy(object_.XmlChildUlTrailSpace);
	if not ifnil(object_.XmlChildDoNotExpandShiftReturn) then
		{self.}DoNotExpandShiftReturn.Copy(object_.XmlChildDoNotExpandShiftReturn);
	if not ifnil(object_.XmlChildAdjustLineHeightInTable) then
		{self.}AdjustLineHeightInTable.Copy(object_.XmlChildAdjustLineHeightInTable);
	if not ifnil(object_.XmlChildUseFELayout) then
		{self.}UseFELayout.Copy(object_.XmlChildUseFELayout);
	elems := object_.CompatSettings();
	for _,elem in elems do
		{self.}AppendChild(new CompatSettingUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

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

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

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

function RsidsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildRsidRoot) then
		{self.}XmlChildRsidRoot := new PureWValUnitDecorator(object_.XmlChildRsidRoot);
	elems := object_.Rsids();
	for _,elem in elems do
		{self.}AppendChild(new PureWValUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

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

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

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

function ClrSchemeMappingUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrBg1) then
		{self.}Bg1 := object_.XmlAttrBg1.Value;
	if not ifnil(object_.XmlAttrT1) then
		{self.}T1 := object_.XmlAttrT1.Value;
	if not ifnil(object_.XmlAttrBg2) then
		{self.}Bg2 := object_.XmlAttrBg2.Value;
	if not ifnil(object_.XmlAttrT2) then
		{self.}T2 := object_.XmlAttrT2.Value;
	if not ifnil(object_.XmlAttrAccent1) then
		{self.}Accent1 := object_.XmlAttrAccent1.Value;
	if not ifnil(object_.XmlAttrAccent2) then
		{self.}Accent2 := object_.XmlAttrAccent2.Value;
	if not ifnil(object_.XmlAttrAccent3) then
		{self.}Accent3 := object_.XmlAttrAccent3.Value;
	if not ifnil(object_.XmlAttrAccent4) then
		{self.}Accent4 := object_.XmlAttrAccent4.Value;
	if not ifnil(object_.XmlAttrAccent5) then
		{self.}Accent5 := object_.XmlAttrAccent5.Value;
	if not ifnil(object_.XmlAttrAccent6) then
		{self.}Accent6 := object_.XmlAttrAccent6.Value;
	if not ifnil(object_.XmlAttrHyperLink) then
		{self.}HyperLink := object_.XmlAttrHyperLink.Value;
	if not ifnil(object_.XmlAttrFollowedHyperlink) then
		{self.}FollowedHyperlink := object_.XmlAttrFollowedHyperlink.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function ShapeDefaults2UnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildShapeDefaults) then
		{self.}XmlChildShapeDefaults := new ShapeDefaultsUnitDecorator(object_.XmlChildShapeDefaults);
	if not ifnil(object_.XmlChildShapeLayout) then
		{self.}XmlChildShapeLayout := new ShapeLayoutUnitDecorator(object_.XmlChildShapeLayout);
	tslassigning := tslassigning_backup;
end;

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

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

function ShapeLayoutUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrExt) then
		{self.}Ext := object_.XmlAttrExt.Value;
	if not ifnil(object_.XmlChildIdMap) then
		{self.}XmlChildIdMap := new IdMapUnitDecorator(object_.XmlChildIdMap);
	tslassigning := tslassigning_backup;
end;

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

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

function IdMapUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrExt) then
		{self.}Ext := object_.XmlAttrExt.Value;
	if not ifnil(object_.XmlAttrData) then
		{self.}Data := object_.XmlAttrData.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function StylesUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrMcIgnorable) then
		{self.}McIgnorable := object_.XmlAttrMcIgnorable.Value;
	if not ifnil(object_.XmlChildDocDefaults) then
		{self.}XmlChildDocDefaults := new DocDefaultsUnitDecorator(object_.XmlChildDocDefaults);
	if not ifnil(object_.XmlChildLatenStyles) then
		{self.}XmlChildLatenStyles := new LatenStylesUnitDecorator(object_.XmlChildLatenStyles);
	elems := object_.Styles();
	for _,elem in elems do
		{self.}AppendChild(new StyleUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function DocDefaultsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildRPrDefault) then
		{self.}XmlChildRPrDefault := new RPrDefaultUnitDecorator(object_.XmlChildRPrDefault);
	if not ifnil(object_.XmlChildPPrDefault) then
		{self.}XmlChildPPrDefault := new PPrDefaultUnitDecorator(object_.XmlChildPPrDefault);
	tslassigning := tslassigning_backup;
end;

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

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

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

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

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

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

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

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

function LatenStylesUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrDefLickedState) then
		{self.}DefLickedState := object_.XmlAttrDefLickedState.Value;
	if not ifnil(object_.XmlAttrDefUIPriority) then
		{self.}DefUIPriority := object_.XmlAttrDefUIPriority.Value;
	if not ifnil(object_.XmlAttrDefSemiHidden) then
		{self.}DefSemiHidden := object_.XmlAttrDefSemiHidden.Value;
	if not ifnil(object_.XmlAttrDefUnhideWhenUsed) then
		{self.}DefUnhideWhenUsed := object_.XmlAttrDefUnhideWhenUsed.Value;
	if not ifnil(object_.XmlAttrDefQFormat) then
		{self.}DefQFormat := object_.XmlAttrDefQFormat.Value;
	if not ifnil(object_.XmlAttrCount) then
		{self.}Count := object_.XmlAttrCount.Value;
	elems := object_.LsdExceptions();
	for _,elem in elems do
		{self.}AppendChild(new LsdExceptionUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function LsdExceptionUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrName) then
		{self.}Name := object_.XmlAttrName.Value;
	if not ifnil(object_.XmlAttrUIPriority) then
		{self.}UIPriority := object_.XmlAttrUIPriority.Value;
	if not ifnil(object_.XmlAttrSemiHidden) then
		{self.}SemiHidden := object_.XmlAttrSemiHidden.Value;
	if not ifnil(object_.XmlAttrUnhideWhenUsed) then
		{self.}UnhideWhenUsed := object_.XmlAttrUnhideWhenUsed.Value;
	if not ifnil(object_.XmlAttrQFormat) then
		{self.}QFormat := object_.XmlAttrQFormat.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function StyleUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	if not ifnil(object_.XmlAttrDefault) then
		{self.}Default := object_.XmlAttrDefault.Value;
	if not ifnil(object_.XmlAttrStyleId) then
		{self.}StyleId := object_.XmlAttrStyleId.Value;
	if not ifnil(object_.XmlChildName) then
		{self.}XmlChildName := new PureWValUnitDecorator(object_.XmlChildName);
	if not ifnil(object_.XmlChildBasedOn) then
		{self.}XmlChildBasedOn := new PureWValUnitDecorator(object_.XmlChildBasedOn);
	if not ifnil(object_.XmlChildNext) then
		{self.}XmlChildNext := new PureWValUnitDecorator(object_.XmlChildNext);
	if not ifnil(object_.XmlChildAutoRedefine) then
		{self.}XmlChildAutoRedefine := new PureWValUnitDecorator(object_.XmlChildAutoRedefine);
	if not ifnil(object_.XmlChildLink) then
		{self.}XmlChildLink := new PureWValUnitDecorator(object_.XmlChildLink);
	if not ifnil(object_.XmlChildUIPriority) then
		{self.}XmlChildUIPriority := new PureWValUnitDecorator(object_.XmlChildUIPriority);
	if not ifnil(object_.XmlChildSemiHidden) then
		{self.}SemiHidden.Copy(object_.XmlChildSemiHidden);
	if not ifnil(object_.XmlChildUnhideWhenUsed) then
		{self.}UnhideWhenUsed.Copy(object_.XmlChildUnhideWhenUsed);
	if not ifnil(object_.XmlChildQFormat) then
		{self.}QFormat.Copy(object_.XmlChildQFormat);
	if not ifnil(object_.XmlChildRsid) then
		{self.}XmlChildRsid := new PureWValUnitDecorator(object_.XmlChildRsid);
	if not ifnil(object_.XmlChildPPr) then
		{self.}XmlChildPPr := new PPrUnitDecorator(object_.XmlChildPPr);
	if not ifnil(object_.XmlChildRPr) then
		{self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
	if not ifnil(object_.XmlChildTblPr) then
		{self.}XmlChildTblPr := new TblPrUnitDecorator(object_.XmlChildTblPr);
	if not ifnil(object_.XmlChildTrPr) then
		{self.}XmlChildTrPr := new TrPrUnitDecorator(object_.XmlChildTrPr);
	if not ifnil(object_.XmlChildTcPr) then
		{self.}XmlChildTcPr := new TcPrUnitDecorator(object_.XmlChildTcPr);
	elems := object_.TblStylePrs();
	for _,elem in elems do
		{self.}AppendChild(new TblStylePrUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function TblStylePrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	if not ifnil(object_.XmlChildPPr) then
		{self.}XmlChildPPr := new PPrUnitDecorator(object_.XmlChildPPr);
	if not ifnil(object_.XmlChildRPr) then
		{self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
	if not ifnil(object_.XmlChildTblPr) then
		{self.}XmlChildTblPr := new TblPrUnitDecorator(object_.XmlChildTblPr);
	if not ifnil(object_.XmlChildTrPr) then
		{self.}XmlChildTrPr := new TrPrUnitDecorator(object_.XmlChildTrPr);
	if not ifnil(object_.XmlChildTcPr) then
		{self.}XmlChildTcPr := new TcPrUnitDecorator(object_.XmlChildTcPr);
	tslassigning := tslassigning_backup;
end;

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

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

function TblIndUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrW) then
		{self.}W := TSSafeUnitConverter.TwipsToPoints(object_.XmlAttrW.Value);
	if not ifnil(object_.XmlAttrType) then
		{self.}Type := object_.XmlAttrType.Value;
	tslassigning := tslassigning_backup;
end;

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

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

function TblCellMarUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildTop) then
		{self.}XmlChildTop := new TblIndUnitDecorator(object_.XmlChildTop);
	if not ifnil(object_.XmlChildLeft) then
		{self.}XmlChildLeft := new TblIndUnitDecorator(object_.XmlChildLeft);
	if not ifnil(object_.XmlChildBottom) then
		{self.}XmlChildBottom := new TblIndUnitDecorator(object_.XmlChildBottom);
	if not ifnil(object_.XmlChildRight) then
		{self.}XmlChildRight := new TblIndUnitDecorator(object_.XmlChildRight);
	tslassigning := tslassigning_backup;
end;

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

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

function WebSettingsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrMcIgnorable) then
		{self.}McIgnorable := object_.XmlAttrMcIgnorable.Value;
	if not ifnil(object_.XmlChildOptimizeForBrowser) then
		{self.}OptimizeForBrowser.Copy(object_.XmlChildOptimizeForBrowser);
	if not ifnil(object_.XmlChildAllowPNG) then
		{self.}AllowPNG.Copy(object_.XmlChildAllowPNG);
	tslassigning := tslassigning_backup;
end;

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

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

function AlternateContentUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildChoice) then
		{self.}XmlChildChoice := new ChoiceUnitDecorator(object_.XmlChildChoice);
	if not ifnil(object_.XmlChildFallback) then
		{self.}XmlChildFallback := new FallbackUnitDecorator(object_.XmlChildFallback);
	tslassigning := tslassigning_backup;
end;

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

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

function ChoiceUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrRequires) then
		{self.}Requires := object_.XmlAttrRequires.Value;
	if not ifnil(object_.XmlChildStyle) then
		{self.}XmlChildStyle := new PureValUnitDecorator(object_.XmlChildStyle);
	if not ifnil(object_.XmlChildDrawing) then
		{self.}XmlChildDrawing := new DrawingUnitDecorator(object_.XmlChildDrawing);
	tslassigning := tslassigning_backup;
end;

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

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

function FallbackUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildStyle) then
		{self.}XmlChildStyle := new PureValUnitDecorator(object_.XmlChildStyle);
	if not ifnil(object_.XmlChildPict) then
		{self.}XmlChildPict := new PictUnitDecorator(object_.XmlChildPict);
	tslassigning := tslassigning_backup;
end;

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

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

function PictUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlChildShapetype) then
		{self.}XmlChildShapetype := new ShapetypeUnitDecorator(object_.XmlChildShapetype);
	if not ifnil(object_.XmlChildShape) then
		{self.}XmlChildShape := new ShapeUnitDecorator(object_.XmlChildShape);
	tslassigning := tslassigning_backup;
end;

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

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

function FtrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrIgnorable) then
		{self.}Ignorable := object_.XmlAttrIgnorable.Value;
	elems := object_.Ps();
	for _,elem in elems do
		{self.}AppendChild(new PUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function HdrUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrIgnorable) then
		{self.}Ignorable := object_.XmlAttrIgnorable.Value;
	elems := object_.Ps();
	for _,elem in elems do
		{self.}AppendChild(new PUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function CommentsUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrIgnorable) then
		{self.}Ignorable := object_.XmlAttrIgnorable.Value;
	elems := object_.Comments();
	for _,elem in elems do
		{self.}AppendChild(new CommentUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function CommentUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrAuthor) then
		{self.}Author := object_.XmlAttrAuthor.Value;
	if not ifnil(object_.XmlAttrDate) then
		{self.}Date := object_.XmlAttrDate.Value;
	if not ifnil(object_.XmlAttrId) then
		{self.}Id := object_.XmlAttrId.Value;
	elems := object_.Ps();
	for _,elem in elems do
		{self.}AppendChild(new PUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function NumberingUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrIgnorable) then
		{self.}Ignorable := object_.XmlAttrIgnorable.Value;
	elems := object_.AbstractNums();
	for _,elem in elems do
		{self.}AppendChild(new AbstractNumUnitDecorator(elem));
	elems := object_.Nums();
	for _,elem in elems do
		{self.}AppendChild(new NumUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function NumUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrNumId) then
		{self.}NumId := object_.XmlAttrNumId.Value;
	if not ifnil(object_.XmlChildAbstractNumId) then
		{self.}XmlChildAbstractNumId := new PureWValUnitDecorator(object_.XmlChildAbstractNumId);
	tslassigning := tslassigning_backup;
end;

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

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

function AbstractNumUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrAbstractNumId) then
		{self.}AbstractNumId := object_.XmlAttrAbstractNumId.Value;
	if not ifnil(object_.XmlAttrRestartNumberingAfterBreak) then
		{self.}RestartNumberingAfterBreak := object_.XmlAttrRestartNumberingAfterBreak.Value;
	if not ifnil(object_.XmlChildNsid) then
		{self.}XmlChildNsid := new PureWValUnitDecorator(object_.XmlChildNsid);
	if not ifnil(object_.XmlChildMultiLevelType) then
		{self.}XmlChildMultiLevelType := new PureWValUnitDecorator(object_.XmlChildMultiLevelType);
	if not ifnil(object_.XmlChildTmpl) then
		{self.}XmlChildTmpl := new PureWValUnitDecorator(object_.XmlChildTmpl);
	elems := object_.Lvls();
	for _,elem in elems do
		{self.}AppendChild(new LvlUnitDecorator(elem));
	tslassigning := tslassigning_backup;
end;

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

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

function LvlUnitDecorator.Convert();
begin
	tslassigning_backup := tslassigning;
	tslassigning := 1;
	if not ifnil(object_.XmlAttrIlvl) then
		{self.}Ilvl := object_.XmlAttrIlvl.Value;
	if not ifnil(object_.XmlAttrTentative) then
		{self.}Tentative := object_.XmlAttrTentative.Value;
	if not ifnil(object_.XmlChildStart) then
		{self.}XmlChildStart := new PureWValUnitDecorator(object_.XmlChildStart);
	if not ifnil(object_.XmlChildNumFmt) then
		{self.}XmlChildNumFmt := new PureWValUnitDecorator(object_.XmlChildNumFmt);
	if not ifnil(object_.XmlChildPStyle) then
		{self.}XmlChildPStyle := new PureWValUnitDecorator(object_.XmlChildPStyle);
	if not ifnil(object_.XmlChildSuff) then
		{self.}XmlChildSuff := new PureWValUnitDecorator(object_.XmlChildSuff);
	if not ifnil(object_.XmlChildLvlText) then
		{self.}XmlChildLvlText := new PureWValUnitDecorator(object_.XmlChildLvlText);
	if not ifnil(object_.XmlChildLvlJc) then
		{self.}XmlChildLvlJc := new PureWValUnitDecorator(object_.XmlChildLvlJc);
	if not ifnil(object_.XmlChildPPr) then
		{self.}XmlChildPPr := new PPrUnitDecorator(object_.XmlChildPPr);
	if not ifnil(object_.XmlChildRPr) then
		{self.}XmlChildRPr := new RPrUnitDecorator(object_.XmlChildRPr);
	tslassigning := tslassigning_backup;
end;

end.