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

public

    // empty property
    property I read ReadXmlChildI write WriteXmlChildI;
    property ICs read ReadXmlChildICs write WriteXmlChildICs;
    property B read ReadXmlChildB write WriteXmlChildB;
    property BCs read ReadXmlChildBCs write WriteXmlChildBCs;
    property Strike read ReadXmlChildStrike write WriteXmlChildStrike;
    property U read ReadXmlChildU write WriteXmlChildU;
    function ReadXmlChildI();
    function WriteXmlChildI(_value);
    function ReadXmlChildICs();
    function WriteXmlChildICs(_value);
    function ReadXmlChildB();
    function WriteXmlChildB(_value);
    function ReadXmlChildBCs();
    function WriteXmlChildBCs(_value);
    function ReadXmlChildStrike();
    function WriteXmlChildStrike(_value);
    function ReadXmlChildU();
    function WriteXmlChildU(_value);

    // normal property
    property NoProof read ReadXmlChildNoProof;
    property Position read ReadXmlChildPosition;
    property WebHidden read ReadXmlChildWebHidden;
    property RStyle read ReadXmlChildRStyle;
    property RFonts read ReadXmlChildRFonts;
    property Kern read ReadXmlChildKern;
    property Color read ReadXmlChildColor;
    property Sz read ReadXmlChildSz;
    property SzCs read ReadXmlChildSzCs;
    property Lang read ReadXmlChildLang;
    property W14Ligatures read ReadXmlChildW14Ligatures;
    function ReadXmlChildNoProof();
    function ReadXmlChildPosition();
    function ReadXmlChildWebHidden();
    function ReadXmlChildRStyle();
    function ReadXmlChildRFonts();
    function ReadXmlChildKern();
    function ReadXmlChildColor();
    function ReadXmlChildSz();
    function ReadXmlChildSzCs();
    function ReadXmlChildLang();
    function ReadXmlChildW14Ligatures();

public
    // Children
    XmlChildNoProof: PureVal;
    XmlChildPosition: PureVal;
    XmlChildWebHidden: PureWVal;
    XmlChildRStyle: PureWVal;
    XmlChildRFonts: RFonts;
    XmlChildKern: PureWVal;
    XmlChildI: OpenXmlEmpty;
    XmlChildICs: OpenXmlEmpty;
    XmlChildB: OpenXmlEmpty;
    XmlChildBCs: OpenXmlEmpty;
    XmlChildStrike: OpenXmlEmpty;
    XmlChildColor: Color;
    XmlChildSz: Sz;
    XmlChildSzCs: SzCs;
    XmlChildU: OpenXmlEmpty;
    XmlChildLang: Lang;
    XmlChildW14Ligatures: PureWVal;

end;

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

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

