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

public

    // attributes property
    property Before read ReadXmlAttrBefore write WriteXmlAttrBefore;
    property BeforeLines read ReadXmlAttrBeforeLines write WriteXmlAttrBeforeLines;
    property BeforeAutospacing read ReadXmlAttrBeforeAutospacing write WriteXmlAttrBeforeAutospacing;
    property After read ReadXmlAttrAfter write WriteXmlAttrAfter;
    property AfterLines read ReadXmlAttrAfterLines write WriteXmlAttrAfterLines;
    property AfterAutospacing read ReadXmlAttrAfterAutospacing write WriteXmlAttrAfterAutospacing;
    property Line read ReadXmlAttrLine write WriteXmlAttrLine;
    property LineRule read ReadXmlAttrLineRule write WriteXmlAttrLineRule;
    function ReadXmlAttrBefore();
    function WriteXmlAttrBefore(_value);
    function ReadXmlAttrBeforeLines();
    function WriteXmlAttrBeforeLines(_value);
    function ReadXmlAttrBeforeAutospacing();
    function WriteXmlAttrBeforeAutospacing(_value);
    function ReadXmlAttrAfter();
    function WriteXmlAttrAfter(_value);
    function ReadXmlAttrAfterLines();
    function WriteXmlAttrAfterLines(_value);
    function ReadXmlAttrAfterAutospacing();
    function WriteXmlAttrAfterAutospacing(_value);
    function ReadXmlAttrLine();
    function WriteXmlAttrLine(_value);
    function ReadXmlAttrLineRule();
    function WriteXmlAttrLineRule(_value);

public
    // Attributes
    XmlAttrBefore: OpenXmlAttribute;
    XmlAttrBeforeLines: OpenXmlAttribute;
    XmlAttrBeforeAutospacing: OpenXmlAttribute;
    XmlAttrAfter: OpenXmlAttribute;
    XmlAttrAfterLines: OpenXmlAttribute;
    XmlAttrAfterAutospacing: OpenXmlAttribute;
    XmlAttrLine: OpenXmlAttribute;
    XmlAttrLineRule: OpenXmlAttribute;


end;

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

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

function Spacing.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 Spacing.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "before": makeweakref(thisFunction(WriteXmlAttrBefore)),
        pre + "beforeLines": makeweakref(thisFunction(WriteXmlAttrBeforeLines)),
        pre + "beforeAutospacing": makeweakref(thisFunction(WriteXmlAttrBeforeAutospacing)),
        pre + "after": makeweakref(thisFunction(WriteXmlAttrAfter)),
        pre + "afterLines": makeweakref(thisFunction(WriteXmlAttrAfterLines)),
        pre + "afterAutospacing": makeweakref(thisFunction(WriteXmlAttrAfterAutospacing)),
        pre + "line": makeweakref(thisFunction(WriteXmlAttrLine)),
        pre + "lineRule": makeweakref(thisFunction(WriteXmlAttrLineRule)),
    );
    sorted_child_ := array(
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function Spacing.Copy(_obj: Spacing);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlElement).Copy(_obj);
    if not ifnil(_obj.Before) then
        {self.}Before := _obj.Before;
    if not ifnil(_obj.BeforeLines) then
        {self.}BeforeLines := _obj.BeforeLines;
    if not ifnil(_obj.BeforeAutospacing) then
        {self.}BeforeAutospacing := _obj.BeforeAutospacing;
    if not ifnil(_obj.After) then
        {self.}After := _obj.After;
    if not ifnil(_obj.AfterLines) then
        {self.}AfterLines := _obj.AfterLines;
    if not ifnil(_obj.AfterAutospacing) then
        {self.}AfterAutospacing := _obj.AfterAutospacing;
    if not ifnil(_obj.Line) then
        {self.}Line := _obj.Line;
    if not ifnil(_obj.LineRule) then
        {self.}LineRule := _obj.LineRule;
    tslassigning := tslassigning_backup;
end;

function Spacing.ReadXmlAttrBefore();
begin
    return {self.}XmlAttrBefore.Value;
end;

function Spacing.WriteXmlAttrBefore(_value);
begin
    if ifnil({self.}XmlAttrBefore) then
    begin
        {self.}XmlAttrBefore := new OpenXmlAttribute({self.}Prefix, "before", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrBefore;
    end
    {self.}XmlAttrBefore.Value := _value;
end;

function Spacing.ReadXmlAttrBeforeLines();
begin
    return {self.}XmlAttrBeforeLines.Value;
end;

function Spacing.WriteXmlAttrBeforeLines(_value);
begin
    if ifnil({self.}XmlAttrBeforeLines) then
    begin
        {self.}XmlAttrBeforeLines := new OpenXmlAttribute({self.}Prefix, "beforeLines", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrBeforeLines;
    end
    {self.}XmlAttrBeforeLines.Value := _value;
end;

function Spacing.ReadXmlAttrBeforeAutospacing();
begin
    return {self.}XmlAttrBeforeAutospacing.Value;
end;

function Spacing.WriteXmlAttrBeforeAutospacing(_value);
begin
    if ifnil({self.}XmlAttrBeforeAutospacing) then
    begin
        {self.}XmlAttrBeforeAutospacing := new OpenXmlAttribute({self.}Prefix, "beforeAutospacing", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrBeforeAutospacing;
    end
    {self.}XmlAttrBeforeAutospacing.Value := _value;
end;

function Spacing.ReadXmlAttrAfter();
begin
    return {self.}XmlAttrAfter.Value;
end;

function Spacing.WriteXmlAttrAfter(_value);
begin
    if ifnil({self.}XmlAttrAfter) then
    begin
        {self.}XmlAttrAfter := new OpenXmlAttribute({self.}Prefix, "after", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrAfter;
    end
    {self.}XmlAttrAfter.Value := _value;
end;

function Spacing.ReadXmlAttrAfterLines();
begin
    return {self.}XmlAttrAfterLines.Value;
end;

function Spacing.WriteXmlAttrAfterLines(_value);
begin
    if ifnil({self.}XmlAttrAfterLines) then
    begin
        {self.}XmlAttrAfterLines := new OpenXmlAttribute({self.}Prefix, "afterLines", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrAfterLines;
    end
    {self.}XmlAttrAfterLines.Value := _value;
end;

function Spacing.ReadXmlAttrAfterAutospacing();
begin
    return {self.}XmlAttrAfterAutospacing.Value;
end;

function Spacing.WriteXmlAttrAfterAutospacing(_value);
begin
    if ifnil({self.}XmlAttrAfterAutospacing) then
    begin
        {self.}XmlAttrAfterAutospacing := new OpenXmlAttribute({self.}Prefix, "afterAutospacing", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrAfterAutospacing;
    end
    {self.}XmlAttrAfterAutospacing.Value := _value;
end;

function Spacing.ReadXmlAttrLine();
begin
    return {self.}XmlAttrLine.Value;
end;

function Spacing.WriteXmlAttrLine(_value);
begin
    if ifnil({self.}XmlAttrLine) then
    begin
        {self.}XmlAttrLine := new OpenXmlAttribute({self.}Prefix, "line", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrLine;
    end
    {self.}XmlAttrLine.Value := _value;
end;

function Spacing.ReadXmlAttrLineRule();
begin
    return {self.}XmlAttrLineRule.Value;
end;

function Spacing.WriteXmlAttrLineRule(_value);
begin
    if ifnil({self.}XmlAttrLineRule) then
    begin
        {self.}XmlAttrLineRule := new OpenXmlAttribute({self.}Prefix, "lineRule", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrLineRule;
    end
    {self.}XmlAttrLineRule.Value := _value;
end;