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

public

    // attributes property
    property XmlnsC read ReadXmlAttrXmlnsC write WriteXmlAttrXmlnsC;
    property XmlnsA read ReadXmlAttrXmlnsA write WriteXmlAttrXmlnsA;
    property XmlnsR read ReadXmlAttrXmlnsR write WriteXmlAttrXmlnsR;
    function ReadXmlAttrXmlnsC();
    function WriteXmlAttrXmlnsC(_value);
    function ReadXmlAttrXmlnsA();
    function WriteXmlAttrXmlnsA(_value);
    function ReadXmlAttrXmlnsR();
    function WriteXmlAttrXmlnsR(_value);

    // empty property
    property Lang read ReadXmlChildLang write WriteXmlChildLang;
    function ReadXmlChildLang();
    function WriteXmlChildLang(_value);

    // normal property
    property Date1904 read ReadXmlChildDate1904;
    property AlternateContent read ReadXmlChildAlternateContent;
    property Chart read ReadXmlChildChart;
    property SpPr read ReadXmlChildSpPr;
    property ExternalData read ReadXmlChildExternalData;
    function ReadXmlChildDate1904();
    function ReadXmlChildAlternateContent();
    function ReadXmlChildChart();
    function ReadXmlChildSpPr();
    function ReadXmlChildExternalData();

public
    // Attributes
    XmlAttrXmlnsC: OpenXmlAttribute;
    XmlAttrXmlnsA: OpenXmlAttribute;
    XmlAttrXmlnsR: OpenXmlAttribute;

    // Children
    XmlChildDate1904: PureVal;
    XmlChildLang: OpenXmlEmpty;
    XmlChildAlternateContent: AlternateContent;
    XmlChildChart: Chart;
    XmlChildSpPr: SpPr;
    XmlChildExternalData: ExternalData;

end;

function ChartSpace.Create();overload;
begin
    {self.}Create(nil, "c", "chartSpace");
end;

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

