type Lvl = 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: Lvl);override;

public

    // attributes property
    property Ilvl read ReadXmlAttrIlvl write WriteXmlAttrIlvl;
    property Tentative read ReadXmlAttrTentative write WriteXmlAttrTentative;
    function ReadXmlAttrIlvl();
    function WriteXmlAttrIlvl(_value);
    function ReadXmlAttrTentative();
    function WriteXmlAttrTentative(_value);

    // normal property
    property Start read ReadXmlChildStart;
    property NumFmt read ReadXmlChildNumFmt;
    property PStyle read ReadXmlChildPStyle;
    property Suff read ReadXmlChildSuff;
    property LvlText read ReadXmlChildLvlText;
    property LvlJc read ReadXmlChildLvlJc;
    property PPr read ReadXmlChildPPr;
    property RPr read ReadXmlChildRPr;
    function ReadXmlChildStart();
    function ReadXmlChildNumFmt();
    function ReadXmlChildPStyle();
    function ReadXmlChildSuff();
    function ReadXmlChildLvlText();
    function ReadXmlChildLvlJc();
    function ReadXmlChildPPr();
    function ReadXmlChildRPr();

public
    // Attributes
    XmlAttrIlvl: OpenXmlAttribute;
    XmlAttrTentative: OpenXmlAttribute;

    // Children
    XmlChildStart: PureWVal;
    XmlChildNumFmt: PureWVal;
    XmlChildPStyle: PureWVal;
    XmlChildSuff: PureWVal;
    XmlChildLvlText: PureWVal;
    XmlChildLvlJc: PureWVal;
    XmlChildPPr: PPr;
    XmlChildRPr: RPr;

end;

function Lvl.Create();overload;
begin
    {self.}Create(nil, "w", "lvl");
end;

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

