Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity
SourceCode/PROMS/VEPROMS.CSLA.Library/Format/PlantFormat.cs

7447 lines
189 KiB
C#
Raw Blame History

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.ComponentModel;
using System.Drawing;
namespace VEPROMS.CSLA.Library
{
#region PlantFormat
[TypeConverter(typeof(ExpandableObjectConverter))]
public class PlantFormat
{
public PlantFormat(IFormatOrFormatInfo format, string config)
{
_MyFormat = format;
string str = null;
if (format is Format) str = (format as Format).Config;
else if (format is FormatInfo) str = (format as FormatInfo).Config;
if (str != null && str != "") _FormatConfig = FormatConfig.Get(str);
}
private FormatConfig _FormatConfig;
public FormatConfig FormatConfig
{
get
{
if (_FormatConfig == null)
{
_FormatConfig = GetFormatConfig(_MyFormat);
}
return _FormatConfig;
}
set { _FormatConfig = value; }
}
#region User Control of Format (UCF)
// User Control of Format allows a PROMS user to make modifications to a very limited set of format settings
// Variables in this region are not set in the format files. They are used only in the C# code
// when IgnoreUCF is true, get the original data, i.e. don't apply any UCF changes to it
private static bool _IgnoreUCF = false;
public static bool IgnoreUCF
{
get { return PlantFormat._IgnoreUCF; }
set { PlantFormat._IgnoreUCF = value; }
}
// flags that the User Control of Format setting for using additional UCF checkoffs is active
private static bool _DoingUCFCheckOffs = false;
public static bool DoingUCFCheckOffs
{
get { return PlantFormat._DoingUCFCheckOffs; }
set { PlantFormat._DoingUCFCheckOffs = value; }
}
// flags the value that should be used (true/false) for using additional UCF checkoffs (used with DoingUCFCheckOffs)
private static bool _DoingUCFCheckOffsUse = false;
public static bool DoingUCFCheckOffsUse
{
get { return PlantFormat._DoingUCFCheckOffsUse; }
set { PlantFormat._DoingUCFCheckOffsUse = value; }
}
#endregion //User Control of Format (UCF)
public static FormatConfig GetFormatConfig(IFormatOrFormatInfo format)
{
FormatConfig fc = null;
string str = null;
if (format is Format) str = (format as Format).Config;
else if (format is FormatInfo) str = (format as FormatInfo).Config;
if (str != null && str != "") fc = FormatConfig.Get(str);
return fc;
}
private IFormatOrFormatInfo _MyFormat;
public IFormatOrFormatInfo MyFormat
{
get { return _MyFormat; }
set { _MyFormat = value; }
}
private vlnFormatDocument _XmlDoc;
internal vlnFormatDocument XmlDoc
{
get
{
if (_XmlDoc == null)
_XmlDoc = new vlnFormatDocument(_MyFormat);
return _XmlDoc;
}
}
// FormatData contains flag and specific settings for step/sub-step types, tabbing information, etc. (pertains to the entire format)
// Reads this information in from the format file
private FormatData _FormatData;
public FormatData FormatData
{
get
{
if (_FormatData == null) _FormatData = new FormatData(XmlDoc.SelectSingleNode("/PlantFormat/FormatData"));
return _FormatData;
}
}
private PageStyles _PageStyles;
// PageStyles (AKA PageList) contains settings used to print page boarders, page numbers, and positions information such as procedure number/title in page headers.
// These are associated with the sections defined in DocStyle
// Reads this information in from the format file
public PageStyles PageStyles
{
get
{
if (_PageStyles == null) _PageStyles = new PageStyles(XmlDoc.SelectNodes("/PlantFormat/PageStyles/PageStyle"));
return _PageStyles;
}
}
private DocStyles _DocStyles;
// DocStyles define page margins, continue messages, end messages and associate each section with a PageSyle
// Reads this information in from the format file
public DocStyles DocStyles
{
get
{
if (_DocStyles == null) _DocStyles = new DocStyles(XmlDoc.SelectSingleNode("/PlantFormat/DocStyles"));
return _DocStyles;
}
}
// Used to test if the current PageStyle uses the passed in "token"
// A token in a PageStyle is surrounded by open/close curly brackets.
// ex: {myToken}
public bool HasPageListToken(string token)
{
string xpath = string.Format("/PlantFormat/PageStyles/PageStyle/Item[@Token = '{0}']", token);
XmlNodeList nl = XmlDoc.SelectNodes(xpath);
return nl.Count > 0;
}
private FormatConfig.ReplaceStrData _UCFandOrigReplaceStrData = null;
// This will return a complete list of ReplaceWords, combining those in the original plant format
// with the ones added by the user via User Control of Format (UCF)
public FormatConfig.ReplaceStrData UCFandOrigReplaceStrData
{
get
{
if (_UCFandOrigReplaceStrData != null) return _UCFandOrigReplaceStrData;
_UCFandOrigReplaceStrData = GetMergedReplaceList(this);
return _UCFandOrigReplaceStrData;
}
}
private FormatConfig.ReplaceStrData GetMergedReplaceList(PlantFormat OriginalPlantFormat)
{
// need to compare the original format list with the list as it is stored for working with property grid.
FormatConfig.ReplaceStrData retlist = new FormatConfig.ReplaceStrData(); // merged list
List<string> inoriglist = new List<string>(); // use this list to find new items in formatconfig (see below)
foreach (ReplaceStr origrepstr in OriginalPlantFormat.FormatData.SectData.ReplaceStrList)
{
// In the format config list (UCF), find the 'ReplaceWord'. This is the 'key' for defining whether the
// replace word has been overwridden by UCF data. If it exists, use it:
FormatConfig.ReplaceStr usethisone = null;
bool deleted = false;
// States for replacewords: 0 = no change, -1 deleted, 1 added, 2 modified
if (FormatConfig != null)
{
foreach (FormatConfig.ReplaceStr ucfrepstr in FormatConfig.PlantFormat.FormatData.ReplaceStrData)
{
if (ucfrepstr.ReplaceWord == origrepstr.ReplaceWord)
{
if (ucfrepstr.State == -1) deleted = true;
else usethisone = ucfrepstr;
ucfrepstr.State = 2;
inoriglist.Add(origrepstr.ReplaceWord);
break;
}
}
}
if (!deleted && usethisone == null)
{
usethisone = new FormatConfig.ReplaceStr();
usethisone.Flag = (FormatConfig.E_ReplaceFlagsUCF)origrepstr.Flag;
usethisone.State = 0; // no change
usethisone.ReplaceWith = origrepstr.ReplaceWith;
usethisone.ReplaceWord = origrepstr.ReplaceWord;
}
if (!deleted) retlist.Add(usethisone);
}
// now add in any ucf only replacements, any that are not in the inoriglist
if (FormatConfig != null)
{
foreach (FormatConfig.ReplaceStr ucfrepstr in FormatConfig.PlantFormat.FormatData.ReplaceStrData)
{
if (!inoriglist.Contains(ucfrepstr.ReplaceWord))
{
FormatConfig.ReplaceStr newone = new FormatConfig.ReplaceStr();
newone.Flag = (FormatConfig.E_ReplaceFlagsUCF)ucfrepstr.Flag;
newone.State = 1;
newone.ReplaceWith = ucfrepstr.ReplaceWith;
newone.ReplaceWord = ucfrepstr.ReplaceWord;
retlist.Add(newone);
}
}
}
return (retlist);
}
}
#endregion
#region VE_Font
[TypeConverter(typeof(ExpandableObjectConverter))]
public class VE_Font : vlnFormatItem
{
public VE_Font(XmlNode xmlNode) : base(xmlNode) { }
private string _ffam = null;
private int _fsize = 0;
private E_Style _fstyle = E_Style.None;
private float _fcpi = 0;
public VE_Font(string family, int size, E_Style style, float CPI)
{
_Family = new LazyLoad<string>(family);
_Size = new LazyLoad<int?>(size);
_Style = new LazyLoad<E_Style?>(style);
_CPI = new LazyLoad<float?>(CPI);
_ffam = family;
_fsize = size;
_fstyle = style;
_fcpi = CPI;
}
private LazyLoad<string> _Family;
private static Dictionary<string, Font> _WinFontLookup = new Dictionary<string, Font>();
// put the fonts in a dictionary so that we don't call new Font each time we reference it
private static Font GetFont(string family, float size, FontStyle style)
{
string key = string.Format("{0}_{1}_{2}", family, size, style);
if (!_WinFontLookup.ContainsKey(key))
_WinFontLookup.Add(key, new Font(family, size, style));
return _WinFontLookup[key];
}
// part of bug B2017-117 and for conservation of window handles to reduce the frequency of
// the Out of Window Handles error when editing and printing.
// we are now using a common dictionary for font usages
public static Font GetWinSysFont(string family, float size, FontStyle style)
{
return GetFont(family, size, style);
}
public static Font GetWinSysFont(string family, float size)
{
return GetFont(family, size, FontStyle.Regular);
}
public static Font GetWinSysFont(FontFamily ffamily, float size, FontStyle style)
{
return GetFont(ffamily.Name, size, style);
}
public static Font GetWinSysFont(Font font, FontStyle style)
{
return GetFont(font.Name, font.Size, style);
}
private Font _WindowsFont;
public Font WindowsFont
{
get
{
if (_WindowsFont == null)
{
//FontStyle style = (Family == "Cornet")?FontStyle.Italic : FontStyle.Regular;
FontStyle style = FontStyle.Regular;
if (Style != E_Style.None)
{
if (((Style & E_Style.Bold) != 0) || ((Style & E_Style.MmBold) !=0))
style |= FontStyle.Bold;
if ((Style & E_Style.Italics) != 0)
style |= FontStyle.Italic;
if ((Style & E_Style.Underline) != 0)
style |= FontStyle.Underline;
}
// for now - check size to be 0 and set to 10 if so, error in fmtxml?
if (Family == null) // Need to get inherited font
_WindowsFont = GetFont("Arial", 10, FontStyle.Regular);
else
{
//if (_ffam != null)
// _WindowsFont = GetFont(_ffam, (float)_fsize, style); // this needs work.
//else
_WindowsFont = GetFont(Family, Size == 0 ? 10 : (float)Size, style);
}
}
return _WindowsFont;
}
set
{
_WindowsFont = value;
}
}
[Description("Font Family")]
public string Family
{
get
{
return LazyLoad(ref _Family,"Font/@Family");
}
}
private LazyLoad<int?> _Size;
[Description("Font Size (in Double Points)")]
public int? Size
{
get
{
return LazyLoad(ref _Size, "Font/@Size");
}
}
private LazyLoad<E_Style?> _Style;
public E_Style? Style
{
get
{
return LazyLoad<E_Style>(ref _Style, "Font/@Style");
}
//set
//{
// _Style.Value = value;
//}
}
private LazyLoad<float?> _CPI;
public float? CPI
{
get
{
return LazyLoad(ref _CPI, "Font/@CPI");
}
}
public float CharsToTwips
{
get
{
return (72 / (CPI ?? 12));
}
}
public override string ToString()
{
return string.Format("{0}, {1} pt, {2}", Family, Size, Style);
}
public bool FontIsProportional()
{
if (Family.Contains("Arial") || Family.Contains("Times New Roman")) return true;
return false;
}
}
#endregion
#region FormatData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class FormatData : vlnFormatItem
{
public FormatData(XmlNode xmlNode) : base(xmlNode) { }
// Name of the format - as it appears when selecting the format to use in PROMS
private LazyLoad<string> _Name;
public string Name
{
get
{
return LazyLoad(ref _Name, "@Name");
}
}
// When true, this format is allowed to be used in the PROMS Express product
private LazyLoad<bool> _Express;
public bool Express
{
get
{
return LazyLoad(ref _Express, "@Express");
}
}
// When set to True, it enables the use of a Procedure Set Specific dialog, containing defined fields
// in which the user enters data that is printed on all or specific pages for all of the procedures in the set using this format
private LazyLoad<bool> _SpecificInfo;
public bool SpecificInfo
{
get
{
return LazyLoad(ref _SpecificInfo, "@SpecificInfo");
}
}
// this is a structure defined in the format file that defines labels and fields on a pop-up dialog
// in which the user will enter data - this is accessible only at the procedure set level
private SI _SI;
public SI SI
{
get
{
return _SI == null ? _SI = new SI(SelectSingleNode("SI")) : _SI;
}
}
// TPL represents Templates which are sizes of columns for 'table' type data. If the format
// has the 'UseSmartTemplate' format flag, this table will have starting location & widths, and
// other data for the listed step types. Data from this table overrides width data as specified
// by the step type format data. The only active format that has 'UseSmartTemplate' is WCNCKL.
// The TPL data is also used by other formats, many of which are using it for Enhanced Background
// & Deviations. The actual format of the template can be in an old or new format. The old format
// uses spaces as delimiters, the new uses commas.
private LazyLoad<string> _TPL;
public string TPL
{
get
{
return LazyLoad(ref _TPL, "@TPL");
}
}
// not defined in format files, we now use TPL to define both the original and new template
// the C# determines if it's a smart (new) template or the old style (search for NewTemplateFormat to see the code)
private bool _NewTemplateFormat;
public bool NewTemplateFormat
{
get { return _NewTemplateFormat; }
set { _NewTemplateFormat = value; }
}
// Creates a dictionary of the templates (TPL) defined in the format
private Dictionary<int, int> _TopTemplateTypes;
public Dictionary<int, int> TopTemplateTypes
{
get
{
if (_TopTemplateTypes == null && Templates != null)
{
_TopTemplateTypes = new Dictionary<int, int>();
// loop through all of templates to find those that are top level, i.e.
// right below the '0'.
int indx = 0;
while (indx < Templates.Count)
{
// level of 0 starts a new group.
if (Templates[indx].level == 0) TopTemplateTypes[Templates[indx + 1].type] = indx + 1;
indx++;
}
}
return _TopTemplateTypes;
}
}
// Parses the templates defined in the format file and creates a list
// this also determines if it a Smart Template or the original style
private List<TPlate> _Templates;
public List<TPlate> Templates
{
get
{
if (_Templates == null) // Load template class from format's string data.
{
NewTemplateFormat = false;
// count newlines - which gives number of template records.
int NumTemplates = 0;
if (TPL == null) return null;
// if the template is modified by the plant specific code in the format migration,
// it will contain an '&amp;' rather than '&'.
string tTPL = TPL.Replace("&amp;", "&");
int indx = tTPL.IndexOf('\n');
while (indx > -1)
{
NumTemplates++;
indx = tTPL.Length > indx + 1 ? tTPL.IndexOf('\n', indx + 1) : -1;
}
if (NumTemplates == 0) return null;
_Templates = new List<TPlate>(NumTemplates);
// for each item, create and add to list
if (TPL.IndexOf(',') > -1) NewTemplateFormat = true;
int cnt = 0;
int tmpStrIndxStart = 0;
int tmpStrIndxEnd = 0;
while (cnt < NumTemplates)
{
tmpStrIndxEnd = TPL.IndexOf("\n", tmpStrIndxStart);
if (tmpStrIndxEnd < 0)
{
cnt++;
continue; // maybe extra newlines at end of string.
}
string tpl = TPL.Substring(tmpStrIndxStart, tmpStrIndxEnd-tmpStrIndxStart);
tmpStrIndxStart = tmpStrIndxEnd + 1;
int level = 0;
int type = 0;
int start = 0;
int width = 0;
short nocol = 0;
int row = 0;
string stmp = null;
if (!NewTemplateFormat) // not the smart template
{
string[] tmpOld = tpl.Split(" ".ToCharArray());
level = Convert.ToInt32(tmpOld[0]);
type = Convert.ToInt32(tmpOld[1]);
if (tmpOld.Length <= 2)
stmp = null;
else if (tmpOld.Length > 3)
{
// Wolf Creek and Turkey Point Background formats have spaces as part of the text in the 3rd field,
// handle this special case
int indxx = tpl.IndexOf(" "); //skip past "level"
if (indxx < 0) stmp = null; // template incomplete set text to a null
else
{
indxx = tpl.IndexOf(" ", indxx + 1); //skip past "type"
stmp = (indxx > -1) ? tpl.Substring(indxx+1) : null; //if valid index grab text after "type" (+1 skips past the space char after the "type" number)
}
}
else
stmp = tmpOld[2];
}
else
{
string[] tmpNew = tpl.Split(",".ToCharArray());
if (tmpNew.Length < 5)
{
cnt++;
continue; // may be extra newlines at end of string
}
level = Convert.ToInt32(tmpNew[0]);
type = Convert.ToInt32(tmpNew[1]);
start = Convert.ToInt32(tmpNew[2]);
width = Convert.ToInt32(tmpNew[3]);
row = Convert.ToInt32(tmpNew[4]);
nocol = Convert.ToInt16(tmpNew[5]);
stmp = tmpNew.Length <= 6 ? null : tmpNew[6];
}
// some plants (Wolf Creek, Turkey Point) have two line titles in their templates with "[(0014])" representing the hard return in the title
if (stmp != null)
{
stmp = stmp.Replace("[(0014])", "\\line "); // Hard Return
stmp = stmp.Replace("\xFFFD", @"\u160?"); // Hard Space B2018-052 replace old(from 16-bit) hardspace character with the unicode hardspace character
}
TPlate tp = new TPlate(level, type, start, width, row, nocol, stmp);
_Templates.Add(tp);
cnt++;
}
}
return _Templates;
}
}
// Old style format flags (from DOS version of PROMS)
// where we check which bits of the integer is set to determine if that option can be used.
// See E_PurchaseOptions in ENums.cs for a description of each option flag (bit)
private LazyLoad<E_PurchaseOptions?> _PurchaseOptions;
public E_PurchaseOptions? PurchaseOptions
{
get
{
return LazyLoad<E_PurchaseOptions>(ref _PurchaseOptions, "@PurchaseOptions");
}
}
// Set at the top of the format(under FormatData) defined the default font used in this format.
// Specific step types can have different font information assigned to override this default
private VE_Font _Font;
public VE_Font Font
{
get
{
return _Font == null? _Font = new VE_Font(base.XmlNode): _Font;
}
}
private PDFPageSize _PDFPageSize;
public PDFPageSize PDFPageSize // C2020-002 paper size is now set in the format files
{
get
{
return _PDFPageSize == null ? _PDFPageSize = new PDFPageSize(SelectSingleNode("PDFPageSize")) : _PDFPageSize;
}
}
//C2021-005 Format file grouping containing a list of possible font sizes (used only for table text via the Table Ribbon)
private FontSizes _FontSizes;
public FontSizes FontSizes
{
get
{
return _FontSizes == null ? _FontSizes = new FontSizes(SelectSingleNode("FontSizes")) : _FontSizes;
}
}
// C2021-004 This gets the list for additional Table Cell shading options defined in the format (base) file
private ShadingOptionList _ShadingOptionList;
public ShadingOptionList ShadingOptionList
{
get
{
return (_ShadingOptionList == null) ? _ShadingOptionList = new ShadingOptionList(SelectNodes("MoreShadingOptions/ShadingOption")) : _ShadingOptionList;
}
set { _ShadingOptionList = value; }
}
// C2022-004 Unit Watermarks defined in the format file - used by Barakah
private UnitWatermarkList _UnitWatermarkList;
public UnitWatermarkList UnitWatermarkList
{
get
{
return (_UnitWatermarkList == null) ? _UnitWatermarkList = new UnitWatermarkList(SelectNodes("UnitWatermarkData/UnitWatermark")) : _UnitWatermarkList;
}
set { _UnitWatermarkList = value; }
}
// This is a list of supported symbol characters used in the PROMS step editor
// the master list is defined in the base format (Baseall.xml)
private SymbolList _SymbolList;
public SymbolList SymbolList
{
get
{
return (_SymbolList == null) ? _SymbolList = new SymbolList(SelectNodes("Symbols/Symbol")) : _SymbolList;
}
set { _SymbolList = value; }
}
private EditData _EditData;
public EditData EditData
{
get
{
return _EditData == null ? _EditData = new EditData(SelectSingleNode("EditData")): _EditData;
}
}
private PrintData _PrintData;
public PrintData PrintData
{
get
{
return _PrintData == null? _PrintData = new PrintData(SelectSingleNode("PrintData")):_PrintData;
}
}
private ProcData _ProcData;
public ProcData ProcData
{
get
{
return _ProcData == null? _ProcData = new ProcData(SelectSingleNode("ProcData")):_ProcData;
}
}
private SectData _SectData;
public SectData SectData
{
get
{
return _SectData == null? _SectData = new SectData(SelectSingleNode("SectData")):_SectData;
}
}
private BoxList _BoxList;
public BoxList BoxList
{
get
{
return _BoxList == null? _BoxList = new BoxList(SelectNodes("BoxData/Box"),MyFormat):_BoxList;
}
set { _BoxList = value; }
}
private TransData _TransData;
public TransData TransData
{
get
{
return _TransData == null? _TransData = new TransData(SelectSingleNode("TransData")):_TransData;
}
}
private ROData _ROData;
public ROData ROData
{
get
{
return _ROData == null ? _ROData = new ROData(SelectSingleNode("ROData")) : _ROData;
}
}
private StepDataList _StepDataList;
public StepDataList StepDataList
{
get
{
return _StepDataList == null? _StepDataList = new StepDataList(SelectNodes("StepData/Step"),MyFormat):_StepDataList;
}
set { _StepDataList = value; }
}
public List<StepDataRetval> GetSearchableSteps()
{
List<StepDataRetval> sds = new List<StepDataRetval>();
foreach (StepData sd in StepDataList)
{
if (!sd.Inactive && sd.StepEditData.Searchable && (sd.StepEditData.TypeMenu.InMenu || sd.Index == 40)) // B2019-016 allow to specify Search of RNO step type
sds.Add(new StepDataRetval(sd.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(sd.Index)));
}
// now add any from the inherited list (but only if type is not in the list)
IFormatOrFormatInfo parentFormat = MyParentFormat;
while (parentFormat != null)
{
vlnIndexedFormatList<StepData> InheritedList = parentFormat.PlantFormat.FormatData.StepDataList;
foreach (StepData sd1 in InheritedList)
{
if (!sd1.Inactive && sd1.StepEditData.Searchable && sd1.StepEditData.TypeMenu.InMenu)
{
// if not in the sds list, add it:
// note that the list of StepDataRetval (sds) 'Contains' method did not find an existing StepData item - that is why the code loops
// through list rather than using 'Contains':
bool found = false;
foreach (StepDataRetval lrtvl in sds)
{
if (lrtvl.Index == sd1.Index)
{
found = true;
break;
}
}
if (!found)
{
StepDataRetval tmpsdrv = new StepDataRetval(sd1.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(sd1.Index));
sds.Add(tmpsdrv);
}
}
}
parentFormat = parentFormat.PlantFormat.FormatData.MyParentFormat;
}
return sds;
}
public StepData StepTopUnderBase(StepData sd, int formatStepType)
{
StepData top = sd;
while (top.ParentType != "Base")
{
bool foundit = false;
string sParStp = StepDataList[formatStepType].ParentType;
foreach (StepData stp in StepDataList)
{
if (top.ParentType == stp.Type)
{
top = stp;
foundit = true;
break;
}
}
if (!foundit)
{
IFormatOrFormatInfo parentFormat = MyParentFormat;
while (parentFormat != null && !foundit)
{
vlnIndexedFormatList<StepData> InheritedList = parentFormat.PlantFormat.FormatData.StepDataList;
foreach (StepData stp1 in InheritedList)
{
if (top.ParentType == stp1.Type)
{
top = stp1;
foundit = true;
break;
}
}
parentFormat = parentFormat.PlantFormat.FormatData.MyParentFormat;
}
}
}
return top;
}
public List<StepDataRetval> StepGetLevelTypes(bool alwaysAdd, StepData topType, ref int cursel, string curType, ItemInfo _CurItemInfo)
{
if (topType == null) return null;
List<StepDataRetval> sds = new List<StepDataRetval>();
int retval = -1;
int cntitm = 0;
// if there are alternatenames for this item, use that list, otherwise, get list from
// xml for current node & its children....
if (topType.StepEditData.TypeMenu.AlternateNameList != null && topType.StepEditData.TypeMenu.AlternateNameList != "")
{
// loop through the AlternateName string, it has indices for step types..
string[] split = topType.StepEditData.TypeMenu.AlternateNameList.Split(new Char[] { ',' });
foreach (string s in split)
{
foreach (StepData sd in this.StepDataList)
{
if (sd.Type == s && !sd.Inactive)
{
sds.Add(new StepDataRetval(sd.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(sd.Index)));
if (curType == sd.Type) retval = cntitm;
cntitm++;
break;
}
}
}
}
// some menu items (step change types) can only be done in aer column, check for that....
// also tables and figures off caution/notes must use rno data.
else if (alwaysAdd || (topType.StepEditData.TypeMenu.InMenu && ((topType.StepEditData.TypeMenu.RnoInMenu) ||
(!topType.StepEditData.TypeMenu.RnoInMenu && !_CurItemInfo.IsInRNO && !_CurItemInfo.IsCaution && !_CurItemInfo.IsNote) ||
(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsInRNO) ||
(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsCaution) ||
(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsNote))))
{
if (!topType.Inactive)
{
if ((_CurItemInfo.IsInRNO || _CurItemInfo.IsCaution || _CurItemInfo.IsNote) && topType.StepEditData.TypeMenu.RnoMenuItem != null && topType.StepEditData.TypeMenu.RnoMenuItem != "")
sds.Add(new StepDataRetval(topType.StepEditData.TypeMenu.RnoMenuItem, Convert.ToInt32(topType.Index)));
else
sds.Add(new StepDataRetval(topType.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(topType.Index)));
if (topType.Type == curType) retval = cntitm;
cntitm++;
}
bool foundInCur = false;
foreach (StepData sd in StepDataList)
{
if (sd.ParentType == topType.Type)
{
int tmpindx = DoListChildStepTypes(alwaysAdd, ref sds, sd, curType, _CurItemInfo, ref cntitm, false);
if (sd.Type == curType) retval = tmpindx;
if (retval < 0 && tmpindx > 0) retval = tmpindx;
foundInCur = true;
}
}
// Handle inheritance (step data may not be in current format, may inherit from parents):
if (!foundInCur)
{
IFormatOrFormatInfo parentFormat = MyParentFormat;
bool foundit = false;
while (parentFormat != null && !foundit)
{
vlnIndexedFormatList<StepData> InheritedList = parentFormat.PlantFormat.FormatData.StepDataList;
foreach (StepData sd1 in InheritedList)
{
if (sd1.ParentType == topType.Type)
{
int tmpindx = DoListChildStepTypes(alwaysAdd, ref sds, sd1, curType, _CurItemInfo, ref cntitm, true);
if (sd1.Type == curType) retval = tmpindx;
if (retval < 0 && tmpindx > 0) retval = tmpindx;
foundit = true; // stop after finding the type in the closest parent, i.e. don't keep walking up tree.
}
}
parentFormat = parentFormat.PlantFormat.FormatData.MyParentFormat;
}
}
}
cursel = retval;
return sds;
}
private int DoListChildStepTypes(bool alwaysAdd, ref List<StepDataRetval> sds, StepData topType, string curType, ItemInfo _CurItemInfo, ref int cntitm, bool doInherit)
{
int retval = -1;
if (alwaysAdd || (topType.StepEditData.TypeMenu.InMenu && ((topType.StepEditData.TypeMenu.RnoInMenu) ||
(!topType.StepEditData.TypeMenu.RnoInMenu && !_CurItemInfo.IsInRNO&&!_CurItemInfo.IsCaution&&!_CurItemInfo.IsNote) ||
(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsInRNO) ||
(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsCaution) ||
(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsNote))))
{
if (!topType.Inactive)
{
// if equation type && in single column mode, put out the rnomenu list, and skip the AER items
bool singleColEq = (topType.Type.ToUpper().Contains("EQUATION") && _CurItemInfo.ColumnMode == 0);
// B2017-004 if a Table type && in single column mode or in a Note or Caution, don't list the AER Table option
bool singleColTable = (_CurItemInfo.IsTable && ( _CurItemInfo.ColumnMode == 0 || _CurItemInfo.IsInCautionOrNote)); // B2017-206 added parens so substeps types can be listed
if ((singleColEq ||_CurItemInfo.IsInRNO || _CurItemInfo.IsCaution || _CurItemInfo.IsNote) && topType.StepEditData.TypeMenu.RnoMenuItem != null && topType.StepEditData.TypeMenu.RnoMenuItem != "")
sds.Add(new StepDataRetval(topType.StepEditData.TypeMenu.RnoMenuItem, Convert.ToInt32(topType.Index)));
else if (!singleColEq && !singleColTable)
sds.Add(new StepDataRetval(topType.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(topType.Index)));
if (!singleColTable && (!singleColEq || (singleColEq && topType.StepEditData.TypeMenu.RnoMenuItem != null && topType.StepEditData.TypeMenu.RnoMenuItem != "")))
{
if (topType.Type == curType) retval = cntitm;
cntitm++;
}
}
bool foundInCur = false;
foreach (StepData sd in StepDataList)
{
if (sd.ParentType == topType.Type)
{
int tmpindx = DoListChildStepTypes(alwaysAdd, ref sds, sd, curType, _CurItemInfo, ref cntitm, false);
if (sd.Type == curType) retval = tmpindx;
if (retval < 0 && tmpindx > 0) retval = tmpindx;
foundInCur = true;
}
}
// Handle inheritance (step data may not be in current format, may inherit from parents):
if (!foundInCur && doInherit)
{
IFormatOrFormatInfo parentFormat = MyParentFormat;
bool foundit = false;
while (parentFormat != null && !foundit)
{
vlnIndexedFormatList<StepData> InheritedList = parentFormat.PlantFormat.FormatData.StepDataList;
foreach (StepData sd1 in InheritedList)
{
if (sd1.ParentType == topType.Type)
{
int tmpindx = DoListChildStepTypes(alwaysAdd, ref sds, sd1, curType, _CurItemInfo, ref cntitm, true);
if (sd1.Type == curType) retval = tmpindx;
if (retval < 0 && tmpindx > 0) retval = tmpindx;
foundit = true;
}
}
parentFormat = parentFormat.PlantFormat.FormatData.MyParentFormat;
}
}
// Handle inheritance (step data may not be in current format, may inherit from parents):
if (!foundInCur && doInherit)
{
IFormatOrFormatInfo parentFormat = MyParentFormat;
bool foundit = false;
while (parentFormat != null && !foundit)
{
vlnIndexedFormatList<StepData> InheritedList = parentFormat.PlantFormat.FormatData.StepDataList;
foreach (StepData sd1 in InheritedList)
{
if (sd1.ParentType == topType.Type)
{
int tmpindx = DoListChildStepTypes(alwaysAdd, ref sds, sd1, curType, _CurItemInfo, ref cntitm, true);
if (sd1.Type == curType) retval = tmpindx;
if (retval < 0 && tmpindx > 0) retval = tmpindx;
foundit = true;
}
}
parentFormat = parentFormat.PlantFormat.FormatData.MyParentFormat;
}
}
}
return retval;
}
/// <summary>
/// for format data given a string representing the Type of step, find the index.
/// </summary>
public int GetIndexFromType(string type)
{
foreach (StepData sd in StepDataList)
{
if (sd.Type == type) return (int)sd.Index;
}
return 0; // default to the base
}
}
#endregion
#region PaperSize
[TypeConverter(typeof(ExpandableObjectConverter))]
public class PDFPageSize : vlnFormatItem
{
public PDFPageSize(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<string> _PaperSize;
public string PaperSize
{
get
{
return LazyLoad(ref _PaperSize, "@PaperSize"); // C2020-002 paper size is now set in the format files
}
}
}
#endregion
#region FontSizes
// C2021-005 the list of possible font sizes are set in the format files
[TypeConverter(typeof(ExpandableObjectConverter))]
public class FontSizes : vlnFormatItem
{
public FontSizes(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<string> _TableFontSizes;
public string TableFontSizes
{
get
{
return LazyLoad(ref _TableFontSizes, "@TableFontSizes"); // C2021-005 list of possible font sizes for table text
}
}
}
#endregion
#region ShadingOptions
// C2021-004 Additional shading color options defined in the format file
/* Example XML in base format file:
<MoreShadingOptions>
<ShadingOption A="255" R="211" G="211" B="211" Desc="15% Gray" />
</MoreShadingOptions>
**/
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ShadingOption : vlnFormatItem
{
public ShadingOption(XmlNode xmlNode) : base(xmlNode) { }
public ShadingOption() : base() { }
[Category("Ints")]
private LazyLoad<int?> _Alpha;
public int? Alpha
{
get
{
return LazyLoad(ref _Alpha, "@A");
}
}
[Category("Ints")]
private LazyLoad<int?> _Red;
public int? Red
{
get
{
return LazyLoad(ref _Red, "@R");
}
}
[Category("Ints")]
private LazyLoad<int?> _Green;
public int? Green
{
get
{
return LazyLoad(ref _Green, "@G");
}
}
[Category("Ints")]
private LazyLoad<int?> _Blue;
public int? Blue
{
get
{
return LazyLoad(ref _Blue, "@B");
}
}
[Category("Strings")]
private LazyLoad<string> _Desc;
public string Desc
{
get
{
return LazyLoad(ref _Desc, "@Desc");
}
}
public override string GetPDDisplayName()
{ return Desc; }
public override string GetPDDescription()
{ return string.Format("Shading Description '{0}' Alpha {1} Red {2} Green {3} Blue {4}", Desc, Alpha, Red, Green, Blue); }
public override string GetPDCategory()
{ return "Additional Shading Options"; }
public override string ToString()
{
return Desc;
}
public string GetARBGstringForTableCells()
{
return string.Format("[A={0}, R={1}, G={2}, B={3}]", Alpha, Red, Green, Blue);
}
}
[TypeConverter(typeof(vlnListConverter<ShadingOptionList, ShadingOption>))]
public class ShadingOptionList : vlnFormatList<ShadingOption>
{
public ShadingOptionList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region UnitWatermarks
// C2022-004 Watermark information based on the beginning of the the procedure number
/* Example XML in BNPP Single Column format file (base format has only the default setting):
<UnitWatermarkData>
<UnitWatermark ProcNumPrefix = "000-" WMText = "0" WMColor="[A=255, R=150, G=150, B=150]"/> <!-- Grey-->
<UnitWatermark ProcNumPrefix = "001-" WMText = "1" WMColor="[A=255, R=184, G=209, B=255]"/> <!-- Blue-->
<UnitWatermark ProcNumPrefix = "002-" WMText = "2" WMColor="[A=255, R=255, G=196, B=171]"/> <!-- Organge-->
<UnitWatermark ProcNumPrefix = "003-" WMText = "3" WMColor="[A=255, R=255, G=252, B=147]"/> <!-- Yellow -->
<UnitWatermark ProcNumPrefix = "004-" WMText = "4" WMColor="[A=255, R=164, G=181, B=120]"/> <!-- Green-->
<UnitWatermark ProcNumPrefix = "1N2-" WMText = "A" WMColor="[A=255, R=150, G=150, B=150]"/> <!-- Grey-->
<UnitWatermark ProcNumPrefix = "3N4-" WMText = "B" WMColor="[A=255, R=150, G=150, B=150]"/> <!-- Grey-->
<UnitWatermark ProcNumPrefix = "1T4-" WMText = "T" WMColor="[A=255, R=150, G=150, B=150]"/> <!-- Grey-->
<UnitWatermark ProcNumPrefix = "1-" WMText = "A" WMColor="[A=255, R=150, G=150, B=150]"/> <!-- Grey-->
<UnitWatermark ProcNumPrefix = "2-" WMText = "A" WMColor="[A=255, R=150, G=150, B=150]"/> <!-- Grey-->
<UnitWatermark ProcNumPrefix = "3-" WMText = "B" WMColor="[A=255, R=150, G=150, B=150]"/> <!-- Grey-->
<UnitWatermark ProcNumPrefix = "4-" WMText = "B" WMColor="[A=255, R=150, G=150, B=150]"/> <!-- Grey-->
<UnitWatermark ProcNumPrefix = "9-" WMText = "[U-Text]" WMColor="[A=255, R=150, G=150, B=150]"/> <!-- Grey--> <!-- this uses the <U-Text> Applicability setting -->
<UnitWatermark ProcNumPrefix = "default" WMText = "[U-Number]" WMColor="Blue"/> <!-- this uses the <U-Number> Applicability setting -->
</UnitWatermarkData>
**/
[TypeConverter(typeof(ExpandableObjectConverter))]
public class UnitWatermark : vlnFormatItem
{
public UnitWatermark(XmlNode xmlNode) : base(xmlNode) { }
public UnitWatermark() : base() { }
[Category("Strings")]
private LazyLoad<string> _ProcNumPrefix;
public string ProcNumPrefix // based on the what the procedure number starts with, usually a resolved unit toke (ex: <U-Number>)
{
get
{
return LazyLoad(ref _ProcNumPrefix, "@ProcNumPrefix");
}
}
[Category("Strings")]
private LazyLoad<string> _WMText;
public string WMText
{
get
{
return LazyLoad(ref _WMText, "@WMText");
}
}
[Category("Strings")]
private LazyLoad<string> _WMColor;
public string WMColor
{
get
{
return LazyLoad(ref _WMColor, "@WMColor");
}
}
}
[TypeConverter(typeof(vlnListConverter<UnitWatermarkList, UnitWatermark>))]
public class UnitWatermarkList : vlnFormatList<UnitWatermark>
{
public UnitWatermarkList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region Symbols
[TypeConverter(typeof(ExpandableObjectConverter))]
public class Symbol : vlnFormatItem
{
public Symbol(XmlNode xmlNode) : base(xmlNode) { }
public Symbol() : base() { }
[Category("Ints")]
private LazyLoad<int?> _Unicode;
public int? Unicode
{
get
{
return LazyLoad(ref _Unicode, "@Unicode");
}
}
[Category("Strings")]
private LazyLoad<string> _Desc;
public string Desc
{
get
{
return LazyLoad(ref _Desc, "@Desc");
}
}
public override string GetPDDisplayName()
{ return Desc; }
public override string GetPDDescription()
{ return string.Format("Symbol Unicode '{0}' Description '{1}'", Unicode, Desc); }
public override string GetPDCategory()
{ return "Supported Symbols"; }
public override string ToString()
{
return Desc;
}
}
[TypeConverter(typeof(vlnListConverter<SymbolList, Symbol>))]
public class SymbolList : vlnFormatList<Symbol>
{
public SymbolList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region Templates
// the nocolm field -- divided into 4 four-bit subfields;
// starting with the 4 lowest order bits :
// field 1 - number of columns
// field 2 - the header macro to print instead of the text(fixed at 4 for now)
// field 3 - the number of blank lines after the header macro
// field 4 - 1 - identifies the template as being boxed, for latter retrieval
public class TPlate
{
public int level; // sub-step level
public int type; // type of step/substep
public int start; // starting position (for horizontal only)
public int width; // width of text in characters (")
public int row;
public short nocolm; // 1 or 2 columns - default(0) is one column
public string text; // text to be automatically entered
public bool boxed;
public int hmacro = 0;
public TPlate(int l, int t, int s, int w, int r, short c, string x)
{
level = l;
type = t;
start = s;
width = w;
row = r;
nocolm = c;
hmacro = 0x00F0 & nocolm >> 4;
if (hmacro > 0) hmacro = 4; // bge - this was in 16bit code
int blines = (0x0F00 & nocolm) >> 8;
boxed = ((0xF000 & nocolm) >> 12) != 0;
nocolm = (short)(0x000F & nocolm);
text = x;
}
}
#endregion
#region EditData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class EditData : vlnFormatItem
{
public EditData(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<E_EMode?> _EMode;
public E_EMode? EMode
{
get
{
return LazyLoad<E_EMode>(ref _EMode, "@EMode");
}
}
private LazyLoad<bool> _PromptForCautionType;
public bool PromptForCautionType
{
get
{
return LazyLoad(ref _PromptForCautionType, "@PromptForCautionType");
}
}
// Put in for Farley. This puts editor in editoral mode while a spell check being performed
// - No change bars will be added
// - existing change bars will remain
private LazyLoad<bool> _EditoralSpellCheck;
public bool EditoralSpellCheck
{
get
{
return LazyLoad(ref _EditoralSpellCheck, "@EditoralSpellCheck");
}
}
}
#endregion
#region PrintDataAll
#region PrintData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class PrintData : vlnFormatItem
{
public PrintData(XmlNode xmlNode) : base(xmlNode) { }
private VersionIdTextList _VersionIdTextList;
public VersionIdTextList VersionIdTextList
{
get
{
return _VersionIdTextList == null? _VersionIdTextList = new VersionIdTextList(SelectNodes("VersionIdText/string")):_VersionIdTextList;
}
set { _VersionIdTextList = value; }
}
private ProcDescrList _ProcDescrList;
public ProcDescrList ProcDescrList
{
get
{
return _ProcDescrList == null? _ProcDescrList = new ProcDescrList(SelectNodes("ProcDescrList/ProcDescr")):_ProcDescrList;
}
}
private LazyLoad<int?> _DoPrnDrvrAdjusts;
public int? DoPrnDrvrAdjusts
{
get
{
return LazyLoad(ref _DoPrnDrvrAdjusts, "@DoPrnDrvrAdjusts");
}
}
private LazyLoad<int?> _SupInfoTabOff;
public int? SupInfoTabOff
{
get
{
return LazyLoad(ref _SupInfoTabOff, "@SupInfoTabOff");
}
}
private LazyLoad<bool> _SupInfoIncludeParTab;
public bool SupInfoIncludeParTab
{
get
{
return LazyLoad(ref _SupInfoIncludeParTab, "@SupInfoIncludeParTab");
}
}
private LazyLoad<bool> _SupInfoAdjustXOffForLongTab;
public bool SupInfoAdjustXOffForLongTab
{
get
{
return LazyLoad(ref _SupInfoAdjustXOffForLongTab, "@SupInfoAdjustXOffForLongTab");
}
}
private LazyLoad<string> _TopOfPageThing;
public string TopOfPageThing
{
get
{
return LazyLoad(ref _TopOfPageThing, "@TopOfPageThing");
}
}
private LazyLoad<bool> _DoRevDate;
public bool DoRevDate
{
get
{
return LazyLoad(ref _DoRevDate, "@DoRevDate");
}
}
private LazyLoad<bool> _AlternateFoldoutPages;
public bool AlternateFoldoutPages
{
get
{
return LazyLoad(ref _AlternateFoldoutPages, "@AlternateFoldoutPages");
}
}
private LazyLoad<bool> _AlternateFloatingFoldout;
public bool AlternateFloatingFoldout
{
get
{
return LazyLoad(ref _AlternateFloatingFoldout, "@AlternateFloatingFoldout");
}
}
private LazyLoad<bool> _SectionLevelFoldouts;
public bool SectionLevelFoldouts
{
get
{
return LazyLoad(ref _SectionLevelFoldouts, "@SectionLevelFoldouts");
}
}
private LazyLoad<string> _SlashReplace;
public string SlashReplace
{
get
{
return LazyLoad(ref _SlashReplace, "@SlashReplace");
}
}
private LazyLoad<bool> _RevDateWithForwardSlash;
public bool RevDateWithForwardSlash
{
get
{
return LazyLoad(ref _RevDateWithForwardSlash, "@RevDateWithForwardSlash");
}
}
private LazyLoad<bool> _UnitNumber;
public bool UnitNumber
{
get
{
return LazyLoad(ref _UnitNumber, "@UnitNumber");
}
}
private LazyLoad<bool> _OutSideTransSetName; //B2019-072: For AEP, use PSI & SI for outside transition text
public bool OutSideTransSetName
{
get
{
return LazyLoad(ref _OutSideTransSetName, "@OutSideTransSetName");
}
}
private LazyLoad<bool> _SpecialCaseCalvert;
public bool SpecialCaseCalvert
{
get
{
return LazyLoad(ref _SpecialCaseCalvert, "@SpecialCaseCalvert");
}
}
private LazyLoad<bool> _SpecialCaseCalvertAlarm;
public bool SpecialCaseCalvertAlarm
{
get
{
return LazyLoad(ref _SpecialCaseCalvertAlarm, "@SpecialCaseCalvertAlarm");
}
}
private LazyLoad<bool> _SpecialCaseCalvertPagination;
public bool SpecialCaseCalvertPagination
{
get
{
return LazyLoad(ref _SpecialCaseCalvertPagination, "@SpecialCaseCalvertPagination");
}
}
// B2023-034 for use with Beaver Valley AOP format
private LazyLoad<bool> _UseOnFirstForSeparatePaginationOnSubSect;
public bool UseOnFirstForSeparatePaginationOnSubSect
{
get
{
return LazyLoad(ref _UseOnFirstForSeparatePaginationOnSubSect, "@UseOnFirstForSeparatePaginationOnSubSect");
}
}
// B2023-043 for use with Beaver Valley AOP format - allow attributes, such as superscript on section titles when printing
private LazyLoad<bool> _SectionTitleWithAttributes;
public bool SectionTitleWithAttributes
{
get
{
return LazyLoad(ref _SectionTitleWithAttributes, "@SectionTitleWithAttributes");
}
}
private LazyLoad<bool> _WCNTraining;
public bool WCNTraining
{
get
{
return LazyLoad(ref _WCNTraining, "@WCNTraining");
}
}
private LazyLoad<bool> _HorizontalSubsteps;
public bool HorizontalSubsteps
{
get
{
return LazyLoad(ref _HorizontalSubsteps, "@HorizontalSubsteps");
}
}
private LazyLoad<bool> _SpecialStepsFoldout;
public bool SpecialStepsFoldout
{
get
{
return LazyLoad(ref _SpecialStepsFoldout, "@SpecialStepsFoldout");
}
}
private LazyLoad<bool> _SpecialStepsFoldoutKeepWhiteSpace;
public bool SpecialStepsFoldoutKeepWhiteSpace
{
get
{
return LazyLoad(ref _SpecialStepsFoldoutKeepWhiteSpace, "@SpecialStepsFoldoutKeepWhiteSpace");
}
}
private LazyLoad<bool> _AllowDuplex;
public bool AllowDuplex
{
get
{
return LazyLoad(ref _AllowDuplex, "@AllowDuplex");
}
}
private LazyLoad<bool> _AccessoryDocsInDuplex;
public bool AccessoryDocsInDuplex
{
get
{
return LazyLoad(ref _AccessoryDocsInDuplex, "@AccessoryDocsInDuplex");
}
}
private LazyLoad<bool> _FoldoutsInDuplex;
public bool FoldoutsInDuplex
{
get
{
return LazyLoad(ref _FoldoutsInDuplex, "@FoldoutsInDuplex");
}
}
private LazyLoad<bool> _PagelistChangeIDsWithCommas;
public bool PagelistChangeIDsWithCommas
{
get
{
return LazyLoad(ref _PagelistChangeIDsWithCommas, "@PagelistChangeIDsWithCommas");
}
}
private LazyLoad<bool> _SpecialCaseWestinghouse;
public bool SpecialCaseWestinghouse
{
get
{
return LazyLoad(ref _SpecialCaseWestinghouse, "@SpecialCaseWestinghouse");
}
}
// Put in for Comanche Peak to print "COMMON" for the unit number instead of "Unit 0"
private LazyLoad<bool> _PrintCommonForZeroUnit;
public bool PrintCommonForZeroUnit
{
get
{
return LazyLoad(ref _PrintCommonForZeroUnit, "@PrintCommonForZeroUnit");
}
}
private LazyLoad<bool> _NoBlankHlsAndFirstSub; // F2021-033: Barakah Alarm: no blank line between HLS & first substep
public bool NoBlankHlsAndFirstSub
{
get
{
return LazyLoad(ref _NoBlankHlsAndFirstSub, "@NoBlankHlsAndFirstSub");
}
}
private LazyLoad<bool> _NoBlankLastNoteCautionWarn; // F2021-025: Barakah Alarm: no blank line between last Note/Caution/Warn & box line
public bool NoBlankLastNoteCautionWarn
{
get
{
return LazyLoad(ref _NoBlankLastNoteCautionWarn, "@NoBlankLastNoteCautionWarn");
}
}
private LazyLoad<bool> _NoteCautionCenterOneAllTypes; // F2023-126: Vogtle Alarms - center single line caution/note if more than one type exist off step
public bool NoteCautionCenterOneAllTypes
{
get
{
return LazyLoad(ref _NoteCautionCenterOneAllTypes, "@NoteCautionCenterOneAllTypes");
}
}
private LazyLoad<bool> _ChkBoxToGeneratePointListText; // C2021-063 Barakah Alarm: check box to generate Alarm Point List Text
public bool ChkBoxToGeneratePointListText
{
get
{
return LazyLoad(ref _ChkBoxToGeneratePointListText, "@ChkBoxToGeneratePointListText");
}
}
// C2022-004 When a procedure is approved, force the watermark of the unit number (defined in the format file under UnitWatermarkData)
private LazyLoad<bool> _UseUnitWatermarkOnApproved;
public bool UseUnitWatermarkOnApproved
{
get
{
return LazyLoad(ref _UseUnitWatermarkOnApproved, "@UseUnitWatermarkOnApproved");
}
}
// B2022-086: Barakah - flag to adjust ypagesize for pagination when 1st and later pages have different printable box size
private LazyLoad<bool> _AdjFirstSecDocStylesInPagination;
public bool AdjFirstSecDocStylesInPagination
{
get
{
return LazyLoad(ref _AdjFirstSecDocStylesInPagination, "@AdjFirstSecDocStylesInPagination");
}
}
private LazyLoad<bool> _AdjustLargeImage;
public bool AdjustLargeImage
{
get
{
return LazyLoad(ref _AdjustLargeImage, "@AdjustLargeImage");
}
}
}
#endregion
#region VersionIdText
[TypeConverter(typeof(ExpandableObjectConverter))]
public class VersionIdText : vlnFormatItem
{
public VersionIdText(XmlNode xmlNode) : base(xmlNode) { }
public VersionIdText() : base() { }
private LazyLoad<string> _Text;
public string Text
{
get
{
return LazyLoad(ref _Text, "text()");
}
}
public override string GetPDDisplayName()
{ return "Text"; }
public override string GetPDDescription()
{ return string.Format("VersionIdText '{0}'", Text); }
public override string GetPDCategory()
{ return "Version Id Text"; }
public override string ToString()
{
return Text;
}
}
#endregion
#region VersionIdTextList
[TypeConverter(typeof(vlnListConverter<VersionIdTextList, VersionIdText>))]
public class VersionIdTextList : vlnFormatList<VersionIdText>
{
public VersionIdTextList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region ProcDescr
[TypeConverter(typeof(ExpandableObjectConverter))]
public partial class ProcDescr : vlnFormatItem //: BusinessBase<ProcDescr>, IDisposable
{
public ProcDescr(XmlNode xmlNode) : base(xmlNode) { }
public ProcDescr() : base() { }
private LazyLoad<string> _MatchProcNumber;
public string MatchProcNumber
{
get
{
return LazyLoad(ref _MatchProcNumber, "@MatchProcNumber");
}
}
private LazyLoad<string> _ProcDescr1;
public string ProcDescr1
{
get
{
return LazyLoad(ref _ProcDescr1, "@ProcDescr1");
}
}
private LazyLoad<string> _ProcDescr2;
public string ProcDescr2
{
get
{
return LazyLoad(ref _ProcDescr2, "@ProcDescr2");
}
}
public override string ToString()
{
return string.Format("{0}, {1}", ProcDescr1, MatchProcNumber);
}
}
#region ProcDescrList
[TypeConverter(typeof(vlnListConverter<ProcDescrList, ProcDescr>))]
public class ProcDescrList : vlnFormatList<ProcDescr>
{
public ProcDescrList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#endregion
#endregion
#region ProcDataAll
#region ProcData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ProcData : vlnFormatItem
{
public ProcData(XmlNode xmlNode) : base(xmlNode) { }
private ProcedureSuffixList _ProcedureSuffixList;
public ProcedureSuffixList ProcedureSuffixList
{
get
{
return _ProcedureSuffixList == null ? _ProcedureSuffixList = new ProcedureSuffixList(SelectNodes("ProcedureSuffix/string")) : _ProcedureSuffixList;
}
set { _ProcedureSuffixList = value; }
}
private ChangeBarData _ChangeBarData;
public ChangeBarData ChangeBarData
{
get
{
return _ChangeBarData == null ? _ChangeBarData = new ChangeBarData(SelectSingleNode("ChangeBarData")) : _ChangeBarData;
}
}
private CheckOffData _CheckOffData;
public CheckOffData CheckOffData
{
get
{
return _CheckOffData == null ? _CheckOffData = new CheckOffData(SelectSingleNode("CheckOffData")) : _CheckOffData;
}
}
private PSI _PSI;
public PSI PSI
{
get
{
return _PSI == null ? _PSI = new PSI(SelectSingleNode("PSI")) : _PSI;
}
}
private LazyLoad<bool> _CheckOffUCF;
public bool CheckOffUCF
{
get
{
// The following line is used in UCF (User Control of Format).
// This needs to be able to control a change in setting in UCF versus its use:
// - This is a special case since the original format, using the value in BaseAll, is always 'false'. And the value
// should never be set in original volian plant format files, if the additional UCF checkoffs are to be used, this must
// be set in the UCF user interface.
if (PlantFormat.DoingUCFCheckOffs) return PlantFormat.DoingUCFCheckOffsUse;
if (PlantFormat.IgnoreUCF) return LazyLoad(ref _CheckOffUCF, "@CheckOffUCF");
bool? localvalue = null; // comes to here if in edit or print - use any UCF data before going to original format.
FormatConfig fc = PlantFormat.GetFormatConfig(MyFormat);
if (fc != null) localvalue = fc.PlantFormat.FormatData.Flags.CheckOffUCF;
return localvalue ?? LazyLoad(ref _CheckOffUCF, "@CheckOffUCF");
}
}
private LazyLoad<int?> _TitleLength;
public int? TitleLength
{
get
{
return LazyLoad(ref _TitleLength, "@TitleLength");
}
}
private LazyLoad<int?> _CoverTitleLength;
public int? CoverTitleLength
{
get
{
return LazyLoad(ref _CoverTitleLength, "@CoverTitleLength");
}
}
private LazyLoad<string> _ProcedureSuffixFlags;
public string ProcedureSuffixFlags
{
get
{
return LazyLoad(ref _ProcedureSuffixFlags, "@ProcedureSuffixFlags");
}
}
private LazyLoad<bool> _CapitalizeTitle;
public bool CapitalizeTitle
{
get
{
return LazyLoad(ref _CapitalizeTitle, "@CapitalizeTitle");
}
}
private LazyLoad<bool> _ChangeStyleForEverySection;
public bool ChangeStyleForEverySection
{
get
{
return LazyLoad(ref _ChangeStyleForEverySection, "@ChangeStyleForEverySection");
}
}
private LazyLoad<bool> _PrintNoTitle;
public bool PrintNoTitle
{
get
{
return LazyLoad(ref _PrintNoTitle, "@PrintNoTitle");
}
}
private LazyLoad<bool> _NotesToFootnotes;
public bool NotesToFootnotes
{
get
{
return LazyLoad(ref _NotesToFootnotes, "@NotesToFootnotes");
}
}
private LazyLoad<bool> _ProcAppl;
public bool ProcAppl // C2021-027: Procedure level PC/PC
{
get
{
return LazyLoad(ref _ProcAppl, "@ProcAppl");
}
}
private LazyLoad<bool> _CountFoldoutPages;
public bool CountFoldoutPages
{
get
{
return LazyLoad(ref _CountFoldoutPages, "@CountFoldoutPages");
}
}
private LazyLoad<string> _ForeColor;
public string ForeColor
{
get
{
return LazyLoad(ref _ForeColor, "@ForeColor");
}
}
private LazyLoad<string> _BackColor;
public string BackColor
{
get
{
return LazyLoad(ref _BackColor, "@BackColor");
}
}
}
#endregion
#region ProcedureSuffix
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ProcedureSuffix : vlnFormatItem
{
public ProcedureSuffix(XmlNode xmlNode) : base(xmlNode) { }
public ProcedureSuffix() : base() { }
private LazyLoad<string> _Text;
public string Text
{
get
{
return LazyLoad(ref _Text, "text()");
}
}
public override string GetPDDisplayName()
{ return "Text"; }
public override string GetPDDescription()
{ return string.Format("ProcedureSuffix '{0}'", Text); }
public override string GetPDCategory()
{ return "Procedure Suffix"; }
public override string ToString()
{
return Text;
}
}
#endregion
#region ProcedureSuffixList
[TypeConverter(typeof(vlnListConverter<ProcedureSuffixList, ProcedureSuffix>))]
public class ProcedureSuffixList : vlnFormatList<ProcedureSuffix>
{
public ProcedureSuffixList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region PsiAll
[TypeConverter(typeof(ExpandableObjectConverter))]
public class PSI : vlnFormatItem
{
public PSI(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<int?> _x;
public int? x
{
get
{
return LazyLoad(ref _x, "@x");
}
}
private LazyLoad<int?> _y;
public int? y
{
get
{
return LazyLoad(ref _y, "@y");
}
}
private LazyLoad<string> _Caption;
public string Caption
{
get
{
return LazyLoad(ref _Caption, "@Caption");
}
}
private LazyLoad<string> _ButtonsOnBottom; // change to bool
public string ButtonsOnBottom
{
get
{
return LazyLoad(ref _ButtonsOnBottom, "@ButtonsOnBottom");
}
}
private SILabels _LabelList;
public SILabels LabelList
{
get
{
return _LabelList == null ? _LabelList = new SILabels(SelectNodes("/PlantFormat/FormatData/ProcData/PSI/Label")) : _LabelList;
}
}
private SIFields _FieldList;
public SIFields FieldList
{
get
{
return _FieldList == null ? _FieldList = new SIFields(SelectNodes("/PlantFormat/FormatData/ProcData/PSI/Field")) : _FieldList;
}
}
}
public class SILabels : vlnFormatList<SILabel>
{
public SILabels(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
public class SILabel : vlnFormatItem
{
public SILabel(XmlNode xmlNode) : base(xmlNode) { }
public SILabel() : base() { }
private LazyLoad<string> _text;
public string text
{
get
{
return LazyLoad(ref _text, "@text");
}
}
private LazyLoad<string> _Justify;
public string Justify
{
get
{
return LazyLoad(ref _Justify, "@Justify");
}
}
private LazyLoad<int?> _x;
public int? x
{
get
{
return LazyLoad(ref _x, "@x");
}
}
private LazyLoad<int?> _y;
public int? y
{
get
{
return LazyLoad(ref _y, "@y");
}
}
private LazyLoad<int?> _width;
public int? width
{
get
{
return LazyLoad(ref _width, "@width");
}
}
private LazyLoad<int?> _height;
public int? height
{
get
{
return LazyLoad(ref _height, "@height");
}
}
}
public class SIFields : vlnFormatList<SIField>
{
public SIFields(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
public class SIField : vlnFormatItem
{
public SIField(XmlNode xmlNode) : base(xmlNode) { }
public SIField() : base() { }
private LazyLoad<string> _name;
public string name
{
get
{
return LazyLoad(ref _name, "@name");
}
}
private LazyLoad<string> _type;
public string type
{
get
{
return LazyLoad(ref _type, "@type");
}
}
private LazyLoad<string> _text;
public string text
{
get
{
return LazyLoad(ref _text, "@text");
}
}
private LazyLoad<int?> _Length;
public int? Length
{
get
{
return LazyLoad(ref _Length, "@Length");
}
}
private LazyLoad<int?> _x;
public int? x
{
get
{
return LazyLoad(ref _x, "@x");
}
}
private LazyLoad<int?> _y;
public int? y
{
get
{
return LazyLoad(ref _y, "@y");
}
}
private LazyLoad<int?> _width;
public int? width
{
get
{
return LazyLoad(ref _width, "@width");
}
}
private LazyLoad<int?> _height;
public int? height
{
get
{
return LazyLoad(ref _height, "@height");
}
}
private LazyLoad<string> _hasAppl;
public string hasAppl
{
get
{
return LazyLoad(ref _hasAppl, "@hasAppl");
}
}
}
#endregion
#region SIAll
[TypeConverter(typeof(ExpandableObjectConverter))]
public class SI : vlnFormatItem
{
public SI(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<int?> _x;
public int? x
{
get
{
return LazyLoad(ref _x, "@x");
}
}
private LazyLoad<int?> _y;
public int? y
{
get
{
return LazyLoad(ref _y, "@y");
}
}
private LazyLoad<string> _Caption;
public string Caption
{
get
{
return LazyLoad(ref _Caption, "@Caption");
}
}
private LazyLoad<string> _ButtonsOnBottom; // change to bool
public string ButtonsOnBottom
{
get
{
return LazyLoad(ref _ButtonsOnBottom, "@ButtonsOnBottom");
}
}
private SILabels _LabelList;
public SILabels LabelList
{
get
{
return _LabelList == null ? _LabelList = new SILabels(SelectNodes("/PlantFormat/FormatData/SI/Label")) : _LabelList;
}
}
private SIFields _FieldList;
public SIFields FieldList
{
get
{
return _FieldList == null ? _FieldList = new SIFields(SelectNodes("/PlantFormat/FormatData/SI/Field")) : _FieldList;
}
}
}
#endregion
#region CheckOffAll
#region CheckOffData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class CheckOffData : vlnFormatItem
{
public CheckOffData(XmlNode xmlNode) : base(xmlNode) { }
private CheckOffList _CheckOffList = null;
public CheckOffList CheckOffList
{
get
{
if (_CheckOffList != null) return _CheckOffList;
// Get a list of checkoffs that should be included:
// if !UseCheckOffUCF (Baseall has it as false. User can change setting in UCF to true)
// if !IgnoreUCF, i.e. use UCF changes, return original lists with only active items (Inactive = false)
// if IgnoreUCF, return original lists with all items
// if UseCheckOffUCF is true use the merged lists from current format and baseall.xml and
// do the same processing for IgnoreUCF described above.
// UseCheckOffUCF is false or there is no FormatConfig (UCF) data:
FormatConfig fc = PlantFormat.GetFormatConfig(MyFormat);
if (!MyFormat.PlantFormat.FormatData.ProcData.CheckOffUCF || fc==null)
{
_CheckOffList = new CheckOffList(SelectNodes("CheckOffList/CheckOff"), MyFormat);
// B2019-100: If Ignoring the UCF data, just return the entire list. Also, return entire list if there is no UCF data (fc == null)
if (PlantFormat.IgnoreUCF || fc == null) return _CheckOffList;
// If not ignoring UCF settings, only return those that are active
foreach (FormatConfig.CheckOff co in fc.PlantFormat.FormatData.CheckOffList)
{
foreach (CheckOff coo in _CheckOffList)
{
if ((int)coo.Index == Convert.ToInt32(co.Index) && !(bool)co.Active)
{
_CheckOffList.Remove(coo);
break;
}
}
}
return _CheckOffList;
}
// UseCheckOfffUCF is true:
// merge the checkoff list from the current format and the checkoff list from the base format
_CheckOffList = new CheckOffList(SelectNodes("CheckOffList/CheckOff"), MyFormat);
CheckOffList retlist2 = new CheckOffList(SelectNodes("../CheckOffDataUCF/CheckOffList/CheckOff"), MyFormat);
if (retlist2 != null && retlist2.Count > 0) foreach (CheckOff co in retlist2) _CheckOffList.Add(co);
if (PlantFormat.IgnoreUCF) return _CheckOffList;
// if applying UCF, then remove those that are inactive:
foreach (FormatConfig.CheckOff co in fc.PlantFormat.FormatData.CheckOffList)
{
foreach (CheckOff coo in _CheckOffList)
{
if ((int)coo.Index == Convert.ToInt32(co.Index) && !(bool)co.Active)
{
_CheckOffList.Remove(coo);
break;
}
}
}
return _CheckOffList;
}
}
public void ClearCheckOffAndHeaderLists()
{
_CheckOffList = null;
_CheckOffHeaderList = null;
}
private CheckOffHeaderList _CheckOffHeaderList;
public CheckOffHeaderList CheckOffHeaderList
{
get
{
if (_CheckOffHeaderList != null) return _CheckOffHeaderList;
FormatConfig fc = PlantFormat.GetFormatConfig(MyFormat);
if (!MyFormat.PlantFormat.FormatData.ProcData.CheckOffUCF || fc == null)
{
_CheckOffHeaderList = new CheckOffHeaderList(SelectNodes("CheckOffHeaderList/CheckOffHeader"), MyFormat);
// Depending on the IgnoreUCF flag, either return this list with UCF Inactive flags set or return the
// list as is.
if (PlantFormat.IgnoreUCF || fc == null) return _CheckOffHeaderList;
// If not ignoring UCF settings, only return those that are active
foreach (FormatConfig.CheckOffHeader coh in fc.PlantFormat.FormatData.CheckOffHeaderList)
{
foreach (CheckOffHeader coo in _CheckOffHeaderList)
{
if ((int)coo.Index == Convert.ToInt32(coh.Index) && !(bool)coh.Active)
{
_CheckOffHeaderList.Remove(coo);
break;
}
}
}
return _CheckOffHeaderList;
}
// merge the checkoff header lists from the current format and the list from the base
_CheckOffHeaderList = new CheckOffHeaderList(SelectNodes("CheckOffHeaderList/CheckOffHeader"), MyFormat);
CheckOffHeaderList retlist2 = new CheckOffHeaderList(SelectNodes("../CheckOffDataUCF/CheckOffHeaderList/CheckOffHeader"), MyFormat);
if (retlist2 != null && retlist2.Count > 0) foreach (CheckOffHeader co in retlist2) _CheckOffHeaderList.Add(co);
if (PlantFormat.IgnoreUCF) return _CheckOffHeaderList;
// if applying UCF, then remove those that are inactive.
foreach (FormatConfig.CheckOffHeader coh in fc.PlantFormat.FormatData.CheckOffHeaderList)
{
foreach (CheckOffHeader cooh in _CheckOffHeaderList)
{
if ((int)cooh.Index == Convert.ToInt32(coh.Index) && !(bool)coh.Active)
{
_CheckOffHeaderList.Remove(cooh);
break;
}
}
}
return _CheckOffHeaderList;
}
}
public void CheckOffHeaderListRefresh(bool CheckOffUCF)
{
if (!CheckOffUCF)
{
_CheckOffHeaderList = new CheckOffHeaderList(SelectNodes("CheckOffHeaderList/CheckOffHeader"), MyFormat);
// Depending on the IgnoreUCF flag, either return this list with UCF Inactive flags set or return the
// list as is.
FormatConfig fc = PlantFormat.GetFormatConfig(MyFormat);
if (PlantFormat.IgnoreUCF || fc == null) return;
// If not ignoring UCF settings, only return those that are active
foreach (FormatConfig.CheckOffHeader coh in fc.PlantFormat.FormatData.CheckOffHeaderList)
{
foreach (CheckOffHeader coo in _CheckOffHeaderList)
{
if ((int)coo.Index == Convert.ToInt32(coh.Index) && !(bool)coh.Active)
{
_CheckOffHeaderList.Remove(coo);
break;
}
}
}
return;
}
// if coming from the UCF dialog, then check for the 'ignoreUCF' this will flag whether to only
// merge the checkoff header lists from the current format and the list from the base
CheckOffHeaderList retlist = new CheckOffHeaderList(SelectNodes("CheckOffHeaderList/CheckOffHeader"), MyFormat);
CheckOffHeaderList retlist2 = new CheckOffHeaderList(SelectNodes("../CheckOffDataUCF/CheckOffHeaderList/CheckOffHeader"), MyFormat);
if (retlist2 != null && retlist2.Count > 0) foreach (CheckOffHeader co in retlist2) retlist.Add(co);
_CheckOffHeaderList = retlist;
}
private LazyLoad<bool> _CheckOffHeaderInPagelist;
public bool CheckOffHeaderInPagelist
{
get
{
return LazyLoad(ref _CheckOffHeaderInPagelist, "@CheckOffHeaderInPagelist");
}
}
private LazyLoad<string> _Menu;
public string Menu
{
get
{
return LazyLoad(ref _Menu, "@Menu");
}
}
private LazyLoad<bool> _AllowSectEdit;
public bool AllowSectEdit
{
get
{
return LazyLoad(ref _AllowSectEdit, "@AllowSectEdit");
}
}
private LazyLoad<bool> _AllowStepEdit;
public bool AllowStepEdit
{
get
{
return LazyLoad(ref _AllowStepEdit, "@AllowStepEdit");
}
}
private LazyLoad<int?> _UseCheckOffsIn;
public int? UseCheckOffsIn
{
get
{
return LazyLoad(ref _UseCheckOffsIn, "@UseCheckOffsIn");
}
}
private LazyLoad<float?> _CheckOffAdjustment;
public float? CheckOffAdjustment
{
get
{
return LazyLoad(ref _CheckOffAdjustment, "@CheckOffAdjustment");
}
}
private LazyLoad<float?> _XLocation;
public float? XLocation
{
get
{
return LazyLoad(ref _XLocation, "@XLocation");
}
}
private LazyLoad<float?> _RelXLocation;
public float? RelXLocation
{
get
{
return LazyLoad(ref _RelXLocation, "@RelXLocation");
}
}
private LazyLoad<bool> _DropCheckOff;
public bool DropCheckOff
{
get
{
return LazyLoad(ref _DropCheckOff, "@DropCheckOff");
}
}
private LazyLoad<bool> _CheckOffOnHLSOnly;
public bool CheckOffOnHLSOnly
{
get
{
return LazyLoad(ref _CheckOffOnHLSOnly, "@CheckOffOnHLSOnly");
}
}
private LazyLoad<bool> _SkipSpaces;
public bool SkipSpaces
{
get
{
return LazyLoad(ref _SkipSpaces, "@SkipSpaces");
}
}
// put in for Bryon and Braidwood
private LazyLoad<bool> _CheckoffOnSubStepsOnly;
public bool CheckoffOnSubStepsOnly
{
get
{
return LazyLoad(ref _CheckoffOnSubStepsOnly, "@CheckoffOnSubStepsOnly");
}
}
// C2019-040 This will adjust the right margin (making room for the checkoff) without the need of selecting a checkoff header
// the flag allows us to use existing coding that prior to this was restricted by format file name
private LazyLoad<bool> _CheckoffsWithoutHeader;
public bool CheckoffsWithoutHeader
{
get
{
return LazyLoad(ref _CheckoffsWithoutHeader, "@CheckoffsWithoutHeader");
}
}
}
#endregion
#region CheckOff
[TypeConverter(typeof(ExpandableObjectConverter))]
public class CheckOff : vlnFormatItem,IVlnIndexedFormatItem
{
public CheckOff(XmlNode xmlNode) : base(xmlNode) { }
public CheckOff() : base() { }
private LazyLoad<int?> _Index;
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
private LazyLoad<float?> _OrderBy; // C2020-003 used to sort list of checkoffs in the combo box
public float? OrderBy
{
get
{
return LazyLoad(ref _OrderBy, "@OrderBy");
}
}
private LazyLoad<int?> _UIMark;
public int? UIMark
{
get
{
return LazyLoad(ref _UIMark, "@UIMark");
}
}
private LazyLoad<float?> _CheckOffWidAdjust;
public float? CheckOffWidAdjust
{
get
{
return LazyLoad(ref _CheckOffWidAdjust, "@CheckOffWidAdjust");
}
}
private LazyLoad<float?> _CheckOffXtraLines;
public float? CheckOffXtraLines
{
get
{
return LazyLoad(ref _CheckOffXtraLines, "@CheckOffXtraLines");
}
}
private LazyLoad<float?> _CheckOffNumberOfLines;
public float? CheckOffNumberOfLines
{
get
{
return LazyLoad(ref _CheckOffNumberOfLines, "@CheckOffNumberOfLines");
}
}
private LazyLoad<string> _MenuItem;
public string MenuItem
{
get
{
return LazyLoad(ref _MenuItem, "@MenuItem");
}
}
private LazyLoad<string> _Macro;
public string Macro
{
get
{
return LazyLoad(ref _Macro, "@Macro");
}
}
private LazyLoad<bool> _NotOnEmpty;
public bool NotOnEmpty
{
get
{
return LazyLoad(ref _NotOnEmpty, "@NotOnEmpty");
}
}
private LazyLoad<bool> _DropCheckOff;
public bool DropCheckOff
{
get
{
return LazyLoad(ref _DropCheckOff, "@DropCheckOff");
}
}
public override string GetPDDisplayName()
{ return string.Format("[{0}]",Index); }
public override string GetPDDescription()
{ return string.Format("[{0}] - {1}", Index, MenuItem); }
public override string GetPDCategory()
{ return "Checkoff Data"; }
public override string ToString()
{
return MenuItem;
}
}
#endregion
#region CheckOffList
[TypeConverter(typeof(vlnIndexedListConverter<CheckOffList, CheckOff>))]
public class CheckOffList : vlnIndexedFormatList<CheckOff>
{
public CheckOffList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
public override vlnIndexedFormatList<CheckOff> InheritedList
{
get
{
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
if (parentFormat != null)
return parentFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffList;
return null;
}
}
}
#endregion
#region CheckOffHeader
[TypeConverter(typeof(ExpandableObjectConverter))]
public class CheckOffHeader : vlnFormatItem,IVlnIndexedFormatItem
{
public CheckOffHeader(XmlNode xmlNode) : base(xmlNode) { }
public CheckOffHeader() : base() { }
private LazyLoad<int?> _Index;
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
private VE_Font _Font;
public VE_Font Font
{
get
{
return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
}
}
private LazyLoad<string> _CheckOffHeading;
public string CheckOffHeading
{
get
{
return LazyLoad(ref _CheckOffHeading, "@CheckOffHeading");
}
}
public override string GetPDDisplayName()
{ return string.Format("[{0}]", Index); }
public override string GetPDDescription()
{ return string.Format("[{0}] - {1}", Index, CheckOffHeading); }
public override string GetPDCategory()
{ return "Checkoff Header Data"; }
public override string ToString()
{
return CheckOffHeading;
}
}
#endregion
#region CheckOffHeaderList
[TypeConverter(typeof(vlnIndexedListConverter<CheckOffHeaderList, CheckOffHeader>))]
public class CheckOffHeaderList : vlnIndexedFormatList<CheckOffHeader>
{
public CheckOffHeaderList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
public override vlnIndexedFormatList<CheckOffHeader> InheritedList
{
get
{
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
if (parentFormat != null)
return parentFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffHeaderList;
return null;
}
}
}
#endregion
#endregion
#region ChangeBarData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ChangeBarData : vlnFormatItem
{
public ChangeBarData(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<string> _DefaultCBLoc;
public string DefaultCBLoc
{
get
{
return LazyLoad(ref _DefaultCBLoc, "@DefaultCBLoc");
}
}
private LazyLoad<string> _ChangeBarMessage;
public string ChangeBarMessage
{
get
{
return LazyLoad(ref _ChangeBarMessage, "@ChangeBarMessage");
}
}
private LazyLoad<int?> _FixedChangeColumn;
public int? FixedChangeColumn
{
get
{
return LazyLoad(ref _FixedChangeColumn, "@FixedChangeColumn");
}
}
private LazyLoad<int?> _FixedAERChangeColumn;
public int? FixedAERChangeColumn
{
get
{
return LazyLoad(ref _FixedAERChangeColumn, "@FixedAERChangeColumn");
}
}
private LazyLoad<E_Style?> _ChangeSummaryStyle;
public E_Style? ChangeSummaryStyle
{
get
{
return LazyLoad<E_Style>(ref _ChangeSummaryStyle, "@ChangeSummaryStyle");
}
}
private LazyLoad<E_Style?> _ChangeBarStyle;
public E_Style? ChangeBarStyle
{
get
{
return LazyLoad<E_Style>(ref _ChangeBarStyle, "@ChangeBarStyle");
}
}
private LazyLoad<string> _SpecialChangeBar;
public string SpecialChangeBar
{
get
{
return LazyLoad(ref _SpecialChangeBar, "@SpecialChangeBar");
}
}
private LazyLoad<bool> _CondensedChangeBar;
public bool CondensedChangeBar
{
get
{
return LazyLoad(ref _CondensedChangeBar, "@CondensedChangeBar");
}
}
private LazyLoad<bool> _AbsoluteFixedChangeColumn;
public bool AbsoluteFixedChangeColumn
{
get
{
return LazyLoad(ref _AbsoluteFixedChangeColumn, "@AbsoluteFixedChangeColumn");
}
}
private LazyLoad<bool> _ContinuousChangeBars;
public bool ContinuousChangeBars
{
get
{
return LazyLoad(ref _ContinuousChangeBars, "@ContinuousChangeBars");
}
}
private LazyLoad<bool> _ChgBarMessageFromEdit;
public bool ChgBarMessageFromEdit
{
get
{
return LazyLoad(ref _ChgBarMessageFromEdit, "@ChgBarMessageFromEdit");
}
}
private LazyLoad<bool> _ChangeIds;
public bool ChangeIds
{
get
{
return LazyLoad(ref _ChangeIds, "@ChangeIds");
}
}
private LazyLoad<bool> _ChangeBarToRNOSep;
public bool ChangeBarToRNOSep
{
get
{
return LazyLoad(ref _ChangeBarToRNOSep, "@ChangeBarToRNOSep");
}
}
private LazyLoad<bool> _ChangeBarsOnLinkedText;
public bool ChangeBarsOnLinkedText
{
get
{
return LazyLoad(ref _ChangeBarsOnLinkedText, "@ChangeBarsOnLinkedText");
}
}
private LazyLoad<bool> _SeparateChangeBarsForDiffNotesCautions;
public bool SeparateChangeBarsForDiffNotesCautions
{
get
{
return LazyLoad(ref _SeparateChangeBarsForDiffNotesCautions, "@SeparateChangeBarsForDiffNotesCautions");
}
}
}
#endregion
#endregion
#region SectDataAll
#region SectData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class SectData : vlnFormatItem
{
public SectData(XmlNode xmlNode) : base(xmlNode) { }
private SectionNumber _SectionNumber;
public SectionNumber SectionNumber
{
get
{
if (_SectionNumber == null) _SectionNumber = new SectionNumber(SelectSingleNode("SectionNumber"));
return _SectionNumber;
}
}
private SectionHeader _SectionHeader;
public SectionHeader SectionHeader
{
get
{
if (_SectionHeader == null) _SectionHeader = new SectionHeader(SelectSingleNode("SectionHeader"));
return _SectionHeader;
}
}
private SectionHeaderSeparatorLine _SectionHeaderSeparatorLine;
public SectionHeaderSeparatorLine SectionHeaderSeparatorLine
{
get
{
if (_SectionHeaderSeparatorLine == null) _SectionHeaderSeparatorLine = new SectionHeaderSeparatorLine(SelectSingleNode("SectionHeaderSeparatorLine"));
return _SectionHeaderSeparatorLine;
}
}
private StepSectionData _StepSectionData;
public StepSectionData StepSectionData
{
get
{
if (_StepSectionData == null) _StepSectionData = new StepSectionData(SelectSingleNode("StepSectionData"));
return _StepSectionData;
}
}
private AccSectionData _AccSectionData;
public AccSectionData AccSectionData
{
get
{
if (_AccSectionData == null) _AccSectionData = new AccSectionData(SelectSingleNode("AccSectionData"));
return _AccSectionData;
}
}
private MetaSectionList _MetaSectionList;
public MetaSectionList MetaSectionList
{
get
{
if (_MetaSectionList == null) _MetaSectionList = new MetaSectionList(SelectNodes("MetaSectionData/MetaSection"),MyFormat);
return _MetaSectionList;
}
set { _MetaSectionList = value; }
}
private ReplaceStrList _ReplaceStrList;
public ReplaceStrList ReplaceStrList
{
get
{
return (_ReplaceStrList == null) ? _ReplaceStrList = new ReplaceStrList(SelectNodes("ReplaceStrData/ReplaceStr")) : _ReplaceStrList;
}
set { _ReplaceStrList = value; }
}
private ReplaceSymbolCharList _ReplaceSymbolCharList;
public ReplaceSymbolCharList ReplaceSymbolCharList
{
get
{
return (_ReplaceSymbolCharList == null) ? _ReplaceSymbolCharList = new ReplaceSymbolCharList(SelectNodes("ReplaceSymbolChars/ReplaceChar"),MyFormat) : _ReplaceSymbolCharList;
}
set { _ReplaceSymbolCharList = value; }
}
private LazyLoad<int?> _SectionTitleLength;
public int? SectionTitleLength
{
get
{
return LazyLoad(ref _SectionTitleLength, "@SectionTitleLength");
}
}
private LazyLoad<int?> _SectionNumberAndTitleLength;
public int? SectionNumberAndTitleLength
{
get
{
return LazyLoad(ref _SectionNumberAndTitleLength, "@SectionNumberAndTitleLength");
}
}
private LazyLoad<int?> _SectNumAndTlLenLand; // B2021-119: large titles on Landscape Word Attachments are printing on 2 lines.
public int? SectNumAndTlLenLand
{
get
{
return LazyLoad(ref _SectNumAndTlLenLand, "@SectNumAndTlLenLand");
}
}
private LazyLoad<string> _ForeColor;
public string ForeColor
{
get
{
return LazyLoad(ref _ForeColor, "@ForeColor");
}
}
private LazyLoad<string> _BackColor;
public string BackColor
{
get
{
return LazyLoad(ref _BackColor, "@BackColor");
}
}
private LazyLoad<bool> _MetaSectEndMessage;
public bool MetaSectEndMessage
{
get
{
return LazyLoad(ref _MetaSectEndMessage, "@MetaSectEndMessage");
}
}
private LazyLoad<bool> _ReadOnlyTypeInContMsg;
public bool ReadOnlyTypeInContMsg
{
get
{
return LazyLoad(ref _ReadOnlyTypeInContMsg, "@ReadOnlyTypeInContMsg");
}
}
private LazyLoad<bool> _ReplaceWordsInROs;
public bool ReplaceWordsInROs
{
get
{
return LazyLoad(ref _ReplaceWordsInROs, "@ReplaceWordsInROs");
}
}
// C2021-061: For Barakah don't do replace if word is surrounded by " or '
// Initial fix was 11/3/21. Added parens do the quotes on 11/16/21
private LazyLoad<bool> _NoReplaceQuoteParenWords;
public bool NoReplaceQuoteParenWords
{
get
{
return LazyLoad(ref _NoReplaceQuoteParenWords, "@NoReplaceQuoteParenWords");
}
}
private LazyLoad<bool> _UseMetaSections;
public bool UseMetaSections
{
get
{
return LazyLoad(ref _UseMetaSections, "@UseMetaSections");
}
}
private LazyLoad<bool> _CountSubSectionsForLevel;
public bool CountSubSectionsForLevel
{
get
{
return LazyLoad(ref _CountSubSectionsForLevel, "@CountSubSectionsForLevel");
}
}
private LazyLoad<bool> _PrintPhoneList;
public bool PrintPhoneList
{
get
{
return LazyLoad(ref _PrintPhoneList, "@PrintPhoneList");
}
}
private LazyLoad<bool> _DefaultNoSubAutoIndent;
public bool DefaultNoSubAutoIndent
{
get
{
return LazyLoad(ref _DefaultNoSubAutoIndent, "@DefaultNoSubAutoIndent");
}
}
private LazyLoad<bool> _NonEditableSteps;
public bool NonEditableSteps
{
get
{
return LazyLoad(ref _NonEditableSteps, "@NonEditableSteps");
}
}
private LazyLoad<bool> _SearchAllReplaceWords;
public bool SearchAllReplaceWords
{
get
{
return LazyLoad(ref _SearchAllReplaceWords, "@SearchAllReplaceWords");
}
}
private LazyLoad<bool> _SecTitleContinue;
public bool SecTitleContinue
{
get
{
return LazyLoad(ref _SecTitleContinue, "@SecTitleContinue");
}
}
private LazyLoad<bool> _ConvertCaretToDelta;
public bool ConvertCaretToDelta
{
get
{
return LazyLoad(ref _ConvertCaretToDelta, "@ConvertCaretToDelta");
}
}
//B2019-037 throw back from DOS VE-PROMS, convert "~" to subscript and "#" to superscript in RO return values
private LazyLoad<bool> _UseTildaPoundCharsForSuperSubScriptInROValues;
public bool UseTildaPoundCharsForSuperSubScriptInROValues
{
get
{
return LazyLoad(ref _UseTildaPoundCharsForSuperSubScriptInROValues, "@UseTildaPoundCharsForSuperSubScriptInROValues");
}
}
// C2022-021 will convert ">=" to the greater than or equal symbol, "<=" to the less than or equal symbol and plus/minus for RO return values
private LazyLoad<bool> _ConvertGTELTEPMinROValue;
public bool ConvertGTELTEPMinROValue
{
get
{
return LazyLoad(ref _ConvertGTELTEPMinROValue, "@ConvertGTELTEPMinROValue");
}
}
// C2019-043 will convert "->" to the right arrow symbol and "<-" to the left arrow symbol for RO return values
private LazyLoad<bool> _UseDashGreaterLessThenForArrowsInROValue;
public bool UseDashGreaterLessThenForArrowsInROValue
{
get
{
return LazyLoad(ref _UseDashGreaterLessThenForArrowsInROValue, "@UseDashGreaterLessThenForArrowsInROValue");
}
}
private LazyLoad<bool> _ConvertUnderscoreToUnderline;
public bool ConvertUnderscoreToUnderline
{
get
{
//B2017-256 - Value was not using _ConvertUnderscoreToUnderline
return LazyLoad(ref _ConvertUnderscoreToUnderline, "@ConvertUnderscoreToUnderline");
}
}
// This format flag turns off the Replace Words functionality.
// in 16-bit proms, this was done simply by having an empty Replace Words list.
// in 32-bit the inheiradence logic finds a replace words list in the base format
// if the plant format does not have one. Thus the need of this format flag.
private LazyLoad<bool> _TurnOffReplaceWords;
public bool TurnOffReplaceWords
{
get
{
return LazyLoad(ref _TurnOffReplaceWords, "@TurnOffReplaceWords");
}
}
// B2022-002: Section text is printing into the INITIAL column (BNPP1new)
private LazyLoad<bool> _AdjWidthForCheckOff;
public bool AdjWidthForCheckOff
{
get
{
return LazyLoad(ref _AdjWidthForCheckOff, "@AdjWidthForCheckOff");
}
}
}
#endregion
#region SectionNumber
[TypeConverter(typeof(ExpandableObjectConverter))]
public class SectionNumber : vlnFormatItem
{
public SectionNumber(XmlNode xmlNode) : base(xmlNode) { }
public SectionNumber() : base() { }
private LazyLoad<float?> _Pos;
public float? Pos
{
get
{
return LazyLoad(ref _Pos, "@Pos");
}
}
private LazyLoad<string> _Just;
public string Just
{
get
{
return LazyLoad(ref _Just, "@Just");
}
}
private LazyLoad<bool> _Level0Big;
public bool Level0Big
{
get
{
return LazyLoad(ref _Level0Big, "@Level0Big");
}
}
private VE_Font _Font;
public VE_Font Font
{
get
{
return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
}
}
}
#endregion
#region SectionHeader
[TypeConverter(typeof(ExpandableObjectConverter))]
public class SectionHeader : vlnFormatItem
{
public SectionHeader(XmlNode xmlNode) : base(xmlNode) { }
public SectionHeader() : base() { }
private LazyLoad<float?> _Pos;
public float? Pos
{
get
{
return LazyLoad(ref _Pos, "@Pos");
}
}
private LazyLoad<string> _Just;
public string Just
{
get
{
return LazyLoad(ref _Just, "@Just");
}
}
private LazyLoad<bool> _Level0Big;
public bool Level0Big
{
get
{
return LazyLoad(ref _Level0Big, "@Level0Big");
}
}
private LazyLoad<bool> _OnlyUnderlineTopSect;
public bool OnlyUnderlineTopSect
{
get
{
return LazyLoad(ref _OnlyUnderlineTopSect, "@OnlyUnderlineTopSect");
}
}
private LazyLoad<bool> _OnlyBoldTopSect;
public bool OnlyBoldTopSect
{
get
{
return LazyLoad(ref _OnlyBoldTopSect, "@OnlyBoldTopSect");
}
}
// If the section number is null or all blanks, then use the SectionNumber.Pos to position the section title
private LazyLoad<bool> _UseNumPosWhenNumBlank;
public bool UseNumPosWhenNumBlank
{
get
{
return LazyLoad(ref _UseNumPosWhenNumBlank, "@UseNumPosWhenNumBlank");
}
}
private VE_Font _Font;
public VE_Font Font
{
get
{
return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
}
}
}
#endregion
#region SectionHeaderSeparatorLine
[TypeConverter(typeof(ExpandableObjectConverter))]
public class SectionHeaderSeparatorLine : vlnFormatItem
{
public SectionHeaderSeparatorLine(XmlNode xmlNode) : base(xmlNode) { }
public SectionHeaderSeparatorLine() : base() { }
private LazyLoad<float?> _XStartPos;
public float? XStartPos
{
get
{
return LazyLoad(ref _XStartPos, "@XStartPos");
}
}
private LazyLoad<float?> _Length;
public float? Length
{
get
{
return LazyLoad(ref _Length, "@Length");
}
}
}
#endregion
#region StepSectionDataAll
#region StepSectionData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class StepSectionData : vlnFormatItem
{
public StepSectionData(XmlNode xmlNode) : base(xmlNode) { }
private TextTypeValueList _TextTypeValueList;
public TextTypeValueList TextTypeValueList
{
get
{
return (_TextTypeValueList == null)? _TextTypeValueList = new TextTypeValueList(SelectNodes("TextTypeValue/short")): _TextTypeValueList;
}
set { _TextTypeValueList = value; }
}
private TextTypeList _TextTypeList;
public TextTypeList TextTypeList
{
get
{
return (_TextTypeList == null)? _TextTypeList = new TextTypeList(SelectNodes("TextType/string")): _TextTypeList;
}
set { _TextTypeList = value; }
}
//private SeqTabList _SeqTabList;
//public SeqTabList SeqTabList
//{
// get
// {
// return (_SeqTabList == null)? _SeqTabList = new SeqTabList(SelectNodes("SeqTab/string")): _SeqTabList;
// }
// set { _SeqTabList = value; }
//}
//private PreSeqTabEditList _PreSeqTabEditList;
//public PreSeqTabEditList PreSeqTabEditList
//{
// get
// {
// return (_PreSeqTabEditList == null) ?_PreSeqTabEditList = new PreSeqTabEditList(SelectNodes("PreSeqTabEdit/string")): _PreSeqTabEditList;
// }
// set { _PreSeqTabEditList = value; }
//}
//private PreSeqTabPrintList _PreSeqTabPrintList;
//public PreSeqTabPrintList PreSeqTabPrintList
//{
// get
// {
// return (_PreSeqTabPrintList == null)? _PreSeqTabPrintList = new PreSeqTabPrintList(SelectNodes("PreSeqTabPrint/string")):_PreSeqTabPrintList;
// }
// set { _PreSeqTabPrintList = value; }
//}
//private PostSeqTabEditList _PostSeqTabEditList;
//public PostSeqTabEditList PostSeqTabEditList
//{
// get
// {
// return (_PostSeqTabEditList == null)? _PostSeqTabEditList = new PostSeqTabEditList(SelectNodes("PostSeqTabEdit/string")): _PostSeqTabEditList;
// }
// set { _PostSeqTabEditList = value; }
//}
//private PostSeqTabPrintList _PostSeqTabPrintList;
//public PostSeqTabPrintList PostSeqTabPrintList
//{
// get
// {
// return (_PostSeqTabPrintList == null)? _PostSeqTabPrintList = new PostSeqTabPrintList(SelectNodes("PostSeqTabPrint/string")): _PostSeqTabPrintList;
// }
// set { _PostSeqTabPrintList = value; }
//}
private UnderlineTerminateList _UnderlineTerminateList;
public UnderlineTerminateList UnderlineTerminateList
{
get
{
return (_UnderlineTerminateList == null)? _UnderlineTerminateList = new UnderlineTerminateList(SelectNodes("UnderlineTerminate/string")):_UnderlineTerminateList;
}
set { _UnderlineTerminateList = value; }
}
private ObserveNCString1List _ObserveNCString1List;
public ObserveNCString1List ObserveNCString1List
{
get
{
return (_ObserveNCString1List == null)? _ObserveNCString1List = new ObserveNCString1List(SelectNodes("ObserveNCString1/string")): _ObserveNCString1List;
}
set { _ObserveNCString1List = value; }
}
private ObserveNCString2List _ObserveNCString2List;
public ObserveNCString2List ObserveNCString2List
{
get
{
return (_ObserveNCString2List == null)? _ObserveNCString2List = new ObserveNCString2List(SelectNodes("ObserveNCString2/string")):_ObserveNCString2List;
}
set { _ObserveNCString2List = value; }
}
private StepSectionLayoutData _StepSectionLayoutData;
public StepSectionLayoutData StepSectionLayoutData
{
get
{
return (_StepSectionLayoutData == null)? _StepSectionLayoutData = new StepSectionLayoutData(SelectSingleNode("StpSectLayData")):_StepSectionLayoutData;
}
}
private StepSectionEditData _StepSectionEditData;
public StepSectionEditData StepSectionEditData
{
get
{
return (_StepSectionEditData == null)? _StepSectionEditData = new StepSectionEditData(SelectSingleNode("StpSectEditData")): _StepSectionEditData;
}
}
private SeqTabFmtList _SeqTabFmtList;
public SeqTabFmtList SeqTabFmtList
{
get
{
return (_SeqTabFmtList == null) ? _SeqTabFmtList = new SeqTabFmtList(SelectNodes("SequentialTabFormat/SeqTabFmt"),MyFormat) : _SeqTabFmtList;
}
}
private StepSectionPrintData _StepSectionPrintData;
public StepSectionPrintData StepSectionPrintData
{
get
{
return (_StepSectionPrintData == null) ? _StepSectionPrintData = new StepSectionPrintData(SelectSingleNode("StpSectPrtData")) : _StepSectionPrintData;
}
}
private LazyLoad<int?> _TopRow;
public int? TopRow
{
get
{
return LazyLoad(ref _TopRow, "@TopRow");
}
}
//private LazyLoad<string> _SeqStart;
//public string SeqStart
//{
// get
// {
// return LazyLoad(ref _SeqStart, "@SeqStart");
// }
//}
//private LazyLoad<string> _LeftJustSeqTab;
//public string LeftJustSeqTab
//{
// get
// {
// return LazyLoad(ref _LeftJustSeqTab, "@LeftJustSeqTab") ;
// }
//}
//private LazyLoad<int?> _HighSeqStart;
//public int? HighSeqStart
//{
// get
// {
// return LazyLoad(ref _HighSeqStart, "@HighSeqStart");
// }
//}
private LazyLoad<string> _IndentToken;
public string IndentToken
{
get
{
return LazyLoad(ref _IndentToken, "@IndentToken");
}
}
private LazyLoad<int?> _NumberOfHighLevelSteps;
public int? NumberOfHighLevelSteps
{
get
{
return LazyLoad(ref _NumberOfHighLevelSteps, "@NumberOfHighLevelSteps");
}
}
private LazyLoad<int?> _NumberOfSubStypeTypes;
public int? NumberOfSubStypeTypes
{
get
{
return LazyLoad(ref _NumberOfSubStypeTypes, "@NumberOfSubStepTypes");
}
}
private LazyLoad<string> _IdentB;
public string IdentB
{
get
{
return LazyLoad(ref _IdentB, "@IdentB");
}
}
private LazyLoad<bool> _WolfCreekBackgroundFormat;
public bool WolfCreekBackgroundFormat
{
get
{
return LazyLoad(ref _WolfCreekBackgroundFormat, "@WolfCreekBackgroundFormat");
}
}
private LazyLoad<bool> _WolfcreekCKLFormat;
public bool WolfcreekCKLFormat
{
get
{
return LazyLoad(ref _WolfcreekCKLFormat, "@WolfcreekCKLFormat");
}
}
private LazyLoad<bool> _WolfcreekCKLBackgndFormat;
public bool WolfcreekCKLBackgndFormat
{
get
{
return LazyLoad(ref _WolfcreekCKLBackgndFormat, "@WolfcreekCKLBackgndFormat");
}
}
private LazyLoad<bool> _Vogtle3and4BackgroundFormat;
public bool Vogtle3and4BackgroundFormat
{
get
{
return LazyLoad(ref _Vogtle3and4BackgroundFormat, "@Vogtle3and4BackgroundFormat");
}
}
private LazyLoad<bool> _FortranFormatNumbers;
public bool FortranFormatNumbers
{
get
{
return LazyLoad(ref _FortranFormatNumbers, "@FortranFormatNumbers");
}
}
private LazyLoad<bool> _UseTopContinueMessageAtEnd;
public bool UseTopContinueMessageAtEnd
{
get
{
return LazyLoad(ref _UseTopContinueMessageAtEnd, "@UseTopContinueMessageAtEnd");
}
}
private LazyLoad<bool> _FloatingContinueMessage;
public bool FloatingContinueMessage
{
get
{
return LazyLoad(ref _FloatingContinueMessage, "@FloatingContinueMessage");
}
}
private LazyLoad<bool> _WrapSameAsEdit;
public bool WrapSameAsEdit
{
get
{
return LazyLoad(ref _WrapSameAsEdit, "@WrapSameAsEdit");
}
}
private LazyLoad<bool> _ContinueSectionHeader;
public bool ContinueSectionHeader
{
get
{
return LazyLoad(ref _ContinueSectionHeader, "@ContinueSectionHeader");
}
}
private LazyLoad<bool> _CompressHPSub;
public bool CompressHPSub
{
get
{
return LazyLoad(ref _CompressHPSub, "@CompressHPSub");
}
}
private LazyLoad<bool> _CompressHPSuper;
public bool CompressHPSuper
{
get
{
return LazyLoad(ref _CompressHPSuper, "@CompressHPSuper");
}
}
private LazyLoad<bool> _CompressPropSubSup;
public bool CompressPropSubSup
{
get
{
return LazyLoad(ref _CompressPropSubSup, "@CompressPropSubSup");
}
}
private LazyLoad<bool> _UndSpecialStepsFoldout;
public bool UndSpecialStepsFoldout
{
get
{
return LazyLoad(ref _UndSpecialStepsFoldout, "@UndSpecialStepsFoldout");
}
}
private LazyLoad<bool> _UnderlineAllMetaTitles;
public bool UnderlineAllMetaTitles
{
get
{
return LazyLoad(ref _UnderlineAllMetaTitles, "@UnderlineAllMetaTitles");
}
}
private LazyLoad<bool> _BoldOnlySectionZero;
public bool BoldOnlySectionZero
{
get
{
return LazyLoad(ref _BoldOnlySectionZero, "@BoldOnlySectionZero");
}
}
// used in Ginna's Attachment format
// adjust the width of the Cautions and Note to not exend page the end of the HLS width
// ie, shorten the width if the Caution or Note is off of a sub-step
private LazyLoad<bool> _LimitCautionNoteWithToHLS;
public bool LimitCautionNoteWidthToHLS
{
get
{
return LazyLoad(ref _LimitCautionNoteWithToHLS, "@LimitCautionNoteWithToHLS");
}
}
// Used in Ginn's Attachment format
// only bullet multiple Caution/Note types if they are exactly the same type (ex. CAUTION vs CAUTION1)
private LazyLoad<bool> _OnlyBulletSameCautionNoteType;
public bool OnlyBulletSameCautionNoteType
{
get
{
return LazyLoad(ref _OnlyBulletSameCautionNoteType, "@OnlyBulletSameCautionNoteType");
}
}
private LazyLoad<bool> _ImperfectStructure;
public bool ImperfectStructure
{
get
{
return LazyLoad(ref _ImperfectStructure, "@ImperfectStructure");
}
}
private LazyLoad<bool> _ImperfectSubstep;
public bool ImperfectSubstep
{
get
{
return LazyLoad(ref _ImperfectSubstep, "@ImperfectSubstep");
}
}
private LazyLoad<bool> _ImperfectStructurePlus4;
public bool ImperfectStructurePlus4
{
get
{
return LazyLoad(ref _ImperfectStructurePlus4, "@ImperfectStructurePlus4");
}
}
private LazyLoad<bool> _SkipNonSeqTabWithPar;
public bool SkipNonSeqTabWithPar
{
get
{
return LazyLoad(ref _SkipNonSeqTabWithPar, "@SkipNonSeqTabWithPar");
}
}
private LazyLoad<bool> _CountAllSubLevels;
public bool CountAllSubLevels
{
get
{
return LazyLoad(ref _CountAllSubLevels, "@CountAllSubLevels");
}
}
private LazyLoad<bool> _UseMultiLineSectionTitle;
public bool UseMultiLineSectionTitle
{
get
{
return LazyLoad(ref _UseMultiLineSectionTitle, "@UseMultiLineSectionTitle");
}
}
private LazyLoad<bool> _AdjustRNOCautionNoteWidth;
public bool AdjustRNOCautionNoteWidth
{
get
{
return LazyLoad(ref _AdjustRNOCautionNoteWidth, "@AdjustRNOCautionNoteWidth");
}
}
private LazyLoad<bool> _DontResetIndentOnNewline;
public bool DontResetIndentOnNewline
{
get
{
return LazyLoad(ref _DontResetIndentOnNewline, "@DontResetIndentOnNewline");
}
}
// C2018-024 I in Arial font changed to I in TimesNewRoman
private LazyLoad<bool> _ChangeFontUpperCaseIinArial;
public bool ChangeFontUpperCaseIinArial
{
get
{
return LazyLoad(ref _ChangeFontUpperCaseIinArial, "@ChangeFontUpperCaseIinArial");
}
}
}
#endregion
#region TextTypeValue
[TypeConverter(typeof(ExpandableObjectConverter))]
public class TextTypeValue : vlnFormatItem
{
public TextTypeValue(XmlNode xmlNode) : base(xmlNode) { }
public TextTypeValue() : base() { }
private LazyLoad<int?> _TheValue;
public int? TheValue
{
get
{
return LazyLoad(ref _TheValue, "text()");
}
}
public override string GetPDDisplayName()
{ return "Value"; }
public override string GetPDDescription()
{ return string.Format("TextTypeValue '{0}'", TheValue); }
public override string GetPDCategory()
{ return "Text Type Value"; }
public override string ToString()
{
return TheValue.ToString();
}
}
#endregion
#region TextTypeValueList
[TypeConverter(typeof(vlnListConverter<TextTypeValueList, TextTypeValue>))]
public class TextTypeValueList : vlnFormatList<TextTypeValue>
{
public TextTypeValueList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region TextType
[TypeConverter(typeof(ExpandableObjectConverter))]
public class TextType : vlnFormatItem
{
public TextType(XmlNode xmlNode) : base(xmlNode) { }
public TextType() : base() { }
//[Category("Strings")]
private LazyLoad<string> _Text;
public string Text
{
get
{
return LazyLoad(ref _Text, "text()");
}
}
public override string GetPDDisplayName()
{ return "Text"; }
public override string GetPDDescription()
{ return string.Format("TextType '{0}'", Text); }
public override string GetPDCategory()
{ return "Text Type"; }
public override string ToString()
{
return Text;
}
}
#endregion
#region TextTypeList
[TypeConverter(typeof(vlnListConverter<TextTypeList, TextType>))]
public class TextTypeList : vlnFormatList<TextType>
{
public TextTypeList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region OLD - SeqTab
//[TypeConverter(typeof(ExpandableObjectConverter))]
//public class SeqTab : vlnFormatItem
//{
// public SeqTab(XmlNode xmlNode) : base(xmlNode) { }
// public SeqTab() : base() { }
// private LazyLoad<string> _Text;
// public string Text
// {
// get
// {
// return LazyLoad(ref _Text, "text()");
// }
// }
// public override string GetPDDisplayName()
// { return "Text"; }
// public override string GetPDDescription()
// { return string.Format("SeqTab '{0}'", Text); }
// public override string GetPDCategory()
// { return "Seq Tab"; }
// public override string ToString()
// {
// return Text;
// }
//}
#endregion
#region OLD - SeqTabList
//[TypeConverter(typeof(vlnListConverter<SeqTabList, SeqTab>))]
//public class SeqTabList : vlnFormatList<SeqTab>
//{
// public SeqTabList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
//}
#endregion
#region OLD - PreSeqTabEdit
//[TypeConverter(typeof(ExpandableObjectConverter))]
//public class PreSeqTabEdit : vlnFormatItem
//{
// public PreSeqTabEdit(XmlNode xmlNode) : base(xmlNode) { }
// public PreSeqTabEdit() : base() { }
// //[Category("Strings")]
// private LazyLoad<string> _Text;
// public string Text
// {
// get
// {
// return LazyLoad(ref _Text, "text()");
// }
// }
// public override string GetPDDisplayName()
// { return "Text"; }
// public override string GetPDDescription()
// { return string.Format("PreSeqTabEdit '{0}'", Text); }
// public override string GetPDCategory()
// { return "PreSeq Tab Edit"; }
// public override string ToString()
// {
// return Text;
// }
//}
#endregion
#region OLD - PreSeqTabEditList
//[TypeConverter(typeof(vlnListConverter<PreSeqTabEditList, PreSeqTabEdit>))]
//public class PreSeqTabEditList : vlnFormatList<PreSeqTabEdit>
//{
// public PreSeqTabEditList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
//}
#endregion
#region OLD - PreSeqTabPrint
//[TypeConverter(typeof(ExpandableObjectConverter))]
//public class PreSeqTabPrint : vlnFormatItem
//{
// public PreSeqTabPrint(XmlNode xmlNode) : base(xmlNode) { }
// public PreSeqTabPrint() : base() { }
// private LazyLoad<string> _Text;
// public string Text
// {
// get
// {
// return LazyLoad(ref _Text, "text()");
// }
// }
// public override string GetPDDisplayName()
// { return "Text"; }
// public override string GetPDDescription()
// { return string.Format("PreSeqTabPrint '{0}'", Text); }
// public override string GetPDCategory()
// { return "PreSeq Tab Printt"; }
// public override string ToString()
// {
// return Text;
// }
//}
#endregion
#region OLD - PreSeqTabPrintList
//[TypeConverter(typeof(vlnListConverter<PreSeqTabPrintList, PreSeqTabPrint>))]
//public class PreSeqTabPrintList : vlnFormatList<PreSeqTabPrint>
//{
// public PreSeqTabPrintList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
//}
#endregion
#region OLD - PostSeqTabEdit
//[TypeConverter(typeof(ExpandableObjectConverter))]
//public class PostSeqTabEdit : vlnFormatItem
//{
// public PostSeqTabEdit(XmlNode xmlNode) : base(xmlNode) { }
// public PostSeqTabEdit() : base() { }
// private LazyLoad<string> _Text;
// public string Text
// {
// get
// {
// return LazyLoad(ref _Text, "text()");
// }
// }
// public override string GetPDDisplayName()
// { return "Text"; }
// public override string GetPDDescription()
// { return string.Format("PostSeqTabEdit '{0}'", Text); }
// public override string GetPDCategory()
// { return "PostSeq Tab Edit"; }
// public override string ToString()
// {
// return Text;
// }
//}
#endregion
#region OLD - PostSeqTabEditList
//[TypeConverter(typeof(vlnListConverter<PostSeqTabEditList, PostSeqTabEdit>))]
//public class PostSeqTabEditList : vlnFormatList<PostSeqTabEdit>
//{
// public PostSeqTabEditList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
//}
#endregion
#region OLD - PostSeqTabPrint
//[TypeConverter(typeof(ExpandableObjectConverter))]
//public class PostSeqTabPrint : vlnFormatItem
//{
// public PostSeqTabPrint(XmlNode xmlNode) : base(xmlNode) { }
// public PostSeqTabPrint() : base() { }
// private LazyLoad<string> _Text;
// public string Text
// {
// get
// {
// return LazyLoad(ref _Text, "text()");
// }
// }
// public override string GetPDDisplayName()
// { return "Text"; }
// public override string GetPDDescription()
// { return string.Format("PostSeqTabPrint '{0}'", Text); }
// public override string GetPDCategory()
// { return "PostSeq Tab Printt"; }
// public override string ToString()
// {
// return Text;
// }
//}
#endregion
#region OLD - PostSeqTabPrintList
//[TypeConverter(typeof(vlnListConverter<PostSeqTabPrintList, PostSeqTabPrint>))]
//public class PostSeqTabPrintList : vlnFormatList<PostSeqTabPrint>
//{
// public PostSeqTabPrintList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
//}
#endregion
#region UnderlineTerminate
[TypeConverter(typeof(ExpandableObjectConverter))]
public class UnderlineTerminate : vlnFormatItem
{
public UnderlineTerminate(XmlNode xmlNode) : base(xmlNode) { }
public UnderlineTerminate() : base() { }
private LazyLoad<string> _Text;
public string Text
{
get
{
return LazyLoad(ref _Text, "text()");
}
}
public override string GetPDDisplayName()
{ return "Text"; }
public override string GetPDDescription()
{ return string.Format("UnderlineTerminate '{0}'", Text); }
public override string GetPDCategory()
{ return "Underline Terminate"; }
public override string ToString()
{
return Text;
}
}
#endregion
#region UnderlineTerminateList
[TypeConverter(typeof(vlnListConverter<UnderlineTerminateList, UnderlineTerminate>))]
public class UnderlineTerminateList : vlnFormatList<UnderlineTerminate>
{
public UnderlineTerminateList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region ObserveNCString1
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ObserveNCString1 : vlnFormatItem
{
public ObserveNCString1(XmlNode xmlNode) : base(xmlNode) { }
public ObserveNCString1() : base() { }
private LazyLoad<string> _Text;
public string Text
{
get
{
return LazyLoad(ref _Text, "text()");
}
}
public override string GetPDDisplayName()
{ return "Text"; }
public override string GetPDDescription()
{ return string.Format("ObserveNCString1 '{0}'", Text); }
public override string GetPDCategory()
{ return "ObserveNCString1"; }
public override string ToString()
{
return Text;
}
}
#endregion
#region ObserveNCString1List
[TypeConverter(typeof(vlnListConverter<ObserveNCString1List, ObserveNCString1>))]
public class ObserveNCString1List : vlnFormatList<ObserveNCString1>
{
public ObserveNCString1List(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region ObserveNCString2
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ObserveNCString2 : vlnFormatItem
{
public ObserveNCString2(XmlNode xmlNode) : base(xmlNode) { }
public ObserveNCString2() : base() { }
private LazyLoad<string> _Text;
public string Text
{
get
{
return LazyLoad(ref _Text, "text()");
}
}
public override string GetPDDisplayName()
{ return "Text"; }
public override string GetPDDescription()
{ return string.Format("ObserveNCString2 '{0}'", Text); }
public override string GetPDCategory()
{ return "ObserveNCString2"; }
public override string ToString()
{
return Text;
}
}
#endregion
#region ObserveNCString2List
[TypeConverter(typeof(vlnListConverter<ObserveNCString2List, ObserveNCString2>))]
public class ObserveNCString2List : vlnFormatList<ObserveNCString2>
{
public ObserveNCString2List(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region ReplaceStr
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ReplaceStr : vlnFormatItem
{
public ReplaceStr(XmlNode xmlNode) : base(xmlNode) { }
public ReplaceStr() : base() { }
[Category("Strings")]
private LazyLoad<string> _ReplaceWord;
public string ReplaceWord
{
get
{
return LazyLoad(ref _ReplaceWord, "@ReplaceWord");
}
}
[Category("Strings")]
private LazyLoad<string> _ReplaceWith;
public string ReplaceWith
{
get
{
return LazyLoad(ref _ReplaceWith, "@ReplaceWith");
}
}
private LazyLoad<E_ReplaceFlags?> _Flag;
public E_ReplaceFlags? Flag
{
get
{
return LazyLoad<E_ReplaceFlags>(ref _Flag, "@Flag");
}
}
public override string GetPDDisplayName()
{ return ReplaceWord; }
public override string GetPDDescription()
{ return string.Format("Replace '{0}' with '{1}'",ReplaceWord,ReplaceWith); }
public override string GetPDCategory()
{ return "Words to Replace"; }
public override string ToString()
{
return ReplaceWith;
}
}
#endregion
#region ReplaceStrList
[TypeConverter(typeof(vlnListConverter<ReplaceStrList, ReplaceStr>))]
public class ReplaceStrList : vlnFormatList<ReplaceStr>
{
public ReplaceStrList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region ReplaceChar
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ReplaceChar : vlnFormatItem, IVlnIndexedFormatItem
{
public ReplaceChar(XmlNode xmlNode) : base(xmlNode) { }
public ReplaceChar() : base() { }
private LazyLoad<int?> _Index;
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
[Category("Strings")]
private LazyLoad<string> _Unicode;
public string Unicode
{
get
{
return LazyLoad(ref _Unicode, "@Unicode");
}
}
[Category("Strings")]
private LazyLoad<string> _Replace;
public string Replace
{
get
{
return LazyLoad(ref _Replace, "@Replace");
}
}
[Category("Strings")]
private LazyLoad<string> _Family;
public string Family
{
get
{
return LazyLoad(ref _Family, "@Family");
}
}
[Category("FontStyle?")]
private LazyLoad<E_Style?> _Style; // format has E_Style value. The public will translate it to a systemdrawing.FontStyle used in printing
public FontStyle? Style
{
get
{
E_Style? eStyle = LazyLoad(ref _Style, "@Style");
if (eStyle == null) return null; // not set in the format, return null
FontStyle sdfStyle = FontStyle.Regular;
if (eStyle != E_Style.None)
{
if (((eStyle & E_Style.Bold) != 0) || ((eStyle & E_Style.MmBold) != 0))
sdfStyle |= FontStyle.Bold;
if ((eStyle & E_Style.Italics) != 0)
sdfStyle |= FontStyle.Italic;
if ((eStyle & E_Style.Underline) != 0)
sdfStyle |= FontStyle.Underline;
}
return sdfStyle; // return systemdrawing.FontStyle
//return LazyLoad(ref _Style, "@Style");
}
}
[Category("float?")]
private LazyLoad<float?> _Size;
public float? Size
{
get
{
return LazyLoad(ref _Size, "@Size");
}
}
public override string GetPDDisplayName()
{ return Unicode; }
public override string GetPDDescription()
{ return string.Format("Replace '{0}' with '{1}'", Unicode, Replace); }
public override string GetPDCategory()
{ return "Chars to Replace"; }
public override string ToString()
{
return Replace;
}
}
#endregion
#region ReplaceSymbolCharList
[TypeConverter(typeof(vlnIndexedListConverter<ReplaceSymbolCharList, ReplaceChar>))]
public class ReplaceSymbolCharList : vlnIndexedFormatList<ReplaceChar>
{
public ReplaceSymbolCharList(XmlNodeList xmlNodeList, IFormatOrFormatInfo myFormat) : base(xmlNodeList, myFormat) { }
public override vlnIndexedFormatList<ReplaceChar> InheritedList
{
get
{
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
if (parentFormat != null)
return parentFormat.PlantFormat.FormatData.SectData.ReplaceSymbolCharList;
return null;
}
}
}
#endregion
#region StepSectionLayoutData
public class StepSectionLayoutData : vlnFormatItem
{
public StepSectionLayoutData(XmlNode xmlNode) : base(xmlNode) { }
private TopOfPage _TopOfPage;
public TopOfPage TopOfPage
{
get
{
return (_TopOfPage == null)? _TopOfPage = new TopOfPage(SelectSingleNode("TopOfPage")): _TopOfPage;
}
}
private Separator _Separator;
public Separator Separator
{
get
{
return (_Separator == null) ?_Separator = new Separator(SelectSingleNode("Separator")):_Separator;
}
}
private LazyLoad<float?> _LastLineToStartStep;
public float? LastLineToStartStep
{
get
{
return LazyLoad(ref _LastLineToStartStep, "@LastLineToStartStep");
}
}
private LazyLoad<int?> _LineDrawingOption;
public int? LineDrawingOption
{
get
{
return LazyLoad(ref _LineDrawingOption, "@LineDrawingOption");
}
}
private LazyLoad<float?> _TabPtsPerChar;
public float? TabPtsPerChar
{
get
{
return LazyLoad(ref _TabPtsPerChar, "@TabPtsPerChar");
}
}
private LazyLoad<string> _CautionNoteOrder;
public string CautionNoteOrder
{
get
{
return LazyLoad(ref _CautionNoteOrder, "@CautionNoteOrder");
}
}
private LazyLoad<float?> _ColS;
public float? ColS
{
get
{
return LazyLoad(ref _ColS, "@ColS");
}
}
private LazyLoad<float?> _ColT;
public float? ColT
{
get
{
return LazyLoad(ref _ColT, "@ColT");
}
}
private LazyLoad<float?> _ColAbs;
public float? ColAbs
{
get
{
return LazyLoad(ref _ColAbs, "@ColAbs");
}
}
private LazyLoad<float?> _WidT;
public float? WidT
{
get
{
return LazyLoad(ref _WidT, "@WidT");
}
}
private LazyLoad<int?> _PMode;
public int? PMode
{
get
{
return LazyLoad(ref _PMode, "@PMode");
}
}
private LazyLoad<int?> _ColumnMode;
public int? ColumnMode
{
get
{
return LazyLoad(ref _ColumnMode, "@ColumnMode");
}
}
private LazyLoad<int?> _MaxRNO;
public int? MaxRNO
{
get
{
return LazyLoad(ref _MaxRNO, "@MaxRNO");
}
}
private LazyLoad<string> _MaxRNOTable;
public string MaxRNOTable
{
get
{
return LazyLoad(ref _MaxRNOTable, "@MaxRNOTable");
}
}
private LazyLoad<bool> _RNOWidthSameAsHighParent;
public bool RNOWidthSameAsHighParent
{
get
{
return LazyLoad(ref _RNOWidthSameAsHighParent, "@RNOWidthSameAsHighParent");
}
}
private LazyLoad<float?> _SingleColumnRNOIndent;
public float? SingleColumnRNOIndent
{
get
{
return LazyLoad(ref _SingleColumnRNOIndent, "@SingleColumnRNOIndent");
}
}
private LazyLoad<int?> _OverrideTableTopIndent;
public int? OverrideTableTopIndent
{
get
{
return LazyLoad(ref _OverrideTableTopIndent, "@OverrideTableTopIndent");
}
}
private LazyLoad<string> _ColRTable;
public string ColRTable
{
get
{
return LazyLoad(ref _ColRTable, "@ColRTable");
}
}
private LazyLoad<string> _WidSTableEdit;
public string WidSTableEdit
{
get
{
return LazyLoad(ref _WidSTableEdit, "@WidSTableEdit");
}
}
private LazyLoad<string> _WidSTablePrint;
public string WidSTablePrint
{
get
{
return LazyLoad(ref _WidSTablePrint, "@WidSTablePrint");
}
}
private LazyLoad<float?> _AdjRNOCol;
public float? AdjRNOCol
{
get
{
return LazyLoad(ref _AdjRNOCol, "@AdjRNOCol");
}
}
private LazyLoad<int?> _EndMessagePos;
public int? EndMessagePos
{
get
{
return LazyLoad(ref _EndMessagePos, "@EndMessagePos");
}
}
private LazyLoad<string> _RNOWidthAlt;
public string RNOWidthAlt
{
get
{
return LazyLoad(ref _RNOWidthAlt, "@RNOWidthAlt");
}
}
private LazyLoad<int?> _RNOWidthAltAll;
public int? RNOWidthAltAll
{
get
{
return LazyLoad(ref _RNOWidthAltAll, "@RNOWidthAltAll");
}
}
private LazyLoad<string> _RNOWidthAdj;
public string RNOWidthAdj
{
get
{
return LazyLoad(ref _RNOWidthAdj, "@RNOWidthAdj");
}
}
private LazyLoad<string> _UseRNOParentIdent;
public string UseRNOParentIdent
{
get
{
return LazyLoad(ref _UseRNOParentIdent, "@UseRNOParentIdent");
}
}
private LazyLoad<string> _DevNoteOrCautionTabOffset;
public string DevNoteOrCautionTabOffset
{
get
{
return LazyLoad(ref _DevNoteOrCautionTabOffset, "@DevNoteOrCautionTabOffset");
}
}
private LazyLoad<string> _BoxLeftAdj;
public string BoxLeftAdj
{
get
{
return LazyLoad(ref _BoxLeftAdj, "@BoxLeftAdj");
}
}
private LazyLoad<int?> _HLSWidthOVRD;
public int? HLSWidthOVRD
{
get
{
return LazyLoad(ref _HLSWidthOVRD, "@HLSWidthOVRD");
}
}
private LazyLoad<int?> _SubPaginationWght;
public int? SubPaginationWght
{
get
{
return LazyLoad(ref _SubPaginationWght, "@SubPaginationWght");
}
}
private LazyLoad<int?> _TextTitleAdjustment;
public int? TextTitleAdjustment
{
get
{
return LazyLoad(ref _TextTitleAdjustment, "@TextTitleAdjustment");
}
}
private VE_Font _VertStyle;
public VE_Font VertStyle
{
get
{
return (_VertStyle == null)? _VertStyle = new VE_Font(base.XmlNode): _VertStyle;
}
}
private LazyLoad<string> _TableCenterPos;
public string TableCenterPos
{
get
{
return LazyLoad(ref _TableCenterPos, "@TableCenterPos");
}
}
private LazyLoad<string> _LowerLimitDivisor;
public string LowerLimitDivisor
{
get
{
return LazyLoad(ref _LowerLimitDivisor, "@LowerLimitDivisor");
}
}
private LazyLoad<string> _NonLinkedStepNumber;
public string NonLinkedStepNumber
{
get
{
return LazyLoad(ref _NonLinkedStepNumber, "@NonLinkedStepNumber");
}
}
private LazyLoad<string> _NonLinkedCautNoteNumber;
public string NonLinkedCautNoteNumber
{
get
{
return LazyLoad(ref _NonLinkedCautNoteNumber, "@NonLinkedCautNoteNumber");
}
}
private LazyLoad<string> _NonLinkedRNONumber;
public string NonLinkedRNONumber
{
get
{
return LazyLoad(ref _NonLinkedRNONumber, "@NonLinkedRNONumber");
}
}
private LazyLoad<bool> _Dev_Format;
public bool Dev_Format
{
get
{
return LazyLoad(ref _Dev_Format, "@Dev_Format");
}
}
private LazyLoad<bool> _EnhancedShortFormDev;
public bool EnhancedShortFormDev
{
get
{
return LazyLoad(ref _EnhancedShortFormDev, "@EnhancedShortFormDev");
}
}
private LazyLoad<bool> _SpecialPageBreakFlag;
public bool SpecialPageBreakFlag
{
get
{
return LazyLoad(ref _SpecialPageBreakFlag, "@SpecialPageBreakFlag");
}
}
private LazyLoad<bool> _PaginateOnStepThatWillFitOnBlankPage;
public bool PaginateOnStepThatWillFitOnBlankPage
{
get
{
return LazyLoad(ref _PaginateOnStepThatWillFitOnBlankPage, "@PaginateOnStepThatWillFitOnBlankPage");
}
}
private LazyLoad<bool> _PaginateOnFirstSubstep;
public bool PaginateOnFirstSubstep
{
get
{
return LazyLoad(ref _PaginateOnFirstSubstep, "@PaginateOnFirstSubstep");
}
}
private LazyLoad<bool> _PaginateOnFirstSubstep2X;
public bool PaginateOnFirstSubstep2X
{
get
{
return LazyLoad(ref _PaginateOnFirstSubstep2X, "@PaginateOnFirstSubstep2X");
}
}
private LazyLoad<bool> _PageBreakParentWithTable; // B2020-101: Add format flag for table pagination
public bool PageBreakParentWithTable
{
get
{
return LazyLoad(ref _PageBreakParentWithTable, "@PageBreakParentWithTable");
}
}
private LazyLoad<bool> _UseHalfLines;
public bool UseHalfLines
{
get
{
return LazyLoad(ref _UseHalfLines, "@UseHalfLines");
}
}
//private LazyLoad<bool> _TryToFillHalfOfPage; C2019-030 Removed Unused Code
//public bool TryToFillHalfOfPage
//{
// get
// {
// return LazyLoad(ref _TryToFillHalfOfPage, "@TryToFillHalfOfPage");
// }
//}
private LazyLoad<bool> _CompressSteps;
public bool CompressSteps
{
get
{
if (PlantFormat.IgnoreUCF) return LazyLoad(ref _CompressSteps, "@CompressSteps");
bool? localvalue = null;
FormatConfig fc = PlantFormat.GetFormatConfig(MyFormat);
if (fc != null) localvalue = fc.PlantFormat.FormatData.Flags.CompressSteps;
return localvalue ?? LazyLoad(ref _CompressSteps, "@CompressSteps");
}
}
private LazyLoad<bool> _DoSTExtraAtTop;
public bool DoSTExtraAtTop
{
get
{
return LazyLoad(ref _DoSTExtraAtTop, "@DoSTExtraAtTop");
}
}
private LazyLoad<bool> _KeepStepsOnPage;
public bool KeepStepsOnPage
{
get
{
return LazyLoad(ref _KeepStepsOnPage, "@KeepStepsOnPage");
}
}
private LazyLoad<bool> _NoOrphans1;
/// <summary>
/// B2017-154 Np Orphans (single sub-step left over from previous page) No Children
/// </summary>
public bool NoOrphans1
{
get
{
return LazyLoad(ref _NoOrphans1, "@NoOrphans1");
}
}
private LazyLoad<bool> _BreakOnSections;
public bool BreakOnSections
{
get
{
return LazyLoad(ref _BreakOnSections, "@BreakOnSections");
}
}
private LazyLoad<bool> _ShowSectionTitles;
public bool ShowSectionTitles
{
get
{
return LazyLoad(ref _ShowSectionTitles, "@ShowSectionTitles");
}
}
private LazyLoad<bool> _EndForSingle;
public bool EndForSingle
{
get
{
return LazyLoad(ref _EndForSingle, "@EndForSingle");
}
}
private LazyLoad<bool> _PaginateOnFirstSubstep3X;
public bool PaginateOnFirstSubstep3X
{
get
{
return LazyLoad(ref _PaginateOnFirstSubstep3X, "@PaginateOnFirstSubstep3X");
}
}
private LazyLoad<bool> _PaginateOnLowerStepLevel;
public bool PaginateOnLowerStepLevel
{
get
{
return LazyLoad(ref _PaginateOnLowerStepLevel, "@PaginateOnLowerStepLevel");
}
}
// B2023-088: alarm format pagination
private LazyLoad<bool> _AlarmPagination;
public bool AlarmPagination
{
get
{
return LazyLoad(ref _AlarmPagination, "@AlarmPagination");
}
}
private LazyLoad<bool> _CustomSpacing;
public bool CustomSpacing
{
get
{
return LazyLoad(ref _CustomSpacing, "@CustomSpacing");
}
}
private LazyLoad<bool> _SplitStepInPrntStep;
public bool SplitStepInPrntStep
{
get
{
return LazyLoad(ref _SplitStepInPrntStep, "@SplitStepInPrntStep");
}
}
private LazyLoad<bool> _LineAboveUnderSection;
public bool LineAboveUnderSection
{
get
{
return LazyLoad(ref _LineAboveUnderSection, "@LineAboveUnderSection");
}
}
private LazyLoad<bool> _PicaIgnoreFiveSixths;
public bool PicaIgnoreFiveSixths
{
get
{
return LazyLoad(ref _PicaIgnoreFiveSixths, "@PicaIgnoreFiveSixths");
}
}
private LazyLoad<bool> _SpaceForNoSecNumb;
public bool SpaceForNoSecNumb
{
get
{
return LazyLoad(ref _SpaceForNoSecNumb, "@SpaceForNoSecNumb");
}
}
private LazyLoad<bool> _PageBreakOnFirstBlankLine;
public bool PageBreakOnFirstBlankLine
{
get
{
return LazyLoad(ref _PageBreakOnFirstBlankLine, "@PageBreakOnFirstBlankLine");
}
}
private LazyLoad<bool> _PutOnPageByItself;
public bool PutOnPageByItself
{
get
{
return LazyLoad(ref _PutOnPageByItself, "@PutOnPageByItself");
}
}
private LazyLoad<bool> _PaginateAtHighestPaginLevel;
public bool PaginateAtHighestPaginLevel
{
get
{
return LazyLoad(ref _PaginateAtHighestPaginLevel, "@PaginateAtHighestPaginLevel");
}
}
private LazyLoad<bool> _UseSTExtraRealValue;
public bool UseSTExtraRealValue
{
get
{
return LazyLoad(ref _UseSTExtraRealValue, "@UseSTExtraRealValue");
}
}
private LazyLoad<bool> _DoSectionSeparatorLine;
public bool DoSectionSeparatorLine
{
get
{
return LazyLoad(ref _DoSectionSeparatorLine, "@DoSectionSeparatorLine");
}
}
private LazyLoad<bool> _TieTabToLevel;
public bool TieTabToLevel
{
get
{
return LazyLoad(ref _TieTabToLevel, "@TieTabToLevel");
}
}
private LazyLoad<bool> _SubSectAndHighSameLevel;
public bool SubSectAndHighSameLevel
{
get
{
return LazyLoad(ref _SubSectAndHighSameLevel, "@SubSectAndHighSameLevel");
}
}
private LazyLoad<bool> _HighLevelRNOBeforeAERSubsteps;
public bool HighLevelRNOBeforeAERSubsteps
{
get
{
return LazyLoad(ref _HighLevelRNOBeforeAERSubsteps, "@HighLevelRNOBeforeAERSubsteps");
}
}
private LazyLoad<bool> _UseStepTypeWidthOverride;
public bool UseStepTypeWidthOverride
{
get
{
return LazyLoad(ref _UseStepTypeWidthOverride, "@UseStepTypeWidthOverride");
}
}
private LazyLoad<bool> _UseStepTypeWidthOverrideEditPrint;
public bool UseStepTypeWidthOverrideEditPrint
{
get
{
return LazyLoad(ref _UseStepTypeWidthOverrideEditPrint, "@UseStepTypeWidthOverrideEditPrint");
}
}
private LazyLoad<bool> _PartialStepCompression;
public bool PartialStepCompression
{
get
{
if (PlantFormat.IgnoreUCF) return LazyLoad(ref _PartialStepCompression, "@PartialStepCompression");
bool? localvalue = null;
FormatConfig fc = PlantFormat.GetFormatConfig(MyFormat);
if (fc != null) localvalue = fc.PlantFormat.FormatData.Flags.PartialStepCompression;
return localvalue ?? LazyLoad(ref _PartialStepCompression, "@PartialStepCompression");
}
}
private LazyLoad<bool> _VirtualDotInHLSTab;
public bool VirtualDotInHLSTab
{
get
{
return LazyLoad(ref _VirtualDotInHLSTab, "@VirtualDotInHLSTab");
}
}
private LazyLoad<bool> _OverrideEnhancedTabs;
public bool OverrideEnhancedTabs
{
get
{
return LazyLoad(ref _OverrideEnhancedTabs, "@OverrideEnhancedTabs");
}
}
private LazyLoad<bool> _RNO;
public bool RNO
{
get
{
return LazyLoad(ref _RNO, "@RNO");
}
}
private LazyLoad<bool> _OnlySingleColumn;
public bool OnlySingleColumn
{
get
{
return LazyLoad(ref _OnlySingleColumn, "@OnlySingleColumn");
}
}
private LazyLoad<bool> _NullBox;
public bool NullBox
{
get
{
return LazyLoad(ref _NullBox, "@NullBox");
}
}
private LazyLoad<bool> _AllowNoteCautionAdd;
public bool AllowNoteCautionAdd
{
get
{
return LazyLoad(ref _AllowNoteCautionAdd, "@AllowNoteCautionAdd");
}
}
}
#endregion
#region TopOfPage
public class TopOfPage : vlnFormatItem
{
public TopOfPage(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<float?> _Row;
public float? Row
{
get
{
return LazyLoad(ref _Row, "@Row");
}
}
private LazyLoad<float?> _Col;
public float? Col
{
get
{
return LazyLoad(ref _Col, "@Col");
}
}
private VE_Font _Font;
public VE_Font Font
{
get
{
return (_Font == null? _Font = new VE_Font(base.XmlNode): _Font);
}
}
}
#endregion
#region Separator
public class Separator : vlnFormatItem
{
public Separator(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<int?> _Location;
public int? Location
{
get
{
return LazyLoad(ref _Location, "@Location");
//return LazyLoad(ref _SeparatorLocation, "@SeparatorLocation");
}
}
private VE_Font _Font;
public VE_Font Font
{
get
{
return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
}
}
}
#endregion
#region StepSectionEditData
public class StepSectionEditData : vlnFormatItem
{
public StepSectionEditData(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<float?> _ColSScreenAdj;
public float? ColSScreenAdj
{
get
{
return LazyLoad(ref _ColSScreenAdj, "@ColSScreenAdj");
}
}
private LazyLoad<float?> _ScrnAdjRNOText;
public float? ScrnAdjRNOText
{
get
{
return LazyLoad(ref _ScrnAdjRNOText, "@ScrnAdjRNOText");
}
}
private LazyLoad<string> _ColRScreen;
public string ColRScreen
{
get
{
return LazyLoad(ref _ColRScreen, "@ColRScreen");
}
}
}
#endregion
#region StepSectionPrintData
public class StepSectionPrintData : vlnFormatItem
{
public StepSectionPrintData(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<float?> _ImmStepHdrCol;
public float? ImmStepHdrCol
{
get
{
return LazyLoad(ref _ImmStepHdrCol, "@ImmStepHdrCol");
}
}
private LazyLoad<bool> _DiffContActBox;
public bool DiffContActBox
{
get
{
return LazyLoad(ref _DiffContActBox, "@DiffContActBox");
}
}
private LazyLoad<bool> _ContActBoxOnSubSteps;
public bool ContActBoxOnSubSteps
{
get
{
return LazyLoad(ref _ContActBoxOnSubSteps, "@ContActBoxOnSubSteps");
}
}
private LazyLoad<int?> _SecColHdrforActPMode;
public int? SecColHdrforActPMode
{
get
{
return LazyLoad(ref _SecColHdrforActPMode, "@SecColHdrforActPMode");
}
}
private LazyLoad<string> _RNOSepString;
public string RNOSepString
{
get
{
return LazyLoad(ref _RNOSepString, "@RNOSepString");
}
}
private LazyLoad<float?> _RNOSepLineLength;
public float? RNOSepLineLength
{
get
{
return LazyLoad(ref _RNOSepLineLength, "@RNOSepLineLength");
}
}
private LazyLoad<string> _HLStpSeparatorString;
public string HLStpSeparatorString
{
get
{
return LazyLoad(ref _HLStpSeparatorString, "@HLStpSeparatorString");
}
}
private LazyLoad<string> _HLRNOStpSeparatorString;
public string HLRNOStpSeparatorString
{
get
{
return LazyLoad(ref _HLRNOStpSeparatorString, "@HLRNOStpSeparatorString");
}
}
private LazyLoad<bool> _LowerCaseRevNum;
public bool LowerCaseRevNum
{
get
{
return LazyLoad(ref _LowerCaseRevNum, "@LowerCaseRevNum");
}
}
private LazyLoad<bool> _UseXtraRevNumber;
public bool UseXtraRevNumber
{
get
{
return LazyLoad(ref _UseXtraRevNumber, "@UseXtraRevNumber");
}
}
private LazyLoad<bool> _SpecialLandscapeMode;
public bool SpecialLandscapeMode
{
get
{
return LazyLoad(ref _SpecialLandscapeMode, "@SpecialLandscapeMode");
}
}
private LazyLoad<bool> _LimitWidToPageWid;
public bool LimitWidToPageWid
{
get
{
return LazyLoad(ref _LimitWidToPageWid, "@LimitWidToPageWid");
}
}
private LazyLoad<bool> _CombinedTabIncludeParenTabs;
public bool CombinedTabIncludeParenTabs
{
get
{
return LazyLoad(ref _CombinedTabIncludeParenTabs, "@CombinedTabIncludeParenTabs");
}
}
private VE_Font _ModifiedTextStyle;
public VE_Font ModifiedTextStyle
{
get
{
return (_ModifiedTextStyle == null)? _ModifiedTextStyle = new VE_Font(base.XmlNode):_ModifiedTextStyle;
}
}
private VE_Font _ImmStepHdrStyle;
public VE_Font ImmStepHdrStyle
{
get
{
return (_ImmStepHdrStyle == null)? _ImmStepHdrStyle = new VE_Font(base.XmlNode):_ImmStepHdrStyle;
}
}
private ImmStepHdrList _ImmStepHdrList;
public ImmStepHdrList ImmStepHdrList
{
get
{
return (_ImmStepHdrList == null)? _ImmStepHdrList = new ImmStepHdrList(SelectNodes("ImmStepHdrList/string")):_ImmStepHdrList;
}
set { _ImmStepHdrList = value; }
}
private LeftJustifyList _LeftJustifyList;
public LeftJustifyList LeftJustifyList
{
get
{
return (_LeftJustifyList == null) ? _LeftJustifyList = new LeftJustifyList(SelectNodes("LeftJustifyList/LeftJustify")) : _LeftJustifyList;
}
set { _LeftJustifyList = value; }
}
}
#region ImmStepHdr
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ImmStepHdr : vlnFormatItem
{
public ImmStepHdr(XmlNode xmlNode) : base(xmlNode) { }
public ImmStepHdr() : base() { }
private LazyLoad<string> _Text;
public string Text
{
get
{
return LazyLoad(ref _Text, "text()");
}
}
public override string GetPDDisplayName()
{ return "Text"; }
public override string GetPDDescription()
{ return string.Format("ImmStepHdr '{0}'", Text); }
public override string GetPDCategory()
{ return "Imm Step Hdr"; }
public override string ToString()
{
return Text;
}
}
#endregion
#region ImmStepHdrList
[TypeConverter(typeof(vlnListConverter<ImmStepHdrList, ImmStepHdr>))]
public class ImmStepHdrList : vlnFormatList<ImmStepHdr>
{
public ImmStepHdrList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region LeftJustifyList
[TypeConverter(typeof(vlnListConverter<LeftJustifyList, LeftJustify>))]
public class LeftJustifyList : vlnFormatList<LeftJustify>
{
public LeftJustifyList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion
#region LeftJustify
[TypeConverter(typeof(ExpandableObjectConverter))]
public class LeftJustify : vlnFormatItem, IVlnIndexedFormatItem
{
public LeftJustify(XmlNode xmlNode) : base(xmlNode) { }
public LeftJustify() : base() { }
private LazyLoad<int?> _Index;
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
private LazyLoad<float?> _Size;
public float? Size
{
get
{
return LazyLoad(ref _Size, "@Size");
}
}
}
#endregion
#endregion
#region SeqTabFmtAll
#region SeqTabFmt
[TypeConverter(typeof(ExpandableObjectConverter))]
public class SeqTabFmt : vlnFormatItem,IVlnIndexedFormatItem
{
public SeqTabFmt() : base() { }
private LazyLoad<int?> _Index; //not included - is it needed?
[Description("SeqTab Index")]
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
private LazyLoad<string> _TabToken;
public string TabToken
{
get
{
return LazyLoad(ref _TabToken, "@TabToken");
}
}
private LazyLoad<string> _TabFormat;
public string TabFormat
{
get
{
return LazyLoad(ref _TabFormat, "@TabFormat");
}
}
private LazyLoad<string> _PrintTabFormat;
public string PrintTabFormat
{
get
{
return LazyLoad(ref _TabFormat, "@PrintTabFormat");
}
}
private LazyLoad<bool> _DontTrimParentTabBeforeAppending; // B2019-011 for Barakah Alarm format
public bool DontTrimParentTabBeforeAppending
{
get
{
return LazyLoad(ref _DontTrimParentTabBeforeAppending, "@DontTrimParentTabBeforeAppending");
}
}
public override string GetPDDisplayName()
{ return string.Format("Index [{0}]",Index); }
public override string GetPDDescription()
{ return string.Format("Sequential Tab Format Index '{0}' Format '{1}'", Index, TabFormat); }
public override string GetPDCategory()
{ return "Sequential Tab Formatting"; }
public override string ToString()
{
return TabFormat;
}
}
#endregion
#region SeqTabFmtList
[TypeConverter(typeof(vlnIndexedListConverter<SeqTabFmtList, SeqTabFmt>))]
public class SeqTabFmtList : vlnIndexedFormatList<SeqTabFmt>
{
public SeqTabFmtList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
public override vlnIndexedFormatList<SeqTabFmt> InheritedList
{
get
{
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
if (parentFormat != null)
return parentFormat.PlantFormat.FormatData.SectData.StepSectionData.SeqTabFmtList;
return null;
}
}
}
#endregion
#endregion
#endregion
#region AccSectionDataAll
#region AccSectionData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class AccSectionData : vlnFormatItem
{
public AccSectionData(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<int?> _AutoContActSumSection;
public int? AutoContActSumSection
{
get
{
return LazyLoad(ref _AutoContActSumSection, "@AutoContActSumSection");
}
}
private TableOfContentsData _TableOfContentsData;
public TableOfContentsData TableOfContentsData
{
get
{
return (_TableOfContentsData == null ? _TableOfContentsData = new TableOfContentsData(SelectSingleNode("TableOfContentsData")) : _TableOfContentsData);
}
}
private ConitnuousActionSummaryData _ContinuousActionSummaryData;
public ConitnuousActionSummaryData ContinuousActionSummaryData
{
get
{
return (_ContinuousActionSummaryData == null? _ContinuousActionSummaryData = new ConitnuousActionSummaryData(SelectSingleNode("ConitnuousActionSummaryData")) : _ContinuousActionSummaryData);
}
}
}
#endregion
#region TableOfContentsData
public class TableOfContentsData : vlnFormatItem
{
public TableOfContentsData(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<float?> _TofCSecNumPos;
public float? TofCSecNumPos
{
get
{
return LazyLoad(ref _TofCSecNumPos, "@TofCSecNumPos");
}
}
private LazyLoad<float?> _TofCSecTitlePos;
public float? TofCSecTitlePos
{
get
{
return LazyLoad(ref _TofCSecTitlePos, "@TofCSecTitlePos");
}
}
private LazyLoad<int?> _TofCSecTitleLen;
public int? TofCSecTitleLen
{
get
{
return LazyLoad(ref _TofCSecTitleLen, "@TofCSecTitleLen");
}
}
private LazyLoad<float?> _TofCPageNumPos;
public float? TofCPageNumPos
{
get
{
return LazyLoad(ref _TofCPageNumPos, "@TofCPageNumPos");
}
}
private LazyLoad<string> _TofCSpaceChar;
public string TofCSpaceChar
{
get
{
return LazyLoad(ref _TofCSpaceChar, "@TofCSpaceChar");
}
}
private LazyLoad<float?> _TofCLineSpacing;
public float? TofCLineSpacing
{
get
{
return LazyLoad(ref _TofCLineSpacing, "@TofCLineSpacing");
}
}
private LazyLoad<int?> _TofCNumLevels;
public int? TofCNumLevels
{
get
{
return LazyLoad(ref _TofCNumLevels, "@TofCNumLevels");
}
}
private LazyLoad<int?> _TofCStartIndentAfterLevel;
public int? TofCStartIndentAfterLevel
{
get
{
return LazyLoad(ref _TofCStartIndentAfterLevel, "@TofCStartIndentAfterLevel");
}
}
private LazyLoad<bool> _TofCUnderlineFirstLevelTitle;
public bool TofCUnderlineFirstLevelTitle
{
get
{
return LazyLoad(ref _TofCUnderlineFirstLevelTitle, "@TofCUnderlineFirstLevelTitle");
}
}
private LazyLoad<string> _TofCPageNumAlign;
public string TofCPageNumAlign
{
get
{
string tocPgNumAlgn = LazyLoad(ref _TofCPageNumAlign, "@TofCPageNumAlign");
return (tocPgNumAlgn == null || tocPgNumAlgn == "") ? "Left" : tocPgNumAlgn;
}
}
private LazyLoad<string> _TofCProcedureStepsTitle;
public string TofCProcedureStepsTitle
{
get
{
string tocProcStepsTitle = LazyLoad(ref _TofCProcedureStepsTitle, "@TofCProcedureStepsTitle");
return (tocProcStepsTitle == null || tocProcStepsTitle == "") ? "" : tocProcStepsTitle;
}
}
private LazyLoad<int?> _TofCLineSpacingSub;
public int? TofCLineSpacingSub
{
get
{
return LazyLoad(ref _TofCLineSpacingSub, "@TofCLineSpacingSub");
}
}
private LazyLoad<bool> _TofCRemoveGrpNameInSects;
public bool TofCRemoveGrpNameInSects
{
get
{
return LazyLoad(ref _TofCRemoveGrpNameInSects, "@TofCRemoveGrpNameInSects");
}
}
// C2021-015: Barakah High Level Steps in Table of Contents
private LazyLoad<bool> _TofCAllowHLS;
public bool TofCAllowHLS
{
get
{
return LazyLoad(ref _TofCAllowHLS, "@TofCAllowHLS");
}
}
private VE_Font _Font;
public VE_Font Font
{
get
{
return (_Font == null) ?_Font = new VE_Font(base.XmlNode):_Font;
}
}
}
#endregion
#region ConitnuousActionSummary
public class ConitnuousActionSummaryData : vlnFormatItem
{
public ConitnuousActionSummaryData(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<bool> _IncludeSectionNumAndTitle;
public bool IncludeSectionNumAndTitle
{
get
{
return LazyLoad(ref _IncludeSectionNumAndTitle, "@IncludeSectionNumAndTitle");
}
}
private VE_Font _Font;
public VE_Font Font
{
get
{
return (_Font == null) ? _Font = new VE_Font(base.XmlNode) : _Font;
}
}
}
#endregion
#endregion
#region MetaSectionAll
#region MetaSection
[TypeConverter(typeof(ExpandableObjectConverter))]
public class MetaSection : vlnFormatItem,IVlnIndexedFormatItem
{
public MetaSection(XmlNode xmlNode) : base(xmlNode) { }
public MetaSection() : base() { }
private LazyLoad<int?> _Index;
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
private LazyLoad<float?> _SecNumPositionAdj;
public float? SecNumPositionAdj
{
get
{
return LazyLoad(ref _SecNumPositionAdj, "@SecNumPositionAdj");
}
}
private LazyLoad<float?> _SecTitlePositionAdj;
public float? SecTitlePositionAdj
{
get
{
return LazyLoad(ref _SecTitlePositionAdj, "@SecTitlePositionAdj");
}
}
private LazyLoad<float?> _ColSByLevel;
public float? ColSByLevel
{
get
{
return LazyLoad(ref _ColSByLevel, "@ColSByLevel");
}
}
private LazyLoad<float?> _TofCPositionAdj;
public float? TofCPositionAdj
{
get
{
return LazyLoad(ref _TofCPositionAdj, "@TofCPositionAdj");
}
}
private LazyLoad<float?> _WidSAdjByLevel;
public float? WidSAdjByLevel
{
get
{
return LazyLoad(ref _WidSAdjByLevel, "@WidSAdjByLevel");
}
}
public override string GetPDDisplayName()
{ return string.Format("[{0}]", Index); }
public override string GetPDCategory()
{ return "Meta Section Values"; }
public override string ToString()
{
return String.Format("{0}, {1}, {2}, {3}, {4}", SecNumPositionAdj, SecTitlePositionAdj, ColSByLevel, TofCPositionAdj, TofCPositionAdj);
}
}
#endregion
#region MetaSectionList
[TypeConverter(typeof(vlnIndexedListConverter<MetaSectionList, MetaSection>))]
public class MetaSectionList : vlnIndexedFormatList<MetaSection>
{
public MetaSectionList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
public override vlnIndexedFormatList<MetaSection> InheritedList
{
get
{
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
if (parentFormat != null)
return parentFormat.PlantFormat.FormatData.SectData.MetaSectionList;
return null;
}
}
}
#endregion
#endregion
#endregion
#region StepDataAll
#region Step
[TypeConverter(typeof(ExpandableObjectConverter))]
public class StepData : vlnFormatItem,IVlnIndexedFormatItem
{
public StepData() : base() { }
private LazyLoad<int?> _Index;
[Description("Step Index")]
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
private LazyLoad<string> _Type;
public string Type
{
get
{
return LazyLoad(ref _Type, "@Type");
}
}
private LazyLoad<string> _ParentType;
public string ParentType
{
get
{
return LazyLoad(ref _ParentType, "@ParentType");
}
}
private LazyLoad<bool> _ReadOnly;
public bool ReadOnly
{
get
{
return LazyLoad(ref _ReadOnly, "@ReadOnly");
}
}
private LazyLoad<bool> _NoYBxAdjust; // F2021-038: SHE/SHEA less space after top line & before bottom line
public bool NoYBxAdjust
{
get
{
return LazyLoad(ref _NoYBxAdjust, "@NoYBxAdjust");
}
}
//private LazyLoad<bool> _SeparateWarning; // KBR: To be used for Proms Express to separate out warnings from notes/cautions on ribbon, etc
//public bool SeparateWarning
//{
// get
// {
// return LazyLoad(ref _SeparateWarning, "@SeparateWarning");
// }
//}
private LazyLoad<bool> _Inactive;
public bool Inactive
{
get
{
return LazyLoad(ref _Inactive, "@Inactive");
}
}
// F2018-022 Added step type flag to append a ".0" to the end of the high level step - put in for Westinghouse single column format (wst1)
private LazyLoad<bool> _AppendDotZero;
public bool AppendDotZero
{
get
{
return LazyLoad(ref _AppendDotZero, "@AppendDotZero");
}
}
// F2019-069: Barakah Hold Point - set xoffset to parent's tab
private LazyLoad<bool> _ColUseParentTab;
public bool ColUseParentTab
{
get
{
return LazyLoad(ref _ColUseParentTab, "@ColUseParentTab");
}
}
private LazyLoad<float?> _ColOverride;
public float? ColOverride
{
get
{
return LazyLoad(ref _ColOverride, "@ColOverride");
}
}
private LazyLoad<float?> _ColOverrideEdit;
public float? ColOverrideEdit
{
get
{
return LazyLoad(ref _ColOverrideEdit, "@ColOverrideEdit");
}
}
private LazyLoad<string> _WidthOverride;
public string WidthOverride
{
get
{
return LazyLoad(ref _WidthOverride, "@WidthOverride");
}
}
//private LazyLoad<float?> _WidthOverride;
//public float? WidthOverride
//{
// get
// {
// return LazyLoad(ref _WidthOverride, "@WidthOverride");
// }
//}
private LazyLoad<float?> _WidthOverrideEdit;
public float? WidthOverrideEdit
{
get
{
return LazyLoad(ref _WidthOverrideEdit, "@WidthOverrideEdit");
}
}
private LazyLoad<string> _Sep;
public string Sep
{
get
{
return LazyLoad(ref _Sep, "@Sep");
}
}
private LazyLoad<string> _Prefix;
public string Prefix
{
get
{
return LazyLoad(ref _Prefix, "@Prefix");
}
}
private LazyLoad<string> _Suffix;
public string Suffix
{
get
{
return LazyLoad(ref _Suffix, "@Suffix");
}
}
// F2019-069: Barakah Hold Point - allow for default text (for Barakah it is 'Hold Point')
private LazyLoad<string> _DefaultText;
public string DefaultText
{
get
{
return LazyLoad(ref _DefaultText, "@DefaultText");
}
}
private LazyLoad<string> _UnderlineTheseChar;
public string UnderlineTheseChar
{
get
{
return LazyLoad(ref _UnderlineTheseChar, "@UnderlineTheseChar");
}
}
private LazyLoad<string> _VertPos;
public string VertPos
{
get
{
return LazyLoad(ref _VertPos, "@VertPos");
}
}
private LazyLoad<bool> _DoubleSpace;
public bool DoubleSpace
{
get
{
return LazyLoad(ref _DoubleSpace, "@DoubleSpace");
}
}
private LazyLoad<bool> _EnhancedStepNumFromPrev;
public bool EnhancedStepNumFromPrev
{
get
{
return LazyLoad(ref _EnhancedStepNumFromPrev, "@EnhancedStepNumFromPrev");
}
}
private LazyLoad<bool> _UseSmartTemplate;
public bool UseSmartTemplate
{
get
{
return LazyLoad(ref _UseSmartTemplate, "@UseSmartTemplate");
}
}
private LazyLoad<bool> _UseOldTemplate;
public bool UseOldTemplate
{
get
{
return LazyLoad(ref _UseOldTemplate, "@UseOldTemplate");
}
}
private LazyLoad<bool> _AlwaysUseExtraLines;
public bool AlwaysUseExtraLines
{
get
{
return LazyLoad(ref _AlwaysUseExtraLines, "@AlwaysUseExtraLines");
}
}
private LazyLoad<bool> _SeparateBox;
public bool SeparateBox
{
get
{
return LazyLoad(ref _SeparateBox, "@SeparateBox");
}
}
private LazyLoad<bool> _SeparateBoxCautions;
public bool SeparateBoxCautions
{
get
{
return LazyLoad(ref _SeparateBoxCautions, "@SeparateBoxCautions");
}
}
private LazyLoad<bool> _SpaceDouble;
public bool SpaceDouble
{
get
{
return LazyLoad(ref _SpaceDouble, "@SpaceDouble");
}
}
private LazyLoad<bool> _ReduceLineAfter;
public bool ReduceLineAfter
{
get
{
return LazyLoad(ref _ReduceLineAfter, "@ReduceLineAfter");
}
}
private LazyLoad<bool> _SameLevel;
public bool SameLevel
{
get
{
return LazyLoad(ref _SameLevel, "@SameLevel");
}
}
private LazyLoad<bool> _BoldHighLevel;
public bool BoldHighLevel
{
get
{
return LazyLoad(ref _BoldHighLevel, "@BoldHighLevel");
}
}
private LazyLoad<bool> _OneLineBeforeTab;
public bool OneLineBeforeTab
{
get
{
return LazyLoad(ref _OneLineBeforeTab, "@OneLineBeforeTab");
}
}
private LazyLoad<bool> _CheckOffOnAllSteps;
public bool CheckOffOnAllSteps
{
get
{
return LazyLoad(ref _CheckOffOnAllSteps, "@CheckOffOnAllSteps");
}
}
private LazyLoad<bool> _BoxIt;
public bool BoxIt
{
get
{
return LazyLoad(ref _BoxIt, "@BoxIt");
}
}
private LazyLoad<bool> _Boxed;
public bool Boxed
{
get
{
return LazyLoad(ref _Boxed, "@Boxed");
}
}
private LazyLoad<bool> _XLines_StepFix;
public bool XLines_StepFix
{
get
{
return LazyLoad(ref _XLines_StepFix, "@XLines_StepFix");
}
}
private LazyLoad<bool> _Rebox;
public bool Rebox
{
get
{
return LazyLoad(ref _Rebox, "@Rebox");
}
}
private LazyLoad<bool> _SpcHdr;
public bool SpcHdr
{
get
{
return LazyLoad(ref _SpcHdr, "@SpcHdr");
}
}
private LazyLoad<bool> _ContinueOnly;
public bool ContinueOnly
{
get
{
return LazyLoad(ref _ContinueOnly, "@ContinueOnly");
}
}
private LazyLoad<bool> _SepAfterAER;
public bool SepAfterAER
{
get
{
return LazyLoad(ref _SepAfterAER, "@SepAfterAER");
}
}
private LazyLoad<bool> _UseAlternateStepBox;
public bool UseAlternateStepBox
{
get
{
return LazyLoad(ref _UseAlternateStepBox, "@UseAlternateStepBox");
}
}
private LazyLoad<bool> _UnderlineAfterDashSpace;
public bool UnderlineAfterDashSpace
{
get
{
return LazyLoad(ref _UnderlineAfterDashSpace, "@UnderlineAfterDashSpace");
}
}
// F2019-065: Allow uppercase of high level steps to be defined in the format
private LazyLoad<bool> _UpperCase;
public bool UpperCase
{
get
{
return LazyLoad(ref _UpperCase, "@UpperCase");
}
}
private LazyLoad<bool> _SpaceIn;
public bool SpaceIn
{
get
{
return LazyLoad(ref _SpaceIn, "@SpaceIn");
}
}
private LazyLoad<bool> _PageBreakOnStep;
public bool PageBreakOnStep
{
get
{
return LazyLoad(ref _PageBreakOnStep, "@PageBreakOnStep");
}
}
private LazyLoad<bool> _AlignNullTabWSectHead;
public bool AlignNullTabWSectHead
{
get
{
return LazyLoad(ref _AlignNullTabWSectHead, "@AlignNullTabWSectHead");
}
}
private LazyLoad<bool> _ForceAlignNullTabWSectHead;
public bool ForceAlignNullTabWSectHead
{
get
{
return LazyLoad(ref _ForceAlignNullTabWSectHead, "@ForceAlignNullTabWSectHead");
}
}
private LazyLoad<bool> _AlignHLSTabWithSectOvride;
public bool AlignHLSTabWithSectOvride
{
get
{
return LazyLoad(ref _AlignHLSTabWithSectOvride, "@AlignHLSTabWithSectOvride");
}
}
private LazyLoad<bool> _TextSubFollowsTextStyle;
public bool TextSubFollowsTextStyle
{
get
{
return LazyLoad(ref _TextSubFollowsTextStyle, "@TextSubFollowsTextStyle");
}
}
private LazyLoad<int?> _CautionOrNoteSubstepIndent;
public int? CautionOrNoteSubstepIndent
{
get
{
return LazyLoad(ref _CautionOrNoteSubstepIndent, "@CautionOrNoteSubstepIndent");
}
}
private LazyLoad<bool> _TreatAsSequential;
public bool TreatAsSequential
{
get
{
return LazyLoad(ref _TreatAsSequential, "@TreatAsSequential");
}
}
private LazyLoad<bool> _MatchUpRNO;
public bool MatchUpRNO
{
get
{
return LazyLoad(ref _MatchUpRNO, "@MatchUpRNO");
}
}
private LazyLoad<bool> _InPageList;
public bool InPageList
{
get
{
return LazyLoad(ref _InPageList, "@InPageList");
}
}
private LazyLoad<bool> _CenterOneLineOnly;
public bool CenterOneLineOnly
{
get
{
return LazyLoad(ref _CenterOneLineOnly, "@CenterOneLineOnly");
}
}
private LazyLoad<bool> _CenterOnlyIfNoSubs;
public bool CenterOnlyIfNoSubs
{
get
{
return LazyLoad(ref _CenterOnlyIfNoSubs, "@CenterOnlyIfNoSubs");
}
}
// F2021-042: Added FormatStepData.AlwaysCenter for BNPP1 - Critical Step text always must be centered
private LazyLoad<bool> _AlwaysCenter;
public bool AlwaysCenter
{
get
{
return LazyLoad(ref _AlwaysCenter, "@AlwaysCenter");
}
}
private LazyLoad<bool> _SubTableGetsUp1Level;
public bool SubTableGetsUp1Level
{
get
{
return LazyLoad(ref _SubTableGetsUp1Level, "@SubTableGetsUp1Level");
}
}
private LazyLoad<bool> _Remember;
public bool Remember
{
get
{
return LazyLoad(ref _Remember, "@Remember");
}
}
private LazyLoad<bool> _CenterOneLineAdjust;
public bool CenterOneLineAdjust
{
get
{
return LazyLoad(ref _CenterOneLineAdjust, "@CenterOneLineAdjust");
}
}
private LazyLoad<bool> _Break;
public bool Break
{
get
{
return LazyLoad(ref _Break, "@Break");
}
}
private LazyLoad<bool> _BreakEquipmentList;
public bool BreakEquipmentList
{
get
{
return LazyLoad(ref _BreakEquipmentList, "@BreakEquipmentList");
}
}
private LazyLoad<bool> _BreakCautionsNotesOnSubstps;
public bool BreakCautionsNotesOnSubstps
{
get
{
return LazyLoad(ref _BreakCautionsNotesOnSubstps, "@BreakCautionsNotesOnSubstps");
}
}
private LazyLoad<bool> _CenterTextWithinWidth;
public bool CenterTextWithinWidth
{
get
{
return LazyLoad(ref _CenterTextWithinWidth, "@CenterTextWithinWidth");
}
}
private LazyLoad<bool> _NewlineAfter;
public bool NewlineAfter
{
get
{
return LazyLoad(ref _NewlineAfter, "@NewlineAfter");
}
}
private LazyLoad<bool> _StartLineWithDash;
public bool StartLineWithDash
{
get
{
return LazyLoad(ref _StartLineWithDash, "@StartLineWithDash");
}
}
private LazyLoad<bool> _BlankLineBeforeSubStep;
public bool BlankLineBeforeSubStep
{
get
{
return LazyLoad(ref _BlankLineBeforeSubStep, "@BlankLineBeforeSubStep");
}
}
private LazyLoad<bool> _AlwaysTab;
public bool AlwaysTab
{
get
{
return LazyLoad(ref _AlwaysTab, "@AlwaysTab");
}
}
private LazyLoad<bool> _NoSpaceMultipleRNOs;
public bool NoSpaceMultipleRNOs
{
get
{
return LazyLoad(ref _NoSpaceMultipleRNOs, "@NoSpaceMultipleRNOs");
}
}
private LazyLoad<bool> _MixCautionsAndNotes;
public bool MixCautionsAndNotes
{
get
{
return LazyLoad(ref _MixCautionsAndNotes, "@MixCautionsAndNotes");
}
}
private LazyLoad<bool> _NumberHighLevel;
public bool NumberHighLevel
{
get
{
return LazyLoad(ref _NumberHighLevel, "@NumberHighLevel");
}
}
private LazyLoad<bool> _NumberWithLevel;
public bool NumberWithLevel
{
get
{
return LazyLoad(ref _NumberWithLevel, "@NumberWithLevel");
}
}
private LazyLoad<bool> _OffsetTab;
public bool OffsetTab
{
get
{
return LazyLoad(ref _OffsetTab, "@OffsetTab");
}
}
private LazyLoad<float?> _AdjHighLevelTab;
public float? AdjHighLevelTab
{
get
{
return LazyLoad(ref _AdjHighLevelTab, "@AdjHighLevelTab");
}
}
private LazyLoad<float?> _ChildIndent;
public float? ChildIndent
{
get
{
return LazyLoad(ref _ChildIndent, "@ChildIndent");
}
}
private LazyLoad<bool> _LeftJustifyBorderless;
public bool LeftJustifyBorderless
{
get
{
return LazyLoad(ref _LeftJustifyBorderless, "@LeftJustifyBorderless");
}
}
private LazyLoad<bool> _StepNumIfOnlyOne;
public bool StepNumIfOnlyOne
{
get
{
return LazyLoad(ref _StepNumIfOnlyOne, "@StepNumIfOnlyOne");
}
}
private LazyLoad<bool> _LJTabs;
public bool LJTabs
{
get
{
return LazyLoad(ref _LJTabs, "@LJTabs");
}
}
private LazyLoad<bool> _NumberSubs;
public bool NumberSubs
{
get
{
return LazyLoad(ref _NumberSubs, "@NumberSubs");
}
}
private LazyLoad<bool> _BulletOnContinuous;
public bool BulletOnContinuous
{
get
{
return LazyLoad(ref _BulletOnContinuous, "@BulletOnContinuous");
}
}
private LazyLoad<bool> _StepNumberForHighLevel;
public bool StepNumberForHighLevel
{
get
{
return LazyLoad(ref _StepNumberForHighLevel, "@StepNumberForHighLevel");
}
}
private LazyLoad<bool> _SameRowAsParent;
public bool SameRowAsParent
{
get
{
return LazyLoad(ref _SameRowAsParent, "@SameRowAsParent");
}
}
private LazyLoad<bool> _SameRowAsParentMultiLines;
public bool SameRowAsParentMultiLines
{
get
{
return LazyLoad(ref _SameRowAsParentMultiLines, "@SameRowAsParentMultiLines");
}
}
private LazyLoad<bool> _CheckOffSameAsParent;
public bool CheckOffSameAsParent
{
get
{
return LazyLoad(ref _CheckOffSameAsParent, "@CheckOffSameAsParent");
}
}
private LazyLoad<bool> _AtLeastTwoDigits;
public bool AtLeastTwoDigits
{
get
{
return LazyLoad(ref _AtLeastTwoDigits, "@AtLeastTwoDigits");
}
}
private LazyLoad<bool> _UseInAcTable;
public bool UseInAcTable
{
get
{
return LazyLoad(ref _UseInAcTable, "@UseInAcTable");
}
}
private LazyLoad<bool> _Number;
public bool Number
{
get
{
return LazyLoad(ref _Number, "@Number");
}
}
private LazyLoad<bool> _ThreeBlanksAbove;
public bool ThreeBlanksAbove
{
get
{
return LazyLoad(ref _ThreeBlanksAbove, "@ThreeBlanksAbove");
}
}
private LazyLoad<bool> _CheckOffs;
public bool CheckOffs
{
get
{
return LazyLoad(ref _CheckOffs, "@CheckOffs");
}
}
private LazyLoad<bool> _Quoted;
public bool Quoted
{
get
{
return LazyLoad(ref _Quoted, "@Quoted");
}
}
private VE_Font GetUCFFontAsVE_Font()
{
// if formatconfig & step list, then go through to see if index exists, if so and if there is a font, use it:
if (MyFormat.PlantFormat.FormatConfig != null && MyFormat.PlantFormat.FormatConfig.PlantFormat != null && MyFormat.PlantFormat.FormatConfig.PlantFormat.FormatData != null && MyFormat.PlantFormat.FormatConfig.PlantFormat.FormatData.StepData != null)
{
foreach (FormatConfig.Step stp in MyFormat.PlantFormat.FormatConfig.PlantFormat.FormatData.StepData)
{
if (Convert.ToInt32(stp.Index) == (int)Index && stp.FontDesc != null && stp.FontDesc.Font != null && stp.FontDesc.Font != "")
{
System.Drawing.FontConverter cvt = new System.Drawing.FontConverter();
System.Drawing.Font windowsFont = cvt.ConvertFromString(stp.FontDesc.Font) as System.Drawing.Font;
E_Style myStyle = E_Style.None;
if (windowsFont.Bold) myStyle |= E_Style.Bold;
if (windowsFont.Underline) myStyle |= E_Style.Underline;
if (windowsFont.Italic) myStyle |= E_Style.Italics;
return (new VE_Font(windowsFont.Name, (int)windowsFont.Size, myStyle, windowsFont.SizeInPoints));
}
}
}
return null;
}
private VE_Font _Font;
public VE_Font Font
{
get
{
if (PlantFormat.IgnoreUCF) return (_Font == null) ?_Font = new VE_Font(base.XmlNode): _Font;
if (_Font != null) return (_Font);
VE_Font vef = GetUCFFontAsVE_Font();
if (vef != null)
{
_Font = vef;
return vef;
}
return (_Font == null) ?_Font = new VE_Font(base.XmlNode): _Font;
}
}
private StepLayoutData _StepLayoutData;
public StepLayoutData StepLayoutData
{
get
{
return (_StepLayoutData == null)? _StepLayoutData = new StepLayoutData(base.XmlNode): _StepLayoutData;
}
}
private StepEditData _StepEditData;
public StepEditData StepEditData
{
get
{
return (_StepEditData == null) ? _StepEditData = new StepEditData(base.XmlNode) : _StepEditData;
}
}
private StepPrintData _StepPrintData;
public StepPrintData StepPrintData
{
get
{
return (_StepPrintData == null) ? _StepPrintData = new StepPrintData(base.XmlNode) : _StepPrintData;
}
}
private TabData _TabData;
public TabData TabData
{
get
{
return (_TabData == null) ? _TabData = new TabData(base.XmlNode) : _TabData;
}
}
public override string ToString()
{
return string.Format("{0}", Type);
}
private LazyLoad<bool> _ExcludeFromContActSum;
public bool ExcludeFromContActSum
{
get
{
return LazyLoad(ref _ExcludeFromContActSum, "@ExcludeFromContActSum", true); // the default setting is true (as is yes, dont include on Continuous Action Summary)
}
}
//F2022-024 Time Critical Action Step
private LazyLoad<bool> _ExcludeFromTimeCriticalActSum;
public bool ExcludeFromTimeCriticalActSum
{
get
{
return LazyLoad(ref _ExcludeFromTimeCriticalActSum, "@ExcludeFromTimeCriticalActSum", true); // the default setting is true (as is yes, dont include on Tim Critical Action Summary)
}
}
}
#endregion
#region StepDataList
[TypeConverter(typeof(vlnIndexedListConverter<StepDataList, StepData>))]
public class StepDataList : vlnIndexedFormatList<StepData>
{
//public new StepData this[int index]
//{
// get
// {
// foreach (StepData stepData in this)
// if (stepData.Index == index) return stepData;
// return null;
// }
//}
public override vlnIndexedFormatList<StepData> InheritedList
{
get
{
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
if (parentFormat != null)
return parentFormat.PlantFormat.FormatData.StepDataList;
return null;
}
}
public StepData this[string type]
{
get
{
foreach (StepData stepData in this)
if (stepData.Type == type) return stepData;
StepDataList ttlParent = (StepDataList) InheritedList; //Check Inherited Value
if (ttlParent != null)
return ttlParent[type]; // note that this is recursive, i.e. if doesn't get found in parent, goes to parent's parent.
return null;
}
}
// the following was commented out because it uses the vlnFormat version of the code that indexes the list.
//public StepData this[int index]
//{
// get
// {
// foreach (StepData stepData in this)
// if (stepData.Index == index) return stepData;
// StepDataList ttlParent = (StepDataList)InheritedList; //Check Inherited Value
// if (ttlParent != null)
// return ttlParent[index];
// return null;
// }
//}
public StepDataList(XmlNodeList xmlNodeList, IFormatOrFormatInfo myFormat) : base(xmlNodeList, myFormat) { }
private StepData _HLS;
public StepData HLS
{
get
{
if (_HLS!=null) return _HLS;
foreach (StepData sd in this)
{
if (sd.Type == "High")
{
_HLS = sd;
return sd;
}
}
return null;
}
}
private StepData _Caution;
public StepData Caution
{
get
{
if (_Caution != null) return _Caution;
foreach (StepData sd in this)
{
if (sd.Type == "Caution")
{
_Caution = sd;
return sd;
}
}
return null;
}
}
private StepData _Note;
public StepData Note
{
get
{
if (_Note != null) return _Note;
foreach (StepData sd in this)
{
if (sd.Type == "Note")
{
_Note = sd;
return sd;
}
}
return null;
}
}
private StepData _RNO;
public StepData RNO
{
get
{
if (_RNO != null) return _RNO;
foreach (StepData sd in this)
{
if (sd.Type == "RNOType")
{
_RNO = sd;
return sd;
}
}
return null;
}
}
private StepData _Fig;
public StepData Fig
{
get
{
if (_Fig != null) return _Fig;
foreach (StepData sd in this)
{
if (sd.Type == "Figure")
{
_Fig = sd;
return sd;
}
}
return null;
}
}
private StepData _Table;
public StepData Table
{
get
{
if (_Table != null) return _Table;
foreach (StepData sd in this)
{
if (sd.Type == "Table")
{
_Table = sd;
return sd;
}
}
return null;
}
}
private StepData _Substep;
public StepData Substep
{
get
{
if (_Substep != null) return _Substep;
foreach (StepData sd in this)
{
if (sd.Type == "Substep")
{
_Substep = sd;
return sd;
}
}
return null;
}
}
// EmbeddedObject has been commented out, 'Equations' are separate top level items.
// This code was left here in case Equations , and other OLE objects, end up
// under the EmbeddedObject:
// EmbeddedObject has inheritted types that represent OLE objects.
// The first of these is 'Equation'. Another that may be implemented later is Image.
// This is a special case, since only 'Equation' exists on initial development of
// embedded objects, 'skip' the embedded object layer when creating the list and
// go right to the equations.
//private StepData _EmbeddedObject;
//public StepData EmbeddedObject
//{
// get
// {
// if (_EmbeddedObject != null) return _EmbeddedObject;
// foreach (StepData sd in this)
// {
// if (sd.Type == "EmbeddedObject")
// {
// _Equation = sd;
// return sd;
// }
// }
// return null;
// }
//}
private StepData _Equation;
public StepData Equation // equation has a parent of embedded object.
{
get
{
if (_Equation != null) return _Equation;
foreach (StepData sd in this)
{
if (sd.Type == "Equation")
{
_Equation = sd;
return sd;
}
}
// Handle inheritance (step data may not be in current format, may inherit from parents):
IFormatOrFormatInfo parentFormat = this.MyFormat.PlantFormat.FormatData.MyParentFormat;
while (parentFormat != null)
{
vlnIndexedFormatList<StepData> InheritedList = parentFormat.PlantFormat.FormatData.StepDataList;
if (InheritedList != null)
{
foreach (StepData sdi in InheritedList)
{
if (sdi.Type == "Equation")
{
_Equation = sdi;
return sdi;
}
}
}
parentFormat = parentFormat.PlantFormat.FormatData.MyParentFormat;
}
return null;
}
}
}
#endregion
#region StepLayoutData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class StepLayoutData : vlnFormatItem
{
public StepLayoutData(XmlNode xmlNode)
: base(xmlNode)
{
}
private LazyLoad<string> _ForeColor;
public string ForeColor
{
get
{
return LazyLoad(ref _ForeColor, "StepLayoutData/@ForeColor");
}
}
private LazyLoad<string> _BackColor;
public string BackColor
{
get
{
return LazyLoad(ref _BackColor, "StepLayoutData/@BackColor");
}
}
private LazyLoad<int?> _STExtraSpace;
public int? STExtraSpace
{
get
{
return LazyLoad(ref _STExtraSpace, "StepLayoutData/@STExtraSpace");
}
}
private LazyLoad<int?> _STBoxindex;
public int? STBoxindex
{
get
{
return LazyLoad(ref _STBoxindex, "StepLayoutData/@STBoxindex");
}
}
private LazyLoad<int?> _EveryNLines;
public int? EveryNLines
{
get
{
return LazyLoad(ref _EveryNLines, "StepLayoutData/@EveryNLines");
}
}
private LazyLoad<bool> _AlignWithParentTab;
public bool AlignWithParentTab
{
get
{
return LazyLoad(ref _AlignWithParentTab, "StepLayoutData/@AlignWithParentTab");
}
}
}
#endregion
#region StepEditData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class StepEditData : vlnFormatItem
{
public StepEditData(XmlNode xmlNode)
: base(xmlNode)
{
}
private TypeMenu _TypeMenu;
public TypeMenu TypeMenu
{
get
{
return (_TypeMenu == null) ? _TypeMenu = new TypeMenu(base.XmlNode) : _TypeMenu;
}
}
private LazyLoad<string> _ForeColor;
public string ForeColor
{
get
{
return LazyLoad(ref _ForeColor, "StepEditData/@ForeColor");
}
}
private LazyLoad<string> _BackColor;
public string BackColor
{
get
{
return LazyLoad(ref _BackColor, "StepEditData/@BackColor");
}
}
private LazyLoad<E_AccStep?> _AcTable;
public E_AccStep? AcTable
{
get
{
return LazyLoad<E_AccStep>(ref _AcTable, "StepEditData/@AcTable");
}
}
private LazyLoad<bool> _Searchable;
public bool Searchable
{
get
{
return LazyLoad(ref _Searchable, "StepEditData/@Searchable");
}
}
}
#endregion
#region StepPrintData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class StepPrintData : vlnFormatItem
{
public StepPrintData(XmlNode xmlNode)
: base(xmlNode)
{
}
private LazyLoad<float?> _PosAdjust;
public float? PosAdjust
{
get
{
return LazyLoad(ref _PosAdjust, "StepPrintData/@PosAdjust");
}
}
private LazyLoad<int?> _HLSLength;
public int? HLSLength
{
get
{
return LazyLoad(ref _HLSLength, "StepPrintData/@HLSLength");
}
}
private LazyLoad<string> _Justify;
public string Justify
{
get
{
return LazyLoad(ref _Justify, "StepPrintData/@Justify");
}
}
private LazyLoad<bool> _BlankAfterSubWithSub;
public bool BlankAfterSubWithSub // B2022-003: BNPP Alarms (BNPPalr) - incorrect line spacing for substeps off substeps.
{
get
{
return LazyLoad(ref _BlankAfterSubWithSub, "StepPrintData/@BlankAfterSubWithSub");
}
}
}
#endregion
#region TypeMenu
[TypeConverter(typeof(ExpandableObjectConverter))]
public class TypeMenu : vlnFormatItem
{
public TypeMenu(XmlNode xmlNode)
: base(xmlNode)
{
}
private LazyLoad<bool> _InMenu;
public bool InMenu
{
get
{
return LazyLoad(ref _InMenu, "StepEditData/TypeMenu/@InMenu");
}
}
private LazyLoad<bool> _RnoInMenu;
public bool RnoInMenu
{
get
{
return LazyLoad(ref _RnoInMenu, "StepEditData/TypeMenu/@RnoInMenu");
}
}
private LazyLoad<string> _MenuItem;
public string MenuItem
{
get
{
return LazyLoad(ref _MenuItem, "StepEditData/TypeMenu/@MenuItem");
}
}
private LazyLoad<string> _RnoMenuItem;
public string RnoMenuItem
{
get
{
return LazyLoad(ref _RnoMenuItem, "StepEditData/TypeMenu/@RnoMenuItem");
}
}
private LazyLoad<string> _NoChgReason;
public string NoChgReason
{
get
{
return LazyLoad(ref _NoChgReason, "StepEditData/TypeMenu/@NoChgReason");
}
}
private LazyLoad<string> _AlternateNameList;
public string AlternateNameList
{
get
{
return LazyLoad(ref _AlternateNameList, "StepEditData/TypeMenu/@AlternateNameList");
}
}
}
#endregion
#region Bullet
[TypeConverter(typeof(ExpandableObjectConverter))]
public class Bullet : vlnFormatItem
{
public Bullet(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<bool> _Separate;
public bool Separate
{
get
{
return LazyLoad(ref _Separate, "TabData/Bullet/@Separate");
}
}
private VE_Font _Font;
public VE_Font Font
{
get
{
if (_Font == null)
{
XmlNode xn = vlnFormatDocument.LookupSingleStepNode(base.XmlNode, "Bullet[Font]");
_Font = new VE_Font(xn);
}
return _Font;
}
}
}
#endregion
#region StepTab
[TypeConverter(typeof(ExpandableObjectConverter))]
public class TabData : vlnFormatItem
{
public TabData(XmlNode xmlNode)
: base(xmlNode)
{
}
private MacroList _MacroList;
public MacroList MacroList
{
get
{
return _MacroList == null ? _MacroList = new MacroList(SelectNodes("TabData/MacroList/Macro")) : _MacroList;
}
}
// F2022-024 used with the Time Critial Step type (used in Robinson EOP/AOP format)
// this will put the character asigned in the Time Critial Step format defination next to the step tab on the edit screen
// When this step is printed, a macro named Clock (genmac format file) is used instead to print a clock symbol
private LazyLoad<string> _MacroEditTag;
public string MacroEditTag
{
get
{
return LazyLoad(ref _MacroEditTag, "TabData/@MacroEditTag");
}
}
private LazyLoad<string> _IdentEdit;
public string IdentEdit
{
get
{
return LazyLoad(ref _IdentEdit, "TabData/@IdentEdit");
}
}
private LazyLoad<string> _IdentPrint;
public string IdentPrint
{
get
{
return LazyLoad(ref _IdentPrint, "TabData/@Ident");
}
}
private LazyLoad<string> _IdentAltPrint;
public string IdentAltPrint
{
get
{
return LazyLoad(ref _IdentAltPrint, "TabData/@IdentAltPrint");
}
}
private LazyLoad<string> _RNOIdentEdit;
public string RNOIdentEdit
{
get
{
return LazyLoad(ref _RNOIdentEdit, "TabData/@RNOIdentEdit");
}
}
private LazyLoad<string> _RNOIdent;
public string RNOIdent
{
get
{
return LazyLoad(ref _RNOIdent, "TabData/@RNOIdent");
}
}
private LazyLoad<string> _RNOIdentPrint;
public string RNOIdentPrint
{
get
{
return LazyLoad(ref _RNOIdentPrint, "TabData/@RNOIdent");
}
}
private LazyLoad<bool> _RNOExcludeMacros;
public bool RNOExcludeMacros
{
get
{
return LazyLoad(ref _RNOExcludeMacros, "TabData/@RNOExcludeMacros");
}
}
private LazyLoad<bool> _NoTabAlign;
public bool NoTabAlign
{
get
{
return LazyLoad(ref _NoTabAlign, "TabData/@NoTabAlign");
}
}
private LazyLoad<bool> _IncludeStepNum;
public bool IncludeStepNum
{
get
{
return LazyLoad(ref _IncludeStepNum, "TabData/@IncludeStepNum");
}
}
private LazyLoad<bool> _IncludeSectionNum;
public bool IncludeSectionNum
{
get
{
return LazyLoad(ref _IncludeSectionNum, "TabData/@IncludeSectionNum");
}
}
private LazyLoad<string> _Justify;
public string Justify
{
get
{
return LazyLoad(ref _Justify, "TabData/@Justify");
}
}
private LazyLoad<bool> _UsePreviousStyle;
public bool UsePreviousStyle
{
get
{
return LazyLoad(ref _UsePreviousStyle, "TabData/@UsePreviousStyle");
}
}
private LazyLoad<bool> _IsTransition;
public bool IsTransition
{
get
{
return LazyLoad(ref _IsTransition, "TabData/@IsTransition");
}
}
private LazyLoad<float?> _IdentWidth;
public float? IdentWidth
{
get
{
return LazyLoad(ref _IdentWidth, "TabData/@IdentWidth");
}
}
private LazyLoad<float?> _RNOAdjustTabSize;
public float? RNOAdjustTabSize
{
get
{
return LazyLoad(ref _RNOAdjustTabSize, "TabData/@RNOAdjustTabSize");
}
}
private LazyLoad<float?> _MacroTabAdjust;
public float? MacroTabAdjust
{
get
{
return LazyLoad(ref _MacroTabAdjust, "TabData/@MacroTabAdjust");
}
}
private VE_Font _Font;
public VE_Font Font
{
get
{
if (_Font == null)
{
XmlNode xn = vlnFormatDocument.LookupSingleStepNode(base.XmlNode, "TabData[Font]");
_Font = new VE_Font(xn);
}
return _Font;
}
}
private Bullet _Bullet;
public Bullet Bullet
{
get
{
return (_Bullet == null) ? _Bullet = new Bullet(base.XmlNode) : _Bullet;
}
}
private LazyLoad<bool> _NoTrim;
public bool NoTrim
{
get
{
return LazyLoad(ref _NoTrim, "TabData/@NoTrim");
}
}
private LazyLoad<bool> _UseEntireSectionNum;
public bool UseEntireSectionNum
{
get
{
return LazyLoad(ref _UseEntireSectionNum, "TabData/@UseEntireSectionNum");
}
}
}
#endregion
#region MacroList
[TypeConverter(typeof(vlnListConverter<MacroList, Macro>))]
public class MacroList : vlnNamedFormatList<Macro>
{
public MacroList(XmlNodeList xmlNodeList) : base(xmlNodeList, null) { }
public override vlnNamedFormatList<Macro> InheritedList
{
get
{
return null;
}
}
}
#endregion
#region Macro
[TypeConverter(typeof(ExpandableObjectConverter))]
public class Macro : vlnFormatItem, IVlnNamedFormatItem
{
public Macro(XmlNode xmlNode) : base(xmlNode) { }
public Macro() : base() { }
private LazyLoad<string> _Name;
public string Name
{
get
{
return LazyLoad(ref _Name, "@Name");
}
}
private LazyLoad<string> _MacroDef;
public string MacroDef
{
get
{
if (_Inherited == null) SetupStepInheritance();
return LazyLoad(ref _MacroDef, "@Macro");
}
}
private LazyLoad<string> _SingleColMacroDef;
public string SingleColMacroDef
{
get
{
if (_Inherited == null) SetupStepInheritance();
return LazyLoad(ref _SingleColMacroDef, "@SingleColMacro");
}
}
private LazyLoad<float?> _MacroXOffSet;
public float? MacroXOffSet
{
get
{
return LazyLoad(ref _MacroXOffSet, "@MacroXOffSet");
}
}
private LazyLoad<float?> _SingleColWidthAdjust;
public float? SingleColWidthAdjust
{
get
{
return LazyLoad(ref _SingleColWidthAdjust, "@SingleColWidthAdjust");
}
}
private LazyLoad<bool> _LocWithXOff;
public bool? LocWithXOff
{
get
{
return LazyLoad(ref _LocWithXOff, "@LocWithXOff");
}
}
private LazyLoad<int?> _Grouping;
public int? Grouping
{
get
{
if (_Inherited == null) SetupStepInheritance();
return LazyLoad(ref _Grouping, "@Grouping");
}
}
private LazyLoad<bool> _NotInRNO;
public bool NotInRNO
{
get
{
if (_Inherited == null) SetupStepInheritance();
return LazyLoad(ref _NotInRNO, "@NotInRNO");
}
}
private bool? _Inherited;
public bool Inherited
{
get
{
if (_Inherited == null) SetupStepInheritance();
return (bool) _Inherited;
}
}
private void SetupStepInheritance()
{
if (_Inherited != null) return;
LazyLoad<string> macroName = null;
_Inherited = (LazyLoad(ref macroName, "@Macro") == null);
// No MacroName, Find parent that has data
string path = string.Format("TabData/MacroList/Macro[@Name='{0}' and @Macro]", Name);
XmlNode xn = vlnFormatDocument.LookupSingleStepNode(XmlNode.ParentNode.ParentNode.ParentNode, path);
if (xn != null)
{
_MacroDef = new LazyLoad<string>(RetrieveString(xn.SelectSingleNode("@Macro")));
_Grouping = new LazyLoad<int?>(RetrieveInt("@Grouping" ,xn.SelectSingleNode("@Grouping")));
_NotInRNO = new LazyLoad<bool>(RetrieveBool( xn.SelectSingleNode("@NotInRNO")));
}
}
}
#endregion
#endregion
#region BoxDataAll
#region Box
[TypeConverter(typeof(ExpandableObjectConverter))]
public class Box : vlnFormatItem,IVlnIndexedFormatItem
{
public Box(XmlNode xmlNode) : base(xmlNode) { }
public Box() : base() { }
private LazyLoad<int?> _Index;
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
private LazyLoad<int?> _NumLines;
public int? NumLines // This was added to support 3 line box for VC Summer Alarms. It is only checked in 'double line' vlnbox.cs code!
{
get
{
return LazyLoad(ref _NumLines, "@NumLines");
}
}
private LazyLoad<float?> _Start;
public float? Start
{
get
{
return LazyLoad(ref _Start, "@Start");
}
}
private LazyLoad<float?> _End;
public float? End
{
get
{
return LazyLoad(ref _End, "@End");
}
}
private LazyLoad<float?> _TxtStart;
public float? TxtStart
{
get
{
return LazyLoad(ref _TxtStart, "@TxtStart");
}
}
private LazyLoad<float?> _TxtWidth;
public float? TxtWidth
{
get
{
return LazyLoad(ref _TxtWidth, "@TxtWidth");
}
}
private LazyLoad<float?> _Height;
public float? Height
{
get
{
return LazyLoad(ref _Height, "@Height");
}
}
private LazyLoad<float?> _TabPos;
public float? TabPos
{
get
{
return LazyLoad(ref _TabPos, "@TabPos");
}
}
private LazyLoad<int?> _TxtRowAdj;
public int? TxtRowAdj
{
get
{
return LazyLoad(ref _TxtRowAdj, "@TxtRowAdj");
}
}
private LazyLoad<bool> _ThickDouble; // F2021-026: Barakah single column 2 thick double lines around Warnings
public bool ThickDouble
{
get
{
return LazyLoad(ref _ThickDouble, "@ThickDouble");
}
}
private LazyLoad<string> _BXURC;
public string BXURC
{
get
{
return LazyLoad(ref _BXURC, "@BXURC");
}
}
private LazyLoad<string> _BXHorz;
public string BXHorz
{
get
{
return LazyLoad(ref _BXHorz, "@BXHorz");
}
}
private LazyLoad<string> _BXULC;
public string BXULC
{
get
{
return LazyLoad(ref _BXULC, "@BXULC");
}
}
private LazyLoad<string> _BXVert;
public string BXVert
{
get
{
return LazyLoad(ref _BXVert, "@BXVert");
}
}
private LazyLoad<string> _BXMLS;
public string BXMLS
{
get
{
return LazyLoad(ref _BXMLS, "@BXMLS");
}
}
private LazyLoad<string> _BXMRS;
public string BXMRS
{
get
{
return LazyLoad(ref _BXMRS, "@BXMRS");
}
}
private LazyLoad<string> _BXLRC;
public string BXLRC
{
get
{
return LazyLoad(ref _BXLRC, "@BXLRC");
}
}
private LazyLoad<string> _BXLLC;
public string BXLLC
{
get
{
return LazyLoad(ref _BXLLC, "@BXLLC");
}
}
private LazyLoad<string> _BXMID;
public string BXMID
{
get
{
return LazyLoad(ref _BXMID, "@BXMID");
}
}
private LazyLoad<string> _BXLHorz;
public string BXLHorz
{
get
{
return LazyLoad(ref _BXLHorz, "@BXLHorz");
}
}
private LazyLoad<string> _BXUMID;
public string BXUMID
{
get
{
return LazyLoad(ref _BXUMID, "@BXUMID");
}
}
private LazyLoad<string> _BXLMID;
public string BXLMID
{
get
{
return LazyLoad(ref _BXLMID, "@BXLMID");
}
}
private VE_Font _Font;
public VE_Font Font
{
get
{
return (_Font == null) ?_Font = new VE_Font(base.XmlNode):_Font;
}
}
public override string GetPDDisplayName()
{ return string.Format("[{0}]", Index); }
public override string GetPDCategory()
{ return "Box Definition"; }
public override string ToString()
{
return String.Format("{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}",
BXURC, BXHorz, BXULC, BXVert, BXMLS, BXMRS, BXLRC, BXLLC, BXMID, BXLHorz, BXUMID, BXLMID);
}
public string BoxStyle
{
get
{
return String.Format("{0}.{1}.{2}.{3}.{4}.{5}.{6}.{7}.{8}.{9}.{10}.{11}",
BXURC ?? " ", BXHorz ?? " ", BXULC ?? " ", BXVert ?? " ", BXMLS ?? " ", BXMRS ?? " ", BXLRC ?? " ", BXLLC ?? " ", BXMID ?? " ", BXLHorz ?? BXHorz, BXUMID ?? " ", BXLMID ?? " ");
}
}
}
#endregion
#region BoxList
[TypeConverter(typeof(vlnIndexedListConverter<BoxList, Box>))]
public class BoxList : vlnIndexedFormatList<Box>
{
public BoxList(XmlNodeList xmlNodeList, IFormatOrFormatInfo myFormat) : base(xmlNodeList, myFormat) { }
public override vlnIndexedFormatList<Box> InheritedList
{
get
{
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
if (parentFormat != null)
return parentFormat.PlantFormat.FormatData.BoxList;
return null;
}
}
}
#endregion
#endregion
#region TransDataAll
#region TransData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class TransData : vlnFormatItem
{
private TransTypeList _TransTypeList;
public TransTypeList TransTypeList
{
get
{
return(_TransTypeList == null || _TransTypeList.MaxIndex==0)? _TransTypeList = new TransTypeList(SelectNodes("TransTypeData/TransTypes"),MyFormat): _TransTypeList;
}
}
public TransData(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<string> _DelimiterForTransitionTitle;
public string DelimiterForTransitionTitle
{
get
{
return LazyLoad(ref _DelimiterForTransitionTitle, "@DelimiterForTransitionTitle");
}
}
private LazyLoad<string> _StepSubstepDelimeter;
public string StepSubstepDelimeter
{
get
{
return LazyLoad(ref _StepSubstepDelimeter, "@StepSubstepDelimeter");
}
}
private LazyLoad<string> _ThroughString;
public string ThroughString
{
get
{
return LazyLoad(ref _ThroughString, "@ThroughString");
}
}
private LazyLoad<bool> _SpecifiedSubstepsOnly;
public bool SpecifiedSubstepsOnly
{
get
{
return LazyLoad(ref _SpecifiedSubstepsOnly, "@SpecifiedSubstepsOnly");
}
}
private LazyLoad<bool> _CapsTransitions;
public bool CapsTransitions
{
get
{
return LazyLoad(ref _CapsTransitions, "@CapsTransitions");
}
}
private LazyLoad<bool> _CapsTransitionsSection;
public bool CapsTransitionsSection
{
get
{
return LazyLoad(ref _CapsTransitionsSection, "@CapsTransitionsSection");
}
}
private LazyLoad<bool> _CapTranStep;
public bool CapTranStep
{
get
{
return LazyLoad(ref _CapTranStep, "@CapTranStep");
}
}
private LazyLoad<bool> _Underline;
public bool Underline
{
get
{
return LazyLoad(ref _Underline, "@Underline");
}
}
private LazyLoad<bool> _TStepNoFlag;
public bool TStepNoFlag
{
get
{
return LazyLoad(ref _TStepNoFlag, "@TStepNoFlag");
}
}
private LazyLoad<bool> _LowerCaseTranNumber;
public bool LowerCaseTranNumber
{
get
{
return LazyLoad(ref _LowerCaseTranNumber, "@LowerCaseTranNumber");
}
}
private LazyLoad<bool> _UpcaseTranAnd;
public bool UpcaseTranAnd
{
get
{
return LazyLoad(ref _UpcaseTranAnd, "@UpcaseTranAnd");
}
}
private LazyLoad<bool> _SuppressAndInTran;
public bool SuppressAndInTran
{
get
{
return LazyLoad(ref _SuppressAndInTran, "@SuppressAndInTran");
}
}
private LazyLoad<bool> _Cap1stCharTrans;
public bool Cap1stCharTrans
{
get
{
return LazyLoad(ref _Cap1stCharTrans, "@Cap1stCharTrans");
}
}
private LazyLoad<bool> _Cap1stCharTransSection;
public bool Cap1stCharTransSection
{
get
{
return LazyLoad(ref _Cap1stCharTransSection, "@Cap1stCharTransSection");
}
}
private LazyLoad<bool> _UseTransitionModifier;
public bool UseTransitionModifier
{
get
{
return LazyLoad(ref _UseTransitionModifier, "@UseTransitionModifier");
}
}
private LazyLoad<bool> _UseSpecificTransitionModifier;
public bool UseSpecificTransitionModifier
{
get
{
return LazyLoad(ref _UseSpecificTransitionModifier, "@UseSpecificTransitionModifier");
}
}
private LazyLoad<bool> _UseSpecificPageNo;
public bool UseSpecificPageNo
{
get
{
return LazyLoad(ref _UseSpecificPageNo, "@UseSpecificPageNo");
}
}
private LazyLoad<bool> _UseSecTitles;
public bool UseSecTitles
{
get
{
return LazyLoad(ref _UseSecTitles, "@UseSecTitles");
}
}
private LazyLoad<bool> _DoSectionTransitions;
public bool DoSectionTransitions
{
get
{
return LazyLoad(ref _DoSectionTransitions, "@DoSectionTransitions");
}
}
private LazyLoad<bool> _NoDefaultSectReq;
public bool NoDefaultSectReq
{
get
{
return LazyLoad(ref _NoDefaultSectReq, "@NoDefaultSectReq");
}
}
private LazyLoad<bool> _AllowTransitionFromSection;
public bool AllowTransitionFromSection
{
get
{
return LazyLoad(ref _AllowTransitionFromSection, "@AllowTransitionFromSection");
}
}
private LazyLoad<bool> _HardSpTranProcNumb;
public bool HardSpTranProcNumb
{
get
{
return LazyLoad(ref _HardSpTranProcNumb, "@HardSpTranProcNumb");
}
}
private LazyLoad<bool> _XchngTranSpForHard;
public bool XchngTranSpForHard
{
get
{
return LazyLoad(ref _XchngTranSpForHard, "@XchngTranSpForHard");
}
}
private LazyLoad<bool> _AbsoluteTransitionUpdate;
public bool AbsoluteTransitionUpdate
{
get
{
return LazyLoad(ref _AbsoluteTransitionUpdate, "@AbsoluteTransitionUpdate");
}
}
private LazyLoad<bool> _LowerCaseStepInTran;
public bool LowerCaseStepInTran
{
get
{
return LazyLoad(ref _LowerCaseStepInTran, "@LowerCaseStepInTran");
}
}
private LazyLoad<bool> _BoldTransition;
public bool BoldTransition
{
get
{
return LazyLoad(ref _BoldTransition, "@BoldTransition");
}
}
private LazyLoad<bool> _BoldTransitionExceptHLS;
public bool BoldTransitionExceptHLS
{
get
{
return LazyLoad(ref _BoldTransitionExceptHLS, "@BoldTransitionExceptHLS");
}
}
// B2017-269 Don't bold transition if font for step is bold
private LazyLoad<bool> _BoldTransitionExceptBoldHLS;
public bool BoldTransitionExceptBoldHLS
{
get
{
return LazyLoad(ref _BoldTransitionExceptBoldHLS, "@BoldTransitionExceptBoldHLS");
}
}
private LazyLoad<bool> _AdjustStepTransitionText;
public bool AdjustStepTransitionText
{
get
{
return LazyLoad(ref _AdjustStepTransitionText, "@AdjustStepTransitionText");
}
}
//ProcLevelPCPC
private LazyLoad<bool> _ProcLevelPCPC;
public bool ProcLevelPCPC // B2022-004: Remove Proc PC/PC token from transition text
{
get
{
return LazyLoad(ref _ProcLevelPCPC, "@ProcLevelPCPC");
}
}
}
#endregion
#region TransType
[TypeConverter(typeof(ExpandableObjectConverter))]
public class TransType : vlnFormatItem,IVlnIndexedFormatItem
{
public TransType(XmlNode xmlNode) : base(xmlNode) { }
public TransType() : base() { }
private LazyLoad<int?> _Index;
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
private LazyLoad<int?> _Type;
public int? Type
{
get
{
return LazyLoad(ref _Type, "@TransType");
}
}
private LazyLoad<string> _TransFormat;
public string TransFormat
{
get
{
return LazyLoad(ref _TransFormat, "@TransFormat");
}
}
private LazyLoad<E_TransUI?> _TransUI;
public E_TransUI? TransUI
{
get
{
return LazyLoad<E_TransUI>(ref _TransUI, "@TransUI");
}
}
private LazyLoad<string> _TransMenu;
public string TransMenu
{
get
{
return LazyLoad(ref _TransMenu, "@TransMenu");
}
}
private LazyLoad<string> _UnitProcSetString; //B2019-072: For AEP, use PSI & SI for outside transition text
public string UnitProcSetString // this is format of string to preface transition with
{
get
{
return LazyLoad(ref _UnitProcSetString, "@UnitProcSetString");
}
}
public override string GetPDDisplayName()
{ return string.Format("[{0}] - Type {1}", Index, Type); }
public override string GetPDCategory()
{ return "Transition Type Data"; }
public override string ToString()
{
return string.Format("{0} - {1}",TransFormat, TransMenu);
}
}
#endregion
#region TransTypeList
[TypeConverter(typeof(vlnIndexedListConverter<TransTypeList, TransType>))]
public class TransTypeList : vlnIndexedFormatList<TransType>
{
public TransTypeList(XmlNodeList xmlNodeList, IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
public override vlnIndexedFormatList<TransType> InheritedList
{
get
{
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
if (parentFormat != null)
return parentFormat.PlantFormat.FormatData.TransData.TransTypeList;
return null;
}
}
}
#endregion
#region RoData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ROData : vlnFormatItem
{
public ROData(XmlNode xmlNode) : base(xmlNode) { }
private LazyLoad<bool> _AllUnits;
public bool AllUnits
{
get
{
return LazyLoad(ref _AllUnits, "@AllUnits");
}
}
private LazyLoad<bool> _UpRoAftrDash;
public bool UpRoAftrDash
{
get
{
return LazyLoad(ref _UpRoAftrDash, "@UpRoAftrDash");
}
}
private LazyLoad<bool> _UpRoImmAftrDashSpace;
public bool UpRoImmAftrDashSpace
{
get
{
return LazyLoad(ref _UpRoImmAftrDashSpace, "@UpRoImmAftrDashSpace");
}
}
private LazyLoad<bool> _UpcaseAllRoUnits;
public bool UpcaseAllRoUnits
{
get
{
return LazyLoad(ref _UpcaseAllRoUnits, "@UpcaseAllRoUnits");
}
}
private LazyLoad<bool> _CapHighRo;
public bool CapHighRo
{
get
{
return LazyLoad(ref _CapHighRo, "@CapHighRo");
}
}
private LazyLoad<bool> _CapRoIfLastLower;
public bool CapRoIfLastLower
{
get
{
return LazyLoad(ref _CapRoIfLastLower, "@CapRoIfLastLower");
}
}
private LazyLoad<bool> _CapSPIfLastLower;
public bool CapSPIfLastLower
{
get
{
return LazyLoad(ref _CapSPIfLastLower, "@CapSPIfLastLower");
}
}
private LazyLoad<bool> _UpRoIfPrevUpper;
public bool UpRoIfPrevUpper
{
get
{
return LazyLoad(ref _UpRoIfPrevUpper, "@UpRoIfPrevUpper");
}
}
private LazyLoad<bool> _UnderlineRo;
public bool UnderlineRo
{
get
{
return LazyLoad(ref _UnderlineRo, "@UnderlineRo");
}
}
private LazyLoad<bool> _CapFirstLetterInHighRO;
public bool CapFirstLetterInHighRO
{
get
{
return LazyLoad(ref _CapFirstLetterInHighRO, "@CapFirstLetterInHighRO");
}
}
private LazyLoad<bool> _DoSpaceDashBeforeROResolve;
public bool DoSpaceDashBeforeROResolve
{
get
{
return LazyLoad(ref _DoSpaceDashBeforeROResolve, "@DoSpaceDashBeforeROResolve");
}
}
}
#endregion
#endregion
#region SupportClasses
public class StepDataRetval
{
private string _Name;
public string Name
{
get { return _Name; }
set { _Name = value; }
}
private int _Index;
public int Index
{
get { return _Index; }
set { _Index = value; }
}
public StepDataRetval(string name, int index)
{
Name = name;
Index = index;
}
}
#endregion
}
Reference in New Issue View Git Blame Copy Permalink