function ChartSpace.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 ChartSpace.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        "xmlns:c": makeweakref(thisFunction(WriteXmlAttrXmlnsC)),
        "xmlns:a": makeweakref(thisFunction(WriteXmlAttrXmlnsA)),
        "xmlns:c": makeweakref(thisFunction(WriteXmlAttrXmlnsR)),
    );
    sorted_child_ := array(
        pre + "date1904": array(0, makeweakref(thisFunction(ReadXmlChildDate1904))),
        pre + "lang": array(1, makeweakref(thisFunction(ReadXmlChildLang))),
        "mc:AlternateContent": array(2, makeweakref(thisFunction(ReadXmlChildAlternateContent))),
        pre + "chart": array(3, makeweakref(thisFunction(ReadXmlChildChart))),
        pre + "spPr": array(4, makeweakref(thisFunction(ReadXmlChildSpPr))),
        pre + "externalData": array(5, makeweakref(thisFunction(ReadXmlChildExternalData))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function ChartSpace.Copy(_obj: ChartSpace);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlElement).Copy(_obj);
    if not ifnil(_obj.XmlnsC) then
        {self.}XmlnsC := _obj.XmlnsC;
    if not ifnil(_obj.XmlnsA) then
        {self.}XmlnsA := _obj.XmlnsA;
    if not ifnil(_obj.XmlnsR) then
        {self.}XmlnsR := _obj.XmlnsR;
    if not ifnil(_obj.XmlChildDate1904) then
        {self.}Date1904.Copy(_obj.XmlChildDate1904);
    if not ifnil(_obj.XmlChildLang) then
        ifnil({self.}XmlChildLang) ? {self.}Lang.Copy(_obj.XmlChildLang) : {self.}XmlChildLang.Copy(_obj.XmlChildLang);
    if not ifnil(_obj.XmlChildAlternateContent) then
        {self.}AlternateContent.Copy(_obj.XmlChildAlternateContent);
    if not ifnil(_obj.XmlChildChart) then
        {self.}Chart.Copy(_obj.XmlChildChart);
    if not ifnil(_obj.XmlChildSpPr) then
        {self.}SpPr.Copy(_obj.XmlChildSpPr);
    if not ifnil(_obj.XmlChildExternalData) then
        {self.}ExternalData.Copy(_obj.XmlChildExternalData);
    tslassigning := tslassigning_backup;
end;

function ChartSpace.ReadXmlAttrXmlnsC();
begin
    return {self.}XmlAttrXmlnsC.Value;
end;

function ChartSpace.WriteXmlAttrXmlnsC(_value);
begin
    if ifnil({self.}XmlAttrXmlnsC) then
    begin
        {self.}XmlAttrXmlnsC := new OpenXmlAttribute("xmlns", "c", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrXmlnsC;
    end
    {self.}XmlAttrXmlnsC.Value := _value;
end;

function ChartSpace.ReadXmlAttrXmlnsA();
begin
    return {self.}XmlAttrXmlnsA.Value;
end;

function ChartSpace.WriteXmlAttrXmlnsA(_value);
begin
    if ifnil({self.}XmlAttrXmlnsA) then
    begin
        {self.}XmlAttrXmlnsA := new OpenXmlAttribute("xmlns", "a", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrXmlnsA;
    end
    {self.}XmlAttrXmlnsA.Value := _value;
end;

function ChartSpace.ReadXmlAttrXmlnsR();
begin
    return {self.}XmlAttrXmlnsR.Value;
end;

function ChartSpace.WriteXmlAttrXmlnsR(_value);
begin
    if ifnil({self.}XmlAttrXmlnsR) then
    begin
        {self.}XmlAttrXmlnsR := new OpenXmlAttribute("xmlns", "c", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrXmlnsR;
    end
    {self.}XmlAttrXmlnsR.Value := _value;
end;

function ChartSpace.ReadXmlChildLang();
begin
    if tslassigning and ifnil({self.}XmlChildLang) then
    begin
        {self.}XmlChildLang := new OpenXmlEmpty(self, {self.}Prefix, "lang");
        container_.Set({self.}XmlChildLang);
        return {self.}XmlChildLang;
    end
    return ifnil({self.}XmlChildLang) ? false : {self.}XmlChildLang.BoolValue();
end;

function ChartSpace.WriteXmlChildLang(_value);
begin
    if ifnil({self.}XmlChildLang) then
    begin
        {self.}XmlChildLang := new OpenXmlEmpty(self, {self.}Prefix, "lang");
        container_.Set({self.}XmlChildLang);
    end
    {self.}XmlChildLang.Value := _value;
end;

function ChartSpace.ReadXmlChildDate1904();
begin
    if tslassigning and ifnil({self.}XmlChildDate1904) then
    begin
        {self.}XmlChildDate1904 := new PureVal(self, {self.}Prefix, "date1904");
        container_.Set({self.}XmlChildDate1904);
    end
    return {self.}XmlChildDate1904;
end;

function ChartSpace.ReadXmlChildAlternateContent();
begin
    if tslassigning and ifnil({self.}XmlChildAlternateContent) then
    begin
        {self.}XmlChildAlternateContent := new AlternateContent(self, "mc", "AlternateContent");
        container_.Set({self.}XmlChildAlternateContent);
    end
    return {self.}XmlChildAlternateContent;
end;

function ChartSpace.ReadXmlChildChart();
begin
    if tslassigning and ifnil({self.}XmlChildChart) then
    begin
        {self.}XmlChildChart := new Chart(self, {self.}Prefix, "chart");
        container_.Set({self.}XmlChildChart);
    end
    return {self.}XmlChildChart;
end;

function ChartSpace.ReadXmlChildSpPr();
begin
    if tslassigning and ifnil({self.}XmlChildSpPr) then
    begin
        {self.}XmlChildSpPr := new SpPr(self, {self.}Prefix, "spPr");
        container_.Set({self.}XmlChildSpPr);
    end
    return {self.}XmlChildSpPr;
end;

function ChartSpace.ReadXmlChildExternalData();
begin
    if tslassigning and ifnil({self.}XmlChildExternalData) then
    begin
        {self.}XmlChildExternalData := new ExternalData(self, {self.}Prefix, "externalData");
        container_.Set({self.}XmlChildExternalData);
    end
    return {self.}XmlChildExternalData;
end;