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

6913 lines
202 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;
}
}
// Defines the printed page size (ex: US Letter, A4)
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; }
}
// gets the high level node that contains setting used in the procedure step editor
private EditData _EditData;
public EditData EditData
{
get
{
return _EditData == null ? _EditData = new EditData(SelectSingleNode("EditData")): _EditData;
}
}
// gets the high level node that contains settings used to generate PDFs (print)
private PrintData _PrintData;
public PrintData PrintData
{
get
{
return _PrintData == null? _PrintData = new PrintData(SelectSingleNode("PrintData")):_PrintData;
}
}
// get high level node containing settings used for both edit and print
private ProcData _ProcData;
public ProcData ProcData
{
get
{
return _ProcData == null? _ProcData = new ProcData(SelectSingleNode("ProcData")):_ProcData;
}
}
// get high level node containing settings pertraining to sections of a procedure
private SectData _SectData;
public SectData SectData
{
get
{
return _SectData == null? _SectData = new SectData(SelectSingleNode("SectData")):_SectData;
}
}
// get a list of box formatting information primarily used for Cautions, Notes, and Warnings.
private BoxList _BoxList;
public BoxList BoxList
{
get
{
return _BoxList == null? _BoxList = new BoxList(SelectNodes("BoxData/Box"),MyFormat):_BoxList;
}
set { _BoxList = value; }
}
// gets a list of trainsition formatting information for various types of transitions
private TransData _TransData;
public TransData TransData
{
get
{
return _TransData == null? _TransData = new TransData(SelectSingleNode("TransData")):_TransData;
}
}
// get format settings related to handling Referenced Object values
private ROData _ROData;
public ROData ROData
{
get
{
return _ROData == null ? _ROData = new ROData(SelectSingleNode("ROData")) : _ROData;
}
}
// gets a list containing all of the defined step types and step parts (high level, sub-steps, cations, notes, etc)
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) { }
// Defines the printed page size (ex: US Letter, A4)
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) { }
// 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) { }
// List of procedure descriptions (ProcDescr) inwhich we match the beginning of a procedure number
// in order to print procedure description text via a pagelist token
private ProcDescrList _ProcDescrList;
public ProcDescrList ProcDescrList
{
get
{
return _ProcDescrList == null? _ProcDescrList = new ProcDescrList(SelectNodes("ProcDescrList/ProcDescr")):_ProcDescrList;
}
}
// an offset value for the placement of step tabs used in a Supplemental Information section of SAMG procedures
// to allow space for a Note or Caution tab.
private LazyLoad<int?> _SupInfoTabOff;
public int? SupInfoTabOff
{
get
{
return LazyLoad(ref _SupInfoTabOff, "@SupInfoTabOff");
}
}
// Flag to determin if the parent tab is used as the first part of a supplemental info step/sub-step tab.
private LazyLoad<bool> _SupInfoIncludeParTab;
public bool SupInfoIncludeParTab
{
get
{
return LazyLoad(ref _SupInfoIncludeParTab, "@SupInfoIncludeParTab");
}
}
// Shift the hoizontal positon of a step by 12 if the supplemental Info step tab was going to print over step text
private LazyLoad<bool> _SupInfoAdjustXOffForLongTab;
public bool SupInfoAdjustXOffForLongTab
{
get
{
return LazyLoad(ref _SupInfoAdjustXOffForLongTab, "@SupInfoAdjustXOffForLongTab");
}
}
// flag to allow user to enter the procedure revision number, either a forward or back slash,
// then the revision date or revision text
private LazyLoad<bool> _DoRevDate;
public bool DoRevDate
{
get
{
return LazyLoad(ref _DoRevDate, "@DoRevDate");
}
}
// Print alternate foldout pages within a defined range of procedure step pages.
// You can have multiple Foldout Page sections within a procedure,
// each pertaining to a range of steps (ranges cannot overlap) - used by Shearon Harris
private LazyLoad<bool> _AlternateFloatingFoldout;
public bool AlternateFloatingFoldout
{
get
{
return LazyLoad(ref _AlternateFloatingFoldout, "@AlternateFloatingFoldout");
}
}
// Allows the user to identify a procedure section that is to be used as a foldout page
// that is printed on the backside of procedure step pages
private LazyLoad<bool> _SectionLevelFoldouts;
public bool SectionLevelFoldouts
{
get
{
return LazyLoad(ref _SectionLevelFoldouts, "@SectionLevelFoldouts");
}
}
// This will replace any forward or back slash character they may be in the procedures's PDF file name
// with the character defined in the plant's format file
private LazyLoad<string> _SlashReplace;
public string SlashReplace
{
get
{
return LazyLoad(ref _SlashReplace, "@SlashReplace");
}
}
// Flag - (flag is named incorrectly) when set allows user to append to the procedure's revision number,
// a backslash character followed by a revision date
private LazyLoad<bool> _RevDateWithForwardSlash;
public bool RevDateWithForwardSlash
{
get
{
return LazyLoad(ref _RevDateWithForwardSlash, "@RevDateWithForwardSlash");
}
}
// On the Working Draft Properties page, Turns on a text box for the user to enter in a unit number
// that is used on cover pages and in the page header - D.C. Cook and Calvert Cliffs formats
private LazyLoad<bool> _UnitNumber;
public bool UnitNumber
{
get
{
return LazyLoad(ref _UnitNumber, "@UnitNumber");
}
}
// Flag allow for using the UnitProcSetString transition defintion variable which will build
// a prefix to the referenced procedure number
// ex: UnitProcSetString ="{PSI:UNITCOM}-{SI:SETNAME}-{PSI:SETID|4023}-" will look for UNITCOM in
// the Procedure Specific Information, then SETNAME in the Set Specific Information (working draft),
// then the SETID in the Procedure Specific Information (or use 4023) if nothing is entered
private LazyLoad<bool> _OutSideTransSetName; //B2019-072: For AEP, use PSI & SI for outside transition text
public bool OutSideTransSetName
{
get
{
return LazyLoad(ref _OutSideTransSetName, "@OutSideTransSetName");
}
}
// For Calvert Cliffs, this allows for double letted step tabs, speical handling in Transitions,
// special pagination logic for their style of procedures
private LazyLoad<bool> _SpecialCaseCalvert;
public bool SpecialCaseCalvert
{
get
{
return LazyLoad(ref _SpecialCaseCalvert, "@SpecialCaseCalvert");
}
}
// Calvert Alarms have the top part of the alarm point page in single column, the the bottom part in two column.
// Also special processing of Note, Cautions and Warnings
private LazyLoad<bool> _SpecialCaseCalvertAlarm;
public bool SpecialCaseCalvertAlarm
{
get
{
return LazyLoad(ref _SpecialCaseCalvertAlarm, "@SpecialCaseCalvertAlarm");
}
}
// Special pagination logic to handle out of the ordinary procedure formating and steps with RNOs
// that go on for pages
private LazyLoad<bool> _SpecialCaseCalvertPagination;
public bool SpecialCaseCalvertPagination
{
get
{
return LazyLoad(ref _SpecialCaseCalvertPagination, "@SpecialCaseCalvertPagination");
}
}
// B2023-034 for use with Beaver Valley AOP format
// This allows for the use of the UseOnFirst docstyle setting on a mixture of sections and sub-sections
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");
}
}
// Format Flag enabling special formatting and printing of training materials - Wolf Creek Training format
private LazyLoad<bool> _WCNTraining;
public bool WCNTraining
{
get
{
return LazyLoad(ref _WCNTraining, "@WCNTraining");
}
}
// Only used in Calvert Cliffs Valve format - only supporting code checks to see
// if a note should be a footnote
private LazyLoad<bool> _HorizontalSubsteps;
public bool HorizontalSubsteps
{
get
{
return LazyLoad(ref _HorizontalSubsteps, "@HorizontalSubsteps");
}
}
// Doesn't reset the paglist for the first sub-section when printing
// - appears to be needed for plants with AP1000 procedures
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");
}
}
// F2021-033: Barakah Alarm: no blank line between HLS & first substep
private LazyLoad<bool> _NoBlankHlsAndFirstSub;
public bool NoBlankHlsAndFirstSub
{
get
{
return LazyLoad(ref _NoBlankHlsAndFirstSub, "@NoBlankHlsAndFirstSub");
}
}
// F2021-025: Barakah Alarm: no blank line between last Note/Caution/Warn & box line
private LazyLoad<bool> _NoBlankLastNoteCautionWarn;
public bool NoBlankLastNoteCautionWarn
{
get
{
return LazyLoad(ref _NoBlankLastNoteCautionWarn, "@NoBlankLastNoteCautionWarn");
}
}
// F2023-126: Vogtle Alarms - center single line caution/note if more than one type exist off step
private LazyLoad<bool> _NoteCautionCenterOneAllTypes;
public bool NoteCautionCenterOneAllTypes
{
get
{
return LazyLoad(ref _NoteCautionCenterOneAllTypes, "@NoteCautionCenterOneAllTypes");
}
}
// C2021-063 Barakah Alarm: check box to generate Alarm Point List Text
private LazyLoad<bool> _ChkBoxToGeneratePointListText;
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");
}
}
// Adjust the image size to better fit on the printed page
private LazyLoad<bool> _AdjustLargeImage;
public bool AdjustLargeImage
{
get
{
return LazyLoad(ref _AdjustLargeImage, "@AdjustLargeImage");
}
}
}
#endregion PrintData
#region ProcDescr
[TypeConverter(typeof(ExpandableObjectConverter))]
public partial class ProcDescr : vlnFormatItem //: BusinessBase<ProcDescr>, IDisposable
{
public ProcDescr(XmlNode xmlNode) : base(xmlNode) { }
public ProcDescr() : base() { }
// procedure number part (pattern) to match to find a description to use with the {PROCDESC} pagelist token
private LazyLoad<string> _MatchProcNumber;
public string MatchProcNumber
{
get
{
return LazyLoad(ref _MatchProcNumber, "@MatchProcNumber");
}
}
// The description text associated with a MatchProcNumber Text is used to replace the {PROCDES1} pagelist
private LazyLoad<string> _ProcDescr1;
public string ProcDescr1
{
get
{
return LazyLoad(ref _ProcDescr1, "@ProcDescr1");
}
}
// A second description text associated with a MatchProcNumber. Text is used to replace the {PROCDES2}
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 ProcDescrList
#endregion ProcDescr
#endregion PrintDataAll
#region ProcDataAll
#region ProcData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ProcData : vlnFormatItem
{
public ProcData(XmlNode xmlNode) : base(xmlNode) { }
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");
}
}
// specifies the maxiumn length of the procedure title before PROMS considers to wrap the title
// this is used with the {PROCTITLE} PageStyle toekn
private LazyLoad<int?> _TitleLength;
public int? TitleLength
{
get
{
return LazyLoad(ref _TitleLength, "@TitleLength");
}
}
// Length of the procedure title before wrapping on the Cover Page. T
// his is used with the {COVERPROCTITLE} PageSytle token
private LazyLoad<int?> _CoverTitleLength;
public int? CoverTitleLength
{
get
{
return LazyLoad(ref _CoverTitleLength, "@CoverTitleLength");
}
}
// Uppercase the procedure title when printed
private LazyLoad<bool> _CapitalizeTitle;
public bool CapitalizeTitle
{
get
{
return LazyLoad(ref _CapitalizeTitle, "@CapitalizeTitle");
}
}
// If a procedure or section does not have a title PROMS puts in "<NO TITLE>" as default title text
// by default (base format) PROMS will print "<NO TITLE>"
// When set to False, this flag prevents PROMS printing the text "<NO TITLE>"
// This also affects transiton references
private LazyLoad<bool> _PrintNoTitle;
public bool PrintNoTitle
{
get
{
return LazyLoad(ref _PrintNoTitle, "@PrintNoTitle");
}
}
// This will print Notes at the bottom of the page as footnotes
// Use by Calvert Cliffs (BGE) primarily for their landscaped valve sections
private LazyLoad<bool> _NotesToFootnotes;
public bool NotesToFootnotes
{
get
{
return LazyLoad(ref _NotesToFootnotes, "@NotesToFootnotes");
}
}
// C2021-027: Procedure level PC/PC
// This allows us to assign an entire procedure's applicability level
// instead of just the sections and steps
private LazyLoad<bool> _ProcAppl;
public bool ProcAppl
{
get
{
return LazyLoad(ref _ProcAppl, "@ProcAppl");
}
}
}
#endregion
#region PsiAll
[TypeConverter(typeof(ExpandableObjectConverter))]
public class PSI : vlnFormatItem
{
// Procedure Specific Information (context menu from a procedure in the tree view)
// Will create a window based on the settings in the plant's format file
// Allows for procedure specific information that is printed via the format file's
// PageList structure. Used for procedure specific text in page headers
// and cover pages (i.e. signaure names, dates, Use Categories)
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;
// caption for the PSI window
public string Caption
{
get
{
return LazyLoad(ref _Caption, "@Caption");
}
}
private LazyLoad<string> _ButtonsOnBottom; // change to bool
// place the OK and Cancel buttons on the bottom of the PSI window
public string ButtonsOnBottom
{
get
{
return LazyLoad(ref _ButtonsOnBottom, "@ButtonsOnBottom");
}
}
// returns a list of labels that are defined in the format's PSI structure
private SILabels _LabelList;
public SILabels LabelList
{
get
{
return _LabelList == null ? _LabelList = new SILabels(SelectNodes("/PlantFormat/FormatData/ProcData/PSI/Label")) : _LabelList;
}
}
// returns a list of fields that are defined in the format's PSI structure
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) { }
}
// PSI label class
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) { }
}
// PSI field class
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
// classes to handle Set Specific information
// Same as PSI but accessable only from the Working draft tree node
[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");
}
}
// caption for the the Set Specific information window
private LazyLoad<string> _Caption;
public string Caption
{
get
{
return LazyLoad(ref _Caption, "@Caption");
}
}
// the the OK and Cancel buttons on the bottom of the SI Window
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;
}
// This is used with the {INITIALS} pagelist token and will put the word "INITIALS" at the specified pagelist
// location for the checkoff column header. Used by Calvert Cliffs (BGEOI and BGESTP formats)
private LazyLoad<bool> _CheckOffHeaderInPagelist;
public bool CheckOffHeaderInPagelist
{
get
{
return LazyLoad(ref _CheckOffHeaderInPagelist, "@CheckOffHeaderInPagelist");
}
}
// Menu heading for checkoffs/signoffs. When this is set to "Signoff", the checkoff list is not enabled
private LazyLoad<string> _Menu;
public string Menu
{
get
{
return LazyLoad(ref _Menu, "@Menu");
}
}
// this will make room on the page for checkoffs by adjusting the step text width. Used for cases where there isn't
// a checkoff header (we adjust step text width when a checkoff header is printed)
private LazyLoad<float?> _CheckOffAdjustment;
public float? CheckOffAdjustment
{
get
{
return LazyLoad(ref _CheckOffAdjustment, "@CheckOffAdjustment");
}
}
// used for checkoff (initial line) next to the step number tab. the XLocation number is added to the left margin
private LazyLoad<float?> _XLocation;
public float? XLocation
{
get
{
return LazyLoad(ref _XLocation, "@XLocation");
}
}
// relative location of the checkoff based on the text width and its location on the page
private LazyLoad<float?> _RelXLocation;
public float? RelXLocation
{
get
{
return LazyLoad(ref _RelXLocation, "@RelXLocation");
}
}
//Start printing the checkoff on the last line of the step text (when set here applies to all checkofs)
private LazyLoad<bool> _DropCheckOff;
public bool DropCheckOff
{
get
{
return LazyLoad(ref _DropCheckOff, "@DropCheckOff");
}
}
// put checkoff only on High Level Steps
private LazyLoad<bool> _CheckOffOnHLSOnly;
public bool CheckOffOnHLSOnly
{
get
{
return LazyLoad(ref _CheckOffOnHLSOnly, "@CheckOffOnHLSOnly");
}
}
// SkipSpaces puts the checkoff macro (if specified in the format) next to the step tab
// the print logic looks at the step tab and skips (backwards) the lenth (width) of the tab
// to position the checkoff
// - this is used for Bryon and Braidwood
private LazyLoad<bool> _SkipSpaces;
public bool SkipSpaces
{
get
{
return LazyLoad(ref _SkipSpaces, "@SkipSpaces");
}
}
// put in for Bryon and Braidwood
// enables the selection of a checkoff only when on a sub-step type
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");
}
}
// C2020-003 used to sort list of checkoffs in the combo box
// a foat number can be used (ex 2.75) to fine tune the sorting
private LazyLoad<float?> _OrderBy;
public float? OrderBy
{
get
{
return LazyLoad(ref _OrderBy, "@OrderBy");
}
}
// User Interface Mark (UIMark) is the deimal number of an ASCII character that is desplayed in the step editor
// to indicate the selected checkoff
private LazyLoad<int?> _UIMark;
public int? UIMark
{
get
{
return LazyLoad(ref _UIMark, "@UIMark");
}
}
// If a positive numer, start the checkoff that number of lines minus one down from the start of the text
// and add that many lines after.
// If it's negative number, start the checkoff on the same line as the text
// and add positive of that number of lines after the checkoff macro. (see vlnPaaragraph.cs)
private LazyLoad<float?> _CheckOffXtraLines;
public float? CheckOffXtraLines
{
get
{
return LazyLoad(ref _CheckOffXtraLines, "@CheckOffXtraLines");
}
}
// Add blank lines to make room for loner signoffs (checkoffs)
private LazyLoad<float?> _CheckOffNumberOfLines;
public float? CheckOffNumberOfLines
{
get
{
return LazyLoad(ref _CheckOffNumberOfLines, "@CheckOffNumberOfLines");
}
}
//Descriptive text shown in the checkoff selection list
private LazyLoad<string> _MenuItem;
public string MenuItem
{
get
{
return LazyLoad(ref _MenuItem, "@MenuItem");
}
}
// Name of the macro defined in the correspoinding SVG (GenMac) file.
// The print logic uese this macro to draw the checkoff
private LazyLoad<string> _Macro;
public string Macro
{
get
{
return LazyLoad(ref _Macro, "@Macro");
}
}
//Don<6F>t' print the checkoff if the step text is empty (all spaces or hardspaces)
private LazyLoad<bool> _NotOnEmpty;
public bool NotOnEmpty
{
get
{
return LazyLoad(ref _NotOnEmpty, "@NotOnEmpty");
}
}
// Start printing the checkoff on the last line of the step text (applies to just this checkoff)
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
{
// Column header for the printed checkoff column
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);
}
}
// the checkoff column heading text (when printed)
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) { }
// Comma separated list of column positions for each of the change bar types:
// With Text
// Outside Box
// AER on LEFT, RNO on Right
// To the Left of Text
private LazyLoad<string> _DefaultCBLoc;
public string DefaultCBLoc
{
get
{
return LazyLoad(ref _DefaultCBLoc, "@DefaultCBLoc");
}
}
// text that is place next to the change bar
// DateChgID (Date and Change ID)
// RevNum (Revision Number)
// ChgID (Change ID)
// None (No Change Bar Message)
// UserDef (User Defined Message)
private LazyLoad<string> _ChangeBarMessage;
public string ChangeBarMessage
{
get
{
return LazyLoad(ref _ChangeBarMessage, "@ChangeBarMessage");
}
}
// FixedChangeColumn + - Column location for change bars
// 0 - Separate AER and RNO change bars to the right of the text
// -10 to -1 - Change bars on left (specify # of columns from the text)
// <-10 - AER change bars on the left and RNO change bars on the right.
private LazyLoad<int?> _FixedChangeColumn;
public int? FixedChangeColumn
{
get
{
return LazyLoad(ref _FixedChangeColumn, "@FixedChangeColumn");
}
}
// specific location of change bars for text in AER column
// - appears to be used when FixedChageColumn is set to a number <-10
private LazyLoad<int?> _FixedAERChangeColumn;
public int? FixedAERChangeColumn
{
get
{
return LazyLoad(ref _FixedAERChangeColumn, "@FixedAERChangeColumn");
}
}
// if the format has the absolutefixedchangecolumn format flag, then always use the fixedchangecolumn from the
// format, otherwise, use the default column based on the selected location, stored in the base format.
private LazyLoad<bool> _AbsoluteFixedChangeColumn;
public bool AbsoluteFixedChangeColumn
{
get
{
return LazyLoad(ref _AbsoluteFixedChangeColumn, "@AbsoluteFixedChangeColumn");
}
}
// Continue the change bar through the blank lines for consectutive changed steps
private LazyLoad<bool> _ContinuousChangeBars;
public bool ContinuousChangeBars
{
get
{
return LazyLoad(ref _ContinuousChangeBars, "@ContinuousChangeBars");
}
}
// will allow user to type in a change ID text to be placed next to the the change bar for the piece of changed text
// user is prompted to enter a change ID when opening a procedure.
// A Change ID tab i placed on the procedure editor ribbon to allow the user to modify the change id entered
// upon opening the procedure
// an option on the step properties pannel allows user to modify the change id text for that piece of changed text.
private LazyLoad<bool> _ChangeIds;
public bool ChangeIds
{
get
{
return LazyLoad(ref _ChangeIds, "@ChangeIds");
}
}
// extend the change bar that is on the last RNO step down to the RNO separator
// (only a couple plants and a RNO separator)
private LazyLoad<bool> _ChangeBarToRNOSep;
public bool ChangeBarToRNOSep
{
get
{
return LazyLoad(ref _ChangeBarToRNOSep, "@ChangeBarToRNOSep");
}
}
// don't do one continuous change bar when there are multiple Notes or Caution types next to each other
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) { }
// contains settings for when(if) the procedure's section number is printed on the page (controled by checkbox
// on section property page)
private SectionNumber _SectionNumber;
public SectionNumber SectionNumber
{
get
{
if (_SectionNumber == null) _SectionNumber = new SectionNumber(SelectSingleNode("SectionNumber"));
return _SectionNumber;
}
}
// contains setting for when (if) the procedure's section title (section header) is printed (controled by checkbox
// on section property page)
private SectionHeader _SectionHeader;
public SectionHeader SectionHeader
{
get
{
if (_SectionHeader == null) _SectionHeader = new SectionHeader(SelectSingleNode("SectionHeader"));
return _SectionHeader;
}
}
// this contains a start position and length of a line that will be drawn at the end of a section - WCNTRN
private SectionHeaderSeparatorLine _SectionHeaderSeparatorLine;
public SectionHeaderSeparatorLine SectionHeaderSeparatorLine
{
get
{
if (_SectionHeaderSeparatorLine == null) _SectionHeaderSeparatorLine = new SectionHeaderSeparatorLine(SelectSingleNode("SectionHeaderSeparatorLine"));
return _SectionHeaderSeparatorLine;
}
}
// contains settings pertaining to the PROMS Step Sections (non-Word sections)
private StepSectionData _StepSectionData;
public StepSectionData StepSectionData
{
get
{
if (_StepSectionData == null) _StepSectionData = new StepSectionData(SelectSingleNode("StepSectionData"));
return _StepSectionData;
}
}
// contains settings pertaining to Word Editor section types
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; }
}
// The maxium length of section titles before PROMS will split it onto another line
// - used when section titles are printed via pagelist
private LazyLoad<int?> _SectionTitleLength;
public int? SectionTitleLength
{
get
{
return LazyLoad(ref _SectionTitleLength, "@SectionTitleLength");
}
}
// The maxium length of the section number plus the section title before PROMS will split it onto another line
// - used when section number and title are printed on the same line via pagelist
private LazyLoad<int?> _SectionNumberAndTitleLength;
public int? SectionNumberAndTitleLength
{
get
{
return LazyLoad(ref _SectionNumberAndTitleLength, "@SectionNumberAndTitleLength");
}
}
// The maxium length of the section number plus the section title before PROMS will split it onto another line
// - used when section number and title are printed on the same line via pagelist
// - used for landscaped sections
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");
}
}
// flag to determine if the ReplaceWords logic will be run on non-Setpoint RO values
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");
}
}
// When set to true, turns on the option to add sub-sections to non-Word sections
private LazyLoad<bool> _UseMetaSections;
public bool UseMetaSections
{
get
{
return LazyLoad(ref _UseMetaSections, "@UseMetaSections");
}
}
// when printing count the sub-section level towards the step level
// - works only when the TieTabToLevel format flag is also true
private LazyLoad<bool> _CountSubSectionsForLevel;
public bool CountSubSectionsForLevel
{
get
{
return LazyLoad(ref _CountSubSectionsForLevel, "@CountSubSectionsForLevel");
}
}
// prints a list of phone numbers at the bottom of the page
// - Calvert Cliffs
private LazyLoad<bool> _PrintPhoneList;
public bool PrintPhoneList
{
get
{
return LazyLoad(ref _PrintPhoneList, "@PrintPhoneList");
}
}
// Set the default to NO for the automatic Indent of sub sections (this a a check box on the section properties page)
private LazyLoad<bool> _DefaultNoSubAutoIndent;
public bool DefaultNoSubAutoIndent
{
get
{
return LazyLoad(ref _DefaultNoSubAutoIndent, "@DefaultNoSubAutoIndent");
}
}
// convert the caret (^) to he delta symbol in Referenced Objects (RO) return values
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 "+-" to plus/minus symbol 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.
// was put in Barakah (BNPP) but found issue when RO was in a PROMS table cell,
// logic was added to no do this convert if in a table.
// BNPP decided to turned it off in altogether in their format files.
private LazyLoad<bool> _UseDashGreaterLessThenForArrowsInROValue;
public bool UseDashGreaterLessThenForArrowsInROValue
{
get
{
return LazyLoad(ref _UseDashGreaterLessThenForArrowsInROValue, "@UseDashGreaterLessThenForArrowsInROValue");
}
}
// Use only for RO return values placed in Word sections, the underbar character '_'
// will toggle underlining ON/OFF in the RO return value text
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() { }
// starting position from the left margin inwhich to place the section number
private LazyLoad<float?> _Pos;
public float? Pos
{
get
{
return LazyLoad(ref _Pos, "@Pos");
}
}
// Left (PSLeft), Center (PSCenter)
// justification of the text for the starting position (Pos)
private LazyLoad<string> _Just;
public string Just
{
get
{
return LazyLoad(ref _Just, "@Just");
}
}
// only for a first level section, print using a font size of 14 and sytle of bold
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() { }
// starting position from the left margin inwhich to place the section number
private LazyLoad<float?> _Pos;
public float? Pos
{
get
{
return LazyLoad(ref _Pos, "@Pos");
}
}
// Left (PSLeft), Center (PSCenter)
// justification of the text for the starting position (Pos)
private LazyLoad<string> _Just;
public string Just
{
get
{
return LazyLoad(ref _Just, "@Just");
}
}
// only for a first level section, print using a font size of 14 and sytle of bold
private LazyLoad<bool> _Level0Big;
public bool Level0Big
{
get
{
return LazyLoad(ref _Level0Big, "@Level0Big");
}
}
// Turn off underlining of section title for sub-sections
private LazyLoad<bool> _OnlyUnderlineTopSect;
public bool OnlyUnderlineTopSect
{
get
{
return LazyLoad(ref _OnlyUnderlineTopSect, "@OnlyUnderlineTopSect");
}
}
//Turn off bolding of section title for sub-sections
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() { }
// starting position, from the left margin, of the sparator line
private LazyLoad<float?> _XStartPos;
public float? XStartPos
{
get
{
return LazyLoad(ref _XStartPos, "@XStartPos");
}
}
// Length of the spearator line
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 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;
}
}
// a list of the sequential tab formatting based on the level of the step/sub-step
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;
}
}
// indent character used in RTF
// base format has this set to "0" which the code that uses this will resign this to "\x5"
private LazyLoad<string> _IndentToken;
public string IndentToken
{
get
{
return LazyLoad(ref _IndentToken, "@IndentToken");
}
}
// this is the default bullet character used for sub-step types that are indented and then use a bullet as the
// sub-step tab. Base format has this as a solid bullet (ascii character number 7),
// other plants use lower cased 'o' for an open bullet.
private LazyLoad<string> _IdentB;
public string IdentB
{
get
{
return LazyLoad(ref _IdentB, "@IdentB");
}
}
// special step tabbing and print formatting for enhanced background documennts
// - required by Wolf Creek's background format.
private LazyLoad<bool> _WolfCreekBackgroundFormat;
public bool WolfCreekBackgroundFormat
{
get
{
return LazyLoad(ref _WolfCreekBackgroundFormat, "@WolfCreekBackgroundFormat");
}
}
// special formatting of steps and sub-steps to create an on the fly table when printed
private LazyLoad<bool> _WolfcreekCKLFormat;
public bool WolfcreekCKLFormat
{
get
{
return LazyLoad(ref _WolfcreekCKLFormat, "@WolfcreekCKLFormat");
}
}
// special formatting Vogtle Unit 3 and 4 Backgrounds: allows use of override width on AND and List sub-step types,
// and the calculation of the width of the paragraph sub-step type
private LazyLoad<bool> _Vogtle3and4BackgroundFormat;
public bool Vogtle3and4BackgroundFormat
{
get
{
return LazyLoad(ref _Vogtle3and4BackgroundFormat, "@Vogtle3and4BackgroundFormat");
}
}
// This translates into nx10x10y where y is superscripted.
// For example, .E3 -> x103 where 3 is superscripted
// and 10.E5 -> 10x10-5 where 5 is superscripted
private LazyLoad<bool> _FortranFormatNumbers;
public bool FortranFormatNumbers
{
get
{
return LazyLoad(ref _FortranFormatNumbers, "@FortranFormatNumbers");
}
}
// FloatingContinueMessage format flag:
// if breaking at the AER put continue message in left column,
// if breaking RNO put continue message in Right column.
private LazyLoad<bool> _FloatingContinueMessage;
public bool FloatingContinueMessage
{
get
{
return LazyLoad(ref _FloatingContinueMessage, "@FloatingContinueMessage");
}
}
// used when section title is not printed via the pagelist, will print the title with "continued"
// appended to it when the section print multiple pages
private LazyLoad<bool> _ContinueSectionHeader;
public bool ContinueSectionHeader
{
get
{
return LazyLoad(ref _ContinueSectionHeader, "@ContinueSectionHeader");
}
}
// the font size of the text that is sub-scripted is made smaller
private LazyLoad<bool> _CompressHPSub;
public bool CompressHPSub
{
get
{
return LazyLoad(ref _CompressHPSub, "@CompressHPSub");
}
}
// the font size of the text that is super-scripted is made smaller
private LazyLoad<bool> _CompressHPSuper;
public bool CompressHPSuper
{
get
{
return LazyLoad(ref _CompressHPSuper, "@CompressHPSuper");
}
}
// special handling of super and sub scripts when the font is a proportial font
private LazyLoad<bool> _CompressPropSubSup;
public bool CompressPropSubSup
{
get
{
return LazyLoad(ref _CompressPropSubSup, "@CompressPropSubSup");
}
}
// 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");
}
}
// ImperfectStructure is used so that the sequential numbering for substeps under an RNO is not same
// numbering (alpha vs numeric), if the HLS has substeps - WCN uses this, as well as other plants.
// skips the step tab level ahead by 2 more
private LazyLoad<bool> _ImperfectStructure;
public bool ImperfectStructure
{
get
{
return LazyLoad(ref _ImperfectStructure, "@ImperfectStructure");
}
}
// like imperfectStructure, but only for the first level RNO
private LazyLoad<bool> _ImperfectSubstep;
public bool ImperfectSubstep
{
get
{
return LazyLoad(ref _ImperfectSubstep, "@ImperfectSubstep");
}
}
// used with ImperfectStructure, skips the step tab level ahead by 2 more (for a total of 4)
private LazyLoad<bool> _ImperfectStructurePlus4;
public bool ImperfectStructurePlus4
{
get
{
return LazyLoad(ref _ImperfectStructurePlus4, "@ImperfectStructurePlus4");
}
}
// When the sub-step tab include it's parent tab, this flag will ignor any step/sub-step tabs that are not a number or letter
private LazyLoad<bool> _SkipNonSeqTabWithPar;
public bool SkipNonSeqTabWithPar
{
get
{
return LazyLoad(ref _SkipNonSeqTabWithPar, "@SkipNonSeqTabWithPar");
}
}
// when determining the sub-step level (for tabs and printing), count only sequential sub-steps (excluding RNOs, Cautions, and Notes
private LazyLoad<bool> _CountAllSubLevels;
public bool CountAllSubLevels
{
get
{
return LazyLoad(ref _CountAllSubLevels, "@CountAllSubLevels");
}
}
// don't reset (remove) the indent (RTF indent char) on step text when there are hard returns
private LazyLoad<bool> _DontResetIndentOnNewline;
public bool DontResetIndentOnNewline
{
get
{
return LazyLoad(ref _DontResetIndentOnNewline, "@DontResetIndentOnNewline");
}
}
// C2018-024 I in Arial font changed to I in TimesNewRoman
// put in for McGuire (MCGall format)
private LazyLoad<bool> _ChangeFontUpperCaseIinArial;
public bool ChangeFontUpperCaseIinArial
{
get
{
return LazyLoad(ref _ChangeFontUpperCaseIinArial, "@ChangeFontUpperCaseIinArial");
}
}
// F2024-080 South Texas
// Used to show if "Initial Line Disable" checkbox should show in the DisplayTab
private LazyLoad<bool> _ShowInitialLineDisable;
public bool ShowInitialLineDisable
{
get
{
return LazyLoad(ref _ShowInitialLineDisable, "@ShowInitialLineDisable");
}
}
}
#endregion - StepSectionData
#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 - TextTypeValue
#region TextTypeValueList
[TypeConverter(typeof(vlnListConverter<TextTypeValueList, TextTypeValue>))]
public class TextTypeValueList : vlnFormatList<TextTypeValue>
{
public TextTypeValueList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion - TextTypeValueList
#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 - TextType
#region TextTypeList
[TypeConverter(typeof(vlnListConverter<TextTypeList, TextType>))]
public class TextTypeList : vlnFormatList<TextType>
{
public TextTypeList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion - TextTypeList
#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 - UnderlineTerminate
#region UnderlineTerminateList
[TypeConverter(typeof(vlnListConverter<UnderlineTerminateList, UnderlineTerminate>))]
public class UnderlineTerminateList : vlnFormatList<UnderlineTerminate>
{
public UnderlineTerminateList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion - UnderlineTerminateList
#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 - ObserveNCString1
#region ObserveNCString1List
[TypeConverter(typeof(vlnListConverter<ObserveNCString1List, ObserveNCString1>))]
public class ObserveNCString1List : vlnFormatList<ObserveNCString1>
{
public ObserveNCString1List(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion - ObserveNCString1List
#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 - ObserveNCString2
#region ObserveNCString2List
[TypeConverter(typeof(vlnListConverter<ObserveNCString2List, ObserveNCString2>))]
public class ObserveNCString2List : vlnFormatList<ObserveNCString2>
{
public ObserveNCString2List(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion - ObserveNCString2List
#region ReplaceStr
// ReplaceStr is a ReplaceStrData item containing the string to find and the string to replace it
// it also has flags to control where the replacements are allows (high level step, sub-steps, etc)
// ex: <ReplaceStr Flag="High, RNO, Caution, Note, Table, Substep, Attach" ReplaceWord="IF" ReplaceWith="\ul IF\ulnone " />
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ReplaceStr : vlnFormatItem
{
public ReplaceStr(XmlNode xmlNode) : base(xmlNode) { }
public ReplaceStr() : base() { }
[Category("Strings")]
// the string what will be replaced
private LazyLoad<string> _ReplaceWord;
public string ReplaceWord
{
get
{
return LazyLoad(ref _ReplaceWord, "@ReplaceWord");
}
}
[Category("Strings")]
// string to use for the replacement
private LazyLoad<string> _ReplaceWith;
public string ReplaceWith
{
get
{
return LazyLoad(ref _ReplaceWith, "@ReplaceWith");
}
}
// flags to control where the replacement is allowed:
// ex: "High, RNO, Caution, Note, Table, Substep, Attach"
// see E_ReplaceFlags in "CSLA.Library\Format\ENums.cs" for the complete list
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 - ReplaceStr
#region ReplaceStrList
[TypeConverter(typeof(vlnListConverter<ReplaceStrList, ReplaceStr>))]
public class ReplaceStrList : vlnFormatList<ReplaceStr>
{
public ReplaceStrList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#endregion - ReplaceStrList
#region ReplaceChar
// Information to replace a symbol character with a new size and/or a difference symbol
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ReplaceChar : vlnFormatItem, IVlnIndexedFormatItem
{
public ReplaceChar(XmlNode xmlNode) : base(xmlNode) { }
public ReplaceChar() : base() { }
// A unique index number for this symbol list
private LazyLoad<int?> _Index;
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
[Category("Strings")]
//The Unicode number of the symbol we are replacing
private LazyLoad<string> _Unicode;
public string Unicode
{
get
{
return LazyLoad(ref _Unicode, "@Unicode");
}
}
[Category("Strings")]
//The Unicode number of the symbol we want to use instead (this is optional)
private LazyLoad<string> _Replace;
public string Replace
{
get
{
return LazyLoad(ref _Replace, "@Replace");
}
}
[Category("Strings")]
// The font family of the replacement symbol character (this is optional)
private LazyLoad<string> _Family;
public string Family
{
get
{
return LazyLoad(ref _Family, "@Family");
}
}
[Category("FontStyle?")]
// the font style for the symbol character (bold, Italics, Underline) - this is optional
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?")]
// The font size of the replacement symbol character (this is optional)
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 - ReplaceChar
#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 - ReplaceSymbolCharList
#region StepSectionLayoutData
public class StepSectionLayoutData : vlnFormatItem
{
public StepSectionLayoutData(XmlNode xmlNode) : base(xmlNode) { }
// the font and placement settings for the separator words used for OR the sub-steps
// and the Explicit And sub-steps
private Separator _Separator;
public Separator Separator
{
get
{
return (_Separator == null) ? _Separator = new Separator(SelectSingleNode("Separator")) : _Separator;
}
}
// the size of a tab in points. If not set, then 6 points will be used.
// note - don't add and set this to Base format, some code check for no value set
private LazyLoad<float?> _TabPtsPerChar;
public float? TabPtsPerChar
{
get
{
return LazyLoad(ref _TabPtsPerChar, "@TabPtsPerChar");
}
}
// will define the placement of Notes, Cautions, and Warning with repect to the step they apply
// value is a string containing a list of StepData Index numbers for the defined Cautions and Notes types - a Warning is a redifined Caution or Note
private LazyLoad<string> _CautionNoteOrder;
public string CautionNoteOrder
{
get
{
return LazyLoad(ref _CautionNoteOrder, "@CautionNoteOrder");
}
}
// starting position for High Level step text from the left margin
private LazyLoad<float?> _ColS;
public float? ColS
{
get
{
return LazyLoad(ref _ColS, "@ColS");
}
}
// starting positon for cautions and notes that do not have a border (box format associated to it)
private LazyLoad<float?> _ColT;
public float? ColT
{
get
{
return LazyLoad(ref _ColT, "@ColT");
}
}
// Width of Text (note/caution) fields. This is overridden by BxTxtWidth, if the text is boxed.
private LazyLoad<float?> _WidT;
public float? WidT
{
get
{
return LazyLoad(ref _WidT, "@WidT");
}
}
// default column mode of the step editor sections - used in Section Properties
// if PMode is zero, the default column mode is two column
private LazyLoad<int?> _PMode;
public int? PMode
{
get
{
return LazyLoad(ref _PMode, "@PMode");
}
}
// default column mode of the step editor sections - used in Procedure Properties
private LazyLoad<int?> _ColumnMode;
public int? ColumnMode
{
get
{
return LazyLoad(ref _ColumnMode, "@ColumnMode");
}
}
// set the width of RNO text to be same as its parent - put in for V.C. Summer (SUM formats)
private LazyLoad<bool> _RNOWidthSameAsHighParent;
public bool RNOWidthSameAsHighParent
{
get
{
return LazyLoad(ref _RNOWidthSameAsHighParent, "@RNOWidthSameAsHighParent");
}
}
// used with the RNOWidthSameAsHighParent flag, is width value if this is the top RNO (parent RNO)
// - put in for V.C. Summer (SUM formats)
private LazyLoad<float?> _SingleColumnRNOIndent;
public float? SingleColumnRNOIndent
{
get
{
return LazyLoad(ref _SingleColumnRNOIndent, "@SingleColumnRNOIndent");
}
}
// B2020-140 for Wolf Creek check boxes in tables were printing too high in the table cells - added format variable to overide topPlacementAdjust (WCN format files)
private LazyLoad<int?> _OverrideTableTopIndent;
public int? OverrideTableTopIndent
{
get
{
return LazyLoad(ref _OverrideTableTopIndent, "@OverrideTableTopIndent");
}
}
// the space between columns of the procedure text (between AER and RNO columns)
private LazyLoad<string> _ColRTable;
public string ColRTable
{
get
{
return LazyLoad(ref _ColRTable, "@ColRTable");
}
}
// the high level step text width, in the PROMS editor, based on on many columns the procedure has
private LazyLoad<string> _WidSTableEdit;
public string WidSTableEdit
{
get
{
return LazyLoad(ref _WidSTableEdit, "@WidSTableEdit");
}
}
// the high level step text width, when printed, based on on many columns the procedure has
private LazyLoad<string> _WidSTablePrint;
public string WidSTablePrint
{
get
{
return LazyLoad(ref _WidSTablePrint, "@WidSTablePrint");
}
}
// Adjust the RNO width off the high level step
private LazyLoad<string> _RNOWidthAlt;
public string RNOWidthAlt
{
get
{
return LazyLoad(ref _RNOWidthAlt, "@RNOWidthAlt");
}
}
// adjust the RNO width for all RNOs - D.C. Cook (AEP formats)
private LazyLoad<int?> _RNOWidthAltAll;
public int? RNOWidthAltAll
{
get
{
return LazyLoad(ref _RNOWidthAltAll, "@RNOWidthAltAll");
}
}
// adjust the width of the RNO off of an AER sub-step
private LazyLoad<string> _RNOWidthAdj;
public string RNOWidthAdj
{
get
{
return LazyLoad(ref _RNOWidthAdj, "@RNOWidthAdj");
}
}
// Use the parent's RNO indent
private LazyLoad<string> _UseRNOParentIdent;
public string UseRNOParentIdent
{
get
{
return LazyLoad(ref _UseRNOParentIdent, "@UseRNOParentIdent");
}
}
// Adjusts the placement of the Note and Caution tabs in deviations
private LazyLoad<string> _DevNoteOrCautionTabOffset;
public string DevNoteOrCautionTabOffset
{
get
{
return LazyLoad(ref _DevNoteOrCautionTabOffset, "@DevNoteOrCautionTabOffset");
}
}
// adjustment to the starting positoin of the note/caution boxes
// - this is used sub-formats for Byron and Braidwood (CEW_00, EXCLN01)
private LazyLoad<string> _BoxLeftAdj;
public string BoxLeftAdj
{
get
{
return LazyLoad(ref _BoxLeftAdj, "@BoxLeftAdj");
}
}
// B2019-049 added check for table being in a Caution or Note - if so, use the single column setting for the format variable TableCenterPos
private LazyLoad<string> _TableCenterPos;
public string TableCenterPos
{
get
{
return LazyLoad(ref _TableCenterPos, "@TableCenterPos");
}
}
// Turn on editing and printing format for Deviation Documents (non-enhanced document)
// uses the Caution and Note type for the EOP and ERG step number, the widths are reduced
// and they are placed to the left of the high level step text
private LazyLoad<bool> _Dev_Format;
public bool Dev_Format
{
get
{
return LazyLoad(ref _Dev_Format, "@Dev_Format");
}
}
// links procedure step number and text (also links Cautions and Note). Uses a template for the step editor to enter deviation and support text (like enhanced backgrounds). Prints like the non-enhanced deviation document
private LazyLoad<bool> _EnhancedShortFormDev;
public bool EnhancedShortFormDev
{
get
{
return LazyLoad(ref _EnhancedShortFormDev, "@EnhancedShortFormDev");
}
}
// this flag is set in the plant format file when you want to be able to break steps that begin in the
// middle of the page. If this flag is not set, then any step that will not fit on a single page will
// cause a page break, i.e. start at the top of the next page.
private LazyLoad<bool> _SpecialPageBreakFlag;
public bool SpecialPageBreakFlag
{
get
{
return LazyLoad(ref _SpecialPageBreakFlag, "@SpecialPageBreakFlag");
}
}
// paginate on a step if the entire step will fit on it's own page but not fit on the remainer of the current page
private LazyLoad<bool> _PaginateOnStepThatWillFitOnBlankPage;
public bool PaginateOnStepThatWillFitOnBlankPage
{
get
{
return LazyLoad(ref _PaginateOnStepThatWillFitOnBlankPage, "@PaginateOnStepThatWillFitOnBlankPage");
}
}
// allows the first child to be separated from its parent
private LazyLoad<bool> _PaginateOnFirstSubstep;
public bool PaginateOnFirstSubstep
{
get
{
return LazyLoad(ref _PaginateOnFirstSubstep, "@PaginateOnFirstSubstep");
}
}
// keep the table's parent with the table (if at all possible, don't break the table from the parent)
private LazyLoad<bool> _PageBreakParentWithTable; // B2020-101: Add format flag for table pagination
public bool PageBreakParentWithTable
{
get
{
return LazyLoad(ref _PageBreakParentWithTable, "@PageBreakParentWithTable");
}
}
// when needed to fit an entire step on a page, PROMS will print the step at 7 lines per inch instead of the standard 6 lines per inch
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");
}
}
// use the STExtraSpace value (defined for each step type) at the top of page
// when that step/sub-step type is the first step part on the page
private LazyLoad<bool> _DoSTExtraAtTop;
public bool DoSTExtraAtTop
{
get
{
return LazyLoad(ref _DoSTExtraAtTop, "@DoSTExtraAtTop");
}
}
// even if a step will fit on a page by itself, print as much of the step as logically possible on the current page
private LazyLoad<bool> _KeepStepsOnPage;
public bool KeepStepsOnPage
{
get
{
return LazyLoad(ref _KeepStepsOnPage, "@KeepStepsOnPage");
}
}
private LazyLoad<bool> _NoOrphans1;
// B2017-154 No Orphans (single sub-step left over from previous page) No Children
// - Don't leave an orphan on the next page if the high level step and first sub-step will fit on the current page
// note: this was put in the V.C.Summ AP1000 plant
public bool NoOrphans1
{
get
{
return LazyLoad(ref _NoOrphans1, "@NoOrphans1");
}
}
// the format default setting as to whether each procedure section start on their own page
// The base format has this set to true - each section starts on a new page
private LazyLoad<bool> _BreakOnSections;
public bool BreakOnSections
{
get
{
return LazyLoad(ref _BreakOnSections, "@BreakOnSections");
}
}
// will print the section number and title before printing the section text. used only with the PROMS
// step editor sections (not Word sections). section number and title will print only on the first page
// of the section. a check box on the section properties page turns printing of this on/off
private LazyLoad<bool> _ShowSectionTitles;
public bool ShowSectionTitles
{
get
{
return LazyLoad(ref _ShowSectionTitles, "@ShowSectionTitles");
}
}
// will print the defined section end message for single columns sections.
// the default setting is True
private LazyLoad<bool> _EndForSingle;
public bool EndForSingle
{
get
{
return LazyLoad(ref _EndForSingle, "@EndForSingle");
}
}
// Special pagination case used in some background document formats. This will turn off the KeepStepsOnPage flag when a paragraph off of a High Level step was put on next page (IP2 bck: E-3/References), and a paragraph was writing into the footer (FR-H.1 step 2.2.3.1. KBR 10/14/14)
private LazyLoad<bool> _PaginateOnLowerStepLevel;
public bool PaginateOnLowerStepLevel
{
get
{
return LazyLoad(ref _PaginateOnLowerStepLevel, "@PaginateOnLowerStepLevel");
}
}
// B2023-088: alarm format pagination
// Special pagination for Alarm procedures to keep substeps with the high level step
private LazyLoad<bool> _AlarmPagination;
public bool AlarmPagination
{
get
{
return LazyLoad(ref _AlarmPagination, "@AlarmPagination");
}
}
// For McGuire and Catawba, they use CustomSpacing which inserts a blank line before high level steps
// if we paginate on one of these blank lines, we want to skip that blank line so that there isn't an
// extra blank line at the top of the page.
private LazyLoad<bool> _CustomSpacing;
public bool CustomSpacing
{
get
{
return LazyLoad(ref _CustomSpacing, "@CustomSpacing");
}
}
// when set to False, a caluation for centering text is done with respect to the CPI defined for
// the font to better match the centering of the 16-bit VEPROMS application
private LazyLoad<bool> _PicaIgnoreFiveSixths;
public bool PicaIgnoreFiveSixths
{
get
{
return LazyLoad(ref _PicaIgnoreFiveSixths, "@PicaIgnoreFiveSixths");
}
}
// keep sub-steps together - on a page by themselves
private LazyLoad<bool> _PutOnPageByItself;
public bool PutOnPageByItself
{
get
{
return LazyLoad(ref _PutOnPageByItself, "@PutOnPageByItself");
}
}
// If a high level step, the 16bit code uses the value of the extra space
// from the high level step format regardless of what type of high level step it is:
// Added check for UseSTExtraRealValue, if set, we want to use what is set for the specific step type
private LazyLoad<bool> _UseSTExtraRealValue;
public bool UseSTExtraRealValue
{
get
{
return LazyLoad(ref _UseSTExtraRealValue, "@UseSTExtraRealValue");
}
}
// Causes step tabs to be built according to the actual level, with respect to the section level and the step level (i.e. sub-sections count as a level)
private LazyLoad<bool> _TieTabToLevel;
public bool TieTabToLevel
{
get
{
return LazyLoad(ref _TieTabToLevel, "@TieTabToLevel");
}
}
// treat sub-sections and High Level Steps as if they are at the same procedure structure level. This is used with the TieTabToLevel flag
private LazyLoad<bool> _SubSectAndHighSameLevel;
public bool SubSectAndHighSameLevel
{
get
{
return LazyLoad(ref _SubSectAndHighSameLevel, "@SubSectAndHighSameLevel");
}
}
// compress only part of the step (i.e. a sub-step) so that the entire step can fit on a page
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");
}
}
// remove the ".0" from a bottom continue message
private LazyLoad<bool> _VirtualDotInHLSTab;
public bool VirtualDotInHLSTab
{
get
{
return LazyLoad(ref _VirtualDotInHLSTab, "@VirtualDotInHLSTab");
}
}
// was put in for NSP's Cautions and Notes which are not boxed but formatted differently than other non-boxed Cautions and Notes, allow to specify a starting column and width where the Note/Caution step types are defined
private LazyLoad<bool> _NullBox;
public bool NullBox
{
get
{
return LazyLoad(ref _NullBox, "@NullBox");
}
}
// turns on the ability to add Notes and Cautions off of a Section title in the PROMS step editor
private LazyLoad<bool> _AllowNoteCautionAdd;
public bool AllowNoteCautionAdd
{
get
{
return LazyLoad(ref _AllowNoteCautionAdd, "@AllowNoteCautionAdd");
}
}
// F2024-037 reset the seq sub-step numbering if the parent is an un-numbered high level step
// F2024-049 changed to specify the level, to change to, via the format file (Generic EOP and Vogtle 3&4)
private LazyLoad<int?> _ResetSeqNumberingAfterUnnumberedHLS;
public int? ResetSeqNumberingAfterUnnumberedHLS
{
get
{
return LazyLoad(ref _ResetSeqNumberingAfterUnnumberedHLS, "@ResetSeqNumberingAfterUnnumberedHLS");
}
}
}
#endregion - StepSectionLayoutData
#region Separator
public class Separator : vlnFormatItem
{
public Separator(XmlNode xmlNode) : base(xmlNode) { }
//the placement setting for the separator words used for OR the sub-steps and the Explicit And sub-steps
private LazyLoad<int?> _Location;
public int? Location
{
get
{
return LazyLoad(ref _Location, "@Location");
//return LazyLoad(ref _SeparatorLocation, "@SeparatorLocation");
}
}
// the font specifications for the separator text for OR the sub-steps and the Explicit And sub-steps
private VE_Font _Font;
public VE_Font Font
{
get
{
return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
}
}
}
#endregion - Separator
#region StepSectionPrintData
public class StepSectionPrintData : vlnFormatItem
{
public StepSectionPrintData(XmlNode xmlNode) : base(xmlNode) { }
// use for the box printed around Continuous Action Steps (if defined in plant format)
// this controls whether there is 1 line or 2 lines between the box line and
// the starting/ending yoffset of the HLS.
// default is False - will put 2 lines between the box line and step text
// when set to True - will put 1 line between the box line and step text resulting in
// no extra line between the box and top/bottom of step.
private LazyLoad<bool> _DiffContActBox;
public bool DiffContActBox
{
get
{
return LazyLoad(ref _DiffContActBox, "@DiffContActBox");
}
}
// will allow the drawing of a box round substeps that have a defined box
private LazyLoad<bool> _ContActBoxOnSubSteps;
public bool ContActBoxOnSubSteps
{
get
{
return LazyLoad(ref _ContActBoxOnSubSteps, "@ContActBoxOnSubSteps");
}
}
// this will print the defined string after the last RNO for a step or sub-step
// some plants print a string of a couple spaces to add an extra blank line instead
private LazyLoad<string> _RNOSepString;
public string RNOSepString
{
get
{
return LazyLoad(ref _RNOSepString, "@RNOSepString");
}
}
// specify the length of the RNO separator. if not set, then code uses length of RNOSepString. if no RNOSepString then the code creates an empty RNO separtor.
private LazyLoad<float?> _RNOSepLineLength;
public float? RNOSepLineLength
{
get
{
return LazyLoad(ref _RNOSepLineLength, "@RNOSepLineLength");
}
}
// will print the defined string between each High Level Step type. Used in the Long Form Deviation format
private LazyLoad<string> _HLStpSeparatorString;
public string HLStpSeparatorString
{
get
{
return LazyLoad(ref _HLStpSeparatorString, "@HLStpSeparatorString");
}
}
// will print the defined string between each High Level RNO Step type. Used in the Long Form Deviation format
private LazyLoad<string> _HLRNOStpSeparatorString;
public string HLRNOStpSeparatorString
{
get
{
return LazyLoad(ref _HLRNOStpSeparatorString, "@HLRNOStpSeparatorString");
}
}
// turns on the ability to enter a procedure set revision number (string) on the Working Draft properties page
private LazyLoad<bool> _UseXtraRevNumber;
public bool UseXtraRevNumber
{
get
{
return LazyLoad(ref _UseXtraRevNumber, "@UseXtraRevNumber");
}
}
// Don't all step text to print past right margin. put in for Point Beach's Background document
private LazyLoad<bool> _LimitWidToPageWid;
public bool LimitWidToPageWid
{
get
{
return LazyLoad(ref _LimitWidToPageWid, "@LimitWidToPageWid");
}
}
// add the parent tab to the step or sub-step tab
private LazyLoad<bool> _CombinedTabIncludeParenTabs;
public bool CombinedTabIncludeParenTabs
{
get
{
return LazyLoad(ref _CombinedTabIncludeParenTabs, "@CombinedTabIncludeParenTabs");
}
}
// a list of hard coded tab placement adjustments per step level
private LeftJustifyList _LeftJustifyList;
public LeftJustifyList LeftJustifyList
{
get
{
return (_LeftJustifyList == null) ? _LeftJustifyList = new LeftJustifyList(SelectNodes("LeftJustifyList/LeftJustify")) : _LeftJustifyList;
}
set { _LeftJustifyList = value; }
}
}
#region LeftJustifyList
[TypeConverter(typeof(vlnListConverter<LeftJustifyList, LeftJustify>))]
public class LeftJustifyList : vlnFormatList<LeftJustify>
{
public LeftJustifyList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
}
#region LeftJustify
[TypeConverter(typeof(ExpandableObjectConverter))]
public class LeftJustify : vlnFormatItem, IVlnIndexedFormatItem
{
public LeftJustify(XmlNode xmlNode) : base(xmlNode) { }
public LeftJustify() : base() { }
// represents the step level in which to use the LeftJustify Size value
private LazyLoad<int?> _Index;
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
// the LeftJustify value
private LazyLoad<float?> _Size;
public float? Size
{
get
{
return LazyLoad(ref _Size, "@Size");
}
}
}
#endregion - LeftJustify
#endregion - LeftJustifyList
#endregion - StepSectionPrintData
#region SeqTabFmtAll
#region SeqTabFmt
[TypeConverter(typeof(ExpandableObjectConverter))]
public class SeqTabFmt : vlnFormatItem, IVlnIndexedFormatItem
{
public SeqTabFmt() : base() { }
// index number of each SeqTabFmt item in the SequentialTabFormat list
private LazyLoad<int?> _Index;
[Description("SeqTab Index")]
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
// the token representing the type of tab to use. ex: {numeric} for a number, {alpha} for a letter
private LazyLoad<string> _TabToken;
public string TabToken
{
get
{
return LazyLoad(ref _TabToken, "@TabToken");
}
}
// the formatting definition for that tab (usually uses the "{seq}" token). defines if the tab ends with a period, closed parenthesis, etc.
// this format setting is also used for printing - we currently ignore the format setting for PrintTabFormat
private LazyLoad<string> _TabFormat;
public string TabFormat
{
get
{
return LazyLoad(ref _TabFormat, "@TabFormat");
}
}
// the formatting definition for that tab. defines if the tab ends with a period, closed parenthesis, etc.
// - we currently ignore this format setting when printing and use the value of TabFormat instead.
// leaving it this way in case we find a need to have different tab formats for editor and printing
private LazyLoad<string> _PrintTabFormat;
public string PrintTabFormat
{
get
{
return LazyLoad(ref _TabFormat, "@PrintTabFormat");
}
}
// when the tab is built with parent tab information, don't trim the parent tab (don't remove the surrounding spaces before building the tab
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 - SeqTabFmt
#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 - SeqTabFmtList
#endregion - SeqTabFmtAll
#endregion - StepSectionDataAll
#region AccSectionDataAll
#region AccSectionData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class AccSectionData : vlnFormatItem
{
public AccSectionData(XmlNode xmlNode) : base(xmlNode) { }
//formatting information for the automatic table of contents
private TableOfContentsData _TableOfContentsData;
public TableOfContentsData TableOfContentsData
{
get
{
return (_TableOfContentsData == null ? _TableOfContentsData = new TableOfContentsData(SelectSingleNode("TableOfContentsData")) : _TableOfContentsData);
}
}
// formatting information for the generation of the Continuous Action Summary.
// Creates a table in an instance of Word that can be copied into a PROMS Word section
// and then modified as needed. (Node in XML is misspelled)
private ConitnuousActionSummaryData _ContinuousActionSummaryData;
public ConitnuousActionSummaryData ContinuousActionSummaryData
{
get
{
return (_ContinuousActionSummaryData == null ? _ContinuousActionSummaryData = new ConitnuousActionSummaryData(SelectSingleNode("ConitnuousActionSummaryData")) : _ContinuousActionSummaryData);
}
}
}
#endregion - AccSectionData
#region TableOfContentsData
public class TableOfContentsData : vlnFormatItem
{
public TableOfContentsData(XmlNode xmlNode) : base(xmlNode) { }
// positon of the section number from the left margin
private LazyLoad<float?> _TofCSecNumPos;
public float? TofCSecNumPos
{
get
{
return LazyLoad(ref _TofCSecNumPos, "@TofCSecNumPos");
}
}
// position of the section title from the left margin
private LazyLoad<float?> _TofCSecTitlePos;
public float? TofCSecTitlePos
{
get
{
return LazyLoad(ref _TofCSecTitlePos, "@TofCSecTitlePos");
}
}
// length of the section title before wrapping onto the next line
private LazyLoad<int?> _TofCSecTitleLen;
public int? TofCSecTitleLen
{
get
{
return LazyLoad(ref _TofCSecTitleLen, "@TofCSecTitleLen");
}
}
// positon of the the section's starting page number
private LazyLoad<float?> _TofCPageNumPos;
public float? TofCPageNumPos
{
get
{
return LazyLoad(ref _TofCPageNumPos, "@TofCPageNumPos");
}
}
// the character used for the spaces between the section title and the page number - i.e. leader dots
private LazyLoad<string> _TofCSpaceChar;
public string TofCSpaceChar
{
get
{
return LazyLoad(ref _TofCSpaceChar, "@TofCSpaceChar");
}
}
// the line spaces between each item on the table of contents
private LazyLoad<float?> _TofCLineSpacing;
public float? TofCLineSpacing
{
get
{
return LazyLoad(ref _TofCLineSpacing, "@TofCLineSpacing");
}
}
// specify how many section / sub-sections to include on the TOC page
private LazyLoad<int?> _TofCNumLevels;
public int? TofCNumLevels
{
get
{
return LazyLoad(ref _TofCNumLevels, "@TofCNumLevels");
}
}
// specify after which section level to start indenting the entries on the TOC page
private LazyLoad<int?> _TofCStartIndentAfterLevel;
public int? TofCStartIndentAfterLevel
{
get
{
return LazyLoad(ref _TofCStartIndentAfterLevel, "@TofCStartIndentAfterLevel");
}
}
// flag to underline the first level section titles
private LazyLoad<bool> _TofCUnderlineFirstLevelTitle;
public bool TofCUnderlineFirstLevelTitle
{
get
{
return LazyLoad(ref _TofCUnderlineFirstLevelTitle, "@TofCUnderlineFirstLevelTitle");
}
}
// specify the page number alignment with respect to the page number position - default is left justify
private LazyLoad<string> _TofCPageNumAlign;
public string TofCPageNumAlign
{
get
{
string tocPgNumAlgn = LazyLoad(ref _TofCPageNumAlign, "@TofCPageNumAlign");
return (tocPgNumAlgn == null || tocPgNumAlgn == "") ? "Left" : tocPgNumAlgn;
}
}
// a replacement section title for "Procedure Steps" - put in for V.C. Summer
private LazyLoad<string> _TofCProcedureStepsTitle;
public string TofCProcedureStepsTitle
{
get
{
string tocProcStepsTitle = LazyLoad(ref _TofCProcedureStepsTitle, "@TofCProcedureStepsTitle");
return (tocProcStepsTitle == null || tocProcStepsTitle == "") ? "" : tocProcStepsTitle;
}
}
// specify the line spacing to be just for the sub-sections entries
private LazyLoad<int?> _TofCLineSpacingSub;
public int? TofCLineSpacingSub
{
get
{
return LazyLoad(ref _TofCLineSpacingSub, "@TofCLineSpacingSub");
}
}
// if the Group Heading (defined in section's properties automation tab) is also part of the section number,
// remove it the Group Heading text from the section number - VEGP1, VEGP2
private LazyLoad<bool> _TofCRemoveGrpNameInSects;
public bool TofCRemoveGrpNameInSects
{
get
{
return LazyLoad(ref _TofCRemoveGrpNameInSects, "@TofCRemoveGrpNameInSects");
}
}
// C2021-015: Barakah High Level Steps in Table of Contents
// if set in the Step Properties pannel
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 - TableOfContentsData
#region ConitnuousActionSummary
public class ConitnuousActionSummaryData : vlnFormatItem
{
public ConitnuousActionSummaryData(XmlNode xmlNode) : base(xmlNode) { }
// include the section number and title for the sections that contains continuous action steps
private LazyLoad<bool> _IncludeSectionNumAndTitle;
public bool IncludeSectionNumAndTitle
{
get
{
return LazyLoad(ref _IncludeSectionNumAndTitle, "@IncludeSectionNumAndTitle");
}
}
// the font and font styles to use for the continuous action summary
private VE_Font _Font;
public VE_Font Font
{
get
{
return (_Font == null) ? _Font = new VE_Font(base.XmlNode) : _Font;
}
}
}
#endregion - ConitnuousActionSummary
#endregion - AccSectionDataAll
#region MetaSectionAll
#region MetaSection
[TypeConverter(typeof(ExpandableObjectConverter))]
public class MetaSection : vlnFormatItem, IVlnIndexedFormatItem
{
public MetaSection(XmlNode xmlNode) : base(xmlNode) { }
public MetaSection() : base() { }
// represents the section level
private LazyLoad<int?> _Index;
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
// the column adjustment (indent) inwhich to print the section number for that level of section (sub-section)
private LazyLoad<float?> _SecNumPositionAdj;
public float? SecNumPositionAdj
{
get
{
return LazyLoad(ref _SecNumPositionAdj, "@SecNumPositionAdj");
}
}
// the column adjustment (indent) inwhich to print the section title for that level of section (sub-section)
private LazyLoad<float?> _SecTitlePositionAdj;
public float? SecTitlePositionAdj
{
get
{
return LazyLoad(ref _SecTitlePositionAdj, "@SecTitlePositionAdj");
}
}
// adjustment (indent) for the high level steps for that level of section (sub-section)
private LazyLoad<float?> _ColSByLevel;
public float? ColSByLevel
{
get
{
return LazyLoad(ref _ColSByLevel, "@ColSByLevel");
}
}
// adjustment for the width of the high level steps for that level of section (sub-section)
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}", SecNumPositionAdj, SecTitlePositionAdj, ColSByLevel, WidSAdjByLevel);
}
}
#endregion - MetaSection
#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 - MetaSectionList
#endregion - MetaSectionAll
#endregion - SectDataAll
#region StepDataAll
#region Step
[TypeConverter(typeof(ExpandableObjectConverter))]
public class StepData : vlnFormatItem, IVlnIndexedFormatItem
{
public StepData() : base() { }
// translated to a step type number - this number is used to allow the BASE format settting in the Plant formats
private LazyLoad<int?> _Index;
[Description("Step Index")]
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
// text description of the step part type (ex. High, Caution, Note)
private LazyLoad<string> _Type;
public string Type
{
get
{
return LazyLoad(ref _Type, "@Type");
}
}
// the step type from which settings are inherited
private LazyLoad<string> _ParentType;
public string ParentType
{
get
{
return LazyLoad(ref _ParentType, "@ParentType");
}
}
// user cannot directly edit the text in step type - usually auto generated text like TITLEWITHTEXTBELOW used in background documents
private LazyLoad<bool> _ReadOnly;
public bool ReadOnly
{
get
{
return LazyLoad(ref _ReadOnly, "@ReadOnly");
}
}
// Less space between text and bottom line of Caution Box
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 - NO CODE TO SUPPORT THIS YET AND IS NOT SET IN PROMS EXPRESS FORMATS
//public bool SeparateWarning
//{
// get
// {
// return LazyLoad(ref _SeparateWarning, "@SeparateWarning");
// }
//}
// when set to Truen the step type will not appear in the insert step or sub-step lists. used to turn off (remove) the availability of step types that are not used or needed by the customer
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)
// - used when a high level step is used as a section number and title
private LazyLoad<bool> _AppendDotZero;
public bool AppendDotZero
{
get
{
return LazyLoad(ref _AppendDotZero, "@AppendDotZero");
}
}
// F2019-069: Barakah Hold Point - set xoffset to parent's tab
// put in for BNPP (Barakah). the Hold Point (note type) needed indented the same as the high level step
// that it apples to, instead of centering it on the page like a normal Note type
private LazyLoad<bool> _ColUseParentTab;
public bool ColUseParentTab
{
get
{
return LazyLoad(ref _ColUseParentTab, "@ColUseParentTab");
}
}
// this will override the ColS format setting for the specific step type
private LazyLoad<float?> _ColOverride;
public float? ColOverride
{
get
{
return LazyLoad(ref _ColOverride, "@ColOverride");
}
}
// this will override the WidS format setting for the specific step type
private LazyLoad<string> _WidthOverride;
public string WidthOverride
{
get
{
return LazyLoad(ref _WidthOverride, "@WidthOverride");
}
}
// Separtor text that is printed beween consecutive step items of this type
// ex: "-OR-" may be printed between two consecutive OR sub-step types
private LazyLoad<string> _Sep;
public string Sep
{
get
{
return LazyLoad(ref _Sep, "@Sep");
}
}
// a text string that is placed before the text of this step type.
// Used in the Checklist formats to draw lines (for a table) when printed.
// Also used to add a step text designator character before step text
private LazyLoad<string> _Prefix;
public string Prefix
{
get
{
return LazyLoad(ref _Prefix, "@Prefix");
}
}
// a text string that is placed after the text of this step type. Used in the Checklist formats to draw lines (for a table) when printed.
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')
//whenever this step type is added to a step,
//this text field will automatically be populated with this text
private LazyLoad<string> _DefaultText;
public string DefaultText
{
get
{
return LazyLoad(ref _DefaultText, "@DefaultText");
}
}
// defines the positioning of the vertical table lines (to define columns). Used for the Checklist Formats which dymanically builds a table based on step and sub-step levels
private LazyLoad<string> _VertPos;
public string VertPos
{
get
{
return LazyLoad(ref _VertPos, "@VertPos");
}
}
// appears to be used for RNOs (step type 40) to control whether there are two blank lines or one line
// between the RNO steps.
// This needs set to true along with SpaceDouble in order for double spacing to happen.
// Default (BASE format) is set to True.
private LazyLoad<bool> _DoubleSpace;
public bool DoubleSpace
{
get
{
return LazyLoad(ref _DoubleSpace, "@DoubleSpace");
}
}
// If 'UseSmartTemplate' is True, the template (defined in FormatData.TPL) will have starting location & widths,
// and other data for the listed step types. Data from the template overrides width data as specified by
// the step type format data.
private LazyLoad<bool> _UseSmartTemplate;
public bool UseSmartTemplate
{
get
{
return LazyLoad(ref _UseSmartTemplate, "@UseSmartTemplate");
}
}
// If 'UseOldTemplate' is True, the template (defined in FormatData.TPL) will define the sub-steps to
// automatically insert when this step is inserted in the procedure data. Mainly used by Enhanced Backgrounds
// and Deviations, but has been used in procedure step formats for specialized items
private LazyLoad<bool> _UseOldTemplate;
public bool UseOldTemplate
{
get
{
return LazyLoad(ref _UseOldTemplate, "@UseOldTemplate");
}
}
// appears to provide extra control as to when the STExtraSpace value is used for extra line spacing
private LazyLoad<bool> _AlwaysUseExtraLines;
public bool AlwaysUseExtraLines
{
get
{
return LazyLoad(ref _AlwaysUseExtraLines, "@AlwaysUseExtraLines");
}
}
// Used for Notes and Cautions that are boxed, create a separate box for each different Note and Caution type.
private LazyLoad<bool> _SeparateBox;
public bool SeparateBox
{
get
{
return LazyLoad(ref _SeparateBox, "@SeparateBox");
}
}
// Used for Cautions that are boxed, create a separate box for each different Caution type.
private LazyLoad<bool> _SeparateBoxCautions;
public bool SeparateBoxCautions
{
get
{
return LazyLoad(ref _SeparateBoxCautions, "@SeparateBoxCautions");
}
}
// appears to be used for RNOs (step type 40) to control whether there are two blank lines or one between the RNO steps. This needs set to true along with DoubleSpace in order for double spacing to happen. Default (BASE format) is set to True.
private LazyLoad<bool> _SpaceDouble;
public bool SpaceDouble
{
get
{
return LazyLoad(ref _SpaceDouble, "@SpaceDouble");
}
}
// This will bold the High Level RNO text - whether the high level step is bolded or not (code doesn't check for that) - this is only set on the RNO step type
private LazyLoad<bool> _BoldHighLevel;
public bool BoldHighLevel
{
get
{
return LazyLoad(ref _BoldHighLevel, "@BoldHighLevel");
}
}
// used on Note and Caution types, will put an extra blank line before the Note or Caution tab
private LazyLoad<bool> _OneLineBeforeTab;
public bool OneLineBeforeTab
{
get
{
return LazyLoad(ref _OneLineBeforeTab, "@OneLineBeforeTab");
}
}
// Turns on the boxing of an entire step (usually LossOfAC high level step type)
private LazyLoad<bool> _BoxIt;
public bool BoxIt
{
get
{
return LazyLoad(ref _BoxIt, "@BoxIt");
}
}
// only put a bottom continue message if we are breaking on an RNO step.
// this flag is set only on the RNO (index 40) step type
private LazyLoad<bool> _ContinueOnly;
public bool ContinueOnly
{
get
{
return LazyLoad(ref _ContinueOnly, "@ContinueOnly");
}
}
// underline the text that follows a "- " for this step type
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");
}
}
// this is applied to Caution and Note step types.
// When set, it will add an extra blank line for cases where the top of the page is a boxed caution or note
// - to move it away from the top page border line
private LazyLoad<bool> _SpaceIn;
public bool SpaceIn
{
get
{
return LazyLoad(ref _SpaceIn, "@SpaceIn");
}
}
// Each step of this type will alway start on a new page. This is used background formats.
private LazyLoad<bool> _PageBreakOnStep;
public bool PageBreakOnStep
{
get
{
return LazyLoad(ref _PageBreakOnStep, "@PageBreakOnStep");
}
}
// if there is no section number defined for the step section and the section title is printed on the page (using the check box on section properties), then align the procedure step tab to the same starting column as the section title
private LazyLoad<bool> _AlignNullTabWSectHead;
public bool AlignNullTabWSectHead
{
get
{
return LazyLoad(ref _AlignNullTabWSectHead, "@AlignNullTabWSectHead");
}
}
// For Calvert Cliffs (BGE formats), when AlignNullTabWSectHead is used in BGEEOP (see EOP-0/Purpose ),
// it caused BGESTP's to print LossOfAC steps (unnumbered HLS) too far to the left.
// The ForceAlignNullTabWSectHead was introduced so that for that step type (LossOfAC) in STP/OI format
// so that the title position was used instead of the section number position
private LazyLoad<bool> _ForceAlignNullTabWSectHead;
public bool ForceAlignNullTabWSectHead
{
get
{
return LazyLoad(ref _ForceAlignNullTabWSectHead, "@ForceAlignNullTabWSectHead");
}
}
// force the alignment of the high level step tab with the section title
private LazyLoad<bool> _AlignHLSTabWithSectOvride;
public bool AlignHLSTabWithSectOvride
{
get
{
return LazyLoad(ref _AlignHLSTabWithSectOvride, "@AlignHLSTabWithSectOvride");
}
}
// set on selected sub-step types, allows sub-steps to use the type attributes of a Note or Caution that they are a part off
private LazyLoad<bool> _TextSubFollowsTextStyle;
public bool TextSubFollowsTextStyle
{
get
{
return LazyLoad(ref _TextSubFollowsTextStyle, "@TextSubFollowsTextStyle");
}
}
// Additional indenting (spaces) to use when the sub-step type is inside a caution or note type
private LazyLoad<int?> _CautionOrNoteSubstepIndent;
public int? CautionOrNoteSubstepIndent
{
get
{
return LazyLoad(ref _CautionOrNoteSubstepIndent, "@CautionOrNoteSubstepIndent");
}
}
// adjust the placement of a Caution or Note when it's in an RNO and is not off of the high level RNO (adds another blank line)
private LazyLoad<bool> _MatchUpRNO;
public bool MatchUpRNO
{
get
{
return LazyLoad(ref _MatchUpRNO, "@MatchUpRNO");
}
}
// used for Background formats - tell PROMS that the text for this step type is printed via the pagelist (PageStyle) logic as part of the page header information
private LazyLoad<bool> _InPageList;
public bool InPageList
{
get
{
return LazyLoad(ref _InPageList, "@InPageList");
}
}
// will center the text within the defined step type width if the text length is shorter than the step type width.
// Used on the Note and Caution step types
private LazyLoad<bool> _CenterOneLineOnly;
public bool CenterOneLineOnly
{
get
{
return LazyLoad(ref _CenterOneLineOnly, "@CenterOneLineOnly");
}
}
// used with CenterOneLineOnly, will not center the single line note/caution text if it as sub-steps
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
// step type is always centered on the page
private LazyLoad<bool> _AlwaysCenter;
public bool AlwaysCenter
{
get
{
return LazyLoad(ref _AlwaysCenter, "@AlwaysCenter");
}
}
// additional logic to better center single line Notes and Cautions that are used in the RNO column
private LazyLoad<bool> _CenterOneLineAdjust;
public bool CenterOneLineAdjust
{
get
{
return LazyLoad(ref _CenterOneLineAdjust, "@CenterOneLineAdjust");
}
}
// used on Caution and Note step types, for steps that have multiple Cautions and/or Notes,
// this will put the Caution or Note tab for each of them
private LazyLoad<bool> _AlwaysTab;
public bool AlwaysTab
{
get
{
return LazyLoad(ref _AlwaysTab, "@AlwaysTab");
}
}
// Don't put a blank line between multiple RNOs
private LazyLoad<bool> _NoSpaceMultipleRNOs;
public bool NoSpaceMultipleRNOs
{
get
{
return LazyLoad(ref _NoSpaceMultipleRNOs, "@NoSpaceMultipleRNOs");
}
}
// allows cautions type to be changed to notes and notes changed to cautions
private LazyLoad<bool> _MixCautionsAndNotes;
public bool MixCautionsAndNotes
{
get
{
return LazyLoad(ref _MixCautionsAndNotes, "@MixCautionsAndNotes");
}
}
// set on the RNO step type, will grab and use the high level step's tab for the RNO
private LazyLoad<bool> _NumberHighLevel;
public bool NumberHighLevel
{
get
{
return LazyLoad(ref _NumberHighLevel, "@NumberHighLevel");
}
}
// set on RNO step types, determines the RNO tab base on the RNO level
private LazyLoad<bool> _NumberWithLevel;
public bool NumberWithLevel
{
get
{
return LazyLoad(ref _NumberWithLevel, "@NumberWithLevel");
}
}
// default is set to True. If set to False, then only the high level RNO step
// will use the high level step's tab (used with the NumberHighLevel format flag)
private LazyLoad<bool> _OffsetTab;
public bool OffsetTab
{
get
{
return LazyLoad(ref _OffsetTab, "@OffsetTab");
}
}
// put in for Farley, value to adjust the xoffset of the step tab based on where the right edge of the text is.
// Their RNO's are numbered with parent numbering so the calculations for determining
// the xoffset backs up from the right edge.
private LazyLoad<float?> _AdjHighLevelTab;
public float? AdjHighLevelTab
{
get
{
return LazyLoad(ref _AdjHighLevelTab, "@AdjHighLevelTab");
}
}
// sets an indent value for child steps (sub-steps) under the TitleWithTextBelow step type
private LazyLoad<float?> _ChildIndent;
public float? ChildIndent
{
get
{
return LazyLoad(ref _ChildIndent, "@ChildIndent");
}
}
// RNO's off of sequential sub-steps will get the parent's (AER sub-step) tab
// - BASE format has this set to True and is set on RNO step type.
// NSP (Prairie Island) has this set to False in some of their formats to allow
// the RNO sub-step type to be use as a signoff/initial line
private LazyLoad<bool> _NumberSubs;
public bool NumberSubs
{
get
{
return LazyLoad(ref _NumberSubs, "@NumberSubs");
}
}
// used in some background document formats - all appear to be set on a Caution type.
// This will place the text of this type (caution) on the same row (of the page) and to the left of its parent.
// Is also used as a step designatior for Commanche Peak
private LazyLoad<bool> _SameRowAsParent;
public bool SameRowAsParent
{
get
{
return LazyLoad(ref _SameRowAsParent, "@SameRowAsParent");
}
}
// Used in Comanche Peak EOP and Flex formats for step designators. Will allow a hard return to be used for multiple step designators.
private LazyLoad<bool> _SameRowAsParentMultiLines;
public bool SameRowAsParentMultiLines
{
get
{
return LazyLoad(ref _SameRowAsParentMultiLines, "@SameRowAsParentMultiLines");
}
}
// is set to False in BASE format (not set to True in any other format as of 2024Jun21). When set to False, we disable the ability to enter another Checkoff in an RNO part if the the parent RNO already has a checkoff set.
private LazyLoad<bool> _CheckOffSameAsParent;
public bool CheckOffSameAsParent
{
get
{
return LazyLoad(ref _CheckOffSameAsParent, "@CheckOffSameAsParent");
}
}
// pad the step number so that is has at least two digits (ex step 1 would be step 01)
private LazyLoad<bool> _AtLeastTwoDigits;
public bool AtLeastTwoDigits
{
get
{
return LazyLoad(ref _AtLeastTwoDigits, "@AtLeastTwoDigits");
}
}
// Put three blank line before this step type (when printed)
private LazyLoad<bool> _ThreeBlanksAbove;
public bool ThreeBlanksAbove
{
get
{
return LazyLoad(ref _ThreeBlanksAbove, "@ThreeBlanksAbove");
}
}
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);
}
// by default, all continuous action steps and sub-steps are included in the PROMS generated
// continuous Action Summary. Not all formats (plants) use dedicated continuous action steps and sub-steps
// and sometimes these step type are redefined for other purposes.
// Setting this to True will exclude this step type from the Continuouse Action Summary.
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
//By default, Time Critical Action steps are included on the PROMS generated Time Critical Action Summary. Setting this to True will not automatically include it on the Time Critical Action Summary.
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)
{
}
// add extra spacing before this step type
private LazyLoad<int?> _STExtraSpace;
public int? STExtraSpace
{
get
{
return LazyLoad(ref _STExtraSpace, "StepLayoutData/@STExtraSpace");
}
}
// the number referencing the definition of a box around that step type - used for Caution and Note boxes
private LazyLoad<int?> _STBoxindex;
public int? STBoxindex
{
get
{
return LazyLoad(ref _STBoxindex, "StepLayoutData/@STBoxindex");
}
}
// will add a blank line after every N number of items
private LazyLoad<int?> _EveryNLines;
public int? EveryNLines
{
get
{
return LazyLoad(ref _EveryNLines, "StepLayoutData/@EveryNLines");
}
}
// position the step item to start in the same column as it's parent
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;
}
}
// list of actions defining what can be added to this step type (ex. addingNext, addingPrev, addingNote, addingCaution, addingTable)
private LazyLoad<E_AccStep?> _AcTable;
public E_AccStep? AcTable
{
get
{
return LazyLoad<E_AccStep>(ref _AcTable, "StepEditData/@AcTable");
}
}
// specify if this step type can be selected in the PROMS Search module
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)
{
}
// allows a Horizontal adjustment (the tab and the text) of the step type when printed
private LazyLoad<float?> _PosAdjust;
public float? PosAdjust
{
get
{
return LazyLoad(ref _PosAdjust, "StepPrintData/@PosAdjust");
}
}
// when printing, if this HLS uses a smart template (checklist formats) this value is used to determine when to split across 2 lines
private LazyLoad<int?> _HLSLength;
public int? HLSLength
{
get
{
return LazyLoad(ref _HLSLength, "StepPrintData/@HLSLength");
}
}
// used to set the text justification when it is something other than Left Justified
private LazyLoad<string> _Justify;
public string Justify
{
get
{
return LazyLoad(ref _Justify, "StepPrintData/@Justify");
}
}
// B2022-003: BNPP Alarms (BNPPalr) - This will add a blank line after the sub of the sub-step
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)
{
}
// This controls whether or not a step or sub-step type appears in the Insert and Search options for the user to select
private LazyLoad<bool> _InMenu;
public bool InMenu
{
get
{
return LazyLoad(ref _InMenu, "StepEditData/TypeMenu/@InMenu");
}
}
// RNOs are a specal case. This controls whether or not a RNO type appears in the Insert and Search options for the user to select
private LazyLoad<bool> _RnoInMenu;
public bool RnoInMenu
{
get
{
return LazyLoad(ref _RnoInMenu, "StepEditData/TypeMenu/@RnoInMenu");
}
}
// The name of the step/sub-step type that appears in step/substep menus and lists.
// This allows us to override the default name
private LazyLoad<string> _MenuItem;
public string MenuItem
{
get
{
return LazyLoad(ref _MenuItem, "StepEditData/TypeMenu/@MenuItem");
}
}
// used to define an alternative menu name for when the sub-step type is used in an RNO (right column)
private LazyLoad<string> _RnoMenuItem;
public string RnoMenuItem
{
get
{
return LazyLoad(ref _RnoMenuItem, "StepEditData/TypeMenu/@RnoMenuItem");
}
}
// text to appear for the reason why a step/sub-step type cannot be changed
private LazyLoad<string> _NoChgReason;
public string NoChgReason
{
get
{
return LazyLoad(ref _NoChgReason, "StepEditData/TypeMenu/@NoChgReason");
}
}
// use with the Caution and Note sub-step types - specifes which other Cautions and Note types the current Caution or Note could be changed to via Step Properties
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) { }
// Pairie Island (NSP) Caution and Note tabs use a larger font
// - When using a bullet for multiple Cautions/Notes, use the font size of the Caution/Note text instead of the tab.
// all the formats that use this specify the font and font size the the Font setting (below)
private LazyLoad<bool> _Separate;
public bool Separate
{
get
{
return LazyLoad(ref _Separate, "TabData/Bullet/@Separate");
}
}
// defines a font to use for the bullet character
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)
{
}
// list of one or more print macros to print with the step tab (used for a checkoff or inital line next to step number)
private MacroList _MacroList;
public MacroList MacroList
{
get
{
return _MacroList == null ? _MacroList = new MacroList(SelectNodes("TabData/MacroList/Macro")) : _MacroList;
}
}
// Used to define a designator character to appear in the Step Editor for when the printed character is a macro
// 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");
}
}
// defines the formatting of the step tab on the edit screen
private LazyLoad<string> _IdentEdit;
public string IdentEdit
{
get
{
return LazyLoad(ref _IdentEdit, "TabData/@IdentEdit");
}
}
// defines the formatting of the step tab when printed
private LazyLoad<string> _IdentPrint;
public string IdentPrint
{
get
{
return LazyLoad(ref _IdentPrint, "TabData/@Ident");
}
}
// used in background document formats - allows us to put the step number on one line, then the step text on the next line and it allows us to define prefix text used before each.
private LazyLoad<string> _IdentAltPrint;
public string IdentAltPrint
{
get
{
return LazyLoad(ref _IdentAltPrint, "TabData/@IdentAltPrint");
}
}
// defines a step type's corresponding RNO tab seen in the PROMS Step Editor
private LazyLoad<string> _RNOIdentEdit;
public string RNOIdentEdit
{
get
{
return LazyLoad(ref _RNOIdentEdit, "TabData/@RNOIdentEdit");
}
}
// defines a step type's corresponding RNO tab for the printed output
private LazyLoad<string> _RNOIdent;
public string RNOIdent
{
get
{
return LazyLoad(ref _RNOIdent, "TabData/@RNOIdent");
}
}
// this uses the same format item as RNOIdent
private LazyLoad<string> _RNOIdentPrint;
public string RNOIdentPrint
{
get
{
return LazyLoad(ref _RNOIdentPrint, "TabData/@RNOIdent");
}
}
// don't use the defined macro when creating a step tab for the step type's RNO
private LazyLoad<bool> _RNOExcludeMacros;
public bool RNOExcludeMacros
{
get
{
return LazyLoad(ref _RNOExcludeMacros, "TabData/@RNOExcludeMacros");
}
}
// Don't Align Tabs for numeric tabs that can go to 2 digits - Default is False - we do align numeric tabs
// - used in the Indian Point Unit 2 Background format (IP2BCK)
private LazyLoad<bool> _NoTabAlign;
public bool NoTabAlign
{
get
{
return LazyLoad(ref _NoTabAlign, "TabData/@NoTabAlign");
}
}
// used for Caution and Note steps, include the step number along with the Caution or Note tab
// was put in for V.C. Summer Units 3 & 4 formats
private LazyLoad<bool> _IncludeStepNum;
public bool IncludeStepNum
{
get
{
return LazyLoad(ref _IncludeStepNum, "TabData/@IncludeStepNum");
}
}
// used for Caution and Note steps, include the section number along with the Caution or Note tab
// - used with IncludeStepNum
// was put in for V.C. Summer Units 3 & 4 formats
private LazyLoad<bool> _IncludeSectionNum;
public bool IncludeSectionNum
{
get
{
return LazyLoad(ref _IncludeSectionNum, "TabData/@IncludeSectionNum");
}
}
// used to center justify the resulting Caution or Note tab within the defined Caution or Note box
private LazyLoad<string> _Justify;
public string Justify
{
get
{
return LazyLoad(ref _Justify, "TabData/@Justify");
}
}
// put in for V.C. Summer's Transition Caution Transition Note types - The text of these types contain a transtion link and is used for the Caution or Note tab of the "normal" Caution or Note - used with IsTransition TabData flag
private LazyLoad<bool> _UsePreviousStyle;
public bool UsePreviousStyle
{
get
{
return LazyLoad(ref _UsePreviousStyle, "TabData/@UsePreviousStyle");
}
}
// The text of these types contain a transtion link and is used for the Caution or Note tab of the "normal" Caution or Note
private LazyLoad<bool> _IsTransition;
public bool IsTransition
{
get
{
return LazyLoad(ref _IsTransition, "TabData/@IsTransition");
}
}
// set a hard-coded with of the step tab
private LazyLoad<float?> _IdentWidth;
public float? IdentWidth
{
get
{
return LazyLoad(ref _IdentWidth, "TabData/@IdentWidth");
}
}
// adjustment for step type's RNO tab width
private LazyLoad<float?> _RNOAdjustTabSize;
public float? RNOAdjustTabSize
{
get
{
return LazyLoad(ref _RNOAdjustTabSize, "TabData/@RNOAdjustTabSize");
}
}
// adjustment to the horizontal position of the step tab's print macro
private LazyLoad<float?> _MacroTabAdjust;
public float? MacroTabAdjust
{
get
{
return LazyLoad(ref _MacroTabAdjust, "TabData/@MacroTabAdjust");
}
}
// specified font to use for the step tab
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;
}
}
// gets the step tab's bull information if so defined
private Bullet _Bullet;
public Bullet Bullet
{
get
{
return (_Bullet == null) ? _Bullet = new Bullet(base.XmlNode) : _Bullet;
}
}
// will prevent white space from being removed before and after the Tab text
// - only used when tab justification is Centered
private LazyLoad<bool> _NoTrim;
public bool NoTrim
{
get
{
return LazyLoad(ref _NoTrim, "TabData/@NoTrim");
}
}
// use the entire section number when building the step tab - existing logic looked for the text "Attachmen" then used the letter/number that followed it
private LazyLoad<bool> _UseEntireSectionNum;
public bool UseEntireSectionNum
{
get
{
return LazyLoad(ref _UseEntireSectionNum, "TabData/@UseEntireSectionNum");
}
}
// this will remove white space before/after the sequential tab value
// put in for Vogtal Units 3 & 4 formats for continuous action sub-steps
// they have tab value within parenthesis and for a single digit/letter we don't want the white steps before or after it
private LazyLoad<bool> _TrimSeqTabValue;
public bool TrimSeqTabValue
{
get
{
return LazyLoad(ref _TrimSeqTabValue, "TabData/@TrimSeqTabValue");
}
}
}
#endregion StepTab
#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 MacroList
#region Macro
[TypeConverter(typeof(ExpandableObjectConverter))]
public class Macro : vlnFormatItem, IVlnNamedFormatItem
{
public Macro(XmlNode xmlNode) : base(xmlNode) { }
public Macro() : base() { }
// used to identify the tab's print macro
private LazyLoad<string> _Name;
public string Name
{
get
{
return LazyLoad(ref _Name, "@Name");
}
}
// the name of the print macro defined in the format's corresponding SVG (genmac) file
private LazyLoad<string> _MacroDef;
public string MacroDef
{
get
{
if (_Inherited == null) SetupStepInheritance();
return LazyLoad(ref _MacroDef, "@Macro");
}
}
// the name of the print macro defined in the format's corresponding SVG (genmac) file
// that is only used when the step type is used in a single column procedure
private LazyLoad<string> _SingleColMacroDef;
public string SingleColMacroDef
{
get
{
if (_Inherited == null) SetupStepInheritance();
return LazyLoad(ref _SingleColMacroDef, "@SingleColMacro");
}
}
// hard coded horizontal addjustment used before printing the macro
private LazyLoad<float?> _MacroXOffSet;
public float? MacroXOffSet
{
get
{
return LazyLoad(ref _MacroXOffSet, "@MacroXOffSet");
}
}
// a width adjustment to the print macro (usually a negative value)
private LazyLoad<float?> _SingleColWidthAdjust;
public float? SingleColWidthAdjust
{
get
{
return LazyLoad(ref _SingleColWidthAdjust, "@SingleColWidthAdjust");
}
}
// locate the macro along with the tab's offset.
// however, if the tab is more than 2 characters long, adjust so that it aligns with the
// last two characters, not the first 2.
private LazyLoad<bool> _LocWithXOff;
public bool? LocWithXOff
{
get
{
return LazyLoad(ref _LocWithXOff, "@LocWithXOff");
}
}
// Groupings is used to only have the macro if there are N or more of the type in the grouping.
private LazyLoad<int?> _Grouping;
public int? Grouping
{
get
{
if (_Inherited == null) SetupStepInheritance();
return LazyLoad(ref _Grouping, "@Grouping");
}
}
// only add this macro to the result list if the item is not in the RNO column.
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 Macro
#endregion
#region BoxDataAll
#region Box
[TypeConverter(typeof(ExpandableObjectConverter))]
public class Box : vlnFormatItem, IVlnIndexedFormatItem
{
public Box(XmlNode xmlNode) : base(xmlNode) { }
public Box() : base() { }
// used by the step type to reference which box to use (Cautions, Notes)
private LazyLoad<int?> _Index;
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
// This was added to support 3 line box for VC Summer Units 3 & 4 Alarms. It is only checked in the 'double line' vlnbox.cs code!
private LazyLoad<int?> _NumLines;
public int? NumLines
{
get
{
return LazyLoad(ref _NumLines, "@NumLines");
}
}
// the column where the box starts printing
private LazyLoad<float?> _Start;
public float? Start
{
get
{
return LazyLoad(ref _Start, "@Start");
}
}
// the column where to stop printing the box
private LazyLoad<float?> _End;
public float? End
{
get
{
return LazyLoad(ref _End, "@End");
}
}
// column position to start printing the text that is inside the box
private LazyLoad<float?> _TxtStart;
public float? TxtStart
{
get
{
return LazyLoad(ref _TxtStart, "@TxtStart");
}
}
// the length of the text before it wraps to the next line
private LazyLoad<float?> _TxtWidth;
public float? TxtWidth
{
get
{
return LazyLoad(ref _TxtWidth, "@TxtWidth");
}
}
// an absolute position from the left margin where the Caution or Note tab text (box header) is placed within the drawn box - used for boxed Cautions and/or Notes - Caution or Note tab justification needs to be "Centered"
private LazyLoad<float?> _TabPos;
public float? TabPos
{
get
{
return LazyLoad(ref _TabPos, "@TabPos");
}
}
// this will adjust the line spacing when an extra thick line is used for a box, so that the text below the box doesn't hit up against the bottom of the box
private LazyLoad<bool> _ThickDouble; // F2021-026: Barakah single column 2 thick double lines around Warnings
public bool ThickDouble
{
get
{
return LazyLoad(ref _ThickDouble, "@ThickDouble");
}
}
// the character used for the Upper Right Corner of the box
private LazyLoad<string> _BXURC;
public string BXURC
{
get
{
return LazyLoad(ref _BXURC, "@BXURC");
}
}
// the character used to drawn the Horizontal line of the box
private LazyLoad<string> _BXHorz;
public string BXHorz
{
get
{
return LazyLoad(ref _BXHorz, "@BXHorz");
}
}
// the character used for the Upper Left Corner of the box
private LazyLoad<string> _BXULC;
public string BXULC
{
get
{
return LazyLoad(ref _BXULC, "@BXULC");
}
}
// the character used for the vertcal lines of the left and right sides of the box
private LazyLoad<string> _BXVert;
public string BXVert
{
get
{
return LazyLoad(ref _BXVert, "@BXVert");
}
}
// the character used for the left side that connect to a horizontal line
// (usually the char looks like a T that is rotated to the left 90 degrees)
private LazyLoad<string> _BXMLS;
public string BXMLS
{
get
{
return LazyLoad(ref _BXMLS, "@BXMLS");
}
}
// the character used for the right side that connect to a horizontal line
// (usually the char looks like a T that is rotated to the right 90 degrees)
private LazyLoad<string> _BXMRS;
public string BXMRS
{
get
{
return LazyLoad(ref _BXMRS, "@BXMRS");
}
}
// the character used for the Lower (bottom) Right Corner of the box
private LazyLoad<string> _BXLRC;
public string BXLRC
{
get
{
return LazyLoad(ref _BXLRC, "@BXLRC");
}
}
// the character used for the Lower (bottom) Left Corner of the box
private LazyLoad<string> _BXLLC;
public string BXLLC
{
get
{
return LazyLoad(ref _BXLLC, "@BXLLC");
}
}
// character used in the middle of the box an intersection of four cells
// - looks like a big plus sign
private LazyLoad<string> _BXMID;
public string BXMID
{
get
{
return LazyLoad(ref _BXMID, "@BXMID");
}
}
// character used for the Lower Horizontal line (bottom of the box)
private LazyLoad<string> _BXLHorz;
public string BXLHorz
{
get
{
return LazyLoad(ref _BXLHorz, "@BXLHorz");
}
}
// character use on the top line of the box that will connect to a horizontal line in the next row of the box
// - looks like a "T" character
private LazyLoad<string> _BXUMID;
public string BXUMID
{
get
{
return LazyLoad(ref _BXUMID, "@BXUMID");
}
}
// character use on the bottom line of the box that will connect to a horizontal line in the row above- looks like an upside down "T" character
private LazyLoad<string> _BXLMID;
public string BXLMID
{
get
{
return LazyLoad(ref _BXLMID, "@BXLMID");
}
}
// a specific font to use for the box drawing characters
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);
}
// this return string is used in a Switch/Case statement to determin the visual style of the box when printing
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 Box
#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 Boxlist
#endregion BoxDataAll
#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) { }
// a character that is placed before and after the title that's in the transition text
private LazyLoad<string> _DelimiterForTransitionTitle;
public string DelimiterForTransitionTitle
{
get
{
return LazyLoad(ref _DelimiterForTransitionTitle, "@DelimiterForTransitionTitle");
}
}
// used to clean up step/sub-step delimeters so they are all just periods in transitions and are removed when getting step/sub-step tab for some reports
private LazyLoad<string> _StepSubstepDelimeter;
public string StepSubstepDelimeter
{
get
{
return LazyLoad(ref _StepSubstepDelimeter, "@StepSubstepDelimeter");
}
}
// string to use between the first step and last step of the transition ("Through" vs "Thur" etc.)
private LazyLoad<string> _ThroughString;
public string ThroughString
{
get
{
return LazyLoad(ref _ThroughString, "@ThroughString");
}
}
// this will uppercase the transition text
private LazyLoad<bool> _CapsTransitions;
public bool CapsTransitions
{
get
{
return LazyLoad(ref _CapsTransitions, "@CapsTransitions");
}
}
// this will uppercase the section title inside the transition
private LazyLoad<bool> _CapsTransitionsSection;
public bool CapsTransitionsSection
{
get
{
return LazyLoad(ref _CapsTransitionsSection, "@CapsTransitionsSection");
}
}
// this will underline the transsition text
private LazyLoad<bool> _Underline;
public bool Underline
{
get
{
return LazyLoad(ref _Underline, "@Underline");
}
}
// add the high level step number to the sub-step tab in the transition
private LazyLoad<bool> _TStepNoFlag;
public bool TStepNoFlag
{
get
{
return LazyLoad(ref _TStepNoFlag, "@TStepNoFlag");
}
}
// will uppercase AND in And transition type
private LazyLoad<bool> _UpcaseTranAnd;
public bool UpcaseTranAnd
{
get
{
return LazyLoad(ref _UpcaseTranAnd, "@UpcaseTranAnd");
}
}
// will uppercase the first letter of each word in the transition
private LazyLoad<bool> _Cap1stCharTrans;
public bool Cap1stCharTrans
{
get
{
return LazyLoad(ref _Cap1stCharTrans, "@Cap1stCharTrans");
}
}
// Title Case section title in the transition
private LazyLoad<bool> _Cap1stCharTransSection;
public bool Cap1stCharTransSection
{
get
{
return LazyLoad(ref _Cap1stCharTransSection, "@Cap1stCharTransSection");
}
}
// Title Case Section Number in the transition
private LazyLoad<bool> _Cap1stCharTransSectionNumber;
public bool Cap1stCharTransSectionNumber
{
get
{
return LazyLoad(ref _Cap1stCharTransSectionNumber, "@Cap1stCharTransSectionNumber");
}
}
// put parenthesis around section title
private LazyLoad<bool> _ParensAroundSectionTitle;
public bool ParensAroundSectionTitle
{
get
{
return LazyLoad(ref _ParensAroundSectionTitle, "@ParensAroundSectionTitle");
}
}
// turns on the option to add a page number to the transition BUT only for transition types 1, 2, and 4
private LazyLoad<bool> _UseTransitionModifier;
public bool UseTransitionModifier
{
get
{
return LazyLoad(ref _UseTransitionModifier, "@UseTransitionModifier");
}
}
// will include a page number with the transitions - will not turn on option box to add a the page number
private LazyLoad<bool> _UseSpecificTransitionModifier;
public bool UseSpecificTransitionModifier
{
get
{
return LazyLoad(ref _UseSpecificTransitionModifier, "@UseSpecificTransitionModifier");
}
}
// the specific page number is always printed even if it is next or previous page, instead of using the 'Next Page' or 'Previous Page' text
private LazyLoad<bool> _UseSpecificPageNo;
public bool UseSpecificPageNo
{
get
{
return LazyLoad(ref _UseSpecificPageNo, "@UseSpecificPageNo");
}
}
// indclude the section number and section title when the {Sect Hdr} transition format token is used - set to False if we only want the section number
private LazyLoad<bool> _UseSecTitles;
public bool UseSecTitles
{
get
{
return LazyLoad(ref _UseSecTitles, "@UseSecTitles");
}
}
// turn on the section selection list for transitions that use the default steps section
private LazyLoad<bool> _DoSectionTransitions;
public bool DoSectionTransitions
{
get
{
return LazyLoad(ref _DoSectionTransitions, "@DoSectionTransitions");
}
}
// having a default step section specified is not required for transitions with section information
private LazyLoad<bool> _NoDefaultSectReq;
public bool NoDefaultSectReq
{
get
{
return LazyLoad(ref _NoDefaultSectReq, "@NoDefaultSectReq");
}
}
// replace spaces with hard spaces in procedure number
private LazyLoad<bool> _HardSpTranProcNumb;
public bool HardSpTranProcNumb
{
get
{
return LazyLoad(ref _HardSpTranProcNumb, "@HardSpTranProcNumb");
}
}
// replaces the frist occurence of a space to a hard space
private LazyLoad<bool> _XchngTranSpForHard;
public bool XchngTranSpForHard
{
get
{
return LazyLoad(ref _XchngTranSpForHard, "@XchngTranSpForHard");
}
}
// Bold all of the transition text
private LazyLoad<bool> _BoldTransition;
public bool BoldTransition
{
get
{
return LazyLoad(ref _BoldTransition, "@BoldTransition");
}
}
// Bold the transition if it's not in a high level step
private LazyLoad<bool> _BoldTransitionExceptHLS;
public bool BoldTransitionExceptHLS
{
get
{
return LazyLoad(ref _BoldTransitionExceptHLS, "@BoldTransitionExceptHLS");
}
}
// B2017-269 Don't bold transition if a high level step or font for step is bold
private LazyLoad<bool> _BoldTransitionExceptBoldHLS;
public bool BoldTransitionExceptBoldHLS
{
get
{
return LazyLoad(ref _BoldTransitionExceptBoldHLS, "@BoldTransitionExceptBoldHLS");
}
}
// remove the "s" in "Procedure Steps" (section title) when transition references only one step
private LazyLoad<bool> _AdjustStepTransitionText;
public bool AdjustStepTransitionText
{
get
{
return LazyLoad(ref _AdjustStepTransitionText, "@AdjustStepTransitionText");
}
}
// remove the parent/child unit designators from the procedure number in the transition references
private LazyLoad<bool> _ProcLevelPCPC;
public bool ProcLevelPCPC // B2022-004: Remove Proc PC/PC token from transition text
{
get
{
return LazyLoad(ref _ProcLevelPCPC, "@ProcLevelPCPC");
}
}
// F2024-030 for Vogtle Units 3 & 4, added KeepOnePCPCTag flag to keep one of the PC/PC tokens when editing
// keep one of the parent/child unit designators in the transition reference
private LazyLoad<bool> _KeepOnePCPCTag;
public bool KeepOnePCPCTag
{
get
{
return LazyLoad(ref _KeepOnePCPCTag, "@KeepOnePCPCTag");
}
}
}
#endregion TransData
#region TransType
[TypeConverter(typeof(ExpandableObjectConverter))]
public class TransType : vlnFormatItem, IVlnIndexedFormatItem
{
public TransType(XmlNode xmlNode) : base(xmlNode) { }
public TransType() : base() { }
// allows us to re-define a default transition (from BASE format) and create new transition types
private LazyLoad<int?> _Index;
public int? Index
{
get
{
return LazyLoad(ref _Index, "@Index");
}
}
// holdover from 16bit, used to define whether transitions are range (types 2 & 3). this is used in the logic for transitions with page numbers
private LazyLoad<int?> _Type;
public int? Type
{
get
{
return LazyLoad(ref _Type, "@TransType");
}
}
// defines the contents that including in a Transition type.
private LazyLoad<string> _TransFormat;
public string TransFormat
{
get
{
return LazyLoad(ref _TransFormat, "@TransFormat");
}
}
// defines what procedure information is selectable in the User Interface used to select a transition type to insert in the procedure text
private LazyLoad<E_TransUI?> _TransUI;
public E_TransUI? TransUI
{
get
{
return LazyLoad<E_TransUI>(ref _TransUI, "@TransUI");
}
}
// defines what is shown in list of transition types, on the User Interface used to select a transition type to insert in the procedure text
private LazyLoad<string> _TransMenu;
public string TransMenu
{
get
{
return LazyLoad(ref _TransMenu, "@TransMenu");
}
}
//B2019-072: For AEP, use PSI & SI for outside transition text.
// ex: UnitProcSetString ="{PSI:UNITCOM}-{SI:SETNAME}-{PSI:SETID|4023}-" will look for UNITCOM in
// the Procedure Specific Information, then SETNAME in the Set Specific Information (working draft),
// then the SETID in the Procedure Specific Information (or use 4023) if nothing is entered
private LazyLoad<string> _UnitProcSetString;
public string UnitProcSetString
{
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 TransType
#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 TransTypeList
#region RoData
[TypeConverter(typeof(ExpandableObjectConverter))]
public class ROData : vlnFormatItem
{
public ROData(XmlNode xmlNode) : base(xmlNode) { }
//In a sequence of RO values, the unit appears with every value
//(e.g., "25 gpm and 30 gpm" vs. "25 and 30 gpm")
private LazyLoad<bool> _AllUnits;
public bool AllUnits
{
get
{
return LazyLoad(ref _AllUnits, "@AllUnits");
}
}
// If a R0 follows a "- " then it will be uppercased, THE "- " can be anywere in the text before the RO value
private LazyLoad<bool> _UpRoAftrDash;
public bool UpRoAftrDash
{
get
{
return LazyLoad(ref _UpRoAftrDash, "@UpRoAftrDash");
}
}
// Put in for Wolf Creek, where the "- " should be right before the link for the RO to be uppercased.
private LazyLoad<bool> _UpRoImmAftrDashSpace;
public bool UpRoImmAftrDashSpace
{
get
{
return LazyLoad(ref _UpRoImmAftrDashSpace, "@UpRoImmAftrDashSpace");
}
}
// Always uppercase the RO value units (PSI, GPM, etc.)
private LazyLoad<bool> _UpcaseAllRoUnits;
public bool UpcaseAllRoUnits
{
get
{
return LazyLoad(ref _UpcaseAllRoUnits, "@UpcaseAllRoUnits");
}
}
// Forces the units for a RO to be uppercased for high level steps
private LazyLoad<bool> _CapHighRo;
public bool CapHighRo
{
get
{
return LazyLoad(ref _CapHighRo, "@CapHighRo");
}
}
// uppercase ROs anywhere if no lower case text follows and an upper case letter immediately precedes the RO.
private LazyLoad<bool> _CapRoIfLastLower;
public bool CapRoIfLastLower
{
get
{
return LazyLoad(ref _CapRoIfLastLower, "@CapRoIfLastLower");
}
}
// uppercase the RO, if it is a Setpoint type of RO, anywhere if no lower case text follows and an upper case letter immediately precedes the RO.
private LazyLoad<bool> _CapSPIfLastLower;
public bool CapSPIfLastLower
{
get
{
return LazyLoad(ref _CapSPIfLastLower, "@CapSPIfLastLower");
}
}
// Uppercase the RO Unit if the previous letter is uppercase
private LazyLoad<bool> _UpRoIfPrevUpper;
public bool UpRoIfPrevUpper
{
get
{
return LazyLoad(ref _UpRoIfPrevUpper, "@UpRoIfPrevUpper");
}
}
// Underline all ROs, values and Units
private LazyLoad<bool> _UnderlineRo;
public bool UnderlineRo
{
get
{
return LazyLoad(ref _UnderlineRo, "@UnderlineRo");
}
}
// Cap only the first letters of the units in a high level RO
// used in FLP (Turkey Point) format
private LazyLoad<bool> _CapFirstLetterInHighRO;
public bool CapFirstLetterInHighRO
{
get
{
return LazyLoad(ref _CapFirstLetterInHighRO, "@CapFirstLetterInHighRO");
}
}
// put in for Byron and Braidwood which has RO values containing non-PROMS procedure references as ROs.
// need to replace the unicode dash (\u8209?) with the dash character before the RO is resolved in order
// to retain the the upper and lower case lettering of the procedure number in the RO value (B2019-171)
private LazyLoad<bool> _DoSpaceDashBeforeROResolve;
public bool DoSpaceDashBeforeROResolve
{
get
{
return LazyLoad(ref _DoSpaceDashBeforeROResolve, "@DoSpaceDashBeforeROResolve");
}
}
}
#endregion RoData
#endregion TransDataAll
#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 SupportClasses
}
Reference in New Issue View Git Blame Copy Permalink