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

public

    // empty property
    property VMerge read ReadXmlChildVMerge write WriteXmlChildVMerge;
    property HideMark read ReadXmlChildHideMark write WriteXmlChildHideMark;
    function ReadXmlChildVMerge();
    function WriteXmlChildVMerge(_value);
    function ReadXmlChildHideMark();
    function WriteXmlChildHideMark(_value);

    // normal property
    property TcW read ReadXmlChildTcW;
    property GridSpan read ReadXmlChildGridSpan;
    property VAlign read ReadXmlChildVAlign;
    property Shd read ReadXmlChildShd;
    function ReadXmlChildTcW();
    function ReadXmlChildGridSpan();
    function ReadXmlChildVAlign();
    function ReadXmlChildShd();

public
    // Children
    XmlChildTcW: TblW;
    XmlChildGridSpan: GridSpan;
    XmlChildVMerge: OpenXmlEmpty;
    XmlChildVAlign: PureWVal;
    XmlChildHideMark: OpenXmlEmpty;
    XmlChildShd: Shd;

end;

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

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

function TcPr.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 TcPr.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
    );
    sorted_child_ := array(
        pre + "tcW": array(0, makeweakref(thisFunction(ReadXmlChildTcW))),
        pre + "gridSpan": array(1, makeweakref(thisFunction(ReadXmlChildGridSpan))),
        pre + "vMerge": array(2, makeweakref(thisFunction(ReadXmlChildVMerge))),
        pre + "vAlign": array(3, makeweakref(thisFunction(ReadXmlChildVAlign))),
        pre + "hideMark": array(4, makeweakref(thisFunction(ReadXmlChildHideMark))),
        pre + "shd": array(5, makeweakref(thisFunction(ReadXmlChildShd))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function TcPr.Copy(_obj: TcPr);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlElement).Copy(_obj);
    if not ifnil(_obj.XmlChildTcW) then
        {self.}TcW.Copy(_obj.XmlChildTcW);
    if not ifnil(_obj.XmlChildGridSpan) then
        {self.}GridSpan.Copy(_obj.XmlChildGridSpan);
    if not ifnil(_obj.XmlChildVMerge) then
        ifnil({self.}XmlChildVMerge) ? {self.}VMerge.Copy(_obj.XmlChildVMerge) : {self.}XmlChildVMerge.Copy(_obj.XmlChildVMerge);
    if not ifnil(_obj.XmlChildVAlign) then
        {self.}VAlign.Copy(_obj.XmlChildVAlign);
    if not ifnil(_obj.XmlChildHideMark) then
        ifnil({self.}XmlChildHideMark) ? {self.}HideMark.Copy(_obj.XmlChildHideMark) : {self.}XmlChildHideMark.Copy(_obj.XmlChildHideMark);
    if not ifnil(_obj.XmlChildShd) then
        {self.}Shd.Copy(_obj.XmlChildShd);
    tslassigning := tslassigning_backup;
end;

function TcPr.ReadXmlChildVMerge();
begin
    if tslassigning and ifnil({self.}XmlChildVMerge) then
    begin
        {self.}XmlChildVMerge := new OpenXmlEmpty(self, {self.}Prefix, "vMerge");
        container_.Set({self.}XmlChildVMerge);
        return {self.}XmlChildVMerge;
    end
    return ifnil({self.}XmlChildVMerge) ? false : {self.}XmlChildVMerge.BoolValue();
end;

function TcPr.WriteXmlChildVMerge(_value);
begin
    if ifnil({self.}XmlChildVMerge) then
    begin
        {self.}XmlChildVMerge := new OpenXmlEmpty(self, {self.}Prefix, "vMerge");
        container_.Set({self.}XmlChildVMerge);
    end
    {self.}XmlChildVMerge.Value := _value;
end;

function TcPr.ReadXmlChildHideMark();
begin
    if tslassigning and ifnil({self.}XmlChildHideMark) then
    begin
        {self.}XmlChildHideMark := new OpenXmlEmpty(self, {self.}Prefix, "hideMark");
        container_.Set({self.}XmlChildHideMark);
        return {self.}XmlChildHideMark;
    end
    return ifnil({self.}XmlChildHideMark) ? false : {self.}XmlChildHideMark.BoolValue();
end;

function TcPr.WriteXmlChildHideMark(_value);
begin
    if ifnil({self.}XmlChildHideMark) then
    begin
        {self.}XmlChildHideMark := new OpenXmlEmpty(self, {self.}Prefix, "hideMark");
        container_.Set({self.}XmlChildHideMark);
    end
    {self.}XmlChildHideMark.Value := _value;
end;

function TcPr.ReadXmlChildTcW();
begin
    if tslassigning and ifnil({self.}XmlChildTcW) then
    begin
        {self.}XmlChildTcW := new TblW(self, {self.}Prefix, "tcW");
        container_.Set({self.}XmlChildTcW);
    end
    return {self.}XmlChildTcW;
end;

function TcPr.ReadXmlChildGridSpan();
begin
    if tslassigning and ifnil({self.}XmlChildGridSpan) then
    begin
        {self.}XmlChildGridSpan := new GridSpan(self, {self.}Prefix, "gridSpan");
        container_.Set({self.}XmlChildGridSpan);
    end
    return {self.}XmlChildGridSpan;
end;

function TcPr.ReadXmlChildVAlign();
begin
    if tslassigning and ifnil({self.}XmlChildVAlign) then
    begin
        {self.}XmlChildVAlign := new PureWVal(self, {self.}Prefix, "vAlign");
        container_.Set({self.}XmlChildVAlign);
    end
    return {self.}XmlChildVAlign;
end;

function TcPr.ReadXmlChildShd();
begin
    if tslassigning and ifnil({self.}XmlChildShd) then
    begin
        {self.}XmlChildShd := new Shd(self, {self.}Prefix, "shd");
        container_.Set({self.}XmlChildShd);
    end
    return {self.}XmlChildShd;
end;