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")]
		//Not used in the PROMS code. Only used as a title for the DocStyles grouping 
		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
		// a unuque number that is use in the SQL record to referenced the DocStyle for a seciton
		private LazyLoad<int?> _Index;
		public int? Index
		{
			get
			{
				return LazyLoad(ref _Index, "@Index");
			}
		}
		[Description("Document Styles Name")]
		// Use in the lists that display the name of a seciton format style (Section Properties)
		private LazyLoad<string> _Name;
		public string Name
		{
			get
			{
				return LazyLoad(ref _Name, "@Name");
			}
		}
		#endregion
		#region Font
		// the font to use for the section
		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")]

		// used  with the "PSOnlyFirst" in pagelist 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.
		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")]
		// defines how the page numbers are counted (i.e. count with procedure,
		// count just within this section, don't count, etc).
		//  - see E_NumberingSequence in Enum.cs 
		private LazyLoad<E_NumberingSequence?> _NumberingSequence;
		public E_NumberingSequence? NumberingSequence
		{ 
			get
			{
				return LazyLoad<E_NumberingSequence>(ref _NumberingSequence, "@NumberingSequence");
			}
		}
		#endregion numberingsequence

		#region IndexOtherThanFirstPage
		[Category("Miscellaneous")]
		[Description("IndexOtherThanFirstPage")]
		// references the DocStyle to use for pages two through the last page of the section. this is used along with the "Where" setting "UseOnFirstPage"
		private LazyLoad<int?> _IndexOtherThanFirstPage;
		public int? IndexOtherThanFirstPage
		{
			get
			{
				return LazyLoad(ref _IndexOtherThanFirstPage, "@IndexOtherThanFirstPage");
			}
		}
		#endregion IndexOtherThanFirstPage

		#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 SecOvrideSupInfoTabOff

		#region IsStepSection
		[Category("Miscellaneous")]
		[Description("Is a Step Section")]

		// When set to True, the section uses the PROMS Step editor, when set to False, Word is used to edit the section contents
		private LazyLoad<bool> _IsStepSection;
		public bool IsStepSection
		{
			get
			{ 
				return LazyLoad(ref _IsStepSection, "@IsStepSection");
			}
		}
		#endregion IsStepSection

		#region Inactive
		[Category("Miscellaneous")]
		[Description("Is Active Section Type")]

		// when set to True, the section type is hidden from the user
		// - but this section type could still be used "internally" by PROMS (i.e. when "Where" is set to "UseOnAllButFirstPage")
		// - is also used to keep un-used section types around  for future use
		private LazyLoad<bool> _Inactive;
		public bool Inactive
		{
			get
			{
				return LazyLoad(ref _Inactive, "@Inactive");
			}
		}
		#endregion Inactive

		#region SupplementalInfo
		[Category("Miscellaneous")]
		[Description("Supports Supplemental Information")]

		// Use in SAMG procedures, flag that tells PROMS this section type can have Supplemental Information.
		// This information is entered as an RNO off of a step but is printed on the backside of the previous page
		// (like a foldout page) so that it is visable along with the steps that it applies.
		private LazyLoad<bool> _SupplementalInformation;
		public bool SupplementalInformation
		{
			get
			{
				return LazyLoad(ref _SupplementalInformation, "@SupplementalInformation");
			}
		}

		// B2023-060: Procedures with Supplemental Information will assume that all sections are printed separately.
		// This flag will 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
		// summary: adjustment to the left margin for the associated supplemental information pages
		private LazyLoad<float?> _SupInfoMargAdj;
		public float? SupInfoMargAdj
		{
			get
			{
				return LazyLoad(ref _SupInfoMargAdj, "@SupInfoMargAdj");
			}
		}

		#endregion SupplementalInfo

		#region LandscapePageList
		[Category("Miscellaneous")]
		[Description("Should PageList be landscape")]
		
		// this will rotate the associated PageStyle information 180 degrees to the left
		private LazyLoad<bool> _LandscapePageList;
		public bool LandscapePageList
		{
			get
			{
				return LazyLoad(ref _LandscapePageList, "@LandscapePageList");
			}
		}
		#endregion LandscapePageList
		
		#region ShowSectionTitles
		[Category("Miscellaneous")]
		[Description("Should Section Titles be shown")]
		private LazyLoad<bool> _ShowSectionTitles;
		// like the ShowSectionTitles at the StepSectionLayData level - turns on printing the section number and title on the first page of the section.  This allows it to be controled based on which section type was selected, so long as it's set to false at the StepSectionLayData level.
		public bool ShowSectionTitles
		{
			get
			{
				return LazyLoad(ref _ShowSectionTitles, "@ShowSectionTitles");
			}
		}
		#endregion ShowSectionTitles

		#region ResetFirstPageOnSection
		[Category("Miscellaneous")]
		[Description("Reset first page of section on Separate pagination section")]
		// put in for V.C. Summer
		private LazyLoad<bool> _ResetFirstPageOnSection;
		public bool ResetFirstPageOnSection
		{
			get
			{
				return LazyLoad(ref _ResetFirstPageOnSection, "@ResetFirstPageOnSection");
			}
		}
		#endregion ResetFirstPageOnSection

		#region IncludeInTOC
		[Category("Miscellaneous")]
		[Description("Include in Auto Table Of Contents")]

		// this will include the section in the Automatic Table Of Contents by default (unless it's turned off in Section Properties)
		private LazyLoad<bool> _IncludeInTOC;
		public bool IncludeInTOC
		{
			get
			{
				return LazyLoad(ref _IncludeInTOC, "@IncludeInTOC");
			}
		}
		#endregion IncludeInTOC

		#region UseCheckOffs
		[Category("Miscellaneous")]
		[Description("Section Uses Checkoffs")]

		// turns on the ability for a step editor section to have checkoffs
		private LazyLoad<bool> _UseCheckOffs;
		public bool UseCheckOffs
		{
			get
			{
				return LazyLoad(ref _UseCheckOffs, "@UseCheckOffs");
			}
		}
		#endregion UseCheckOffs

		#region UseCheckOffs
		[Category("Miscellaneous")]
		[Description("Section Uses MetaSection ColSByLevel")]
		// the section uses the MetaSection ColSByLevel setting (based on step text level) to position the step on the page
		private LazyLoad<bool> _UseColSByLevel;
		public bool UseColSByLevel
		{
			get
			{
				return LazyLoad(ref _UseColSByLevel, "@UseColSByLevel");
			}
		}
		#endregion UseCheckOffs

		#region CancelSectTitle
		[Category("Miscellaneous")]
		[Description("Section Cancel Section Title")]
		// this will prevent the section number and title from printing at the beginning of the section.  This is set to false when the section number and/or title is printed from the PageStyle instead
		private LazyLoad<bool> _CancelSectTitle;
		public bool CancelSectTitle
		{
			get
			{
				return LazyLoad(ref _CancelSectTitle, "@CancelSectTitle");
			}
		}
		#endregion CancelSectTitle

		#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 DontInsertBlankPages

		#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")]
		// horizontal positon of a center line that is drawn on the printed page
		public float? CenterLineX
		{
			get
			{
				return LazyLoad(ref _CenterLineX, "@CenterLineX");
			}
		}

		// the vertical starting positon of a center line that is drawn on the printed page
		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");
			}
		}

		// the vertical ending positon of a center line that is drawn on the printed page
		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")]
		
		// overrides the default pen width (.95) used to draw the center line
		public float? CLineWidth
		{
			get
			{
				return LazyLoad(ref _CLineWidth, "@CLineWidth");
			}
		}
		#endregion CenterLine

		#region OptionalSectionContent
		[Category("Miscellaneous")]
		[Description("Section Optional Content")]
		
		// don't print the "No Section Content" message when section is empty
		private LazyLoad<bool> _OptionalSectionContent;
		public bool OptionalSectionContent
		{
			get
			{
				return LazyLoad(ref _OptionalSectionContent, "@OptionalSectionContent");
			}
		}
		#endregion OptionalSectionContent

		#region Section Number Flags
		[Category("Miscellaneous")]
		[Description("Don't parse the section number - use DisplayNumber value")]

		// when creating a section tab, use as was entered in section properties
		private LazyLoad<bool> _DontParseSectionNumber;
		public bool DontParseSectionNumber
		{
			get
			{
				return LazyLoad(ref _DontParseSectionNumber, "@DontParseSectionNumber");
			}
		}
		#endregion

		#region SpecialStepsFoldout
		[Category("Miscellaneous")]
		[Description("Section Special Steps Foldout")]

		// (for step editor foldouts) reduces white space on the foldout page to allow more information on the page,
		// also special handling of step tabs when section numbers normally are part of step numbers
		private LazyLoad<bool> _SpecialStepsFoldout;
		public bool SpecialStepsFoldout
		{
			get
			{
				return LazyLoad(ref _SpecialStepsFoldout, "@SpecialStepsFoldout");
			}
		}

		[Category("Miscellaneous")]
		[Description("Section Special Steps Foldout with white space")]

		// allow for all of the other special foldout formatting, but not compress the page
		private LazyLoad<bool> _SpecialStepsFoldoutKeepWhiteSpace;
		public bool SpecialStepsFoldoutKeepWhiteSpace
		{
			get
			{
				return LazyLoad(ref _SpecialStepsFoldoutKeepWhiteSpace, "@SpecialStepsFoldoutKeepWhiteSpace");
			}
		}

		[Category("Miscellaneous")]
		[Description("Section Extra Line Header")]
		// add and extra blank line before a Caution/Note header, appears to be used with SpecialStepsFoldout logic
		// and the SpaceIn set on Caution and Note step types
		private LazyLoad<bool> _ExtraLineHeader;
		public bool ExtraLineHeader
		{
			get
			{
				return LazyLoad(ref _ExtraLineHeader, "@ExtraLineHeader");
			}
		}
		#endregion SpecialStepsFoldout

		#region UndSpecialStepsFoldout
		[Category("Miscellaneous")]
		[Description("Section Cancel Section Title")]
		
		// used in Foldout section types, will underline the High Level Steps of a Foldout (Step Editor Section)
		private LazyLoad<bool> _UndSpecialStepsFoldout;
		public bool UndSpecialStepsFoldout
		{
			get
			{
				return LazyLoad(ref _UndSpecialStepsFoldout, "@UndSpecialStepsFoldout");
			}
		}
		#endregion UndSpecialStepsFoldout

		#region CoverNoMergedPageNum
		[Category("Miscellaneous")]
		[Description("Cover Page Do Not Show Page Count")]

		// F2021-046: When doing the Merge option when printing all procedures, flag if cover page section
		// doesn't print the merged page number on first page of the merged pdf (used in printing Alarm Procedure sets)
		private LazyLoad<bool> _CoverNoMergedPageNum;   
		public bool CoverNoMergedPageNum
		{
			get
			{
				return LazyLoad(ref _CoverNoMergedPageNum, "@CoverNoMergedPageNum");
			}
		}
		#endregion CoverNoMergedPageNum

		#region AlignHLSTabWithSect
		[Category("Miscellaneous")]
		[Description("Align HLS Tab With Sect")]

		// Align the starting position of the High Level Step to be under the section header (section title).
		// The step width is also ajusted to fit within the page margins
		private LazyLoad<bool> _AlignHLSTabWithSect;
		public bool AlignHLSTabWithSect
		{
			get
			{
				return LazyLoad(ref _AlignHLSTabWithSect, "@AlignHLSTabWithSect");
			}
		}
		#endregion AlignHLSTabWithSect

		#region AdjSectTitleLoc
		[Category("Miscellaneous")]
		[Description("Adjust Section Title Location")]

		// When high level steps are used as the high level section number and title (a ".0" is added to the high level
		// step number). This flag adds additional tabbing logic (location & numbering) and deals with printing
		// the INITIAL header (checkoffs/signoffs) when then continuous pagination is set with other sections.
		// This was added to support Barakah’s meta sections step/sub-step tabbing and the INITIAL sign off header
		// placement in the page header.
		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");
			}
		}

		// this will add additional spacing between the Section Numbers and Titles
		private LazyLoad<float?> _SectTitleOffsetOverride;
		public float? SectTitleOffsetOverride
		{
			get
			{
				return LazyLoad(ref _SectTitleOffsetOverride, "@SectTitleOffsetOverride");
			}
		}

		#endregion AdjSectTitleLoc

		#region ShowAlarmPointWindowInfo
		[Category("Miscellaneous")]
		[Description("Show Alarm Point Table Info in Step Editor")]

		//C2021-018 show alarm point RO data in step editor (BNPP Alarms)
		// used to display Alarm Point Table RO values in the editor. A read-only Note type is used, off of step the section title, to display the Alarm Point table RO information.
		private LazyLoad<bool> _ShowAlarmPointWindowInfo;
		public bool ShowAlarmPointWindowInfo
		{
			get
			{
				return LazyLoad(ref _ShowAlarmPointWindowInfo, "@ShowAlarmPointWindowInfo");
			}
		}
		#endregion ShowAlarmPointWindowInfo

		#region ComponentList
		[Category("Miscellaneous")]
		[Description("Component List")]

		// this is used generate a could different types of section and step formatting.
		// Along with this flag, it uses a Template (defined in the format file)
		// and specially defined step and sub-step types to create specialized formatting when printed.
		// It's used for Calvert Cliffs Alarm Point pages, Calvert Cliffs Valve List sections,
		// and Farley Component List  tales (Figure section in EOP procedures).
		private LazyLoad<bool> _ComponentList;
		public bool ComponentList
		{
			get
			{
				return LazyLoad(ref _ComponentList, "@ComponentList");
			}
		}
		#endregion ComponentList

		#region pagestyle
		private PageStyle _pagestyle;
		[Category("Miscellaneous")]
		[DisplayName("Page Style")]
		[Description("Page Style")]
		
		// Get the PageStyle associated with the DocStyle
		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 pagestyle

		#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

		#region AltMultiUnitWording
		[Category("Miscellaneous")]
		[Description("Alternate Wording for Printing when MultiUnit")]

		// this will utilize Alternate Wording for Printing when MultiUnit and PrintCommonForZeroUnit is set
		private LazyLoad<string> _AltMultiUnitWording;
		public string AltMultiUnitWording
		{
			get
			{
				return LazyLoad(ref _AltMultiUnitWording, "@AltMultiUnitWording");
			}
		}
		#endregion IncludeInTOC
		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")]

		// The top point of the printed page to start printing the step text (or section number/title)
		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")]

		// space to reserve if needed for bottom page messages (ex: continue message) 
		public float? FooterLength
		{
			get
			{
				return LazyLoad(ref _FooterLength, "@FooterLength");
			}
		}
		#endregion
		#region ChangeBarAdjustment
		// 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")]

		// when AbsoluteFixedChangeColumn flag is used it is from the LeftMargin. If a unique section has a different LeftMarge define, change bars in that section will not be located at the same location as the other sections.  This allows for an adjustment to the change bar location to match the other sections
		public float? AbsChgBarAdj
		{
			get
			{
				return LazyLoad(ref _AbsChgBarAdj, "@AbsChgBarAdj");
			}
		}
		#endregion ChangeBarAdjustment

		#region LeftMargin
		private LazyLoad<float?> _LeftMargin;
		[Category("Location")]
		[DisplayName("Size of left margin")]
		[Description("Size of left margin")]

		// the absolute left position on the printed page that text can be printed.  other format variables and PageStyle column positions used this as the starting reference point
		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 LeftMargin

		#region PageLength
		private LazyLoad<float?> _PageLength;
		[Category("Location")]
		[DisplayName("Length of Page")]
		[Description("Length of Page")]

		// the length of the printable area for step text (also for Word sections) - used to determin page breaks when printing
		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 PageLength

		#region PageWidth
		private LazyLoad<float?> _PageWidth;
		[Category("Location")]
		[DisplayName("Width of Page")]
		[Description("Width of Page")]

		// width of the printed page from the LeftMargin (defines the Right Margin of the section)
		public float? PageWidth
		{
			get
			{
				return LazyLoad(ref _PageWidth, "@PageWidth");
			}
		}
		#endregion PageWidth

		#region MSWordXAdj
		private LazyLoad<float?> _MSWordXAdj;
		[Category("Location")]
		[DisplayName("MSWord X Adjustment")]
		[Description("X Placement of PDF during Print")]

		// used for landscape Word sections, adjusts the Horizontal position on the printed page
		public float? MSWordXAdj
		{
			get
			{
				return LazyLoad(ref _MSWordXAdj, "@MSWordXAdj");
			}
		}
		#endregion MSWordXAdj

		#region MSWordYAdj
		private LazyLoad<float?> _MSWordYAdj;
		[Category("Location")]
		[DisplayName("MSWord Y Adjustment")]
		[Description("Y Placement of PDF during Print")]

		// used for landscape Word sections, adjusts the Vertical position on the printed page
		public float? MSWordYAdj
		{
			get
			{
				return LazyLoad(ref _MSWordYAdj, "@MSWordYAdj");
			}
		}
		#endregion MSWordYAdj

		#region SectionMacro
		private LazyLoad<string> _SectionMacro;
		[Category("Extras")]
		[DisplayName("Section Macro")]
		[Description("Section Macro Prints With Title")]

		// will print a defined print macro with the section title.
		// (ex. Westinghouse Alarms format will print a solid line before the section title
		// for the "Line Above Section Title" section style)
		public string SectionMacro
		{
			get
			{
				return LazyLoad(ref _SectionMacro, "@SectionMacro");
			}
		}
		#endregion SectionMacro


		#region CenterToStepThenPage
		[Category("Layout")]
		[Description("CenterToStepThenPage")]

		// centering position of Tables and Figures is calulated first with repect to the table or figure width, then that positionm is centered with respect the printable page width and left margin
		private LazyLoad<bool> _CenterToStepThenPage;
		public bool CenterToStepThenPage
		{
			get
			{
				return LazyLoad(ref _CenterToStepThenPage, "@CenterToStepThenPage");
			}
		}
		#endregion CenterToStepThenPage
	}
	#endregion Layout

	#region SectTopWcnTraining
	[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")]

		// used to position Responsibility text for Wolf Creek Training format
		public float? Margin
		{
			get
			{
				return LazyLoad(ref _Margin, "@Margin");
			}
		}
		#endregion Margin

		#region MaxLen
		private LazyLoad<int?> _MaxLen;
		[Category("Section Continue Msg")]
		[DisplayName("MaxLen for text within the column")]
		[Description("MaxLen for text within the column")]

		// the maxium length of Responsibility text (Wolf Creek Training format)
		public int? MaxLen
		{
			get
			{
				return LazyLoad(ref _MaxLen, "@MaxLen");
			}
		}
		#endregion MaxLen
		#region Message
		private LazyLoad<string> _Message;
		[Category("Continue Msg")]
		[DisplayName("Section Top Continue Msg")]
		[Description("Section Top Continue Msg")]

		// top continue message used only for Wolf Creek Training format
		public string Message
		{
			get
			{
				return LazyLoad(ref _Message, "@Message");
			}
		}
		#endregion Message
	}
	#endregion SectTopWcnTraining

	#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")]

		//value added to the left margin when calculating the center point of a top continue message.
		public float? Margin
		{
			get
			{
				return LazyLoad(ref _Margin, "@Margin");
			}
		}
		#endregion Margin

		#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")]

		// added for Comanche Peak will print out step tabs as a top comtinue message.
		public bool UseStepTabs
		{
			get
			{
				return LazyLoad(ref _UseStepTabs, "@UseStepTabs");
			}
		}
		#endregion UseStepTabs

		#region HLS
		private LazyLoad<int?> _HLS;
		[Category("Continue Msg")]
		[DisplayName("Include HLS in top continue msg")]
		[Description("Include HLS in top continue msg")]

		// include the High Level Step in the top continue message
		// - see DoTopContinueMsg in VlnParagraph for details
		// set to "1" will use high level step tab and text
		// set to "4" the high level step text is the section title, appears when fist level sub-step breaks
		// set to "7" similar logic as "4" but for Vogtle Main Control Room alarms but use high level step text
		// set to "6" handle when break occures on Caution/Note
		// set to "3" special logic for Calvert Cliffs Alarms (the two column part)
		public int? HLS
		{
			get
			{
				return LazyLoad(ref _HLS, "@HLS");
			}
		}
		#endregion HLS

		#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")]

		// position the top continue message with respect only to the left margin
		public bool PlaceAtLeftMargin
		{
			get
			{
				return LazyLoad(ref _PlaceAtLeftMargin, "@PlaceAtLeftMargin");
			}
		}
		#endregion PlaceAtLeftMargin

		#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")]

		// the top continue message string - may caontain special formatting items - see DoTopContinueMsg in vlnParagraph for different format settings
		public string Message
		{
			get
			{
				return LazyLoad(ref _Message, "@Message");
			}
		}
		#endregion Message
	}

	#endregion Top

	#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")]

		// horitzontal position of the bottom continue message from the left margin
		public float? Margin
		{
			get
			{
				return LazyLoad(ref _Margin, "@Margin");
			}
		}
		#endregion Margin

		#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)")]

		// horitzontal position from the left margin for a RNO bottom continue message
		public float? MarginR
		{
			get
			{
				return LazyLoad(ref _MarginR, "@MarginR");
			}
		}
		#endregion MarginR BGE

		#region Location
		[Category("Continue Msg")]
		[Description("Bottom Continue Location")]
		private LazyLoad<E_ContBottomLoc?> _Location;

		// location of the bottom continue message
		// E_ContBottomLoc list (ENum.cs):
		//   EndOfText = 0,
		//   BtwnTextAndBottom = 1,
		//   BottomOfPage = 2,
		//   BelowBottom1 = 3,
		//   BottomWithFooter = 4,	 - added for BGE for Alarms.  This puts continue message on bottom AND if in CONDITION/RESPONSE table, at bottom of both columns.
		//   EndOfText2 = 5,
		//   BtwnTextAndBottom2 = 6 - Added for BGE, their continue message was a line or so too far down the page

		public E_ContBottomLoc? Location
		{
			get
			{
				return LazyLoad<E_ContBottomLoc>(ref _Location, "@Location");
			}
		}

		// flag for cases where step text was printing on top of the bottom continue messsage due to how a step was paginated - put in for Farley
		private LazyLoad<bool> _NoOverrideSpace;
		public bool NoOverrideSpace
		{
			get
			{
				return LazyLoad(ref _NoOverrideSpace, "@NoOverrideSpace");
			}
		}

		// Location Adjustment of the calculated vertical position of the bottom continue message (from Location setting)
		private LazyLoad<int?> _LocAdj;
		public int? LocAdj
		{
			get
			{

				return LazyLoad(ref _LocAdj, "@LocAdj");
			}
		}
		#endregion Location

		#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")]

		//the bottom continue message string - may caontain special formatting items
		//- see DoBottomContinueMsg in vlnParagraph for different format settings
		public string Message
		{
			get
			{
				return LazyLoad(ref _Message, "@Message");
			}
		}
		#endregion Message
	}
	#endregion Bottom

	#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")]

		// continue message to add to the section title
	    public string AppendToTitle
	    {
	        get
	        {
	            return LazyLoad(ref _AppendToTitle, "@AppendToTitle");
	        }
	    }
		#endregion AppendToTitle
	}
	#endregion //SectionTitle - continue setting
	#endregion ContinueAll

	#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")]

		// vertical positon adjustment of the End message
		public int? Flag
		{
			get
			{
				return LazyLoad(ref _Flag, "@Flag");
			}
		}
		#endregion Flag

		#region Message
		private LazyLoad<string> _Message;
		[Category("End Msg")]
		[DisplayName("End Message")]
		[Description("End Message")]

		// End Message Text
		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");
			}
		}

		// amount of space from the left margin to print the End Message
		private LazyLoad<float?> _Margin;
		public float? Margin
		{
			get
			{
				return LazyLoad(ref _Margin, "@Margin");
			}
		}

		// print the end message at the end of each sub-section
		private LazyLoad<bool> _EndMessageOnEachSubSection;
		public bool EndMessageOnEachSubSection
		{
			get
			{
				return LazyLoad(ref _EndMessageOnEachSubSection, "@EndMessageOnEachSubSection");
			}
		}
		#endregion Message
	}
	#endregion End

	#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")]
		
		// Final Message text to be printed on last page of procedure
		public string Message
		{
			get
			{
				return LazyLoad(ref _Message, "@Message");
			}
		}
	}
	#endregion Final

	#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;

		// where with repect to the section is this DocStyle/PageList relationship used:
		// UseOnAllPages (all pages of the section), UseOnFirstPage (only the first page of the section),
		// UseOnAllButFirstPage (all except for the first page of the section).
		// Note that when UseOnFirstPage is used, it but reference a DocStyle (IndexOtherThanFirstPage)
		// that uses UseOnAllButFirstPage. 

		public E_DocStyleUse? Where
		{
			get
			{
				return LazyLoad<E_DocStyleUse>(ref _Where, "@Where");
			}
		}
		#endregion Where

		#region Style
		[Category("Structure Style")]
		[Description("Style")]

		// allow us to identify a specialized type of section (Table of Contents, Foldout Page, etc) as well as other unique formatting that deviates from the normal formatting/data entry of the procedure. See "E_DocStructStyle" in VEPROMS.CSLA.Library\ENums.cs for alist of the possible flags and descriptions.
		private LazyLoad<E_DocStructStyle?> _Style;
		public E_DocStructStyle? Style
		{
			get 
			{
				return LazyLoad<E_DocStructStyle>(ref _Style, "@Style");
			} 
		}
		#endregion Style
	}
	#endregion StructureStyle
	#endregion DocStyleAll
}