function RPr.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 RPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "noProof": array(0, makeweakref(thisFunction(ReadXmlChildNoProof))),
        pre + "position": array(1, makeweakref(thisFunction(ReadXmlChildPosition))),
        pre + "wedHidden": array(2, makeweakref(thisFunction(ReadXmlChildWebHidden))),
        pre + "rStyle": array(3, makeweakref(thisFunction(ReadXmlChildRStyle))),
        pre + "rFonts": array(4, makeweakref(thisFunction(ReadXmlChildRFonts))),
        pre + "kern": array(5, makeweakref(thisFunction(ReadXmlChildKern))),
        pre + "i": array(6, makeweakref(thisFunction(ReadXmlChildI))),
        pre + "iCs": array(7, makeweakref(thisFunction(ReadXmlChildICs))),
        pre + "b": array(8, makeweakref(thisFunction(ReadXmlChildB))),
        pre + "bCs": array(9, makeweakref(thisFunction(ReadXmlChildBCs))),
        pre + "strike": array(10, makeweakref(thisFunction(ReadXmlChildStrike))),
        pre + "color": array(11, makeweakref(thisFunction(ReadXmlChildColor))),
        pre + "sz": array(12, makeweakref(thisFunction(ReadXmlChildSz))),
        pre + "szCs": array(13, makeweakref(thisFunction(ReadXmlChildSzCs))),
        pre + "u": array(14, makeweakref(thisFunction(ReadXmlChildU))),
        pre + "lang": array(15, makeweakref(thisFunction(ReadXmlChildLang))),
        "w14:ligatures": array(16, makeweakref(thisFunction(ReadXmlChildW14Ligatures))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function RPr.Copy(_obj: RPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlElement).Copy(_obj);
    if not ifnil(_obj.XmlChildNoProof) then
        {self.}NoProof.Copy(_obj.XmlChildNoProof);
    if not ifnil(_obj.XmlChildPosition) then
        {self.}Position.Copy(_obj.XmlChildPosition);
    if not ifnil(_obj.XmlChildWebHidden) then
        {self.}WebHidden.Copy(_obj.XmlChildWebHidden);
    if not ifnil(_obj.XmlChildRStyle) then
        {self.}RStyle.Copy(_obj.XmlChildRStyle);
    if not ifnil(_obj.XmlChildRFonts) then
        {self.}RFonts.Copy(_obj.XmlChildRFonts);
    if not ifnil(_obj.XmlChildKern) then
        {self.}Kern.Copy(_obj.XmlChildKern);
    if not ifnil(_obj.XmlChildI) then
        ifnil({self.}XmlChildI) ? {self.}I.Copy(_obj.XmlChildI) : {self.}XmlChildI.Copy(_obj.XmlChildI);
    if not ifnil(_obj.XmlChildICs) then
        ifnil({self.}XmlChildICs) ? {self.}ICs.Copy(_obj.XmlChildICs) : {self.}XmlChildICs.Copy(_obj.XmlChildICs);
    if not ifnil(_obj.XmlChildB) then
        ifnil({self.}XmlChildB) ? {self.}B.Copy(_obj.XmlChildB) : {self.}XmlChildB.Copy(_obj.XmlChildB);
    if not ifnil(_obj.XmlChildBCs) then
        ifnil({self.}XmlChildBCs) ? {self.}BCs.Copy(_obj.XmlChildBCs) : {self.}XmlChildBCs.Copy(_obj.XmlChildBCs);
    if not ifnil(_obj.XmlChildStrike) then
        ifnil({self.}XmlChildStrike) ? {self.}Strike.Copy(_obj.XmlChildStrike) : {self.}XmlChildStrike.Copy(_obj.XmlChildStrike);
    if not ifnil(_obj.XmlChildColor) then
        {self.}Color.Copy(_obj.XmlChildColor);
    if not ifnil(_obj.XmlChildSz) then
        {self.}Sz.Copy(_obj.XmlChildSz);
    if not ifnil(_obj.XmlChildSzCs) then
        {self.}SzCs.Copy(_obj.XmlChildSzCs);
    if not ifnil(_obj.XmlChildU) then
        ifnil({self.}XmlChildU) ? {self.}U.Copy(_obj.XmlChildU) : {self.}XmlChildU.Copy(_obj.XmlChildU);
    if not ifnil(_obj.XmlChildLang) then
        {self.}Lang.Copy(_obj.XmlChildLang);
    if not ifnil(_obj.XmlChildW14Ligatures) then
        {self.}W14Ligatures.Copy(_obj.XmlChildW14Ligatures);
    tslassigning := tslassigning_backup;
end;

function RPr.ReadXmlChildI();
begin
    if tslassigning and ifnil({self.}XmlChildI) then
    begin
        {self.}XmlChildI := new OpenXmlEmpty(self, {self.}Prefix, "i");
        container_.Set({self.}XmlChildI);
        return {self.}XmlChildI;
    end
    return ifnil({self.}XmlChildI) ? false : {self.}XmlChildI.BoolValue();
end;

function RPr.WriteXmlChildI(_value);
begin
    if ifnil({self.}XmlChildI) then
    begin
        {self.}XmlChildI := new OpenXmlEmpty(self, {self.}Prefix, "i");
        container_.Set({self.}XmlChildI);
    end
    {self.}XmlChildI.Value := _value;
end;

function RPr.ReadXmlChildICs();
begin
    if tslassigning and ifnil({self.}XmlChildICs) then
    begin
        {self.}XmlChildICs := new OpenXmlEmpty(self, {self.}Prefix, "iCs");
        container_.Set({self.}XmlChildICs);
        return {self.}XmlChildICs;
    end
    return ifnil({self.}XmlChildICs) ? false : {self.}XmlChildICs.BoolValue();
end;

function RPr.WriteXmlChildICs(_value);
begin
    if ifnil({self.}XmlChildICs) then
    begin
        {self.}XmlChildICs := new OpenXmlEmpty(self, {self.}Prefix, "iCs");
        container_.Set({self.}XmlChildICs);
    end
    {self.}XmlChildICs.Value := _value;
end;

function RPr.ReadXmlChildB();
begin
    if tslassigning and ifnil({self.}XmlChildB) then
    begin
        {self.}XmlChildB := new OpenXmlEmpty(self, {self.}Prefix, "b");
        container_.Set({self.}XmlChildB);
        return {self.}XmlChildB;
    end
    return ifnil({self.}XmlChildB) ? false : {self.}XmlChildB.BoolValue();
end;

function RPr.WriteXmlChildB(_value);
begin
    if ifnil({self.}XmlChildB) then
    begin
        {self.}XmlChildB := new OpenXmlEmpty(self, {self.}Prefix, "b");
        container_.Set({self.}XmlChildB);
    end
    {self.}XmlChildB.Value := _value;
end;

function RPr.ReadXmlChildBCs();
begin
    if tslassigning and ifnil({self.}XmlChildBCs) then
    begin
        {self.}XmlChildBCs := new OpenXmlEmpty(self, {self.}Prefix, "bCs");
        container_.Set({self.}XmlChildBCs);
        return {self.}XmlChildBCs;
    end
    return ifnil({self.}XmlChildBCs) ? false : {self.}XmlChildBCs.BoolValue();
end;

function RPr.WriteXmlChildBCs(_value);
begin
    if ifnil({self.}XmlChildBCs) then
    begin
        {self.}XmlChildBCs := new OpenXmlEmpty(self, {self.}Prefix, "bCs");
        container_.Set({self.}XmlChildBCs);
    end
    {self.}XmlChildBCs.Value := _value;
end;

function RPr.ReadXmlChildStrike();
begin
    if tslassigning and ifnil({self.}XmlChildStrike) then
    begin
        {self.}XmlChildStrike := new OpenXmlEmpty(self, {self.}Prefix, "strike");
        container_.Set({self.}XmlChildStrike);
        return {self.}XmlChildStrike;
    end
    return ifnil({self.}XmlChildStrike) ? false : {self.}XmlChildStrike.BoolValue();
end;

function RPr.WriteXmlChildStrike(_value);
begin
    if ifnil({self.}XmlChildStrike) then
    begin
        {self.}XmlChildStrike := new OpenXmlEmpty(self, {self.}Prefix, "strike");
        container_.Set({self.}XmlChildStrike);
    end
    {self.}XmlChildStrike.Value := _value;
end;

function RPr.ReadXmlChildU();
begin
    if tslassigning and ifnil({self.}XmlChildU) then
    begin
        {self.}XmlChildU := new OpenXmlEmpty(self, {self.}Prefix, "u");
        container_.Set({self.}XmlChildU);
        return {self.}XmlChildU;
    end
    return ifnil({self.}XmlChildU) ? false : {self.}XmlChildU.BoolValue();
end;

function RPr.WriteXmlChildU(_value);
begin
    if ifnil({self.}XmlChildU) then
    begin
        {self.}XmlChildU := new OpenXmlEmpty(self, {self.}Prefix, "u");
        container_.Set({self.}XmlChildU);
    end
    {self.}XmlChildU.Value := _value;
end;

function RPr.ReadXmlChildNoProof();
begin
    if tslassigning and ifnil({self.}XmlChildNoProof) then
    begin
        {self.}XmlChildNoProof := new PureVal(self, {self.}Prefix, "noProof");
        container_.Set({self.}XmlChildNoProof);
    end
    return {self.}XmlChildNoProof;
end;

function RPr.ReadXmlChildPosition();
begin
    if tslassigning and ifnil({self.}XmlChildPosition) then
    begin
        {self.}XmlChildPosition := new PureVal(self, {self.}Prefix, "position");
        container_.Set({self.}XmlChildPosition);
    end
    return {self.}XmlChildPosition;
end;

function RPr.ReadXmlChildWebHidden();
begin
    if tslassigning and ifnil({self.}XmlChildWebHidden) then
    begin
        {self.}XmlChildWebHidden := new PureWVal(self, {self.}Prefix, "wedHidden");
        container_.Set({self.}XmlChildWebHidden);
    end
    return {self.}XmlChildWebHidden;
end;

function RPr.ReadXmlChildRStyle();
begin
    if tslassigning and ifnil({self.}XmlChildRStyle) then
    begin
        {self.}XmlChildRStyle := new PureWVal(self, {self.}Prefix, "rStyle");
        container_.Set({self.}XmlChildRStyle);
    end
    return {self.}XmlChildRStyle;
end;

function RPr.ReadXmlChildRFonts();
begin
    if tslassigning and ifnil({self.}XmlChildRFonts) then
    begin
        {self.}XmlChildRFonts := new RFonts(self, {self.}Prefix, "rFonts");
        container_.Set({self.}XmlChildRFonts);
    end
    return {self.}XmlChildRFonts;
end;

function RPr.ReadXmlChildKern();
begin
    if tslassigning and ifnil({self.}XmlChildKern) then
    begin
        {self.}XmlChildKern := new PureWVal(self, {self.}Prefix, "kern");
        container_.Set({self.}XmlChildKern);
    end
    return {self.}XmlChildKern;
end;

function RPr.ReadXmlChildColor();
begin
    if tslassigning and ifnil({self.}XmlChildColor) then
    begin
        {self.}XmlChildColor := new Color(self, {self.}Prefix, "color");
        container_.Set({self.}XmlChildColor);
    end
    return {self.}XmlChildColor;
end;

function RPr.ReadXmlChildSz();
begin
    if tslassigning and ifnil({self.}XmlChildSz) then
    begin
        {self.}XmlChildSz := new Sz(self, {self.}Prefix, "sz");
        container_.Set({self.}XmlChildSz);
    end
    return {self.}XmlChildSz;
end;

function RPr.ReadXmlChildSzCs();
begin
    if tslassigning and ifnil({self.}XmlChildSzCs) then
    begin
        {self.}XmlChildSzCs := new SzCs(self, {self.}Prefix, "szCs");
        container_.Set({self.}XmlChildSzCs);
    end
    return {self.}XmlChildSzCs;
end;

function RPr.ReadXmlChildLang();
begin
    if tslassigning and ifnil({self.}XmlChildLang) then
    begin
        {self.}XmlChildLang := new Lang(self, {self.}Prefix, "lang");
        container_.Set({self.}XmlChildLang);
    end
    return {self.}XmlChildLang;
end;

function RPr.ReadXmlChildW14Ligatures();
begin
    if tslassigning and ifnil({self.}XmlChildW14Ligatures) then
    begin
        {self.}XmlChildW14Ligatures := new PureWVal(self, "w14", "ligatures");
        container_.Set({self.}XmlChildW14Ligatures);
    end
    return {self.}XmlChildW14Ligatures;
end;