OfficeXml/autoclass/docx/LatenStyles@DOCX.tsf

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

public

    // attributes property
    property DefLickedState read ReadXmlAttrDefLickedState write WriteXmlAttrDefLickedState;
    property DefUIPriority read ReadXmlAttrDefUIPriority write WriteXmlAttrDefUIPriority;
    property DefSemiHidden read ReadXmlAttrDefSemiHidden write WriteXmlAttrDefSemiHidden;
    property DefUnhideWhenUsed read ReadXmlAttrDefUnhideWhenUsed write WriteXmlAttrDefUnhideWhenUsed;
    property DefQFormat read ReadXmlAttrDefQFormat write WriteXmlAttrDefQFormat;
    property Count read ReadXmlAttrCount write WriteXmlAttrCount;
    function ReadXmlAttrDefLickedState();
    function WriteXmlAttrDefLickedState(_value);
    function ReadXmlAttrDefUIPriority();
    function WriteXmlAttrDefUIPriority(_value);
    function ReadXmlAttrDefSemiHidden();
    function WriteXmlAttrDefSemiHidden(_value);
    function ReadXmlAttrDefUnhideWhenUsed();
    function WriteXmlAttrDefUnhideWhenUsed(_value);
    function ReadXmlAttrDefQFormat();
    function WriteXmlAttrDefQFormat(_value);
    function ReadXmlAttrCount();
    function WriteXmlAttrCount(_value);

    // multi property
    property LsdExceptions read ReadLsdExceptions;
    function ReadLsdExceptions(_index);
    function AddLsdException(): LsdException;
    function AppendLsdException(): LsdException;

public
    // Attributes
    XmlAttrDefLickedState: OpenXmlAttribute;
    XmlAttrDefUIPriority: OpenXmlAttribute;
    XmlAttrDefSemiHidden: OpenXmlAttribute;
    XmlAttrDefUnhideWhenUsed: OpenXmlAttribute;
    XmlAttrDefQFormat: OpenXmlAttribute;
    XmlAttrCount: OpenXmlAttribute;

    // Children

end;

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

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

function LatenStyles.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 LatenStyles.Init();override;
begin
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    attributes_ := array();
    attributes_pf_ := array(
        pre + "defLickedState": makeweakref(thisFunction(WriteXmlAttrDefLickedState)),
        pre + "defUIPriority": makeweakref(thisFunction(WriteXmlAttrDefUIPriority)),
        pre + "defSemiHidden": makeweakref(thisFunction(WriteXmlAttrDefSemiHidden)),
        pre + "defUnhideWhenUsed": makeweakref(thisFunction(WriteXmlAttrDefUnhideWhenUsed)),
        pre + "defQFormat": makeweakref(thisFunction(WriteXmlAttrDefQFormat)),
        pre + "count": makeweakref(thisFunction(WriteXmlAttrCount)),
    );
    sorted_child_ := array(
        pre + "lsdException": array(0, makeweakref(thisFunction(AppendLsdException))),
    );
    container_ := new TSOfficeContainer(sorted_child_);
end;

function LatenStyles.Copy(_obj: LatenStyles);override;
begin
    tslassigning_backup := tslassigning;
    tslassigning := 1;
    class(OpenXmlElement).Copy(_obj);
    if not ifnil(_obj.DefLickedState) then
        {self.}DefLickedState := _obj.DefLickedState;
    if not ifnil(_obj.DefUIPriority) then
        {self.}DefUIPriority := _obj.DefUIPriority;
    if not ifnil(_obj.DefSemiHidden) then
        {self.}DefSemiHidden := _obj.DefSemiHidden;
    if not ifnil(_obj.DefUnhideWhenUsed) then
        {self.}DefUnhideWhenUsed := _obj.DefUnhideWhenUsed;
    if not ifnil(_obj.DefQFormat) then
        {self.}DefQFormat := _obj.DefQFormat;
    if not ifnil(_obj.Count) then
        {self.}Count := _obj.Count;
    tslassigning := tslassigning_backup;
