1237 lines
32 KiB
C#
1237 lines
32 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.ComponentModel;
|
|
using System.Xml;
|
|
|
|
namespace VEPROMS.CSLA.Library
|
|
{
|
|
#region DocStyles
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class DocStyles : vlnFormatItem
|
|
{
|
|
[Description("Document Styles Name")]
|
|
private LazyLoad<string> _Name;
|
|
public string Name
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Name, "@Name");
|
|
}
|
|
}
|
|
private DocStyleList _DocStyleList;
|
|
public DocStyleList DocStyleList
|
|
{
|
|
get
|
|
{
|
|
if (_DocStyleList == null)
|
|
{
|
|
DocStyleList tmp = new DocStyleList(SelectNodes("DocStyle"));
|
|
DocStyleList retval = new DocStyleList(null);
|
|
foreach (DocStyle ds in tmp) retval.Add(ds);
|
|
_DocStyleList = retval;
|
|
}
|
|
return (_DocStyleList);
|
|
}
|
|
set { _DocStyleList = value; }
|
|
}
|
|
private DocStyleList _DocStyleListActive;
|
|
public DocStyleList DocStyleListActive
|
|
{
|
|
get
|
|
{
|
|
if (_DocStyleListActive == null)
|
|
{
|
|
DocStyleList tmp = new DocStyleList(SelectNodes("DocStyle"));
|
|
DocStyleList retval = new DocStyleList(null);
|
|
foreach (DocStyle ds in tmp)
|
|
{
|
|
if (!ds.Inactive) retval.Add(ds);
|
|
}
|
|
_DocStyleListActive = retval;
|
|
}
|
|
return (_DocStyleListActive);
|
|
}
|
|
set { _DocStyleListActive = value; }
|
|
}
|
|
public DocStyles(XmlNode xmlNode) : base(xmlNode) { }
|
|
}
|
|
#endregion
|
|
#region DocStyleAll
|
|
#region DocStyle
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class DocStyle : vlnFormatItem, IVlnIndexedFormatItem
|
|
{
|
|
public DocStyle(XmlNode xmlNode) : base(xmlNode) { }
|
|
public DocStyle() : base() { }
|
|
#region IndexName
|
|
private LazyLoad<int?> _Index;
|
|
public int? Index
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Index, "@Index");
|
|
}
|
|
}
|
|
[Description("Document Styles Name")]
|
|
private LazyLoad<string> _Name;
|
|
public string Name
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Name, "@Name");
|
|
}
|
|
}
|
|
#endregion
|
|
#region Font
|
|
private VE_Font _Font;
|
|
[Category("Font")]
|
|
[DisplayName("Font")]
|
|
[Description("Font")]
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return(_Font == null) ?_Font = new VE_Font(XmlNode): _Font;
|
|
}
|
|
}
|
|
#endregion
|
|
#region AdjustTopMarginOnStepContinuePages
|
|
// B2017-267 Put in for Farley who uses the "PSOnlyFirst" in some of their pagelists so that a section title is printed only on the first page of the section.
|
|
// This will adjust the top margin when the section title is not printed on the other pages. (CreateStepPDF() in PromsPrinter.cs)
|
|
[Category("Miscellaneous")]
|
|
[Description("AdjustTopMarginOnStepContinuePages")]
|
|
private LazyLoad<int?> _AdjustTopMarginOnStepContinuePages;
|
|
public int AdjustTopMarginOnStepContinuePages
|
|
{
|
|
get
|
|
{
|
|
int? value = LazyLoad(ref _AdjustTopMarginOnStepContinuePages, "@AdjustTopMarginOnStepContinuePages");
|
|
if (value == null) _AdjustTopMarginOnStepContinuePages.Value = 0;
|
|
return _AdjustTopMarginOnStepContinuePages.Value??0;
|
|
}
|
|
}
|
|
#endregion
|
|
#region numberingsequence
|
|
[Category("Miscellaneous")]
|
|
[Description("Numbering Sequence")]
|
|
private LazyLoad<E_NumberingSequence?> _NumberingSequence;
|
|
public E_NumberingSequence? NumberingSequence
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad<E_NumberingSequence>(ref _NumberingSequence, "@NumberingSequence");
|
|
}
|
|
}
|
|
#endregion
|
|
#region IndexOtherThanFirstPage
|
|
[Category("Miscellaneous")]
|
|
[Description("IndexOtherThanFirstPage")]
|
|
private LazyLoad<int?> _IndexOtherThanFirstPage;
|
|
public int? IndexOtherThanFirstPage
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IndexOtherThanFirstPage, "@IndexOtherThanFirstPage");
|
|
}
|
|
}
|
|
#endregion
|
|
#region SecOvrideSupInfoTabOff
|
|
// This overrides the tab position of the Supplemental Information steps at the section level
|
|
// This will also override the overall supplemental Information tab adjustment set at the format level (SupInfoTabOff)
|
|
[Category("Miscellaneous")]
|
|
[Description("SecOvrideSupInfoTabOff")]
|
|
private LazyLoad<int?> _SecOvrideSupInfoTabOff;
|
|
public int? SecOvrideSupInfoTabOff
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SecOvrideSupInfoTabOff, "@SecOvrideSupInfoTabOff");
|
|
}
|
|
}
|
|
#endregion
|
|
#region IsStepSection
|
|
[Category("Miscellaneous")]
|
|
[Description("Is a Step Section")]
|
|
private LazyLoad<bool> _IsStepSection;
|
|
public bool IsStepSection
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IsStepSection, "@IsStepSection");
|
|
}
|
|
}
|
|
#endregion
|
|
#region Inactive
|
|
[Category("Miscellaneous")]
|
|
[Description("Is Active Section Type")]
|
|
private LazyLoad<bool> _Inactive;
|
|
public bool Inactive
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Inactive, "@Inactive");
|
|
}
|
|
}
|
|
#endregion
|
|
#region SupplementalInfo
|
|
[Category("Miscellaneous")]
|
|
[Description("Supports Supplemental Information")]
|
|
private LazyLoad<bool> _SupplementalInformation;
|
|
public bool SupplementalInformation
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SupplementalInformation, "@SupplementalInformation");
|
|
}
|
|
}
|
|
// B2023-060: Pagination - if section uses supplemental information, use the Section's properties/pagination (continuous or
|
|
// separate) rather than always setting to separate
|
|
[Category("Miscellaneous")]
|
|
[Description("Supports Supplemental Information Pagination")]
|
|
private LazyLoad<bool> _SupInfoNoPaginOverride;
|
|
public bool SupInfoNoPaginOverride
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SupInfoNoPaginOverride, "@SupInfoNoPaginOverride");
|
|
}
|
|
}
|
|
// F2023-035: WCN - allow for change in left margin for supplemental information pages by
|
|
// setting a value in the DocStyle for the adjustment. This is used when importing the vlnParagraph page
|
|
// page & when doing pagelist items
|
|
private LazyLoad<float?> _SupInfoMargAdj;
|
|
public float? SupInfoMargAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SupInfoMargAdj, "@SupInfoMargAdj");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
#region LandscapePageList
|
|
[Category("Miscellaneous")]
|
|
[Description("Should PageList be landscape")]
|
|
private LazyLoad<bool> _LandscapePageList;
|
|
public bool LandscapePageList
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LandscapePageList, "@LandscapePageList");
|
|
}
|
|
}
|
|
#endregion
|
|
#region ShowSectionTitles
|
|
[Category("Miscellaneous")]
|
|
[Description("Should Section Titles be shown")]
|
|
private LazyLoad<bool> _ShowSectionTitles;
|
|
public bool ShowSectionTitles
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ShowSectionTitles, "@ShowSectionTitles");
|
|
}
|
|
}
|
|
#endregion
|
|
#region ResetFirstPageOnSection
|
|
[Category("Miscellaneous")]
|
|
[Description("Reset first page of section on Separate pagination section")]
|
|
private LazyLoad<bool> _ResetFirstPageOnSection;
|
|
public bool ResetFirstPageOnSection
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ResetFirstPageOnSection, "@ResetFirstPageOnSection");
|
|
}
|
|
}
|
|
#endregion
|
|
#region IncludeInTOC
|
|
[Category("Miscellaneous")]
|
|
[Description("Include in Auto Table Of Contents")]
|
|
private LazyLoad<bool> _IncludeInTOC;
|
|
public bool IncludeInTOC
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IncludeInTOC, "@IncludeInTOC");
|
|
}
|
|
}
|
|
#endregion
|
|
#region UseCheckOffs
|
|
[Category("Miscellaneous")]
|
|
[Description("Section Uses Checkoffs")]
|
|
private LazyLoad<bool> _UseCheckOffs;
|
|
public bool UseCheckOffs
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseCheckOffs, "@UseCheckOffs");
|
|
}
|
|
}
|
|
#endregion
|
|
#region UseCheckOffs
|
|
[Category("Miscellaneous")]
|
|
[Description("Section Uses MetaSection ColSByLevel")]
|
|
private LazyLoad<bool> _UseColSByLevel;
|
|
public bool UseColSByLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseColSByLevel, "@UseColSByLevel");
|
|
}
|
|
}
|
|
#endregion
|
|
#region Oldtonew
|
|
[Category("Miscellaneous")]
|
|
[Description("Convert from old to new")]
|
|
private LazyLoad<int?> _OldToNew;
|
|
public int? OldToNew
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _OldToNew, "@OldToNew");
|
|
}
|
|
}
|
|
#endregion
|
|
#region CancelSectTitle
|
|
[Category("Miscellaneous")]
|
|
[Description("Section Cancel Section Title")]
|
|
private LazyLoad<bool> _CancelSectTitle;
|
|
public bool CancelSectTitle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CancelSectTitle, "@CancelSectTitle");
|
|
}
|
|
}
|
|
#endregion
|
|
#region DontInsertBlankPages
|
|
[Category("Miscellaneous")]
|
|
[Description("Don't insert blank pages in this section when printing duplex with blank pages")]
|
|
//C2023-001 Added for Beaver Valley CAS sections (their two column format)
|
|
private LazyLoad<bool> _DontInsertBlankPages;
|
|
public bool DontInsertBlankPages
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DontInsertBlankPages, "@DontInsertBlankPages");
|
|
}
|
|
}
|
|
#endregion
|
|
#region CenterLine
|
|
//CenterLineX="261.9" CenterLineYTop="673.2" CenterLineYBottom="44.2"
|
|
private LazyLoad<float?> _CenterLineX;
|
|
[Category("CenterLine")]
|
|
[DisplayName("X Location")]
|
|
[Description("Distance from left side of page")]
|
|
public float? CenterLineX
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CenterLineX, "@CenterLineX");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _CenterLineYTop;
|
|
[Category("CenterLine")]
|
|
[DisplayName("Y Top Location")]
|
|
[Description("starting vertical point of line")]
|
|
public float? CenterLineYTop
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CenterLineYTop, "@CenterLineYTop");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _CenterLineYBottom;
|
|
[Category("CenterLine")]
|
|
[DisplayName("Y Bottom Location")]
|
|
[Description("ending vertical point of line")]
|
|
public float? CenterLineYBottom
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CenterLineYBottom, "@CenterLineYBottom");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _CLineWidth;
|
|
[Category("CenterLine")]
|
|
[DisplayName("Line Width")]
|
|
[Description("Width of Lines Internal to Boxes")]
|
|
public float? CLineWidth
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CLineWidth, "@CLineWidth");
|
|
}
|
|
}
|
|
#endregion
|
|
#region OptionalSectionContent
|
|
[Category("Miscellaneous")]
|
|
[Description("Section Optional Content")]
|
|
private LazyLoad<bool> _OptionalSectionContent;
|
|
public bool OptionalSectionContent
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _OptionalSectionContent, "@OptionalSectionContent");
|
|
}
|
|
}
|
|
#endregion
|
|
#region Section Number Flags
|
|
[Category("Miscellaneous")]
|
|
[Description("Don't parse the section number - use DisplayNumber value")]
|
|
private LazyLoad<bool> _DontParseSectionNumber;
|
|
public bool DontParseSectionNumber
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DontParseSectionNumber, "@DontParseSectionNumber");
|
|
}
|
|
}
|
|
#endregion
|
|
#region SpecialStepsFoldout
|
|
[Category("Miscellaneous")]
|
|
[Description("Section Special Steps Foldout")]
|
|
private LazyLoad<bool> _SpecialStepsFoldout;
|
|
public bool SpecialStepsFoldout
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpecialStepsFoldout, "@SpecialStepsFoldout");
|
|
}
|
|
}
|
|
[Category("Miscellaneous")]
|
|
[Description("Section Special Steps Foldout with white space")]
|
|
private LazyLoad<bool> _SpecialStepsFoldoutKeepWhiteSpace;
|
|
public bool SpecialStepsFoldoutKeepWhiteSpace
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpecialStepsFoldoutKeepWhiteSpace, "@SpecialStepsFoldoutKeepWhiteSpace");
|
|
}
|
|
}
|
|
[Category("Miscellaneous")]
|
|
[Description("Section Extra Line Header")]
|
|
private LazyLoad<bool> _ExtraLineHeader;
|
|
public bool ExtraLineHeader
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ExtraLineHeader, "@ExtraLineHeader");
|
|
}
|
|
}
|
|
#endregion
|
|
#region UndSpecialStepsFoldout
|
|
[Category("Miscellaneous")]
|
|
[Description("Section Cancel Section Title")]
|
|
private LazyLoad<bool> _UndSpecialStepsFoldout;
|
|
public bool UndSpecialStepsFoldout
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UndSpecialStepsFoldout, "@UndSpecialStepsFoldout");
|
|
}
|
|
}
|
|
#endregion
|
|
#region CoverNoMergedPageNum
|
|
[Category("Miscellaneous")]
|
|
[Description("Cover Page Do Not Show Page Count")]
|
|
private LazyLoad<bool> _CoverNoMergedPageNum; // F2021-046: flag if cover page section doesn't print page number on first page of merged pdf:
|
|
public bool CoverNoMergedPageNum
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CoverNoMergedPageNum, "@CoverNoMergedPageNum");
|
|
}
|
|
}
|
|
#endregion
|
|
#region AlignHLSTabWithSect
|
|
[Category("Miscellaneous")]
|
|
[Description("Align HLS Tab With Sect")]
|
|
private LazyLoad<bool> _AlignHLSTabWithSect;
|
|
public bool AlignHLSTabWithSect
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AlignHLSTabWithSect, "@AlignHLSTabWithSect");
|
|
}
|
|
}
|
|
#endregion
|
|
#region AdjSectTitleLoc
|
|
[Category("Miscellaneous")]
|
|
[Description("Adjust Section Title Location")]
|
|
private LazyLoad<bool> _AdjSectTitleLoc;
|
|
public bool AdjSectTitleLoc // B2022-129: don't indent HLS when flag is on (Barakah - single column step attachment with meta sect)
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AdjSectTitleLoc, "@AdjSectTitleLoc");
|
|
}
|
|
}
|
|
#endregion
|
|
#region ShowAlarmPointWindowInfo
|
|
[Category("Miscellaneous")]
|
|
[Description("Show Alarm Point Table Info in Step Editor")]
|
|
private LazyLoad<bool> _ShowAlarmPointWindowInfo;
|
|
//C2021-018 show alarm point RO data in step editor (BNPP Alarms)
|
|
public bool ShowAlarmPointWindowInfo
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ShowAlarmPointWindowInfo, "@ShowAlarmPointWindowInfo");
|
|
}
|
|
}
|
|
#endregion
|
|
#region ComponentList
|
|
[Category("Miscellaneous")]
|
|
[Description("Component List")]
|
|
private LazyLoad<bool> _ComponentList;
|
|
public bool ComponentList
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ComponentList, "@ComponentList");
|
|
}
|
|
}
|
|
#endregion
|
|
#region pagestyle
|
|
private PageStyle _pagestyle;
|
|
[Category("Miscellaneous")]
|
|
[DisplayName("Page Style")]
|
|
[Description("Page Style")]
|
|
public PageStyle pagestyle
|
|
{
|
|
get
|
|
{
|
|
string str = "//PageStyles/PageStyle[" + (IntLookup("@PageStyle") + 1).ToString() + "]";
|
|
XmlNode xn = SelectSingleNode(str);
|
|
if (_pagestyle == null) _pagestyle = new PageStyle(SelectSingleNode("//PageStyles/PageStyle[" + (IntLookup("@PageStyle") + 1).ToString() + "]"));
|
|
return _pagestyle;
|
|
}
|
|
}
|
|
#endregion
|
|
#region SubElements
|
|
private Layout _Layout;
|
|
public Layout Layout
|
|
{
|
|
get
|
|
{
|
|
return (_Layout == null ? _Layout = new Layout(SelectSingleNode("Layout")) : _Layout);
|
|
}
|
|
}
|
|
private SectTop _SectTop;
|
|
public SectTop SectTop
|
|
{
|
|
get
|
|
{
|
|
return (_SectTop == null ? _SectTop = new SectTop(SelectSingleNode("SectTop")) : _SectTop);
|
|
}
|
|
}
|
|
private Continue _Continue;
|
|
public Continue Continue
|
|
{
|
|
get
|
|
{
|
|
return (_Continue == null ? _Continue = new Continue(SelectSingleNode("Continue")) : _Continue);
|
|
}
|
|
}
|
|
private End _End;
|
|
public End End
|
|
{
|
|
get
|
|
{
|
|
return (_End == null ? _End = new End(SelectSingleNode("End")) : _End);
|
|
}
|
|
}
|
|
private Final _Final;
|
|
public Final Final
|
|
{
|
|
get
|
|
{
|
|
return (_Final == null ? _Final = new Final(SelectSingleNode("Final")) : _Final);
|
|
}
|
|
}
|
|
private StructureStyle _StructureStyle;
|
|
public StructureStyle StructureStyle
|
|
{
|
|
get
|
|
{
|
|
return (_StructureStyle == null ? _StructureStyle = new StructureStyle(SelectSingleNode("StructureStyle")) : _StructureStyle);
|
|
}
|
|
}
|
|
#endregion
|
|
public override string ToString()
|
|
{
|
|
return String.Format("{0:D2} - {1}", Index, Name);
|
|
}
|
|
}
|
|
#endregion
|
|
#region DocStyleList
|
|
[TypeConverter(typeof(vlnListConverter<DocStyleList, DocStyle>))]
|
|
public class DocStyleList : vlnIndexedFormatList<DocStyle>
|
|
{
|
|
public DocStyleList(XmlNodeList xmlNodeList) : base(xmlNodeList, null) { }
|
|
public DocStyle GetDocStyleItem(int itmcnt) // get the 'itm'th one from list, starting at '0'
|
|
{
|
|
int cnt = 0;
|
|
foreach (DocStyle ds in this)
|
|
{
|
|
if (cnt == itmcnt) return ds;
|
|
cnt++;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Layout
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Layout : vlnFormatItem
|
|
{
|
|
public Layout(XmlNode xmlNode) : base(xmlNode) { }
|
|
public Layout() : base() { }
|
|
#region TopMargin
|
|
private LazyLoad<float?> _TopMargin;
|
|
[Category("Layout")]
|
|
[DisplayName("Top Margin on Printed Page")]
|
|
[Description("Top Margin on Printed Page")]
|
|
public float? TopMargin
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TopMargin, "@TopMargin");
|
|
}
|
|
}
|
|
#endregion
|
|
#region FooterLength
|
|
private LazyLoad<float?> _FooterLength;
|
|
[Category("Location")]
|
|
[DisplayName("Number of lines required for footer")]
|
|
[Description("Number of lines required for footer")]
|
|
public float? FooterLength
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _FooterLength, "@FooterLength");
|
|
}
|
|
}
|
|
// B2023-052: Beaver Valley - Inconsistent change bar location
|
|
private LazyLoad<float?> _AbsChgBarAdj;
|
|
[Category("Location")]
|
|
[DisplayName("Absolute change bar adjustment for margin differences")]
|
|
[Description("Absolute change bar adjustment for margin differences")]
|
|
public float? AbsChgBarAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AbsChgBarAdj, "@AbsChgBarAdj");
|
|
}
|
|
}
|
|
#endregion
|
|
#region LeftMargin
|
|
private LazyLoad<float?> _LeftMargin;
|
|
[Category("Location")]
|
|
[DisplayName("Size of left margin")]
|
|
[Description("Size of left margin")]
|
|
public float? LeftMargin
|
|
{
|
|
get
|
|
{
|
|
if (PlantFormat.IgnoreUCF) return LazyLoad(ref _LeftMargin, "@LeftMargin");
|
|
if (MyFormat.PlantFormat.FormatConfig == null) return LazyLoad(ref _LeftMargin, "@LeftMargin");
|
|
|
|
// see if there is UCF (User Control of Format) data, need to match the index of the ucf data to that in the original format, and
|
|
// also need to check that LeftMargin is not null, since other docstyle data may exist in UCF but not LeftMargin:
|
|
XmlNode par = this.XmlNode.ParentNode;
|
|
string indx = null;
|
|
XmlElement ele = par as XmlElement;
|
|
if (ele.HasAttribute("Index")) indx = ele.GetAttribute("Index");
|
|
if (indx == null) return LazyLoad(ref _LeftMargin, "@LeftMargin");
|
|
if (MyFormat.PlantFormat.FormatConfig != null && this.MyFormat.PlantFormat.FormatConfig.PlantFormat.DocStyles != null && MyFormat.PlantFormat.FormatConfig.PlantFormat.DocStyles.Count > 0)
|
|
{
|
|
foreach (FormatConfig.DocStyle ds in MyFormat.PlantFormat.FormatConfig.PlantFormat.DocStyles)
|
|
{
|
|
if (indx == ds.Index)
|
|
{
|
|
float? test = ds.Layout.LeftMargin;
|
|
if (test != null) _LeftMargin = new LazyLoad<float?>(ds.Layout.LeftMargin);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return LazyLoad(ref _LeftMargin, "@LeftMargin");
|
|
}
|
|
}
|
|
#endregion
|
|
#region PageLength
|
|
private LazyLoad<float?> _PageLength;
|
|
[Category("Location")]
|
|
[DisplayName("Length of Page")]
|
|
[Description("Length of Page")]
|
|
public float? PageLength
|
|
{
|
|
get
|
|
{
|
|
if (PlantFormat.IgnoreUCF) return LazyLoad(ref _PageLength, "@PageLength");
|
|
if (MyFormat.PlantFormat.FormatConfig == null) return LazyLoad(ref _PageLength, "@PageLength");
|
|
|
|
// see if there is UCF (User Control of Format) data, need to match the index of the ucf data to that in the original format, and
|
|
// also need to check that PageLength is not null, since other docstyle data may exist in UCF but not PageLength:
|
|
XmlNode par = this.XmlNode.ParentNode;
|
|
string indx = null;
|
|
XmlElement ele = par as XmlElement;
|
|
if (ele.HasAttribute("Index")) indx = ele.GetAttribute("Index");
|
|
if (indx == null) return LazyLoad(ref _PageLength, "@PageLength");
|
|
if (MyFormat.PlantFormat.FormatConfig != null && this.MyFormat.PlantFormat.FormatConfig.PlantFormat.DocStyles != null && MyFormat.PlantFormat.FormatConfig.PlantFormat.DocStyles.Count > 0)
|
|
{
|
|
foreach (FormatConfig.DocStyle ds in MyFormat.PlantFormat.FormatConfig.PlantFormat.DocStyles)
|
|
{
|
|
if (indx == ds.Index)
|
|
{
|
|
float? test = ds.Layout.PageLength;
|
|
if (test != null) _PageLength = new LazyLoad<float?>(ds.Layout.PageLength);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return LazyLoad(ref _PageLength, "@PageLength");
|
|
}
|
|
}
|
|
#endregion
|
|
#region PageWidth
|
|
private LazyLoad<float?> _PageWidth;
|
|
[Category("Location")]
|
|
[DisplayName("Width of Page")]
|
|
[Description("Width of Page")]
|
|
public float? PageWidth
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PageWidth, "@PageWidth");
|
|
}
|
|
}
|
|
#endregion
|
|
#region MSWordXAdj
|
|
private LazyLoad<float?> _MSWordXAdj;
|
|
[Category("Location")]
|
|
[DisplayName("MSWord X Adjustment")]
|
|
[Description("X Placement of PDF during Print")]
|
|
public float? MSWordXAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MSWordXAdj, "@MSWordXAdj");
|
|
}
|
|
}
|
|
#endregion
|
|
#region MSWordYAdj
|
|
private LazyLoad<float?> _MSWordYAdj;
|
|
[Category("Location")]
|
|
[DisplayName("MSWord Y Adjustment")]
|
|
[Description("Y Placement of PDF during Print")]
|
|
public float? MSWordYAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MSWordYAdj, "@MSWordYAdj");
|
|
}
|
|
}
|
|
#endregion
|
|
#region SectionMacro
|
|
private LazyLoad<string> _SectionMacro;
|
|
[Category("Extras")]
|
|
[DisplayName("Section Macro")]
|
|
[Description("Section Macro Prints With Title")]
|
|
public string SectionMacro
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SectionMacro, "@SectionMacro");
|
|
}
|
|
}
|
|
#endregion
|
|
#region CenterToStepThenPage
|
|
[Category("Layout")]
|
|
[Description("CenterToStepThenPage")]
|
|
private LazyLoad<bool> _CenterToStepThenPage;
|
|
public bool CenterToStepThenPage
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CenterToStepThenPage, "@CenterToStepThenPage");
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region SectTop
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class SectTop : vlnFormatItem
|
|
{
|
|
public SectTop(XmlNode xmlNode) : base(xmlNode) { }
|
|
public SectTop() : base() { }
|
|
#region Font
|
|
private VE_Font _Font;
|
|
[Category("Font")]
|
|
[DisplayName("Font")]
|
|
[Description("Font")]
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null) ? _Font = new VE_Font(XmlNode) : _Font;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Margin
|
|
private LazyLoad<float?> _Margin;
|
|
[Category("Section Continue Msg")]
|
|
[DisplayName("Margin for Section top msg")]
|
|
[Description("Margin for Section top msg")]
|
|
public float? Margin
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Margin, "@Margin");
|
|
}
|
|
}
|
|
#endregion
|
|
#region MaxLen
|
|
private LazyLoad<int?> _MaxLen;
|
|
[Category("Section Continue Msg")]
|
|
[DisplayName("MaxLen for text within the column")]
|
|
[Description("MaxLen for text within the column")]
|
|
public int? MaxLen
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MaxLen, "@MaxLen");
|
|
}
|
|
}
|
|
#endregion
|
|
#region Message
|
|
private LazyLoad<string> _Message;
|
|
[Category("Continue Msg")]
|
|
[DisplayName("Section Top Continue Msg")]
|
|
[Description("Section Top Continue Msg")]
|
|
public string Message
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Message, "@Message");
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region ContinueAll
|
|
#region Continue
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Continue : vlnFormatItem
|
|
{
|
|
public Continue(XmlNode xmlNode) : base(xmlNode) { }
|
|
public Continue() : base() { }
|
|
#region Font
|
|
private VE_Font _Font;
|
|
[Category("Continue Msg")]
|
|
[DisplayName("Font")]
|
|
[Description("Font")]
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
|
|
}
|
|
}
|
|
#endregion
|
|
#region SubElements
|
|
private Top _Top;
|
|
public Top Top
|
|
{
|
|
get
|
|
{
|
|
return (_Top == null? _Top = new Top(SelectSingleNode("Top")): _Top);
|
|
}
|
|
}
|
|
private Bottom _Bottom;
|
|
public Bottom Bottom
|
|
{
|
|
get
|
|
{
|
|
return (_Bottom == null ? _Bottom = new Bottom(SelectSingleNode("Bottom")) : _Bottom);
|
|
}
|
|
}
|
|
private SectionTitle _SectionTitle;
|
|
public SectionTitle SectionTitle
|
|
{
|
|
get
|
|
{
|
|
return (_SectionTitle == null ? _SectionTitle = new SectionTitle(SelectSingleNode("SectionTitle")) : _SectionTitle);
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Top
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Top : vlnFormatItem
|
|
{
|
|
public Top(XmlNode xmlNode) : base(xmlNode) { }
|
|
public Top() : base() { }
|
|
#region Font
|
|
private VE_Font _Font;
|
|
[Category("Font")]
|
|
[DisplayName("Font")]
|
|
[Description("Font")]
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null) ? _Font = new VE_Font(XmlNode) : _Font;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Margin
|
|
private LazyLoad<float?> _Margin;
|
|
[Category("Continue Msg")]
|
|
[DisplayName("Margin for top msg")]
|
|
[Description("Margin for top msg")]
|
|
public float? Margin
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Margin, "@Margin");
|
|
}
|
|
}
|
|
#endregion
|
|
#region RowOverride
|
|
// C2019-044 put in for Barakah Single Column format
|
|
// specify the row to put the top continue message
|
|
// this allows us to put the Top Continue Message on the same row as the checkoff (initials) header - per their writer's guide
|
|
private LazyLoad<float?> _RowOverride;
|
|
[Category("Continue Msg")]
|
|
[DisplayName("Top msg on specific row")]
|
|
[Description("Top msg on specific row")]
|
|
public float? RowOverride
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RowOverride, "@RowOverride");
|
|
}
|
|
}
|
|
#endregion
|
|
#region UseStepTabs
|
|
private LazyLoad<bool> _UseStepTabs;
|
|
[Category("Continue Msg")]
|
|
[DisplayName("Flag to use step tabs")]
|
|
[Description("Flag to use step tabs")]
|
|
public bool UseStepTabs
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseStepTabs, "@UseStepTabs");
|
|
}
|
|
}
|
|
#endregion
|
|
#region HLS
|
|
private LazyLoad<int?> _HLS;
|
|
[Category("Continue Msg")]
|
|
[DisplayName("Include HLS in top continue msg")]
|
|
[Description("Include HLS in top continue msg")]
|
|
public int? HLS
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _HLS, "@HLS");
|
|
}
|
|
}
|
|
#endregion
|
|
#region PlaceAtLeftMargin
|
|
private LazyLoad<bool> _PlaceAtLeftMargin; // F2019-033 only use the Left Margin plus any Top message margin
|
|
[Category("Continue Msg")]
|
|
[DisplayName("Flag to position at left margin")]
|
|
[Description("Flag to position at left margin")]
|
|
public bool PlaceAtLeftMargin
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PlaceAtLeftMargin, "@PlaceAtLeftMargin");
|
|
}
|
|
}
|
|
#endregion
|
|
#region Message
|
|
private LazyLoad<bool> _RemoveBullet;
|
|
public bool RemoveBullet // C2021-024: WCN1 if bullet exists in combined tab, stop right before bullet.
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RemoveBullet, "@RemoveBullet");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Message;
|
|
[Category("Continue Msg")]
|
|
[DisplayName("Top Continue Msg")]
|
|
[Description("Top Continue Msg")]
|
|
public string Message
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Message, "@Message");
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Bottom
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Bottom : vlnFormatItem
|
|
{
|
|
public Bottom(XmlNode xmlNode) : base(xmlNode) { }
|
|
public Bottom() : base() { }
|
|
#region Font
|
|
private VE_Font _Font;
|
|
[Category("Font")]
|
|
[DisplayName("Font")]
|
|
[Description("Font")]
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null) ? _Font = new VE_Font(XmlNode) : _Font;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Margin
|
|
private LazyLoad<float?> _Margin;
|
|
[Category("Continue Msg")]
|
|
[DisplayName("Margin for bottom msg")]
|
|
[Description("Margin for bottom msg")]
|
|
public float? Margin
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Margin, "@Margin");
|
|
}
|
|
}
|
|
#endregion
|
|
#region MarginR BGE
|
|
private LazyLoad<float?> _MarginR;
|
|
[Category("Continue Msg")]
|
|
[DisplayName("Margin for bottom msg RNO Column (if in both columns)")]
|
|
[Description("Margin for bottom msg RNO Column (if in both columns)")]
|
|
public float? MarginR
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MarginR, "@MarginR");
|
|
}
|
|
}
|
|
#endregion
|
|
#region Location
|
|
[Category("Continue Msg")]
|
|
[Description("Bottom Continue Location")]
|
|
|
|
private LazyLoad<E_NumberingSequence?> _NumberingSequence;
|
|
public E_NumberingSequence? NumberingSequence
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad<E_NumberingSequence>(ref _NumberingSequence, "@NumberingSequence");
|
|
}
|
|
}
|
|
private LazyLoad<E_ContBottomLoc?> _Location;
|
|
public E_ContBottomLoc? Location
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad<E_ContBottomLoc>(ref _Location, "@Location");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NoOverrideSpace;
|
|
public bool NoOverrideSpace
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NoOverrideSpace, "@NoOverrideSpace");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _LocAdj;
|
|
public int? LocAdj
|
|
{
|
|
get
|
|
{
|
|
|
|
return LazyLoad(ref _LocAdj, "@LocAdj");
|
|
}
|
|
}
|
|
#endregion
|
|
#region Message
|
|
private LazyLoad<bool> _RemoveBullet;
|
|
public bool RemoveBullet // C2021-024: WCN1 if bullet exists in combined tab, stop right before bullet.
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RemoveBullet, "@RemoveBullet");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Message;
|
|
[Category("Continue Msg")]
|
|
[DisplayName("Bottom Continue Msg")]
|
|
[Description("Bottom Continue Msg")]
|
|
public string Message
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Message, "@Message");
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region SectionTitle
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class SectionTitle : vlnFormatItem
|
|
{
|
|
public SectionTitle(XmlNode xmlNode) : base(xmlNode) { }
|
|
public SectionTitle() : base() { }
|
|
#region AppendToTitle
|
|
private LazyLoad<string> _AppendToTitle;
|
|
[Category("Section Title Continue Msg")]
|
|
[DisplayName("AppendToTitle")]
|
|
[Description("Append Text to Section Title For Continue Msg")]
|
|
public string AppendToTitle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AppendToTitle, "@AppendToTitle");
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion //SectionTitle - continue setting
|
|
#endregion
|
|
#region End
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class End : vlnFormatItem
|
|
{
|
|
public End(XmlNode xmlNode) : base(xmlNode) { }
|
|
public End() : base() { }
|
|
#region Font
|
|
private VE_Font _Font;
|
|
[Category("End Msg")]
|
|
[DisplayName("Font")]
|
|
[Description("Font")]
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null ? _Font = new VE_Font(XmlNode) : _Font);
|
|
}
|
|
}
|
|
#endregion
|
|
#region Flag
|
|
private LazyLoad<int?> _Flag;
|
|
[Category("End Msg")]
|
|
[DisplayName("End Msg Exists")]
|
|
[Description("End Msg Exists")]
|
|
public int? Flag
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Flag, "@Flag");
|
|
}
|
|
}
|
|
#endregion
|
|
#region Message
|
|
private LazyLoad<string> _Message;
|
|
[Category("End Msg")]
|
|
[DisplayName("End Message")]
|
|
[Description("End Message")]
|
|
public string Message
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Message, "@Message");
|
|
}
|
|
}
|
|
public string FixedMessage
|
|
{
|
|
get
|
|
{
|
|
return Message == null ? null : Message.Replace("\n","\r\n").Replace(@"{par}","\r\n");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _Margin;
|
|
public float? Margin
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Margin, "@Margin");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _EndMessageOnEachSubSection;
|
|
public bool EndMessageOnEachSubSection
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _EndMessageOnEachSubSection, "@EndMessageOnEachSubSection");
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Final
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Final : vlnFormatItem
|
|
{
|
|
public Final(XmlNode xmlNode) : base(xmlNode) { }
|
|
public Final() : base() { }
|
|
private LazyLoad<string> _Message;
|
|
[Category("Final Msg")]
|
|
[DisplayName("Final Message")]
|
|
[Description("Final Message")]
|
|
public string Message
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Message, "@Message");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region StructureStyle
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class StructureStyle : vlnFormatItem
|
|
{
|
|
public StructureStyle(XmlNode xmlNode) : base(xmlNode) { }
|
|
public StructureStyle() : base() { }
|
|
#region Where
|
|
[Category("Structure Style")]
|
|
[Description("Where Used")]
|
|
private LazyLoad<E_DocStyleUse?> _Where;
|
|
public E_DocStyleUse? Where
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad<E_DocStyleUse>(ref _Where, "@Where");
|
|
}
|
|
}
|
|
#endregion
|
|
#region Style
|
|
[Category("Structure Style")]
|
|
[Description("Style")]
|
|
private LazyLoad<E_DocStructStyle?> _Style;
|
|
public E_DocStructStyle? Style
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad<E_DocStructStyle>(ref _Style, "@Style");
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#endregion
|
|
}
|