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

public

    // attributes property
    property DistT read ReadXmlAttrDistT write WriteXmlAttrDistT;
    property DistB read ReadXmlAttrDistB write WriteXmlAttrDistB;
    property DistL read ReadXmlAttrDistL write WriteXmlAttrDistL;
    property DistR read ReadXmlAttrDistR write WriteXmlAttrDistR;
    property AnchorId read ReadXmlAttrAnchorId write WriteXmlAttrAnchorId;
    property EditId read ReadXmlAttrEditId write WriteXmlAttrEditId;
    function ReadXmlAttrDistT();
    function WriteXmlAttrDistT(_value);
    function ReadXmlAttrDistB();
    function WriteXmlAttrDistB(_value);
    function ReadXmlAttrDistL();
    function WriteXmlAttrDistL(_value);
    function ReadXmlAttrDistR();
    function WriteXmlAttrDistR(_value);
    function ReadXmlAttrAnchorId();
    function WriteXmlAttrAnchorId(_value);
    function ReadXmlAttrEditId();
    function WriteXmlAttrEditId(_value);

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

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

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

end;

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

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

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

function _Inline.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "distT": makeweakref(thisFunction(WriteXmlAttrDistT)),
        "distB": makeweakref(thisFunction(WriteXmlAttrDistB)),
        "distL": makeweakref(thisFunction(WriteXmlAttrDistL)),
        "distR": makeweakref(thisFunction(WriteXmlAttrDistR)),
        "wp14:anchorId": makeweakref(thisFunction(WriteXmlAttrAnchorId)),
        "wp14:editId": makeweakref(thisFunction(WriteXmlAttrEditId)),
    );
    sorted_child_ := array(
        pre + "extent": array(0, makeweakref(thisFunction(ReadXmlChildExtent))),
        pre + "effectExtent": array(1, makeweakref(thisFunction(ReadXmlChildEffectExtent))),
        pre + "docPr": array(2, makeweakref(thisFunction(ReadXmlChildDocPr))),
        pre + "cNvGraphicFramePr": array(3, makeweakref(thisFunction(ReadXmlChildCNvGraphicFramePr))),
        "a:graphic": array(4, makeweakref(thisFunction(ReadXmlChildGraphic))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function _Inline.Copy(_obj: _Inline);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlElement).Copy(_obj);
    if not ifnil(_obj.DistT) then
        {self.}DistT := _obj.DistT;
    if not ifnil(_obj.DistB) then
        {self.}DistB := _obj.DistB;
    if not ifnil(_obj.DistL) then
        {self.}DistL := _obj.DistL;
    if not ifnil(_obj.DistR) then
        {self.}DistR := _obj.DistR;
    if not ifnil(_obj.AnchorId) then
        {self.}AnchorId := _obj.AnchorId;
    if not ifnil(_obj.EditId) then
        {self.}EditId := _obj.EditId;
    if not ifnil(_obj.XmlChildExtent) then
        {self.}Extent.Copy(_obj.XmlChildExtent);
    if not ifnil(_obj.XmlChildEffectExtent) then
        {self.}EffectExtent.Copy(_obj.XmlChildEffectExtent);
    if not ifnil(_obj.XmlChildDocPr) then
        {self.}DocPr.Copy(_obj.XmlChildDocPr);
    if not ifnil(_obj.XmlChildCNvGraphicFramePr) then
        {self.}CNvGraphicFramePr.Copy(_obj.XmlChildCNvGraphicFramePr);
    if not ifnil(_obj.XmlChildGraphic) then
        {self.}Graphic.Copy(_obj.XmlChildGraphic);
    tslassigning := tslassigning_backup;
end;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

function _Inline.ReadXmlChildGraphic();
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;