function Lvl.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 Lvl.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "ilvl": makeweakref(thisFunction(WriteXmlAttrIlvl)),
        pre + "tentative": makeweakref(thisFunction(WriteXmlAttrTentative)),
    );
    sorted_child_ := array(
        pre + "start": array(0, makeweakref(thisFunction(ReadXmlChildStart))),
        pre + "numFmt": array(1, makeweakref(thisFunction(ReadXmlChildNumFmt))),
        pre + "pStyle": array(2, makeweakref(thisFunction(ReadXmlChildPStyle))),
        pre + "suff": array(3, makeweakref(thisFunction(ReadXmlChildSuff))),
        pre + "lvlText": array(4, makeweakref(thisFunction(ReadXmlChildLvlText))),
        pre + "lvlJc": array(5, makeweakref(thisFunction(ReadXmlChildLvlJc))),
        pre + "pPr": array(6, makeweakref(thisFunction(ReadXmlChildPPr))),
        pre + "rPr": array(7, makeweakref(thisFunction(ReadXmlChildRPr))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Lvl.Copy(_obj: Lvl);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlElement).Copy(_obj);
    if not ifnil(_obj.Ilvl) then
        {self.}Ilvl := _obj.Ilvl;
    if not ifnil(_obj.Tentative) then
        {self.}Tentative := _obj.Tentative;
    if not ifnil(_obj.XmlChildStart) then
        {self.}Start.Copy(_obj.XmlChildStart);
    if not ifnil(_obj.XmlChildNumFmt) then
        {self.}NumFmt.Copy(_obj.XmlChildNumFmt);
    if not ifnil(_obj.XmlChildPStyle) then
        {self.}PStyle.Copy(_obj.XmlChildPStyle);
    if not ifnil(_obj.XmlChildSuff) then
        {self.}Suff.Copy(_obj.XmlChildSuff);
    if not ifnil(_obj.XmlChildLvlText) then
        {self.}LvlText.Copy(_obj.XmlChildLvlText);
    if not ifnil(_obj.XmlChildLvlJc) then
        {self.}LvlJc.Copy(_obj.XmlChildLvlJc);
    if not ifnil(_obj.XmlChildPPr) then
        {self.}PPr.Copy(_obj.XmlChildPPr);
    if not ifnil(_obj.XmlChildRPr) then
        {self.}RPr.Copy(_obj.XmlChildRPr);
    tslassigning := tslassigning_backup;
end;

function Lvl.ReadXmlAttrIlvl();
begin
    return {self.}XmlAttrIlvl.Value;
end;

function Lvl.WriteXmlAttrIlvl(_value);
begin
    if ifnil({self.}XmlAttrIlvl) then
    begin
        {self.}XmlAttrIlvl := new OpenXmlAttribute({self.}Prefix, "ilvl", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrIlvl;
    end
    {self.}XmlAttrIlvl.Value := _value;
end;

function Lvl.ReadXmlAttrTentative();
begin
    return {self.}XmlAttrTentative.Value;
end;

function Lvl.WriteXmlAttrTentative(_value);
begin
    if ifnil({self.}XmlAttrTentative) then
    begin
        {self.}XmlAttrTentative := new OpenXmlAttribute({self.}Prefix, "tentative", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrTentative;
    end
    {self.}XmlAttrTentative.Value := _value;
end;

function Lvl.ReadXmlChildStart();
begin
    if tslassigning and ifnil({self.}XmlChildStart) then
    begin
        {self.}XmlChildStart := new PureWVal(self, {self.}Prefix, "start");
        container_.Set({self.}XmlChildStart);
    end
    return {self.}XmlChildStart;
end;

function Lvl.ReadXmlChildNumFmt();
begin
    if tslassigning and ifnil({self.}XmlChildNumFmt) then
    begin
        {self.}XmlChildNumFmt := new PureWVal(self, {self.}Prefix, "numFmt");
        container_.Set({self.}XmlChildNumFmt);
    end
    return {self.}XmlChildNumFmt;
end;

function Lvl.ReadXmlChildPStyle();
begin
    if tslassigning and ifnil({self.}XmlChildPStyle) then
    begin
        {self.}XmlChildPStyle := new PureWVal(self, {self.}Prefix, "pStyle");
        container_.Set({self.}XmlChildPStyle);
    end
    return {self.}XmlChildPStyle;
end;

function Lvl.ReadXmlChildSuff();
begin
    if tslassigning and ifnil({self.}XmlChildSuff) then
    begin
        {self.}XmlChildSuff := new PureWVal(self, {self.}Prefix, "suff");
        container_.Set({self.}XmlChildSuff);
    end
    return {self.}XmlChildSuff;
end;

function Lvl.ReadXmlChildLvlText();
begin
    if tslassigning and ifnil({self.}XmlChildLvlText) then
    begin
        {self.}XmlChildLvlText := new PureWVal(self, {self.}Prefix, "lvlText");
        container_.Set({self.}XmlChildLvlText);
    end
    return {self.}XmlChildLvlText;
end;

function Lvl.ReadXmlChildLvlJc();
begin
    if tslassigning and ifnil({self.}XmlChildLvlJc) then
    begin
        {self.}XmlChildLvlJc := new PureWVal(self, {self.}Prefix, "lvlJc");
        container_.Set({self.}XmlChildLvlJc);
    end
    return {self.}XmlChildLvlJc;
end;

function Lvl.ReadXmlChildPPr();
begin
    if tslassigning and ifnil({self.}XmlChildPPr) then
    begin
        {self.}XmlChildPPr := new PPr(self, {self.}Prefix, "pPr");
        container_.Set({self.}XmlChildPPr);
    end
    return {self.}XmlChildPPr;
end;

function Lvl.ReadXmlChildRPr();
begin
    if tslassigning and ifnil({self.}XmlChildRPr) then
    begin
        {self.}XmlChildRPr := new RPr(self, {self.}Prefix, "rPr");
        container_.Set({self.}XmlChildRPr);
    end
    return {self.}XmlChildRPr;
end;