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

public

    // attributes property
    property DistT read ReadXmlAttrDistT write WriteXmlAttrDistT;
    property DistB read ReadXmlAttrDistB write WriteXmlAttrDistB;
    property DistL read ReadXmlAttrDistL write WriteXmlAttrDistL;
    property DistR read ReadXmlAttrDistR write WriteXmlAttrDistR;
    property SimplePos read ReadXmlAttrSimplePos write WriteXmlAttrSimplePos;
    property RelativeHeight read ReadXmlAttrRelativeHeight write WriteXmlAttrRelativeHeight;
    property BehindDoc read ReadXmlAttrBehindDoc write WriteXmlAttrBehindDoc;
    property Locked read ReadXmlAttrLocked write WriteXmlAttrLocked;
    property Hidden read ReadXmlAttrHidden write WriteXmlAttrHidden;
    property LayoutInCell read ReadXmlAttrLayoutInCell write WriteXmlAttrLayoutInCell;
    property AllowOverlap read ReadXmlAttrAllowOverlap write WriteXmlAttrAllowOverlap;
    property AnchorId read ReadXmlAttrAnchorId write WriteXmlAttrAnchorId;
    property EditId read ReadXmlAttrEditId write WriteXmlAttrEditId;
    function ReadXmlAttrDistT();
    function WriteXmlAttrDistT(_value);
    function ReadXmlAttrDistB();
    function WriteXmlAttrDistB(_value);
    function ReadXmlAttrDistL();
    function WriteXmlAttrDistL(_value);
    function ReadXmlAttrDistR();
    function WriteXmlAttrDistR(_value);
    function ReadXmlAttrSimplePos();
    function WriteXmlAttrSimplePos(_value);
    function ReadXmlAttrRelativeHeight();
    function WriteXmlAttrRelativeHeight(_value);
    function ReadXmlAttrBehindDoc();
    function WriteXmlAttrBehindDoc(_value);
    function ReadXmlAttrLocked();
    function WriteXmlAttrLocked(_value);
    function ReadXmlAttrHidden();
    function WriteXmlAttrHidden(_value);
    function ReadXmlAttrLayoutInCell();
    function WriteXmlAttrLayoutInCell(_value);
    function ReadXmlAttrAllowOverlap();
    function WriteXmlAttrAllowOverlap(_value);
    function ReadXmlAttrAnchorId();
    function WriteXmlAttrAnchorId(_value);
    function ReadXmlAttrEditId();
    function WriteXmlAttrEditId(_value);

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

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

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

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

end;

function Anchor.Create();overload;
begin
    {self.}Create(nil, "wp", "anchor");
end;

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

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