end;

function LatenStyles.ReadXmlAttrDefLickedState();
begin
    return {self.}XmlAttrDefLickedState.Value;
end;

function LatenStyles.WriteXmlAttrDefLickedState(_value);
begin
    if ifnil({self.}XmlAttrDefLickedState) then
    begin
        {self.}XmlAttrDefLickedState := new OpenXmlAttribute({self.}Prefix, "defLickedState", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrDefLickedState;
    end
    {self.}XmlAttrDefLickedState.Value := _value;
end;

function LatenStyles.ReadXmlAttrDefUIPriority();
begin
    return {self.}XmlAttrDefUIPriority.Value;
end;

function LatenStyles.WriteXmlAttrDefUIPriority(_value);
begin
    if ifnil({self.}XmlAttrDefUIPriority) then
    begin
        {self.}XmlAttrDefUIPriority := new OpenXmlAttribute({self.}Prefix, "defUIPriority", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrDefUIPriority;
    end
    {self.}XmlAttrDefUIPriority.Value := _value;
end;

function LatenStyles.ReadXmlAttrDefSemiHidden();
begin
    return {self.}XmlAttrDefSemiHidden.Value;
end;

function LatenStyles.WriteXmlAttrDefSemiHidden(_value);
begin
    if ifnil({self.}XmlAttrDefSemiHidden) then
    begin
        {self.}XmlAttrDefSemiHidden := new OpenXmlAttribute({self.}Prefix, "defSemiHidden", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrDefSemiHidden;
    end
    {self.}XmlAttrDefSemiHidden.Value := _value;
end;

function LatenStyles.ReadXmlAttrDefUnhideWhenUsed();
begin
    return {self.}XmlAttrDefUnhideWhenUsed.Value;
end;

function LatenStyles.WriteXmlAttrDefUnhideWhenUsed(_value);
begin
    if ifnil({self.}XmlAttrDefUnhideWhenUsed) then
    begin
        {self.}XmlAttrDefUnhideWhenUsed := new OpenXmlAttribute({self.}Prefix, "defUnhideWhenUsed", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrDefUnhideWhenUsed;
    end
    {self.}XmlAttrDefUnhideWhenUsed.Value := _value;
end;

function LatenStyles.ReadXmlAttrDefQFormat();
begin
    return {self.}XmlAttrDefQFormat.Value;
end;

function LatenStyles.WriteXmlAttrDefQFormat(_value);
begin
    if ifnil({self.}XmlAttrDefQFormat) then
    begin
        {self.}XmlAttrDefQFormat := new OpenXmlAttribute({self.}Prefix, "defQFormat", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrDefQFormat;
    end
    {self.}XmlAttrDefQFormat.Value := _value;
end;

function LatenStyles.ReadXmlAttrCount();
begin
    return {self.}XmlAttrCount.Value;
end;

function LatenStyles.WriteXmlAttrCount(_value);
begin
    if ifnil({self.}XmlAttrCount) then
    begin
        {self.}XmlAttrCount := new OpenXmlAttribute({self.}Prefix, "count", nil);
        attributes_[length(attributes_)] := {self.}XmlAttrCount;
    end
    {self.}XmlAttrCount.Value := _value;
end;

function LatenStyles.ReadLsdExceptions(_index);
begin
    ind := ifnil(_index) ? -2 : _index;
    pre := {self.}Prefix ? {self.}Prefix + ":" : "";
    return container_.Get(pre + "lsdException", ind);
end;

function LatenStyles.AddLsdException(): LsdException;
begin
    obj := new LsdException(self, {self.}Prefix, "lsdException");
    container_.Insert(obj);
    return obj;
end;

function LatenStyles.AppendLsdException(): LsdException;
begin
    obj := new LsdException(self, {self.}Prefix, "lsdException");
    container_.Append(obj);
    return obj;
end;