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

public

    // attributes property
    property Rot read ReadXmlAttrRot write WriteXmlAttrRot;
    property SpcFirstLastPara read ReadXmlAttrSpcFirstLastPara write WriteXmlAttrSpcFirstLastPara;
    property VertOverflow read ReadXmlAttrVertOverflow write WriteXmlAttrVertOverflow;
    property HorzOverflow read ReadXmlAttrHorzOverflow write WriteXmlAttrHorzOverflow;
    property Vert read ReadXmlAttrVert write WriteXmlAttrVert;
    property Wrap read ReadXmlAttrWrap write WriteXmlAttrWrap;
    property LIns read ReadXmlAttrLIns write WriteXmlAttrLIns;
    property TIns read ReadXmlAttrTIns write WriteXmlAttrTIns;
    property RIns read ReadXmlAttrRIns write WriteXmlAttrRIns;
    property BIns read ReadXmlAttrBIns write WriteXmlAttrBIns;
    property NumCol read ReadXmlAttrNumCol write WriteXmlAttrNumCol;
    property SpcCol read ReadXmlAttrSpcCol write WriteXmlAttrSpcCol;
    property RtlCol read ReadXmlAttrRtlCol write WriteXmlAttrRtlCol;
    property FromWordArt read ReadXmlAttrFromWordArt write WriteXmlAttrFromWordArt;
    property Anchor read ReadXmlAttrAnchor write WriteXmlAttrAnchor;
    property AnchorCtr read ReadXmlAttrAnchorCtr write WriteXmlAttrAnchorCtr;
    property ForceAA read ReadXmlAttrForceAA write WriteXmlAttrForceAA;
    property CompatLnSpc read ReadXmlAttrCompatLnSpc write WriteXmlAttrCompatLnSpc;
    function ReadXmlAttrRot();
    function WriteXmlAttrRot(_value);
    function ReadXmlAttrSpcFirstLastPara();
    function WriteXmlAttrSpcFirstLastPara(_value);
    function ReadXmlAttrVertOverflow();
    function WriteXmlAttrVertOverflow(_value);
    function ReadXmlAttrHorzOverflow();
    function WriteXmlAttrHorzOverflow(_value);
    function ReadXmlAttrVert();
    function WriteXmlAttrVert(_value);
    function ReadXmlAttrWrap();
    function WriteXmlAttrWrap(_value);
    function ReadXmlAttrLIns();
    function WriteXmlAttrLIns(_value);
    function ReadXmlAttrTIns();
    function WriteXmlAttrTIns(_value);
    function ReadXmlAttrRIns();
    function WriteXmlAttrRIns(_value);
    function ReadXmlAttrBIns();
    function WriteXmlAttrBIns(_value);
    function ReadXmlAttrNumCol();
    function WriteXmlAttrNumCol(_value);
    function ReadXmlAttrSpcCol();
    function WriteXmlAttrSpcCol(_value);
    function ReadXmlAttrRtlCol();
    function WriteXmlAttrRtlCol(_value);
    function ReadXmlAttrFromWordArt();
    function WriteXmlAttrFromWordArt(_value);
    function ReadXmlAttrAnchor();
    function WriteXmlAttrAnchor(_value);
    function ReadXmlAttrAnchorCtr();
    function WriteXmlAttrAnchorCtr(_value);
    function ReadXmlAttrForceAA();
    function WriteXmlAttrForceAA(_value);
    function ReadXmlAttrCompatLnSpc();
    function WriteXmlAttrCompatLnSpc(_value);

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

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

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

    // Children
    XmlChildPrstTxWrap: PrstTxWrap;
    XmlChildNoAutofit: OpenXmlEmpty;

end;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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