function Anchor.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "distT": makeweakref(thisFunction(WriteXmlAttrDistT)),
        "distB": makeweakref(thisFunction(WriteXmlAttrDistB)),
        "distL": makeweakref(thisFunction(WriteXmlAttrDistL)),
        "distR": makeweakref(thisFunction(WriteXmlAttrDistR)),
        "simplePos": makeweakref(thisFunction(WriteXmlAttrSimplePos)),
        "relativeHeight": makeweakref(thisFunction(WriteXmlAttrRelativeHeight)),
        "behindDoc": makeweakref(thisFunction(WriteXmlAttrBehindDoc)),
        "locked": makeweakref(thisFunction(WriteXmlAttrLocked)),
        "hidden": makeweakref(thisFunction(WriteXmlAttrHidden)),
        "layoutInCell": makeweakref(thisFunction(WriteXmlAttrLayoutInCell)),
        "allowOverlap": makeweakref(thisFunction(WriteXmlAttrAllowOverlap)),
        "wp14:anchorId": makeweakref(thisFunction(WriteXmlAttrAnchorId)),
        "wp14:editId": makeweakref(thisFunction(WriteXmlAttrEditId)),
    );
    sorted_child_ := array(
        pre + "simplePos": array(0, makeweakref(thisFunction(ReadXmlChildSimplePos))),
        pre + "positionH": array(1, makeweakref(thisFunction(ReadXmlChildPositionH))),
        pre + "positionV": array(2, makeweakref(thisFunction(ReadXmlChildPositionV))),
        pre + "extent": array(3, makeweakref(thisFunction(ReadXmlChildExtent))),
        pre + "effectExtent": array(4, makeweakref(thisFunction(ReadXmlChildEffectExtent))),
        pre + "wrapNone": array(5, makeweakref(thisFunction(ReadXmlChildWrapNone))),
        pre + "docPr": array(6, makeweakref(thisFunction(ReadXmlChildDocPr))),
        pre + "cNvGraphicFramePr": array(7, makeweakref(thisFunction(ReadXmlChildCNvGraphicFramePr))),
        "a:graphic": array(8, makeweakref(thisFunction(ReadXmlChildGraphic))),
        "wp14:sizeRelH": array(9, makeweakref(thisFunction(ReadXmlChildSizeRelH))),
        "wp14:sizeRelV": array(10, makeweakref(thisFunction(ReadXmlChildSizeRelV))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Anchor.Copy(_obj: Anchor);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlElement).Copy(_obj);
    if not ifnil(_obj.DistT) then
        {self.}DistT := _obj.DistT;
    if not ifnil(_obj.DistB) then
        {self.}DistB := _obj.DistB;
    if not ifnil(_obj.DistL) then
        {self.}DistL := _obj.DistL;
    if not ifnil(_obj.DistR) then
        {self.}DistR := _obj.DistR;
    if not ifnil(_obj.SimplePos) then
        {self.}SimplePos := _obj.SimplePos;
    if not ifnil(_obj.RelativeHeight) then
        {self.}RelativeHeight := _obj.RelativeHeight;
    if not ifnil(_obj.BehindDoc) then
        {self.}BehindDoc := _obj.BehindDoc;
    if not ifnil(_obj.Locked) then
        {self.}Locked := _obj.Locked;
    if not ifnil(_obj.Hidden) then
        {self.}Hidden := _obj.Hidden;
    if not ifnil(_obj.LayoutInCell) then
        {self.}LayoutInCell := _obj.LayoutInCell;
    if not ifnil(_obj.AllowOverlap) then
        {self.}AllowOverlap := _obj.AllowOverlap;
    if not ifnil(_obj.AnchorId) then
        {self.}AnchorId := _obj.AnchorId;
    if not ifnil(_obj.EditId) then
        {self.}EditId := _obj.EditId;
    if not ifnil(_obj.XmlChildSimplePos) then
        {self.}SimplePos.Copy(_obj.XmlChildSimplePos);
    if not ifnil(_obj.XmlChildPositionH) then
        {self.}PositionH.Copy(_obj.XmlChildPositionH);
    if not ifnil(_obj.XmlChildPositionV) then
        {self.}PositionV.Copy(_obj.XmlChildPositionV);
    if not ifnil(_obj.XmlChildExtent) then
        {self.}Extent.Copy(_obj.XmlChildExtent);
    if not ifnil(_obj.XmlChildEffectExtent) then
        {self.}EffectExtent.Copy(_obj.XmlChildEffectExtent);
    if not ifnil(_obj.XmlChildWrapNone) then
        ifnil({self.}XmlChildWrapNone) ? {self.}WrapNone.Copy(_obj.XmlChildWrapNone) : {self.}XmlChildWrapNone.Copy(_obj.XmlChildWrapNone);
    if not ifnil(_obj.XmlChildDocPr) then
        {self.}DocPr.Copy(_obj.XmlChildDocPr);
    if not ifnil(_obj.XmlChildCNvGraphicFramePr) then
        {self.}CNvGraphicFramePr.Copy(_obj.XmlChildCNvGraphicFramePr);
    if not ifnil(_obj.XmlChildGraphic) then
        {self.}Graphic.Copy(_obj.XmlChildGraphic);
    if not ifnil(_obj.XmlChildSizeRelH) then
        {self.}SizeRelH.Copy(_obj.XmlChildSizeRelH);
    if not ifnil(_obj.XmlChildSizeRelV) then
        {self.}SizeRelV.Copy(_obj.XmlChildSizeRelV);
    tslassigning := tslassigning_backup;
end;

function Anchor.ReadXmlAttrDistT();
begin
    return {self.}XmlAttrDistT.Value;
end;

function Anchor.WriteXmlAttrDistT(_value);
begin
    if ifnil({self.}XmlAttrDistT) then
    begin
        {self.}XmlAttrDistT := new OpenXmlAttribute("", "distT", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrDistT;
    end
    {self.}XmlAttrDistT.Value := _value;
end;

function Anchor.ReadXmlAttrDistB();
begin
    return {self.}XmlAttrDistB.Value;
end;

function Anchor.WriteXmlAttrDistB(_value);
begin
    if ifnil({self.}XmlAttrDistB) then
    begin
        {self.}XmlAttrDistB := new OpenXmlAttribute("", "distB", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrDistB;
    end
    {self.}XmlAttrDistB.Value := _value;
end;

function Anchor.ReadXmlAttrDistL();
begin
    return {self.}XmlAttrDistL.Value;
end;

function Anchor.WriteXmlAttrDistL(_value);
begin
    if ifnil({self.}XmlAttrDistL) then
    begin
        {self.}XmlAttrDistL := new OpenXmlAttribute("", "distL", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrDistL;
    end
    {self.}XmlAttrDistL.Value := _value;
end;

function Anchor.ReadXmlAttrDistR();
begin
    return {self.}XmlAttrDistR.Value;
end;

function Anchor.WriteXmlAttrDistR(_value);
begin
    if ifnil({self.}XmlAttrDistR) then
    begin
        {self.}XmlAttrDistR := new OpenXmlAttribute("", "distR", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrDistR;
    end
    {self.}XmlAttrDistR.Value := _value;
end;

function Anchor.ReadXmlAttrSimplePos();
begin
    return {self.}XmlAttrSimplePos.Value;
end;

function Anchor.WriteXmlAttrSimplePos(_value);
begin
    if ifnil({self.}XmlAttrSimplePos) then
    begin
        {self.}XmlAttrSimplePos := new OpenXmlAttribute("", "simplePos", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrSimplePos;
    end
    {self.}XmlAttrSimplePos.Value := _value;
end;

function Anchor.ReadXmlAttrRelativeHeight();
begin
    return {self.}XmlAttrRelativeHeight.Value;
end;

function Anchor.WriteXmlAttrRelativeHeight(_value);
begin
    if ifnil({self.}XmlAttrRelativeHeight) then
    begin
        {self.}XmlAttrRelativeHeight := new OpenXmlAttribute("", "relativeHeight", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrRelativeHeight;
    end
    {self.}XmlAttrRelativeHeight.Value := _value;
end;

function Anchor.ReadXmlAttrBehindDoc();
begin
    return {self.}XmlAttrBehindDoc.Value;
end;

function Anchor.WriteXmlAttrBehindDoc(_value);
begin
    if ifnil({self.}XmlAttrBehindDoc) then
    begin
        {self.}XmlAttrBehindDoc := new OpenXmlAttribute("", "behindDoc", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrBehindDoc;
    end
    {self.}XmlAttrBehindDoc.Value := _value;
end;

function Anchor.ReadXmlAttrLocked();
begin
    return {self.}XmlAttrLocked.Value;
end;

function Anchor.WriteXmlAttrLocked(_value);
begin
    if ifnil({self.}XmlAttrLocked) then
    begin
        {self.}XmlAttrLocked := new OpenXmlAttribute("", "locked", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrLocked;
    end
    {self.}XmlAttrLocked.Value := _value;
end;

function Anchor.ReadXmlAttrHidden();
begin
    return {self.}XmlAttrHidden.Value;
end;

function Anchor.WriteXmlAttrHidden(_value);
begin
    if ifnil({self.}XmlAttrHidden) then
    begin
        {self.}XmlAttrHidden := new OpenXmlAttribute("", "hidden", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrHidden;
    end
    {self.}XmlAttrHidden.Value := _value;
end;

function Anchor.ReadXmlAttrLayoutInCell();
begin
    return {self.}XmlAttrLayoutInCell.Value;
end;

function Anchor.WriteXmlAttrLayoutInCell(_value);
begin
    if ifnil({self.}XmlAttrLayoutInCell) then
    begin
        {self.}XmlAttrLayoutInCell := new OpenXmlAttribute("", "layoutInCell", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrLayoutInCell;
    end
    {self.}XmlAttrLayoutInCell.Value := _value;
end;

function Anchor.ReadXmlAttrAllowOverlap();
begin
    return {self.}XmlAttrAllowOverlap.Value;
end;

function Anchor.WriteXmlAttrAllowOverlap(_value);
begin
    if ifnil({self.}XmlAttrAllowOverlap) then
    begin
        {self.}XmlAttrAllowOverlap := new OpenXmlAttribute("", "allowOverlap", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrAllowOverlap;
    end
    {self.}XmlAttrAllowOverlap.Value := _value;
end;

function Anchor.ReadXmlAttrAnchorId();
begin
    return {self.}XmlAttrAnchorId.Value;
end;

function Anchor.WriteXmlAttrAnchorId(_value);
begin
    if ifnil({self.}XmlAttrAnchorId) then
    begin
        {self.}XmlAttrAnchorId := new OpenXmlAttribute("wp14", "anchorId", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrAnchorId;
    end
    {self.}XmlAttrAnchorId.Value := _value;
end;

function Anchor.ReadXmlAttrEditId();
begin
    return {self.}XmlAttrEditId.Value;
end;

function Anchor.WriteXmlAttrEditId(_value);
begin
    if ifnil({self.}XmlAttrEditId) then
    begin
        {self.}XmlAttrEditId := new OpenXmlAttribute("wp14", "editId", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrEditId;
    end
    {self.}XmlAttrEditId.Value := _value;
end;

function Anchor.ReadXmlChildWrapNone();
begin
    if tslassigning and ifnil({self.}XmlChildWrapNone) then
    begin
        {self.}XmlChildWrapNone := new OpenXmlEmpty(self, {self.}Prefix, "wrapNone");
        container_.Set({self.}XmlChildWrapNone);
        return {self.}XmlChildWrapNone;
    end
    return ifnil({self.}XmlChildWrapNone) ? false : {self.}XmlChildWrapNone.BoolValue();
end;

function Anchor.WriteXmlChildWrapNone(_value);
begin
    if ifnil({self.}XmlChildWrapNone) then
    begin
        {self.}XmlChildWrapNone := new OpenXmlEmpty(self, {self.}Prefix, "wrapNone");
        container_.Set({self.}XmlChildWrapNone);
    end
    {self.}XmlChildWrapNone.Value := _value;
end;

function Anchor.ReadXmlChildSimplePos();
begin
    if tslassigning and ifnil({self.}XmlChildSimplePos) then
    begin
        {self.}XmlChildSimplePos := new XY(self, {self.}Prefix, "simplePos");
        container_.Set({self.}XmlChildSimplePos);
    end
    return {self.}XmlChildSimplePos;
end;

function Anchor.ReadXmlChildPositionH();
begin
    if tslassigning and ifnil({self.}XmlChildPositionH) then
    begin
        {self.}XmlChildPositionH := new PositionH(self, {self.}Prefix, "positionH");
        container_.Set({self.}XmlChildPositionH);
    end
    return {self.}XmlChildPositionH;
end;

function Anchor.ReadXmlChildPositionV();
begin
    if tslassigning and ifnil({self.}XmlChildPositionV) then
    begin
        {self.}XmlChildPositionV := new PositionV(self, {self.}Prefix, "positionV");
        container_.Set({self.}XmlChildPositionV);
    end
    return {self.}XmlChildPositionV;
end;

function Anchor.ReadXmlChildExtent();
begin
    if tslassigning and ifnil({self.}XmlChildExtent) then
    begin
        {self.}XmlChildExtent := new CXY(self, {self.}Prefix, "extent");
        container_.Set({self.}XmlChildExtent);
    end
    return {self.}XmlChildExtent;
end;

function Anchor.ReadXmlChildEffectExtent();
begin
    if tslassigning and ifnil({self.}XmlChildEffectExtent) then
    begin
        {self.}XmlChildEffectExtent := new EffectExtent(self, {self.}Prefix, "effectExtent");
        container_.Set({self.}XmlChildEffectExtent);
    end
    return {self.}XmlChildEffectExtent;
end;

function Anchor.ReadXmlChildDocPr();
begin
    if tslassigning and ifnil({self.}XmlChildDocPr) then
    begin
        {self.}XmlChildDocPr := new DocPr(self, {self.}Prefix, "docPr");
        container_.Set({self.}XmlChildDocPr);
    end
    return {self.}XmlChildDocPr;
end;

function Anchor.ReadXmlChildCNvGraphicFramePr();
begin
    if tslassigning and ifnil({self.}XmlChildCNvGraphicFramePr) then
    begin
        {self.}XmlChildCNvGraphicFramePr := new CNvGraphicFramePr(self, {self.}Prefix, "cNvGraphicFramePr");
        container_.Set({self.}XmlChildCNvGraphicFramePr);
    end
    return {self.}XmlChildCNvGraphicFramePr;
end;

function Anchor.ReadXmlChildGraphic();
begin
    if tslassigning and ifnil({self.}XmlChildGraphic) then
    begin
        {self.}XmlChildGraphic := new Graphic(self, "a", "graphic");
        container_.Set({self.}XmlChildGraphic);
    end
    return {self.}XmlChildGraphic;
end;

function Anchor.ReadXmlChildSizeRelH();
begin
    if tslassigning and ifnil({self.}XmlChildSizeRelH) then
    begin
        {self.}XmlChildSizeRelH := new SizeRelH(self, "wp14", "sizeRelH");
        container_.Set({self.}XmlChildSizeRelH);
    end
    return {self.}XmlChildSizeRelH;
end;

function Anchor.ReadXmlChildSizeRelV();
begin
    if tslassigning and ifnil({self.}XmlChildSizeRelV) then
    begin
        {self.}XmlChildSizeRelV := new SizeRelV(self, "wp14", "sizeRelV");
        container_.Set({self.}XmlChildSizeRelV);
    end
    return {self.}XmlChildSizeRelV;
end;