6825 lines
167 KiB
C#
6825 lines
167 KiB
C#
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; }
|
|
}
|
|
// 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; }
|
|
}
|
|
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;
|
|
}
|
|
}
|
|
private FormatData _FormatData;
|
|
public FormatData FormatData
|
|
{
|
|
get
|
|
{
|
|
if (_FormatData == null) _FormatData = new FormatData(XmlDoc.SelectSingleNode("/PlantFormat/FormatData"));
|
|
return _FormatData;
|
|
}
|
|
}
|
|
private PageStyles _PageStyles;
|
|
public PageStyles PageStyles
|
|
{
|
|
get
|
|
{
|
|
if (_PageStyles == null) _PageStyles = new PageStyles(XmlDoc.SelectNodes("/PlantFormat/PageStyles/PageStyle"));
|
|
return _PageStyles;
|
|
}
|
|
}
|
|
private DocStyles _DocStyles;
|
|
public DocStyles DocStyles
|
|
{
|
|
get
|
|
{
|
|
if (_DocStyles == null) _DocStyles = new DocStyles(XmlDoc.SelectSingleNode("/PlantFormat/DocStyles"));
|
|
return _DocStyles;
|
|
}
|
|
}
|
|
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;
|
|
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 winow 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) { }
|
|
private LazyLoad<string> _Name;
|
|
public string Name
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Name, "@Name");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Express;
|
|
public bool Express
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Express, "@Express");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpecificInfo;
|
|
public bool SpecificInfo
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpecificInfo, "@SpecificInfo");
|
|
}
|
|
}
|
|
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");
|
|
}
|
|
}
|
|
private bool _NewTemplateFormat;
|
|
public bool NewTemplateFormat
|
|
{
|
|
get { return _NewTemplateFormat; }
|
|
set { _NewTemplateFormat = value; }
|
|
}
|
|
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;
|
|
}
|
|
}
|
|
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 '&' rather than '&'.
|
|
string tTPL = TPL.Replace("&", "&");
|
|
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;
|
|
}
|
|
}
|
|
|
|
private LazyLoad<E_PurchaseOptions?> _PurchaseOptions;
|
|
public E_PurchaseOptions? PurchaseOptions
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad<E_PurchaseOptions>(ref _PurchaseOptions, "@PurchaseOptions");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return _Font == null? _Font = new VE_Font(base.XmlNode): _Font;
|
|
}
|
|
}
|
|
private SymbolList _SymbolList;
|
|
public SymbolList SymbolList
|
|
{
|
|
get
|
|
{
|
|
return (_SymbolList == null) ? _SymbolList = new SymbolList(SelectNodes("Symbols/Symbol")) : _SymbolList;
|
|
}
|
|
set { _SymbolList = value; }
|
|
}
|
|
private EditData _EditData;
|
|
public EditData EditData
|
|
{
|
|
get
|
|
{
|
|
return _EditData == null ? _EditData = new EditData(SelectSingleNode("EditData")): _EditData;
|
|
}
|
|
}
|
|
private PrintData _PrintData;
|
|
public PrintData PrintData
|
|
{
|
|
get
|
|
{
|
|
return _PrintData == null? _PrintData = new PrintData(SelectSingleNode("PrintData")):_PrintData;
|
|
}
|
|
}
|
|
private ProcData _ProcData;
|
|
public ProcData ProcData
|
|
{
|
|
get
|
|
{
|
|
return _ProcData == null? _ProcData = new ProcData(SelectSingleNode("ProcData")):_ProcData;
|
|
}
|
|
}
|
|
private SectData _SectData;
|
|
public SectData SectData
|
|
{
|
|
get
|
|
{
|
|
return _SectData == null? _SectData = new SectData(SelectSingleNode("SectData")):_SectData;
|
|
}
|
|
}
|
|
private BoxList _BoxList;
|
|
public BoxList BoxList
|
|
{
|
|
get
|
|
{
|
|
return _BoxList == null? _BoxList = new BoxList(SelectNodes("BoxData/Box"),MyFormat):_BoxList;
|
|
}
|
|
set { _BoxList = value; }
|
|
}
|
|
private TransData _TransData;
|
|
public TransData TransData
|
|
{
|
|
get
|
|
{
|
|
return _TransData == null? _TransData = new TransData(SelectSingleNode("TransData")):_TransData;
|
|
}
|
|
}
|
|
private ROData _ROData;
|
|
public ROData ROData
|
|
{
|
|
get
|
|
{
|
|
return _ROData == null ? _ROData = new ROData(SelectSingleNode("ROData")) : _ROData;
|
|
}
|
|
}
|
|
private StepDataList _StepDataList;
|
|
public StepDataList StepDataList
|
|
{
|
|
get
|
|
{
|
|
return _StepDataList == null? _StepDataList = new StepDataList(SelectNodes("StepData/Step"),MyFormat):_StepDataList;
|
|
}
|
|
set { _StepDataList = value; }
|
|
}
|
|
public List<StepDataRetval> GetSearchableSteps()
|
|
{
|
|
List<StepDataRetval> sds = new List<StepDataRetval>();
|
|
foreach (StepData sd in StepDataList)
|
|
{
|
|
if (!sd.Inactive && sd.StepEditData.Searchable && (sd.StepEditData.TypeMenu.InMenu || sd.Index == 40)) // B2019-016 allow to specify Search of RNO step type
|
|
sds.Add(new StepDataRetval(sd.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(sd.Index)));
|
|
}
|
|
// now add any from the inherited list (but only if type is not in the list)
|
|
IFormatOrFormatInfo parentFormat = MyParentFormat;
|
|
while (parentFormat != null)
|
|
{
|
|
vlnIndexedFormatList<StepData> InheritedList = parentFormat.PlantFormat.FormatData.StepDataList;
|
|
foreach (StepData sd1 in InheritedList)
|
|
{
|
|
if (!sd1.Inactive && sd1.StepEditData.Searchable && sd1.StepEditData.TypeMenu.InMenu)
|
|
{
|
|
// if not in the sds list, add it:
|
|
// note that the list of StepDataRetval (sds) 'Contains' method did not find an existing StepData item - that is why the code loops
|
|
// through list rather than using 'Contains':
|
|
bool found = false;
|
|
foreach (StepDataRetval lrtvl in sds)
|
|
{
|
|
if (lrtvl.Index == sd1.Index)
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found)
|
|
{
|
|
StepDataRetval tmpsdrv = new StepDataRetval(sd1.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(sd1.Index));
|
|
sds.Add(tmpsdrv);
|
|
}
|
|
}
|
|
}
|
|
parentFormat = parentFormat.PlantFormat.FormatData.MyParentFormat;
|
|
}
|
|
return sds;
|
|
}
|
|
public StepData StepTopUnderBase(StepData sd, int formatStepType)
|
|
{
|
|
StepData top = sd;
|
|
while (top.ParentType != "Base")
|
|
{
|
|
bool foundit = false;
|
|
string sParStp = StepDataList[formatStepType].ParentType;
|
|
foreach (StepData stp in StepDataList)
|
|
{
|
|
if (top.ParentType == stp.Type)
|
|
{
|
|
top = stp;
|
|
foundit = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!foundit)
|
|
{
|
|
IFormatOrFormatInfo parentFormat = MyParentFormat;
|
|
while (parentFormat != null && !foundit)
|
|
{
|
|
vlnIndexedFormatList<StepData> InheritedList = parentFormat.PlantFormat.FormatData.StepDataList;
|
|
foreach (StepData stp1 in InheritedList)
|
|
{
|
|
if (top.ParentType == stp1.Type)
|
|
{
|
|
top = stp1;
|
|
foundit = true;
|
|
break;
|
|
}
|
|
}
|
|
parentFormat = parentFormat.PlantFormat.FormatData.MyParentFormat;
|
|
}
|
|
}
|
|
}
|
|
return top;
|
|
}
|
|
public List<StepDataRetval> StepGetLevelTypes(bool alwaysAdd, StepData topType, ref int cursel, string curType, ItemInfo _CurItemInfo)
|
|
{
|
|
if (topType == null) return null;
|
|
List<StepDataRetval> sds = new List<StepDataRetval>();
|
|
int retval = -1;
|
|
int cntitm = 0;
|
|
// if there are alternatenames for this item, use that list, otherwise, get list from
|
|
// xml for current node & its children....
|
|
if (topType.StepEditData.TypeMenu.AlternateNameList != null && topType.StepEditData.TypeMenu.AlternateNameList != "")
|
|
{
|
|
// loop through the AlternateName string, it has indices for step types..
|
|
string[] split = topType.StepEditData.TypeMenu.AlternateNameList.Split(new Char[] { ',' });
|
|
foreach (string s in split)
|
|
{
|
|
foreach (StepData sd in this.StepDataList)
|
|
{
|
|
if (sd.Type == s && !sd.Inactive)
|
|
{
|
|
sds.Add(new StepDataRetval(sd.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(sd.Index)));
|
|
if (curType == sd.Type) retval = cntitm;
|
|
cntitm++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// some menu items (step change types) can only be done in aer column, check for that....
|
|
// also tables and figures off caution/notes must use rno data.
|
|
else if (alwaysAdd || (topType.StepEditData.TypeMenu.InMenu && ((topType.StepEditData.TypeMenu.RnoInMenu) ||
|
|
(!topType.StepEditData.TypeMenu.RnoInMenu && !_CurItemInfo.IsInRNO && !_CurItemInfo.IsCaution && !_CurItemInfo.IsNote) ||
|
|
(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsInRNO) ||
|
|
(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsCaution) ||
|
|
(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsNote))))
|
|
{
|
|
if (!topType.Inactive)
|
|
{
|
|
if ((_CurItemInfo.IsInRNO || _CurItemInfo.IsCaution || _CurItemInfo.IsNote) && topType.StepEditData.TypeMenu.RnoMenuItem != null && topType.StepEditData.TypeMenu.RnoMenuItem != "")
|
|
sds.Add(new StepDataRetval(topType.StepEditData.TypeMenu.RnoMenuItem, Convert.ToInt32(topType.Index)));
|
|
else
|
|
sds.Add(new StepDataRetval(topType.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(topType.Index)));
|
|
|
|
if (topType.Type == curType) retval = cntitm;
|
|
cntitm++;
|
|
}
|
|
bool foundInCur = false;
|
|
foreach (StepData sd in StepDataList)
|
|
{
|
|
if (sd.ParentType == topType.Type)
|
|
{
|
|
int tmpindx = DoListChildStepTypes(alwaysAdd, ref sds, sd, curType, _CurItemInfo, ref cntitm, false);
|
|
if (sd.Type == curType) retval = tmpindx;
|
|
if (retval < 0 && tmpindx > 0) retval = tmpindx;
|
|
foundInCur = true;
|
|
}
|
|
}
|
|
// Handle inheritance (step data may not be in current format, may inherit from parents):
|
|
if (!foundInCur)
|
|
{
|
|
IFormatOrFormatInfo parentFormat = MyParentFormat;
|
|
bool foundit = false;
|
|
while (parentFormat != null && !foundit)
|
|
{
|
|
vlnIndexedFormatList<StepData> InheritedList = parentFormat.PlantFormat.FormatData.StepDataList;
|
|
foreach (StepData sd1 in InheritedList)
|
|
{
|
|
if (sd1.ParentType == topType.Type)
|
|
{
|
|
int tmpindx = DoListChildStepTypes(alwaysAdd, ref sds, sd1, curType, _CurItemInfo, ref cntitm, true);
|
|
if (sd1.Type == curType) retval = tmpindx;
|
|
if (retval < 0 && tmpindx > 0) retval = tmpindx;
|
|
foundit = true; // stop after finding the type in the closest parent, i.e. don't keep walking up tree.
|
|
}
|
|
}
|
|
parentFormat = parentFormat.PlantFormat.FormatData.MyParentFormat;
|
|
}
|
|
}
|
|
}
|
|
cursel = retval;
|
|
return sds;
|
|
}
|
|
|
|
private int DoListChildStepTypes(bool alwaysAdd, ref List<StepDataRetval> sds, StepData topType, string curType, ItemInfo _CurItemInfo, ref int cntitm, bool doInherit)
|
|
{
|
|
int retval = -1;
|
|
if (alwaysAdd || (topType.StepEditData.TypeMenu.InMenu && ((topType.StepEditData.TypeMenu.RnoInMenu) ||
|
|
(!topType.StepEditData.TypeMenu.RnoInMenu && !_CurItemInfo.IsInRNO&&!_CurItemInfo.IsCaution&&!_CurItemInfo.IsNote) ||
|
|
(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsInRNO) ||
|
|
(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsCaution) ||
|
|
(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsNote))))
|
|
{
|
|
if (!topType.Inactive)
|
|
{
|
|
// if equation type && in single column mode, put out the rnomenu list, and skip the AER items
|
|
bool singleColEq = (topType.Type.ToUpper().Contains("EQUATION") && _CurItemInfo.ColumnMode == 0);
|
|
// B2017-004 if a Table type && in single column mode or in a Note or Caution, don't list the AER Table option
|
|
bool singleColTable = (_CurItemInfo.IsTable && ( _CurItemInfo.ColumnMode == 0 || _CurItemInfo.IsInCautionOrNote)); // B2017-206 added parens so substeps types can be listed
|
|
if ((singleColEq ||_CurItemInfo.IsInRNO || _CurItemInfo.IsCaution || _CurItemInfo.IsNote) && topType.StepEditData.TypeMenu.RnoMenuItem != null && topType.StepEditData.TypeMenu.RnoMenuItem != "")
|
|
sds.Add(new StepDataRetval(topType.StepEditData.TypeMenu.RnoMenuItem, Convert.ToInt32(topType.Index)));
|
|
else if (!singleColEq && !singleColTable)
|
|
sds.Add(new StepDataRetval(topType.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(topType.Index)));
|
|
|
|
if (!singleColTable && (!singleColEq || (singleColEq && topType.StepEditData.TypeMenu.RnoMenuItem != null && topType.StepEditData.TypeMenu.RnoMenuItem != "")))
|
|
{
|
|
if (topType.Type == curType) retval = cntitm;
|
|
cntitm++;
|
|
}
|
|
}
|
|
bool foundInCur = false;
|
|
foreach (StepData sd in StepDataList)
|
|
{
|
|
if (sd.ParentType == topType.Type)
|
|
{
|
|
int tmpindx = DoListChildStepTypes(alwaysAdd, ref sds, sd, curType, _CurItemInfo, ref cntitm, false);
|
|
if (sd.Type == curType) retval = tmpindx;
|
|
if (retval < 0 && tmpindx > 0) retval = tmpindx;
|
|
foundInCur = true;
|
|
}
|
|
}
|
|
// Handle inheritance (step data may not be in current format, may inherit from parents):
|
|
if (!foundInCur && doInherit)
|
|
{
|
|
IFormatOrFormatInfo parentFormat = MyParentFormat;
|
|
bool foundit = false;
|
|
while (parentFormat != null && !foundit)
|
|
{
|
|
vlnIndexedFormatList<StepData> InheritedList = parentFormat.PlantFormat.FormatData.StepDataList;
|
|
foreach (StepData sd1 in InheritedList)
|
|
{
|
|
if (sd1.ParentType == topType.Type)
|
|
{
|
|
int tmpindx = DoListChildStepTypes(alwaysAdd, ref sds, sd1, curType, _CurItemInfo, ref cntitm, true);
|
|
if (sd1.Type == curType) retval = tmpindx;
|
|
if (retval < 0 && tmpindx > 0) retval = tmpindx;
|
|
foundit = true;
|
|
}
|
|
}
|
|
parentFormat = parentFormat.PlantFormat.FormatData.MyParentFormat;
|
|
}
|
|
}
|
|
}
|
|
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 Symbols
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Symbol : vlnFormatItem
|
|
{
|
|
public Symbol(XmlNode xmlNode) : base(xmlNode) { }
|
|
public Symbol() : base() { }
|
|
[Category("Ints")]
|
|
private LazyLoad<int?> _Unicode;
|
|
public int? Unicode
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Unicode, "@Unicode");
|
|
}
|
|
}
|
|
[Category("Strings")]
|
|
private LazyLoad<string> _Desc;
|
|
public string Desc
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Desc, "@Desc");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return Desc; }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("Symbol Unicode '{0}' Description '{1}'", Unicode, Desc); }
|
|
public override string GetPDCategory()
|
|
{ return "Supported Symbols"; }
|
|
public override string ToString()
|
|
{
|
|
return Desc;
|
|
}
|
|
}
|
|
[TypeConverter(typeof(vlnListConverter<SymbolList, Symbol>))]
|
|
public class SymbolList : vlnFormatList<Symbol>
|
|
{
|
|
public SymbolList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region Templates
|
|
// the nocolm field -- divided into 4 four-bit subfields;
|
|
// starting with the 4 lowest order bits :
|
|
// field 1 - number of columns
|
|
// field 2 - the header macro to print instead of the text(fixed at 4 for now)
|
|
// field 3 - the number of blank lines after the header macro
|
|
// field 4 - 1 - identifies the template as being boxed, for latter retrieval
|
|
public class TPlate
|
|
{
|
|
public int level; // sub-step level
|
|
public int type; // type of step/substep
|
|
public int start; // starting position (for horizontal only)
|
|
public int width; // width of text in characters (")
|
|
public int row;
|
|
public short nocolm; // 1 or 2 columns - default(0) is one column
|
|
public string text; // text to be automatically entered
|
|
public bool boxed;
|
|
public int hmacro = 0;
|
|
public TPlate(int l, int t, int s, int w, int r, short c, string x)
|
|
{
|
|
level = l;
|
|
type = t;
|
|
start = s;
|
|
width = w;
|
|
row = r;
|
|
nocolm = c;
|
|
hmacro = 0x00F0 & nocolm >> 4;
|
|
if (hmacro > 0) hmacro = 4; // bge - this was in 16bit code
|
|
int blines = (0x0F00 & nocolm) >> 8;
|
|
boxed = ((0xF000 & nocolm) >> 12) != 0;
|
|
nocolm = (short)(0x000F & nocolm);
|
|
text = x;
|
|
}
|
|
}
|
|
#endregion
|
|
#region EditData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class EditData : vlnFormatItem
|
|
{
|
|
public EditData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<E_EMode?> _EMode;
|
|
public E_EMode? EMode
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad<E_EMode>(ref _EMode, "@EMode");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PromptForCautionType;
|
|
public bool PromptForCautionType
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PromptForCautionType, "@PromptForCautionType");
|
|
}
|
|
}
|
|
// Put in for Farley. This puts editor in editoral mode while a spell check being performed
|
|
// - No change bars will be added
|
|
// - existing change bars will remain
|
|
private LazyLoad<bool> _EditoralSpellCheck;
|
|
public bool EditoralSpellCheck
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _EditoralSpellCheck, "@EditoralSpellCheck");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region PrintDataAll
|
|
#region PrintData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class PrintData : vlnFormatItem
|
|
{
|
|
public PrintData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private VersionIdTextList _VersionIdTextList;
|
|
public VersionIdTextList VersionIdTextList
|
|
{
|
|
get
|
|
{
|
|
return _VersionIdTextList == null? _VersionIdTextList = new VersionIdTextList(SelectNodes("VersionIdText/string")):_VersionIdTextList;
|
|
}
|
|
set { _VersionIdTextList = value; }
|
|
}
|
|
private ProcDescrList _ProcDescrList;
|
|
public ProcDescrList ProcDescrList
|
|
{
|
|
get
|
|
{
|
|
return _ProcDescrList == null? _ProcDescrList = new ProcDescrList(SelectNodes("ProcDescrList/ProcDescr")):_ProcDescrList;
|
|
}
|
|
}
|
|
private LazyLoad<int?> _DoPrnDrvrAdjusts;
|
|
public int? DoPrnDrvrAdjusts
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DoPrnDrvrAdjusts, "@DoPrnDrvrAdjusts");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _SupInfoTabOff;
|
|
public int? SupInfoTabOff
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SupInfoTabOff, "@SupInfoTabOff");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SupInfoIncludeParTab;
|
|
public bool SupInfoIncludeParTab
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SupInfoIncludeParTab, "@SupInfoIncludeParTab");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SupInfoAdjustXOffForLongTab;
|
|
public bool SupInfoAdjustXOffForLongTab
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SupInfoAdjustXOffForLongTab, "@SupInfoAdjustXOffForLongTab");
|
|
}
|
|
}
|
|
private LazyLoad<string> _TopOfPageThing;
|
|
public string TopOfPageThing
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TopOfPageThing, "@TopOfPageThing");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _DoRevDate;
|
|
public bool DoRevDate
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DoRevDate, "@DoRevDate");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AlternateFoldoutPages;
|
|
public bool AlternateFoldoutPages
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AlternateFoldoutPages, "@AlternateFoldoutPages");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AlternateFloatingFoldout;
|
|
public bool AlternateFloatingFoldout
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AlternateFloatingFoldout, "@AlternateFloatingFoldout");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SectionLevelFoldouts;
|
|
public bool SectionLevelFoldouts
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SectionLevelFoldouts, "@SectionLevelFoldouts");
|
|
}
|
|
}
|
|
private LazyLoad<string> _SlashReplace;
|
|
public string SlashReplace
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SlashReplace, "@SlashReplace");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _RevDateWithForwardSlash;
|
|
public bool RevDateWithForwardSlash
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RevDateWithForwardSlash, "@RevDateWithForwardSlash");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UnitNumber;
|
|
public bool UnitNumber
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UnitNumber, "@UnitNumber");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _OutSideTransSetName; //B2019-072: For AEP, use PSI & SI for outside transition text
|
|
public bool OutSideTransSetName
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _OutSideTransSetName, "@OutSideTransSetName");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpecialCaseCalvert;
|
|
public bool SpecialCaseCalvert
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpecialCaseCalvert, "@SpecialCaseCalvert");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpecialCaseCalvertAlarm;
|
|
public bool SpecialCaseCalvertAlarm
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpecialCaseCalvertAlarm, "@SpecialCaseCalvertAlarm");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpecialCaseCalvertPagination;
|
|
public bool SpecialCaseCalvertPagination
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpecialCaseCalvertPagination, "@SpecialCaseCalvertPagination");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _WCNTraining;
|
|
public bool WCNTraining
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _WCNTraining, "@WCNTraining");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _HorizontalSubsteps;
|
|
public bool HorizontalSubsteps
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _HorizontalSubsteps, "@HorizontalSubsteps");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpecialStepsFoldout;
|
|
public bool SpecialStepsFoldout
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpecialStepsFoldout, "@SpecialStepsFoldout");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AllowDuplex;
|
|
public bool AllowDuplex
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AllowDuplex, "@AllowDuplex");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AccessoryDocsInDuplex;
|
|
public bool AccessoryDocsInDuplex
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AccessoryDocsInDuplex, "@AccessoryDocsInDuplex");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _FoldoutsInDuplex;
|
|
public bool FoldoutsInDuplex
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _FoldoutsInDuplex, "@FoldoutsInDuplex");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PagelistChangeIDsWithCommas;
|
|
public bool PagelistChangeIDsWithCommas
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PagelistChangeIDsWithCommas, "@PagelistChangeIDsWithCommas");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpecialCaseWestinghouse;
|
|
public bool SpecialCaseWestinghouse
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpecialCaseWestinghouse, "@SpecialCaseWestinghouse");
|
|
}
|
|
}
|
|
// Put in for Comanche Peak to print "COMMON" for the unit number instead of "Unit 0"
|
|
private LazyLoad<bool> _PrintCommonForZeroUnit;
|
|
public bool PrintCommonForZeroUnit
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PrintCommonForZeroUnit, "@PrintCommonForZeroUnit");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region VersionIdText
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class VersionIdText : vlnFormatItem
|
|
{
|
|
public VersionIdText(XmlNode xmlNode) : base(xmlNode) { }
|
|
public VersionIdText() : base() { }
|
|
private LazyLoad<string> _Text;
|
|
public string Text
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Text, "text()");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return "Text"; }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("VersionIdText '{0}'", Text); }
|
|
public override string GetPDCategory()
|
|
{ return "Version Id Text"; }
|
|
public override string ToString()
|
|
{
|
|
return Text;
|
|
}
|
|
}
|
|
#endregion
|
|
#region VersionIdTextList
|
|
[TypeConverter(typeof(vlnListConverter<VersionIdTextList, VersionIdText>))]
|
|
public class VersionIdTextList : vlnFormatList<VersionIdText>
|
|
{
|
|
public VersionIdTextList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region ProcDescr
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public partial class ProcDescr : vlnFormatItem //: BusinessBase<ProcDescr>, IDisposable
|
|
{
|
|
public ProcDescr(XmlNode xmlNode) : base(xmlNode) { }
|
|
public ProcDescr() : base() { }
|
|
private LazyLoad<string> _MatchProcNumber;
|
|
public string MatchProcNumber
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MatchProcNumber, "@MatchProcNumber");
|
|
}
|
|
}
|
|
private LazyLoad<string> _ProcDescr1;
|
|
public string ProcDescr1
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ProcDescr1, "@ProcDescr1");
|
|
}
|
|
}
|
|
private LazyLoad<string> _ProcDescr2;
|
|
public string ProcDescr2
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ProcDescr2, "@ProcDescr2");
|
|
}
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0}, {1}", ProcDescr1, MatchProcNumber);
|
|
}
|
|
}
|
|
#region ProcDescrList
|
|
[TypeConverter(typeof(vlnListConverter<ProcDescrList, ProcDescr>))]
|
|
public class ProcDescrList : vlnFormatList<ProcDescr>
|
|
{
|
|
public ProcDescrList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#endregion
|
|
#region ProcDataAll
|
|
#region ProcData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ProcData : vlnFormatItem
|
|
{
|
|
public ProcData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private ProcedureSuffixList _ProcedureSuffixList;
|
|
public ProcedureSuffixList ProcedureSuffixList
|
|
{
|
|
get
|
|
{
|
|
return _ProcedureSuffixList == null ? _ProcedureSuffixList = new ProcedureSuffixList(SelectNodes("ProcedureSuffix/string")) : _ProcedureSuffixList;
|
|
}
|
|
set { _ProcedureSuffixList = value; }
|
|
}
|
|
private ChangeBarData _ChangeBarData;
|
|
public ChangeBarData ChangeBarData
|
|
{
|
|
get
|
|
{
|
|
return _ChangeBarData == null ? _ChangeBarData = new ChangeBarData(SelectSingleNode("ChangeBarData")) : _ChangeBarData;
|
|
}
|
|
}
|
|
private CheckOffData _CheckOffData;
|
|
public CheckOffData CheckOffData
|
|
{
|
|
get
|
|
{
|
|
return _CheckOffData == null ? _CheckOffData = new CheckOffData(SelectSingleNode("CheckOffData")) : _CheckOffData;
|
|
}
|
|
}
|
|
private PSI _PSI;
|
|
public PSI PSI
|
|
{
|
|
get
|
|
{
|
|
return _PSI == null ? _PSI = new PSI(SelectSingleNode("PSI")) : _PSI;
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CheckOffUCF;
|
|
public bool CheckOffUCF
|
|
{
|
|
get
|
|
{
|
|
// The following line is used in UCF: this needs to be able to control a change in setting in UCF versus its use:
|
|
// This is a special case since the original format, using the value in BaseAll, is always 'false'. And the value
|
|
// should never be set in original volian plant format files, if the additional UCF checkoffs are to be used, this must
|
|
// be set in the UCF user interface.
|
|
if (PlantFormat.DoingUCFCheckOffs) return PlantFormat.DoingUCFCheckOffsUse;
|
|
|
|
if (PlantFormat.IgnoreUCF) return LazyLoad(ref _CheckOffUCF, "@CheckOffUCF");
|
|
bool? localvalue = null; // comes to here if in edit or print - use any UCF data before going to original format.
|
|
FormatConfig fc = PlantFormat.GetFormatConfig(MyFormat);
|
|
if (fc != null) localvalue = fc.PlantFormat.FormatData.Flags.CheckOffUCF;
|
|
return localvalue ?? LazyLoad(ref _CheckOffUCF, "@CheckOffUCF");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TitleLength;
|
|
public int? TitleLength
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TitleLength, "@TitleLength");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _CoverTitleLength;
|
|
public int? CoverTitleLength
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CoverTitleLength, "@CoverTitleLength");
|
|
}
|
|
}
|
|
private LazyLoad<string> _ProcedureSuffixFlags;
|
|
public string ProcedureSuffixFlags
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ProcedureSuffixFlags, "@ProcedureSuffixFlags");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CapitalizeTitle;
|
|
public bool CapitalizeTitle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CapitalizeTitle, "@CapitalizeTitle");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ChangeStyleForEverySection;
|
|
public bool ChangeStyleForEverySection
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ChangeStyleForEverySection, "@ChangeStyleForEverySection");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PrintNoTitle;
|
|
public bool PrintNoTitle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PrintNoTitle, "@PrintNoTitle");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NotesToFootnotes;
|
|
public bool NotesToFootnotes
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NotesToFootnotes, "@NotesToFootnotes");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CountFoldoutPages;
|
|
public bool CountFoldoutPages
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CountFoldoutPages, "@CountFoldoutPages");
|
|
}
|
|
}
|
|
private LazyLoad<string> _ForeColor;
|
|
public string ForeColor
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ForeColor, "@ForeColor");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BackColor;
|
|
public string BackColor
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BackColor, "@BackColor");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region ProcedureSuffix
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ProcedureSuffix : vlnFormatItem
|
|
{
|
|
public ProcedureSuffix(XmlNode xmlNode) : base(xmlNode) { }
|
|
public ProcedureSuffix() : base() { }
|
|
private LazyLoad<string> _Text;
|
|
public string Text
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Text, "text()");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return "Text"; }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("ProcedureSuffix '{0}'", Text); }
|
|
public override string GetPDCategory()
|
|
{ return "Procedure Suffix"; }
|
|
public override string ToString()
|
|
{
|
|
return Text;
|
|
}
|
|
}
|
|
#endregion
|
|
#region ProcedureSuffixList
|
|
[TypeConverter(typeof(vlnListConverter<ProcedureSuffixList, ProcedureSuffix>))]
|
|
public class ProcedureSuffixList : vlnFormatList<ProcedureSuffix>
|
|
{
|
|
public ProcedureSuffixList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region PsiAll
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class PSI : vlnFormatItem
|
|
{
|
|
public PSI(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<int?> _x;
|
|
public int? x
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _x, "@x");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _y;
|
|
public int? y
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _y, "@y");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Caption;
|
|
public string Caption
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Caption, "@Caption");
|
|
}
|
|
}
|
|
private LazyLoad<string> _ButtonsOnBottom; // change to bool
|
|
public string ButtonsOnBottom
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ButtonsOnBottom, "@ButtonsOnBottom");
|
|
}
|
|
}
|
|
private SILabels _LabelList;
|
|
public SILabels LabelList
|
|
{
|
|
get
|
|
{
|
|
return _LabelList == null ? _LabelList = new SILabels(SelectNodes("/PlantFormat/FormatData/ProcData/PSI/Label")) : _LabelList;
|
|
}
|
|
}
|
|
private SIFields _FieldList;
|
|
public SIFields FieldList
|
|
{
|
|
get
|
|
{
|
|
return _FieldList == null ? _FieldList = new SIFields(SelectNodes("/PlantFormat/FormatData/ProcData/PSI/Field")) : _FieldList;
|
|
}
|
|
}
|
|
}
|
|
public class SILabels : vlnFormatList<SILabel>
|
|
{
|
|
public SILabels(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
|
|
public class SILabel : vlnFormatItem
|
|
{
|
|
public SILabel(XmlNode xmlNode) : base(xmlNode) { }
|
|
public SILabel() : base() { }
|
|
private LazyLoad<string> _text;
|
|
public string text
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _text, "@text");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Justify;
|
|
public string Justify
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Justify, "@Justify");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _x;
|
|
public int? x
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _x, "@x");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _y;
|
|
public int? y
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _y, "@y");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _width;
|
|
public int? width
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _width, "@width");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _height;
|
|
public int? height
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _height, "@height");
|
|
}
|
|
}
|
|
}
|
|
public class SIFields : vlnFormatList<SIField>
|
|
{
|
|
public SIFields(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
public class SIField : vlnFormatItem
|
|
{
|
|
public SIField(XmlNode xmlNode) : base(xmlNode) { }
|
|
public SIField() : base() { }
|
|
private LazyLoad<string> _name;
|
|
public string name
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _name, "@name");
|
|
}
|
|
}
|
|
private LazyLoad<string> _type;
|
|
public string type
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _type, "@type");
|
|
}
|
|
}
|
|
private LazyLoad<string> _text;
|
|
public string text
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _text, "@text");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _Length;
|
|
public int? Length
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Length, "@Length");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _x;
|
|
public int? x
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _x, "@x");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _y;
|
|
public int? y
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _y, "@y");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _width;
|
|
public int? width
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _width, "@width");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _height;
|
|
public int? height
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _height, "@height");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region SIAll
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class SI : vlnFormatItem
|
|
{
|
|
public SI(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<int?> _x;
|
|
public int? x
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _x, "@x");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _y;
|
|
public int? y
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _y, "@y");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Caption;
|
|
public string Caption
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Caption, "@Caption");
|
|
}
|
|
}
|
|
private LazyLoad<string> _ButtonsOnBottom; // change to bool
|
|
public string ButtonsOnBottom
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ButtonsOnBottom, "@ButtonsOnBottom");
|
|
}
|
|
}
|
|
private SILabels _LabelList;
|
|
public SILabels LabelList
|
|
{
|
|
get
|
|
{
|
|
return _LabelList == null ? _LabelList = new SILabels(SelectNodes("/PlantFormat/FormatData/SI/Label")) : _LabelList;
|
|
}
|
|
}
|
|
private SIFields _FieldList;
|
|
public SIFields FieldList
|
|
{
|
|
get
|
|
{
|
|
return _FieldList == null ? _FieldList = new SIFields(SelectNodes("/PlantFormat/FormatData/SI/Field")) : _FieldList;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region CheckOffAll
|
|
#region CheckOffData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class CheckOffData : vlnFormatItem
|
|
{
|
|
public CheckOffData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private CheckOffList _CheckOffList = null;
|
|
public CheckOffList CheckOffList
|
|
{
|
|
get
|
|
{
|
|
if (_CheckOffList != null) return _CheckOffList;
|
|
|
|
// Get a list of checkoffs that should be included:
|
|
// if !UseCheckOffUCF (Baseall has it as false. User can change setting in UCF to true)
|
|
// if !IgnoreUCF, i.e. use UCF changes, return original lists with only active items (Inactive = false)
|
|
// if IgnoreUCF, return original lists with all items
|
|
// if UseCheckOffUCF is true use the merged lists from current format and baseall.xml and
|
|
// do the same processing for IgnoreUCF described above.
|
|
|
|
// UseCheckOffUCF is false or there is no FormatConfig (UCF) data:
|
|
FormatConfig fc = PlantFormat.GetFormatConfig(MyFormat);
|
|
if (!MyFormat.PlantFormat.FormatData.ProcData.CheckOffUCF || fc==null)
|
|
{
|
|
_CheckOffList = new CheckOffList(SelectNodes("CheckOffList/CheckOff"), MyFormat);
|
|
// B2019-100: If Ignoring the UCF data, just return the entire list. Also, return entire list if there is no UCF data (fc == null)
|
|
if (PlantFormat.IgnoreUCF || fc == null) return _CheckOffList;
|
|
// If not ignoring UCF settings, only return those that are active
|
|
foreach (FormatConfig.CheckOff co in fc.PlantFormat.FormatData.CheckOffList)
|
|
{
|
|
foreach (CheckOff coo in _CheckOffList)
|
|
{
|
|
if ((int)coo.Index == Convert.ToInt32(co.Index) && !(bool)co.Active)
|
|
{
|
|
_CheckOffList.Remove(coo);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return _CheckOffList;
|
|
}
|
|
// UseCheckOfffUCF is true:
|
|
// merge the checkoff list from the current format and the checkoff list from the base format
|
|
_CheckOffList = new CheckOffList(SelectNodes("CheckOffList/CheckOff"), MyFormat);
|
|
CheckOffList retlist2 = new CheckOffList(SelectNodes("../CheckOffDataUCF/CheckOffList/CheckOff"), MyFormat);
|
|
if (retlist2 != null && retlist2.Count > 0) foreach (CheckOff co in retlist2) _CheckOffList.Add(co);
|
|
if (PlantFormat.IgnoreUCF) return _CheckOffList;
|
|
|
|
// if applying UCF, then remove those that are inactive:
|
|
foreach (FormatConfig.CheckOff co in fc.PlantFormat.FormatData.CheckOffList)
|
|
{
|
|
foreach (CheckOff coo in _CheckOffList)
|
|
{
|
|
if ((int)coo.Index == Convert.ToInt32(co.Index) && !(bool)co.Active)
|
|
{
|
|
_CheckOffList.Remove(coo);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return _CheckOffList;
|
|
}
|
|
}
|
|
public void ClearCheckOffAndHeaderLists()
|
|
{
|
|
_CheckOffList = null;
|
|
_CheckOffHeaderList = null;
|
|
}
|
|
private CheckOffHeaderList _CheckOffHeaderList;
|
|
public CheckOffHeaderList CheckOffHeaderList
|
|
{
|
|
get
|
|
{
|
|
if (_CheckOffHeaderList != null) return _CheckOffHeaderList;
|
|
FormatConfig fc = PlantFormat.GetFormatConfig(MyFormat);
|
|
if (!MyFormat.PlantFormat.FormatData.ProcData.CheckOffUCF || fc == null)
|
|
{
|
|
_CheckOffHeaderList = new CheckOffHeaderList(SelectNodes("CheckOffHeaderList/CheckOffHeader"), MyFormat);
|
|
// Depending on the IgnoreUCF flag, either return this list with UCF Inactive flags set or return the
|
|
// list as is.
|
|
if (PlantFormat.IgnoreUCF || fc == null) return _CheckOffHeaderList;
|
|
// If not ignoring UCF settings, only return those that are active
|
|
foreach (FormatConfig.CheckOffHeader coh in fc.PlantFormat.FormatData.CheckOffHeaderList)
|
|
{
|
|
foreach (CheckOffHeader coo in _CheckOffHeaderList)
|
|
{
|
|
if ((int)coo.Index == Convert.ToInt32(coh.Index) && !(bool)coh.Active)
|
|
{
|
|
_CheckOffHeaderList.Remove(coo);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return _CheckOffHeaderList;
|
|
}
|
|
// merge the checkoff header lists from the current format and the list from the base
|
|
_CheckOffHeaderList = new CheckOffHeaderList(SelectNodes("CheckOffHeaderList/CheckOffHeader"), MyFormat);
|
|
CheckOffHeaderList retlist2 = new CheckOffHeaderList(SelectNodes("../CheckOffDataUCF/CheckOffHeaderList/CheckOffHeader"), MyFormat);
|
|
if (retlist2 != null && retlist2.Count > 0) foreach (CheckOffHeader co in retlist2) _CheckOffHeaderList.Add(co);
|
|
if (PlantFormat.IgnoreUCF) return _CheckOffHeaderList;
|
|
|
|
// if applying UCF, then remove those that are inactive.
|
|
foreach (FormatConfig.CheckOffHeader coh in fc.PlantFormat.FormatData.CheckOffHeaderList)
|
|
{
|
|
foreach (CheckOffHeader cooh in _CheckOffHeaderList)
|
|
{
|
|
if ((int)cooh.Index == Convert.ToInt32(coh.Index) && !(bool)coh.Active)
|
|
{
|
|
_CheckOffHeaderList.Remove(cooh);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return _CheckOffHeaderList;
|
|
}
|
|
}
|
|
public void CheckOffHeaderListRefresh(bool CheckOffUCF)
|
|
{
|
|
if (!CheckOffUCF)
|
|
{
|
|
_CheckOffHeaderList = new CheckOffHeaderList(SelectNodes("CheckOffHeaderList/CheckOffHeader"), MyFormat);
|
|
// Depending on the IgnoreUCF flag, either return this list with UCF Inactive flags set or return the
|
|
// list as is.
|
|
FormatConfig fc = PlantFormat.GetFormatConfig(MyFormat);
|
|
if (PlantFormat.IgnoreUCF || fc == null) return;
|
|
// If not ignoring UCF settings, only return those that are active
|
|
foreach (FormatConfig.CheckOffHeader coh in fc.PlantFormat.FormatData.CheckOffHeaderList)
|
|
{
|
|
foreach (CheckOffHeader coo in _CheckOffHeaderList)
|
|
{
|
|
if ((int)coo.Index == Convert.ToInt32(coh.Index) && !(bool)coh.Active)
|
|
{
|
|
_CheckOffHeaderList.Remove(coo);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
// if coming from the UCF dialog, then check for the 'ignoreUCF' this will flag whether to only
|
|
// merge the checkoff header lists from the current format and the list from the base
|
|
CheckOffHeaderList retlist = new CheckOffHeaderList(SelectNodes("CheckOffHeaderList/CheckOffHeader"), MyFormat);
|
|
CheckOffHeaderList retlist2 = new CheckOffHeaderList(SelectNodes("../CheckOffDataUCF/CheckOffHeaderList/CheckOffHeader"), MyFormat);
|
|
if (retlist2 != null && retlist2.Count > 0) foreach (CheckOffHeader co in retlist2) retlist.Add(co);
|
|
_CheckOffHeaderList = retlist;
|
|
}
|
|
private LazyLoad<bool> _CheckOffHeaderInPagelist;
|
|
public bool CheckOffHeaderInPagelist
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOffHeaderInPagelist, "@CheckOffHeaderInPagelist");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Menu;
|
|
public string Menu
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Menu, "@Menu");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AllowSectEdit;
|
|
public bool AllowSectEdit
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AllowSectEdit, "@AllowSectEdit");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AllowStepEdit;
|
|
public bool AllowStepEdit
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AllowStepEdit, "@AllowStepEdit");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _UseCheckOffsIn;
|
|
public int? UseCheckOffsIn
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseCheckOffsIn, "@UseCheckOffsIn");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _CheckOffAdjustment;
|
|
public float? CheckOffAdjustment
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOffAdjustment, "@CheckOffAdjustment");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _XLocation;
|
|
public float? XLocation
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _XLocation, "@XLocation");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _RelXLocation;
|
|
public float? RelXLocation
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RelXLocation, "@RelXLocation");
|
|
}
|
|
}
|
|
|
|
private LazyLoad<bool> _DropCheckOff;
|
|
public bool DropCheckOff
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DropCheckOff, "@DropCheckOff");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CheckOffOnHLSOnly;
|
|
public bool CheckOffOnHLSOnly
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOffOnHLSOnly, "@CheckOffOnHLSOnly");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SkipSpaces;
|
|
public bool SkipSpaces
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SkipSpaces, "@SkipSpaces");
|
|
}
|
|
}
|
|
// put in for Bryon and Braidwood
|
|
private LazyLoad<bool> _CheckoffOnSubStepsOnly;
|
|
public bool CheckoffOnSubStepsOnly
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckoffOnSubStepsOnly, "@CheckoffOnSubStepsOnly");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region CheckOff
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class CheckOff : vlnFormatItem,IVlnIndexedFormatItem
|
|
{
|
|
public CheckOff(XmlNode xmlNode) : base(xmlNode) { }
|
|
public CheckOff() : base() { }
|
|
private LazyLoad<int?> _Index;
|
|
public int? Index
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Index, "@Index");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _UIMark;
|
|
public int? UIMark
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UIMark, "@UIMark");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _CheckOffWidAdjust;
|
|
public float? CheckOffWidAdjust
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOffWidAdjust, "@CheckOffWidAdjust");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _CheckOffXtraLines;
|
|
public float? CheckOffXtraLines
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOffXtraLines, "@CheckOffXtraLines");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _CheckOffNumberOfLines;
|
|
public float? CheckOffNumberOfLines
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOffNumberOfLines, "@CheckOffNumberOfLines");
|
|
}
|
|
}
|
|
private LazyLoad<string> _MenuItem;
|
|
public string MenuItem
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MenuItem, "@MenuItem");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Macro;
|
|
public string Macro
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Macro, "@Macro");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NotOnEmpty;
|
|
public bool NotOnEmpty
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NotOnEmpty, "@NotOnEmpty");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _DropCheckOff;
|
|
public bool DropCheckOff
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DropCheckOff, "@DropCheckOff");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return string.Format("[{0}]",Index); }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("[{0}] - {1}", Index, MenuItem); }
|
|
public override string GetPDCategory()
|
|
{ return "Checkoff Data"; }
|
|
public override string ToString()
|
|
{
|
|
return MenuItem;
|
|
}
|
|
}
|
|
#endregion
|
|
#region CheckOffList
|
|
[TypeConverter(typeof(vlnIndexedListConverter<CheckOffList, CheckOff>))]
|
|
public class CheckOffList : vlnIndexedFormatList<CheckOff>
|
|
{
|
|
public CheckOffList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
|
|
public override vlnIndexedFormatList<CheckOff> InheritedList
|
|
{
|
|
get
|
|
{
|
|
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
|
|
if (parentFormat != null)
|
|
return parentFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffList;
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region CheckOffHeader
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class CheckOffHeader : vlnFormatItem,IVlnIndexedFormatItem
|
|
{
|
|
public CheckOffHeader(XmlNode xmlNode) : base(xmlNode) { }
|
|
public CheckOffHeader() : base() { }
|
|
private LazyLoad<int?> _Index;
|
|
public int? Index
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Index, "@Index");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
|
|
}
|
|
}
|
|
private LazyLoad<string> _CheckOffHeading;
|
|
public string CheckOffHeading
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOffHeading, "@CheckOffHeading");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return string.Format("[{0}]", Index); }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("[{0}] - {1}", Index, CheckOffHeading); }
|
|
public override string GetPDCategory()
|
|
{ return "Checkoff Header Data"; }
|
|
public override string ToString()
|
|
{
|
|
return CheckOffHeading;
|
|
}
|
|
}
|
|
#endregion
|
|
#region CheckOffHeaderList
|
|
[TypeConverter(typeof(vlnIndexedListConverter<CheckOffHeaderList, CheckOffHeader>))]
|
|
public class CheckOffHeaderList : vlnIndexedFormatList<CheckOffHeader>
|
|
{
|
|
public CheckOffHeaderList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
|
|
public override vlnIndexedFormatList<CheckOffHeader> InheritedList
|
|
{
|
|
get
|
|
{
|
|
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
|
|
if (parentFormat != null)
|
|
return parentFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffHeaderList;
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region ChangeBarData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ChangeBarData : vlnFormatItem
|
|
{
|
|
public ChangeBarData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<string> _DefaultCBLoc;
|
|
public string DefaultCBLoc
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DefaultCBLoc, "@DefaultCBLoc");
|
|
}
|
|
}
|
|
private LazyLoad<string> _ChangeBarMessage;
|
|
public string ChangeBarMessage
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ChangeBarMessage, "@ChangeBarMessage");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _FixedChangeColumn;
|
|
public int? FixedChangeColumn
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _FixedChangeColumn, "@FixedChangeColumn");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _FixedAERChangeColumn;
|
|
public int? FixedAERChangeColumn
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _FixedAERChangeColumn, "@FixedAERChangeColumn");
|
|
}
|
|
}
|
|
private LazyLoad<E_Style?> _ChangeSummaryStyle;
|
|
public E_Style? ChangeSummaryStyle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad<E_Style>(ref _ChangeSummaryStyle, "@ChangeSummaryStyle");
|
|
}
|
|
}
|
|
private LazyLoad<E_Style?> _ChangeBarStyle;
|
|
public E_Style? ChangeBarStyle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad<E_Style>(ref _ChangeBarStyle, "@ChangeBarStyle");
|
|
}
|
|
}
|
|
private LazyLoad<string> _SpecialChangeBar;
|
|
public string SpecialChangeBar
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpecialChangeBar, "@SpecialChangeBar");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CondensedChangeBar;
|
|
public bool CondensedChangeBar
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CondensedChangeBar, "@CondensedChangeBar");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AbsoluteFixedChangeColumn;
|
|
public bool AbsoluteFixedChangeColumn
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AbsoluteFixedChangeColumn, "@AbsoluteFixedChangeColumn");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ContinuousChangeBars;
|
|
public bool ContinuousChangeBars
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ContinuousChangeBars, "@ContinuousChangeBars");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ChgBarMessageFromEdit;
|
|
public bool ChgBarMessageFromEdit
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ChgBarMessageFromEdit, "@ChgBarMessageFromEdit");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ChangeIds;
|
|
public bool ChangeIds
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ChangeIds, "@ChangeIds");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ChangeBarToRNOSep;
|
|
public bool ChangeBarToRNOSep
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ChangeBarToRNOSep, "@ChangeBarToRNOSep");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ChangeBarsOnLinkedText;
|
|
public bool ChangeBarsOnLinkedText
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ChangeBarsOnLinkedText, "@ChangeBarsOnLinkedText");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region SectDataAll
|
|
#region SectData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class SectData : vlnFormatItem
|
|
{
|
|
public SectData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private SectionNumber _SectionNumber;
|
|
public SectionNumber SectionNumber
|
|
{
|
|
get
|
|
{
|
|
if (_SectionNumber == null) _SectionNumber = new SectionNumber(SelectSingleNode("SectionNumber"));
|
|
return _SectionNumber;
|
|
}
|
|
}
|
|
private SectionHeader _SectionHeader;
|
|
public SectionHeader SectionHeader
|
|
{
|
|
get
|
|
{
|
|
if (_SectionHeader == null) _SectionHeader = new SectionHeader(SelectSingleNode("SectionHeader"));
|
|
return _SectionHeader;
|
|
}
|
|
}
|
|
private SectionHeaderSeparatorLine _SectionHeaderSeparatorLine;
|
|
public SectionHeaderSeparatorLine SectionHeaderSeparatorLine
|
|
{
|
|
get
|
|
{
|
|
if (_SectionHeaderSeparatorLine == null) _SectionHeaderSeparatorLine = new SectionHeaderSeparatorLine(SelectSingleNode("SectionHeaderSeparatorLine"));
|
|
return _SectionHeaderSeparatorLine;
|
|
}
|
|
}
|
|
private StepSectionData _StepSectionData;
|
|
public StepSectionData StepSectionData
|
|
{
|
|
get
|
|
{
|
|
if (_StepSectionData == null) _StepSectionData = new StepSectionData(SelectSingleNode("StepSectionData"));
|
|
return _StepSectionData;
|
|
}
|
|
}
|
|
private AccSectionData _AccSectionData;
|
|
public AccSectionData AccSectionData
|
|
{
|
|
get
|
|
{
|
|
if (_AccSectionData == null) _AccSectionData = new AccSectionData(SelectSingleNode("AccSectionData"));
|
|
return _AccSectionData;
|
|
}
|
|
}
|
|
private MetaSectionList _MetaSectionList;
|
|
public MetaSectionList MetaSectionList
|
|
{
|
|
get
|
|
{
|
|
if (_MetaSectionList == null) _MetaSectionList = new MetaSectionList(SelectNodes("MetaSectionData/MetaSection"),MyFormat);
|
|
return _MetaSectionList;
|
|
}
|
|
set { _MetaSectionList = value; }
|
|
}
|
|
private ReplaceStrList _ReplaceStrList;
|
|
public ReplaceStrList ReplaceStrList
|
|
{
|
|
get
|
|
{
|
|
return (_ReplaceStrList == null) ? _ReplaceStrList = new ReplaceStrList(SelectNodes("ReplaceStrData/ReplaceStr")) : _ReplaceStrList;
|
|
}
|
|
set { _ReplaceStrList = value; }
|
|
}
|
|
private ReplaceSymbolCharList _ReplaceSymbolCharList;
|
|
public ReplaceSymbolCharList ReplaceSymbolCharList
|
|
{
|
|
get
|
|
{
|
|
return (_ReplaceSymbolCharList == null) ? _ReplaceSymbolCharList = new ReplaceSymbolCharList(SelectNodes("ReplaceSymbolChars/ReplaceChar"),MyFormat) : _ReplaceSymbolCharList;
|
|
}
|
|
set { _ReplaceSymbolCharList = value; }
|
|
}
|
|
private LazyLoad<int?> _SectionTitleLength;
|
|
public int? SectionTitleLength
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SectionTitleLength, "@SectionTitleLength");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _SectionNumberAndTitleLength;
|
|
public int? SectionNumberAndTitleLength
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SectionNumberAndTitleLength, "@SectionNumberAndTitleLength");
|
|
}
|
|
}
|
|
private LazyLoad<string> _ForeColor;
|
|
public string ForeColor
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ForeColor, "@ForeColor");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BackColor;
|
|
public string BackColor
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BackColor, "@BackColor");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _MetaSectEndMessage;
|
|
public bool MetaSectEndMessage
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MetaSectEndMessage, "@MetaSectEndMessage");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ReadOnlyTypeInContMsg;
|
|
public bool ReadOnlyTypeInContMsg
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ReadOnlyTypeInContMsg, "@ReadOnlyTypeInContMsg");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ReplaceWordsInROs;
|
|
public bool ReplaceWordsInROs
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ReplaceWordsInROs, "@ReplaceWordsInROs");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseMetaSections;
|
|
public bool UseMetaSections
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseMetaSections, "@UseMetaSections");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CountSubSectionsForLevel;
|
|
public bool CountSubSectionsForLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CountSubSectionsForLevel, "@CountSubSectionsForLevel");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PrintPhoneList;
|
|
public bool PrintPhoneList
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PrintPhoneList, "@PrintPhoneList");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _DefaultNoSubAutoIndent;
|
|
public bool DefaultNoSubAutoIndent
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DefaultNoSubAutoIndent, "@DefaultNoSubAutoIndent");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NonEditableSteps;
|
|
public bool NonEditableSteps
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NonEditableSteps, "@NonEditableSteps");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SearchAllReplaceWords;
|
|
public bool SearchAllReplaceWords
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SearchAllReplaceWords, "@SearchAllReplaceWords");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SecTitleContinue;
|
|
public bool SecTitleContinue
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SecTitleContinue, "@SecTitleContinue");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ConvertCaretToDelta;
|
|
public bool ConvertCaretToDelta
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ConvertCaretToDelta, "@ConvertCaretToDelta");
|
|
}
|
|
}
|
|
//B2019-037 throw back from DOS VE-PROMS, convert "~" to subscript and "#" to superscript in RO return values
|
|
private LazyLoad<bool> _UseTildaPoundCharsForSuperSubScriptInROValues;
|
|
public bool UseTildaPoundCharsForSuperSubScriptInROValues
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseTildaPoundCharsForSuperSubScriptInROValues, "@UseTildaPoundCharsForSuperSubScriptInROValues");
|
|
}
|
|
}
|
|
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");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region SectionNumber
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class SectionNumber : vlnFormatItem
|
|
{
|
|
public SectionNumber(XmlNode xmlNode) : base(xmlNode) { }
|
|
public SectionNumber() : base() { }
|
|
private LazyLoad<float?> _Pos;
|
|
public float? Pos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Pos, "@Pos");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Just;
|
|
public string Just
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Just, "@Just");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Level0Big;
|
|
public bool Level0Big
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Level0Big, "@Level0Big");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region SectionHeader
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class SectionHeader : vlnFormatItem
|
|
{
|
|
public SectionHeader(XmlNode xmlNode) : base(xmlNode) { }
|
|
public SectionHeader() : base() { }
|
|
private LazyLoad<float?> _Pos;
|
|
public float? Pos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Pos, "@Pos");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Just;
|
|
public string Just
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Just, "@Just");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Level0Big;
|
|
public bool Level0Big
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Level0Big, "@Level0Big");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _OnlyUnderlineTopSect;
|
|
public bool OnlyUnderlineTopSect
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _OnlyUnderlineTopSect, "@OnlyUnderlineTopSect");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region SectionHeaderSeparatorLine
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class SectionHeaderSeparatorLine : vlnFormatItem
|
|
{
|
|
public SectionHeaderSeparatorLine(XmlNode xmlNode) : base(xmlNode) { }
|
|
public SectionHeaderSeparatorLine() : base() { }
|
|
private LazyLoad<float?> _XStartPos;
|
|
public float? XStartPos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _XStartPos, "@XStartPos");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _Length;
|
|
public float? Length
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Length, "@Length");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region StepSectionDataAll
|
|
#region StepSectionData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class StepSectionData : vlnFormatItem
|
|
{
|
|
public StepSectionData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private TextTypeValueList _TextTypeValueList;
|
|
public TextTypeValueList TextTypeValueList
|
|
{
|
|
get
|
|
{
|
|
return (_TextTypeValueList == null)? _TextTypeValueList = new TextTypeValueList(SelectNodes("TextTypeValue/short")): _TextTypeValueList;
|
|
}
|
|
set { _TextTypeValueList = value; }
|
|
}
|
|
private TextTypeList _TextTypeList;
|
|
public TextTypeList TextTypeList
|
|
{
|
|
get
|
|
{
|
|
return (_TextTypeList == null)? _TextTypeList = new TextTypeList(SelectNodes("TextType/string")): _TextTypeList;
|
|
}
|
|
set { _TextTypeList = value; }
|
|
}
|
|
//private SeqTabList _SeqTabList;
|
|
//public SeqTabList SeqTabList
|
|
//{
|
|
// get
|
|
// {
|
|
// return (_SeqTabList == null)? _SeqTabList = new SeqTabList(SelectNodes("SeqTab/string")): _SeqTabList;
|
|
// }
|
|
// set { _SeqTabList = value; }
|
|
//}
|
|
//private PreSeqTabEditList _PreSeqTabEditList;
|
|
//public PreSeqTabEditList PreSeqTabEditList
|
|
//{
|
|
// get
|
|
// {
|
|
// return (_PreSeqTabEditList == null) ?_PreSeqTabEditList = new PreSeqTabEditList(SelectNodes("PreSeqTabEdit/string")): _PreSeqTabEditList;
|
|
// }
|
|
// set { _PreSeqTabEditList = value; }
|
|
//}
|
|
//private PreSeqTabPrintList _PreSeqTabPrintList;
|
|
//public PreSeqTabPrintList PreSeqTabPrintList
|
|
//{
|
|
// get
|
|
// {
|
|
// return (_PreSeqTabPrintList == null)? _PreSeqTabPrintList = new PreSeqTabPrintList(SelectNodes("PreSeqTabPrint/string")):_PreSeqTabPrintList;
|
|
// }
|
|
// set { _PreSeqTabPrintList = value; }
|
|
//}
|
|
//private PostSeqTabEditList _PostSeqTabEditList;
|
|
//public PostSeqTabEditList PostSeqTabEditList
|
|
//{
|
|
// get
|
|
// {
|
|
// return (_PostSeqTabEditList == null)? _PostSeqTabEditList = new PostSeqTabEditList(SelectNodes("PostSeqTabEdit/string")): _PostSeqTabEditList;
|
|
// }
|
|
// set { _PostSeqTabEditList = value; }
|
|
//}
|
|
//private PostSeqTabPrintList _PostSeqTabPrintList;
|
|
//public PostSeqTabPrintList PostSeqTabPrintList
|
|
//{
|
|
// get
|
|
// {
|
|
// return (_PostSeqTabPrintList == null)? _PostSeqTabPrintList = new PostSeqTabPrintList(SelectNodes("PostSeqTabPrint/string")): _PostSeqTabPrintList;
|
|
// }
|
|
// set { _PostSeqTabPrintList = value; }
|
|
//}
|
|
private UnderlineTerminateList _UnderlineTerminateList;
|
|
public UnderlineTerminateList UnderlineTerminateList
|
|
{
|
|
get
|
|
{
|
|
return (_UnderlineTerminateList == null)? _UnderlineTerminateList = new UnderlineTerminateList(SelectNodes("UnderlineTerminate/string")):_UnderlineTerminateList;
|
|
}
|
|
set { _UnderlineTerminateList = value; }
|
|
}
|
|
private ObserveNCString1List _ObserveNCString1List;
|
|
public ObserveNCString1List ObserveNCString1List
|
|
{
|
|
get
|
|
{
|
|
return (_ObserveNCString1List == null)? _ObserveNCString1List = new ObserveNCString1List(SelectNodes("ObserveNCString1/string")): _ObserveNCString1List;
|
|
}
|
|
set { _ObserveNCString1List = value; }
|
|
}
|
|
private ObserveNCString2List _ObserveNCString2List;
|
|
public ObserveNCString2List ObserveNCString2List
|
|
{
|
|
get
|
|
{
|
|
return (_ObserveNCString2List == null)? _ObserveNCString2List = new ObserveNCString2List(SelectNodes("ObserveNCString2/string")):_ObserveNCString2List;
|
|
}
|
|
set { _ObserveNCString2List = value; }
|
|
}
|
|
private StepSectionLayoutData _StepSectionLayoutData;
|
|
public StepSectionLayoutData StepSectionLayoutData
|
|
{
|
|
get
|
|
{
|
|
return (_StepSectionLayoutData == null)? _StepSectionLayoutData = new StepSectionLayoutData(SelectSingleNode("StpSectLayData")):_StepSectionLayoutData;
|
|
}
|
|
}
|
|
private StepSectionEditData _StepSectionEditData;
|
|
public StepSectionEditData StepSectionEditData
|
|
{
|
|
get
|
|
{
|
|
return (_StepSectionEditData == null)? _StepSectionEditData = new StepSectionEditData(SelectSingleNode("StpSectEditData")): _StepSectionEditData;
|
|
}
|
|
}
|
|
private SeqTabFmtList _SeqTabFmtList;
|
|
public SeqTabFmtList SeqTabFmtList
|
|
{
|
|
get
|
|
{
|
|
return (_SeqTabFmtList == null) ? _SeqTabFmtList = new SeqTabFmtList(SelectNodes("SequentialTabFormat/SeqTabFmt"),MyFormat) : _SeqTabFmtList;
|
|
}
|
|
}
|
|
private StepSectionPrintData _StepSectionPrintData;
|
|
public StepSectionPrintData StepSectionPrintData
|
|
{
|
|
get
|
|
{
|
|
return (_StepSectionPrintData == null) ? _StepSectionPrintData = new StepSectionPrintData(SelectSingleNode("StpSectPrtData")) : _StepSectionPrintData;
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TopRow;
|
|
public int? TopRow
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TopRow, "@TopRow");
|
|
}
|
|
}
|
|
//private LazyLoad<string> _SeqStart;
|
|
//public string SeqStart
|
|
//{
|
|
// get
|
|
// {
|
|
// return LazyLoad(ref _SeqStart, "@SeqStart");
|
|
// }
|
|
//}
|
|
//private LazyLoad<string> _LeftJustSeqTab;
|
|
//public string LeftJustSeqTab
|
|
//{
|
|
// get
|
|
// {
|
|
// return LazyLoad(ref _LeftJustSeqTab, "@LeftJustSeqTab") ;
|
|
// }
|
|
//}
|
|
//private LazyLoad<int?> _HighSeqStart;
|
|
//public int? HighSeqStart
|
|
//{
|
|
// get
|
|
// {
|
|
// return LazyLoad(ref _HighSeqStart, "@HighSeqStart");
|
|
// }
|
|
//}
|
|
private LazyLoad<string> _IndentToken;
|
|
public string IndentToken
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IndentToken, "@IndentToken");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _NumberOfHighLevelSteps;
|
|
public int? NumberOfHighLevelSteps
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NumberOfHighLevelSteps, "@NumberOfHighLevelSteps");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _NumberOfSubStypeTypes;
|
|
public int? NumberOfSubStypeTypes
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NumberOfSubStypeTypes, "@NumberOfSubStepTypes");
|
|
}
|
|
}
|
|
private LazyLoad<string> _IdentB;
|
|
public string IdentB
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IdentB, "@IdentB");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _WolfCreekBackgroundFormat;
|
|
public bool WolfCreekBackgroundFormat
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _WolfCreekBackgroundFormat, "@WolfCreekBackgroundFormat");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _WolfcreekCKLFormat;
|
|
public bool WolfcreekCKLFormat
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _WolfcreekCKLFormat, "@WolfcreekCKLFormat");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _WolfcreekCKLBackgndFormat;
|
|
public bool WolfcreekCKLBackgndFormat
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _WolfcreekCKLBackgndFormat, "@WolfcreekCKLBackgndFormat");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _FortranFormatNumbers;
|
|
public bool FortranFormatNumbers
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _FortranFormatNumbers, "@FortranFormatNumbers");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseTopContinueMessageAtEnd;
|
|
public bool UseTopContinueMessageAtEnd
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseTopContinueMessageAtEnd, "@UseTopContinueMessageAtEnd");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _FloatingContinueMessage;
|
|
public bool FloatingContinueMessage
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _FloatingContinueMessage, "@FloatingContinueMessage");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _WrapSameAsEdit;
|
|
public bool WrapSameAsEdit
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _WrapSameAsEdit, "@WrapSameAsEdit");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ContinueSectionHeader;
|
|
public bool ContinueSectionHeader
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ContinueSectionHeader, "@ContinueSectionHeader");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CompressHPSub;
|
|
public bool CompressHPSub
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CompressHPSub, "@CompressHPSub");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CompressHPSuper;
|
|
public bool CompressHPSuper
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CompressHPSuper, "@CompressHPSuper");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CompressPropSubSup;
|
|
public bool CompressPropSubSup
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CompressPropSubSup, "@CompressPropSubSup");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UndSpecialStepsFoldout;
|
|
public bool UndSpecialStepsFoldout
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UndSpecialStepsFoldout, "@UndSpecialStepsFoldout");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UnderlineAllMetaTitles;
|
|
public bool UnderlineAllMetaTitles
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UnderlineAllMetaTitles, "@UnderlineAllMetaTitles");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _BoldOnlySectionZero;
|
|
public bool BoldOnlySectionZero
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BoldOnlySectionZero, "@BoldOnlySectionZero");
|
|
}
|
|
}
|
|
// used in Ginna's Attachment format
|
|
// adjust the width of the Cautions and Note to not exend page the end of the HLS width
|
|
// ie, shorten the width if the Caution or Note is off of a sub-step
|
|
private LazyLoad<bool> _LimitCautionNoteWithToHLS;
|
|
public bool LimitCautionNoteWidthToHLS
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LimitCautionNoteWithToHLS, "@LimitCautionNoteWithToHLS");
|
|
}
|
|
}
|
|
// Used in Ginn's Attachment format
|
|
// only bullet multiple Caution/Note types if they are exactly the same type (ex. CAUTION vs CAUTION1)
|
|
private LazyLoad<bool> _OnlyBulletSameCautionNoteType;
|
|
public bool OnlyBulletSameCautionNoteType
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _OnlyBulletSameCautionNoteType, "@OnlyBulletSameCautionNoteType");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ImperfectStructure;
|
|
public bool ImperfectStructure
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ImperfectStructure, "@ImperfectStructure");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ImperfectSubstep;
|
|
public bool ImperfectSubstep
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ImperfectSubstep, "@ImperfectSubstep");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ImperfectStructurePlus4;
|
|
public bool ImperfectStructurePlus4
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ImperfectStructurePlus4, "@ImperfectStructurePlus4");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SkipNonSeqTabWithPar;
|
|
public bool SkipNonSeqTabWithPar
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SkipNonSeqTabWithPar, "@SkipNonSeqTabWithPar");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CountAllSubLevels;
|
|
public bool CountAllSubLevels
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CountAllSubLevels, "@CountAllSubLevels");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseMultiLineSectionTitle;
|
|
public bool UseMultiLineSectionTitle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseMultiLineSectionTitle, "@UseMultiLineSectionTitle");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AdjustRNOCautionNoteWidth;
|
|
public bool AdjustRNOCautionNoteWidth
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AdjustRNOCautionNoteWidth, "@AdjustRNOCautionNoteWidth");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _DontResetIndentOnNewline;
|
|
public bool DontResetIndentOnNewline
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DontResetIndentOnNewline, "@DontResetIndentOnNewline");
|
|
}
|
|
}
|
|
// C2018-024 I in Arial font changed to I in TimesNewRoman
|
|
private LazyLoad<bool> _ChangeFontUpperCaseIinArial;
|
|
public bool ChangeFontUpperCaseIinArial
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ChangeFontUpperCaseIinArial, "@ChangeFontUpperCaseIinArial");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region TextTypeValue
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class TextTypeValue : vlnFormatItem
|
|
{
|
|
public TextTypeValue(XmlNode xmlNode) : base(xmlNode) { }
|
|
public TextTypeValue() : base() { }
|
|
private LazyLoad<int?> _TheValue;
|
|
public int? TheValue
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TheValue, "text()");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return "Value"; }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("TextTypeValue '{0}'", TheValue); }
|
|
public override string GetPDCategory()
|
|
{ return "Text Type Value"; }
|
|
public override string ToString()
|
|
{
|
|
return TheValue.ToString();
|
|
}
|
|
}
|
|
#endregion
|
|
#region TextTypeValueList
|
|
[TypeConverter(typeof(vlnListConverter<TextTypeValueList, TextTypeValue>))]
|
|
public class TextTypeValueList : vlnFormatList<TextTypeValue>
|
|
{
|
|
public TextTypeValueList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region TextType
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class TextType : vlnFormatItem
|
|
{
|
|
public TextType(XmlNode xmlNode) : base(xmlNode) { }
|
|
public TextType() : base() { }
|
|
//[Category("Strings")]
|
|
private LazyLoad<string> _Text;
|
|
public string Text
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Text, "text()");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return "Text"; }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("TextType '{0}'", Text); }
|
|
public override string GetPDCategory()
|
|
{ return "Text Type"; }
|
|
public override string ToString()
|
|
{
|
|
return Text;
|
|
}
|
|
}
|
|
#endregion
|
|
#region TextTypeList
|
|
[TypeConverter(typeof(vlnListConverter<TextTypeList, TextType>))]
|
|
public class TextTypeList : vlnFormatList<TextType>
|
|
{
|
|
public TextTypeList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region OLD - SeqTab
|
|
//[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
//public class SeqTab : vlnFormatItem
|
|
//{
|
|
// public SeqTab(XmlNode xmlNode) : base(xmlNode) { }
|
|
// public SeqTab() : base() { }
|
|
// private LazyLoad<string> _Text;
|
|
// public string Text
|
|
// {
|
|
// get
|
|
// {
|
|
// return LazyLoad(ref _Text, "text()");
|
|
// }
|
|
// }
|
|
// public override string GetPDDisplayName()
|
|
// { return "Text"; }
|
|
// public override string GetPDDescription()
|
|
// { return string.Format("SeqTab '{0}'", Text); }
|
|
// public override string GetPDCategory()
|
|
// { return "Seq Tab"; }
|
|
// public override string ToString()
|
|
// {
|
|
// return Text;
|
|
// }
|
|
//}
|
|
#endregion
|
|
#region OLD - SeqTabList
|
|
//[TypeConverter(typeof(vlnListConverter<SeqTabList, SeqTab>))]
|
|
//public class SeqTabList : vlnFormatList<SeqTab>
|
|
//{
|
|
// public SeqTabList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
//}
|
|
#endregion
|
|
#region OLD - PreSeqTabEdit
|
|
//[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
//public class PreSeqTabEdit : vlnFormatItem
|
|
//{
|
|
// public PreSeqTabEdit(XmlNode xmlNode) : base(xmlNode) { }
|
|
// public PreSeqTabEdit() : base() { }
|
|
// //[Category("Strings")]
|
|
// private LazyLoad<string> _Text;
|
|
// public string Text
|
|
// {
|
|
// get
|
|
// {
|
|
// return LazyLoad(ref _Text, "text()");
|
|
// }
|
|
// }
|
|
// public override string GetPDDisplayName()
|
|
// { return "Text"; }
|
|
// public override string GetPDDescription()
|
|
// { return string.Format("PreSeqTabEdit '{0}'", Text); }
|
|
// public override string GetPDCategory()
|
|
// { return "PreSeq Tab Edit"; }
|
|
// public override string ToString()
|
|
// {
|
|
// return Text;
|
|
// }
|
|
//}
|
|
#endregion
|
|
#region OLD - PreSeqTabEditList
|
|
//[TypeConverter(typeof(vlnListConverter<PreSeqTabEditList, PreSeqTabEdit>))]
|
|
//public class PreSeqTabEditList : vlnFormatList<PreSeqTabEdit>
|
|
//{
|
|
// public PreSeqTabEditList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
//}
|
|
#endregion
|
|
#region OLD - PreSeqTabPrint
|
|
//[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
//public class PreSeqTabPrint : vlnFormatItem
|
|
//{
|
|
// public PreSeqTabPrint(XmlNode xmlNode) : base(xmlNode) { }
|
|
// public PreSeqTabPrint() : base() { }
|
|
// private LazyLoad<string> _Text;
|
|
// public string Text
|
|
// {
|
|
// get
|
|
// {
|
|
// return LazyLoad(ref _Text, "text()");
|
|
// }
|
|
// }
|
|
// public override string GetPDDisplayName()
|
|
// { return "Text"; }
|
|
// public override string GetPDDescription()
|
|
// { return string.Format("PreSeqTabPrint '{0}'", Text); }
|
|
// public override string GetPDCategory()
|
|
// { return "PreSeq Tab Printt"; }
|
|
// public override string ToString()
|
|
// {
|
|
// return Text;
|
|
// }
|
|
//}
|
|
#endregion
|
|
#region OLD - PreSeqTabPrintList
|
|
//[TypeConverter(typeof(vlnListConverter<PreSeqTabPrintList, PreSeqTabPrint>))]
|
|
//public class PreSeqTabPrintList : vlnFormatList<PreSeqTabPrint>
|
|
//{
|
|
// public PreSeqTabPrintList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
//}
|
|
#endregion
|
|
#region OLD - PostSeqTabEdit
|
|
//[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
//public class PostSeqTabEdit : vlnFormatItem
|
|
//{
|
|
// public PostSeqTabEdit(XmlNode xmlNode) : base(xmlNode) { }
|
|
// public PostSeqTabEdit() : base() { }
|
|
// private LazyLoad<string> _Text;
|
|
// public string Text
|
|
// {
|
|
// get
|
|
// {
|
|
// return LazyLoad(ref _Text, "text()");
|
|
// }
|
|
// }
|
|
// public override string GetPDDisplayName()
|
|
// { return "Text"; }
|
|
// public override string GetPDDescription()
|
|
// { return string.Format("PostSeqTabEdit '{0}'", Text); }
|
|
// public override string GetPDCategory()
|
|
// { return "PostSeq Tab Edit"; }
|
|
// public override string ToString()
|
|
// {
|
|
// return Text;
|
|
// }
|
|
//}
|
|
#endregion
|
|
#region OLD - PostSeqTabEditList
|
|
//[TypeConverter(typeof(vlnListConverter<PostSeqTabEditList, PostSeqTabEdit>))]
|
|
//public class PostSeqTabEditList : vlnFormatList<PostSeqTabEdit>
|
|
//{
|
|
// public PostSeqTabEditList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
//}
|
|
#endregion
|
|
#region OLD - PostSeqTabPrint
|
|
//[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
//public class PostSeqTabPrint : vlnFormatItem
|
|
//{
|
|
// public PostSeqTabPrint(XmlNode xmlNode) : base(xmlNode) { }
|
|
// public PostSeqTabPrint() : base() { }
|
|
// private LazyLoad<string> _Text;
|
|
// public string Text
|
|
// {
|
|
// get
|
|
// {
|
|
// return LazyLoad(ref _Text, "text()");
|
|
// }
|
|
// }
|
|
// public override string GetPDDisplayName()
|
|
// { return "Text"; }
|
|
// public override string GetPDDescription()
|
|
// { return string.Format("PostSeqTabPrint '{0}'", Text); }
|
|
// public override string GetPDCategory()
|
|
// { return "PostSeq Tab Printt"; }
|
|
// public override string ToString()
|
|
// {
|
|
// return Text;
|
|
// }
|
|
//}
|
|
#endregion
|
|
#region OLD - PostSeqTabPrintList
|
|
//[TypeConverter(typeof(vlnListConverter<PostSeqTabPrintList, PostSeqTabPrint>))]
|
|
//public class PostSeqTabPrintList : vlnFormatList<PostSeqTabPrint>
|
|
//{
|
|
// public PostSeqTabPrintList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
//}
|
|
#endregion
|
|
#region UnderlineTerminate
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class UnderlineTerminate : vlnFormatItem
|
|
{
|
|
public UnderlineTerminate(XmlNode xmlNode) : base(xmlNode) { }
|
|
public UnderlineTerminate() : base() { }
|
|
private LazyLoad<string> _Text;
|
|
public string Text
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Text, "text()");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return "Text"; }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("UnderlineTerminate '{0}'", Text); }
|
|
public override string GetPDCategory()
|
|
{ return "Underline Terminate"; }
|
|
public override string ToString()
|
|
{
|
|
return Text;
|
|
}
|
|
}
|
|
#endregion
|
|
#region UnderlineTerminateList
|
|
[TypeConverter(typeof(vlnListConverter<UnderlineTerminateList, UnderlineTerminate>))]
|
|
public class UnderlineTerminateList : vlnFormatList<UnderlineTerminate>
|
|
{
|
|
public UnderlineTerminateList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region ObserveNCString1
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ObserveNCString1 : vlnFormatItem
|
|
{
|
|
public ObserveNCString1(XmlNode xmlNode) : base(xmlNode) { }
|
|
public ObserveNCString1() : base() { }
|
|
private LazyLoad<string> _Text;
|
|
public string Text
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Text, "text()");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return "Text"; }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("ObserveNCString1 '{0}'", Text); }
|
|
public override string GetPDCategory()
|
|
{ return "ObserveNCString1"; }
|
|
public override string ToString()
|
|
{
|
|
return Text;
|
|
}
|
|
}
|
|
#endregion
|
|
#region ObserveNCString1List
|
|
[TypeConverter(typeof(vlnListConverter<ObserveNCString1List, ObserveNCString1>))]
|
|
public class ObserveNCString1List : vlnFormatList<ObserveNCString1>
|
|
{
|
|
public ObserveNCString1List(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region ObserveNCString2
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ObserveNCString2 : vlnFormatItem
|
|
{
|
|
public ObserveNCString2(XmlNode xmlNode) : base(xmlNode) { }
|
|
public ObserveNCString2() : base() { }
|
|
private LazyLoad<string> _Text;
|
|
public string Text
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Text, "text()");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return "Text"; }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("ObserveNCString2 '{0}'", Text); }
|
|
public override string GetPDCategory()
|
|
{ return "ObserveNCString2"; }
|
|
public override string ToString()
|
|
{
|
|
return Text;
|
|
}
|
|
}
|
|
#endregion
|
|
#region ObserveNCString2List
|
|
[TypeConverter(typeof(vlnListConverter<ObserveNCString2List, ObserveNCString2>))]
|
|
public class ObserveNCString2List : vlnFormatList<ObserveNCString2>
|
|
{
|
|
public ObserveNCString2List(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region ReplaceStr
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ReplaceStr : vlnFormatItem
|
|
{
|
|
public ReplaceStr(XmlNode xmlNode) : base(xmlNode) { }
|
|
public ReplaceStr() : base() { }
|
|
[Category("Strings")]
|
|
private LazyLoad<string> _ReplaceWord;
|
|
public string ReplaceWord
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ReplaceWord, "@ReplaceWord");
|
|
}
|
|
}
|
|
[Category("Strings")]
|
|
private LazyLoad<string> _ReplaceWith;
|
|
public string ReplaceWith
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ReplaceWith, "@ReplaceWith");
|
|
}
|
|
}
|
|
private LazyLoad<E_ReplaceFlags?> _Flag;
|
|
public E_ReplaceFlags? Flag
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad<E_ReplaceFlags>(ref _Flag, "@Flag");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return ReplaceWord; }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("Replace '{0}' with '{1}'",ReplaceWord,ReplaceWith); }
|
|
public override string GetPDCategory()
|
|
{ return "Words to Replace"; }
|
|
public override string ToString()
|
|
{
|
|
return ReplaceWith;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
#region ReplaceStrList
|
|
[TypeConverter(typeof(vlnListConverter<ReplaceStrList, ReplaceStr>))]
|
|
public class ReplaceStrList : vlnFormatList<ReplaceStr>
|
|
{
|
|
public ReplaceStrList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region ReplaceChar
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ReplaceChar : vlnFormatItem, IVlnIndexedFormatItem
|
|
{
|
|
public ReplaceChar(XmlNode xmlNode) : base(xmlNode) { }
|
|
public ReplaceChar() : base() { }
|
|
private LazyLoad<int?> _Index;
|
|
public int? Index
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Index, "@Index");
|
|
}
|
|
}
|
|
[Category("Strings")]
|
|
private LazyLoad<string> _Unicode;
|
|
public string Unicode
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Unicode, "@Unicode");
|
|
}
|
|
}
|
|
[Category("Strings")]
|
|
private LazyLoad<string> _Replace;
|
|
public string Replace
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Replace, "@Replace");
|
|
}
|
|
}
|
|
[Category("Strings")]
|
|
private LazyLoad<string> _Family;
|
|
public string Family
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Family, "@Family");
|
|
}
|
|
}
|
|
[Category("FontStyle?")]
|
|
private LazyLoad<E_Style?> _Style; // format has E_Style value. The public will translate it to a systemdrawing.FontStyle used in printing
|
|
public FontStyle? Style
|
|
{
|
|
get
|
|
{
|
|
E_Style? eStyle = LazyLoad(ref _Style, "@Style");
|
|
if (eStyle == null) return null; // not set in the format, return null
|
|
FontStyle sdfStyle = FontStyle.Regular;
|
|
if (eStyle != E_Style.None)
|
|
{
|
|
if (((eStyle & E_Style.Bold) != 0) || ((eStyle & E_Style.MmBold) != 0))
|
|
sdfStyle |= FontStyle.Bold;
|
|
if ((eStyle & E_Style.Italics) != 0)
|
|
sdfStyle |= FontStyle.Italic;
|
|
if ((eStyle & E_Style.Underline) != 0)
|
|
sdfStyle |= FontStyle.Underline;
|
|
}
|
|
return sdfStyle; // return systemdrawing.FontStyle
|
|
//return LazyLoad(ref _Style, "@Style");
|
|
}
|
|
}
|
|
[Category("float?")]
|
|
private LazyLoad<float?> _Size;
|
|
public float? Size
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Size, "@Size");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return Unicode; }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("Replace '{0}' with '{1}'", Unicode, Replace); }
|
|
public override string GetPDCategory()
|
|
{ return "Chars to Replace"; }
|
|
public override string ToString()
|
|
{
|
|
return Replace;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
#region ReplaceSymbolCharList
|
|
[TypeConverter(typeof(vlnIndexedListConverter<ReplaceSymbolCharList, ReplaceChar>))]
|
|
public class ReplaceSymbolCharList : vlnIndexedFormatList<ReplaceChar>
|
|
{
|
|
public ReplaceSymbolCharList(XmlNodeList xmlNodeList, IFormatOrFormatInfo myFormat) : base(xmlNodeList, myFormat) { }
|
|
public override vlnIndexedFormatList<ReplaceChar> InheritedList
|
|
{
|
|
get
|
|
{
|
|
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
|
|
if (parentFormat != null)
|
|
return parentFormat.PlantFormat.FormatData.SectData.ReplaceSymbolCharList;
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region StepSectionLayoutData
|
|
public class StepSectionLayoutData : vlnFormatItem
|
|
{
|
|
public StepSectionLayoutData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private TopOfPage _TopOfPage;
|
|
public TopOfPage TopOfPage
|
|
{
|
|
get
|
|
{
|
|
return (_TopOfPage == null)? _TopOfPage = new TopOfPage(SelectSingleNode("TopOfPage")): _TopOfPage;
|
|
}
|
|
}
|
|
private Separator _Separator;
|
|
public Separator Separator
|
|
{
|
|
get
|
|
{
|
|
return (_Separator == null) ?_Separator = new Separator(SelectSingleNode("Separator")):_Separator;
|
|
}
|
|
}
|
|
private LazyLoad<float?> _LastLineToStartStep;
|
|
public float? LastLineToStartStep
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LastLineToStartStep, "@LastLineToStartStep");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _LineDrawingOption;
|
|
public int? LineDrawingOption
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LineDrawingOption, "@LineDrawingOption");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _TabPtsPerChar;
|
|
public float? TabPtsPerChar
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TabPtsPerChar, "@TabPtsPerChar");
|
|
}
|
|
}
|
|
private LazyLoad<string> _CautionNoteOrder;
|
|
public string CautionNoteOrder
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CautionNoteOrder, "@CautionNoteOrder");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _ColS;
|
|
public float? ColS
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColS, "@ColS");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _ColT;
|
|
public float? ColT
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColT, "@ColT");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _ColAbs;
|
|
public float? ColAbs
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColAbs, "@ColAbs");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _WidT;
|
|
public float? WidT
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _WidT, "@WidT");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _PMode;
|
|
public int? PMode
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PMode, "@PMode");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _ColumnMode;
|
|
public int? ColumnMode
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColumnMode, "@ColumnMode");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _MaxRNO;
|
|
public int? MaxRNO
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MaxRNO, "@MaxRNO");
|
|
}
|
|
}
|
|
private LazyLoad<string> _MaxRNOTable;
|
|
public string MaxRNOTable
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MaxRNOTable, "@MaxRNOTable");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _RNOWidthSameAsHighParent;
|
|
public bool RNOWidthSameAsHighParent
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOWidthSameAsHighParent, "@RNOWidthSameAsHighParent");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _SingleColumnRNOIndent;
|
|
public float? SingleColumnRNOIndent
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SingleColumnRNOIndent, "@SingleColumnRNOIndent");
|
|
}
|
|
}
|
|
private LazyLoad<string> _ColRTable;
|
|
public string ColRTable
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColRTable, "@ColRTable");
|
|
}
|
|
}
|
|
private LazyLoad<string> _WidSTableEdit;
|
|
public string WidSTableEdit
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _WidSTableEdit, "@WidSTableEdit");
|
|
}
|
|
}
|
|
private LazyLoad<string> _WidSTablePrint;
|
|
public string WidSTablePrint
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _WidSTablePrint, "@WidSTablePrint");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _AdjRNOCol;
|
|
public float? AdjRNOCol
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AdjRNOCol, "@AdjRNOCol");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _EndMessagePos;
|
|
public int? EndMessagePos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _EndMessagePos, "@EndMessagePos");
|
|
}
|
|
}
|
|
private LazyLoad<string> _RNOWidthAlt;
|
|
public string RNOWidthAlt
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOWidthAlt, "@RNOWidthAlt");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _RNOWidthAltAll;
|
|
public int? RNOWidthAltAll
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOWidthAltAll, "@RNOWidthAltAll");
|
|
}
|
|
}
|
|
private LazyLoad<string> _RNOWidthAdj;
|
|
public string RNOWidthAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOWidthAdj, "@RNOWidthAdj");
|
|
}
|
|
}
|
|
private LazyLoad<string> _UseRNOParentIdent;
|
|
public string UseRNOParentIdent
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseRNOParentIdent, "@UseRNOParentIdent");
|
|
}
|
|
}
|
|
private LazyLoad<string> _DevNoteOrCautionTabOffset;
|
|
public string DevNoteOrCautionTabOffset
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DevNoteOrCautionTabOffset, "@DevNoteOrCautionTabOffset");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BoxLeftAdj;
|
|
public string BoxLeftAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BoxLeftAdj, "@BoxLeftAdj");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _HLSWidthOVRD;
|
|
public int? HLSWidthOVRD
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _HLSWidthOVRD, "@HLSWidthOVRD");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _SubPaginationWght;
|
|
public int? SubPaginationWght
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SubPaginationWght, "@SubPaginationWght");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TextTitleAdjustment;
|
|
public int? TextTitleAdjustment
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TextTitleAdjustment, "@TextTitleAdjustment");
|
|
}
|
|
}
|
|
private VE_Font _VertStyle;
|
|
public VE_Font VertStyle
|
|
{
|
|
get
|
|
{
|
|
return (_VertStyle == null)? _VertStyle = new VE_Font(base.XmlNode): _VertStyle;
|
|
}
|
|
}
|
|
private LazyLoad<string> _TableCenterPos;
|
|
public string TableCenterPos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TableCenterPos, "@TableCenterPos");
|
|
}
|
|
}
|
|
private LazyLoad<string> _LowerLimitDivisor;
|
|
public string LowerLimitDivisor
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LowerLimitDivisor, "@LowerLimitDivisor");
|
|
}
|
|
}
|
|
private LazyLoad<string> _NonLinkedStepNumber;
|
|
public string NonLinkedStepNumber
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NonLinkedStepNumber, "@NonLinkedStepNumber");
|
|
}
|
|
}
|
|
private LazyLoad<string> _NonLinkedCautNoteNumber;
|
|
public string NonLinkedCautNoteNumber
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NonLinkedCautNoteNumber, "@NonLinkedCautNoteNumber");
|
|
}
|
|
}
|
|
private LazyLoad<string> _NonLinkedRNONumber;
|
|
public string NonLinkedRNONumber
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NonLinkedRNONumber, "@NonLinkedRNONumber");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Dev_Format;
|
|
public bool Dev_Format
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Dev_Format, "@Dev_Format");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _EnhancedShortFormDev;
|
|
public bool EnhancedShortFormDev
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _EnhancedShortFormDev, "@EnhancedShortFormDev");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpecialPageBreakFlag;
|
|
public bool SpecialPageBreakFlag
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpecialPageBreakFlag, "@SpecialPageBreakFlag");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PaginateOnFirstSubstep;
|
|
public bool PaginateOnFirstSubstep
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PaginateOnFirstSubstep, "@PaginateOnFirstSubstep");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PaginateOnFirstSubstep2X;
|
|
public bool PaginateOnFirstSubstep2X
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PaginateOnFirstSubstep2X, "@PaginateOnFirstSubstep2X");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseHalfLines;
|
|
public bool UseHalfLines
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseHalfLines, "@UseHalfLines");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _TryToFillHalfOfPage;
|
|
public bool TryToFillHalfOfPage
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TryToFillHalfOfPage, "@TryToFillHalfOfPage");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CompressSteps;
|
|
public bool CompressSteps
|
|
{
|
|
get
|
|
{
|
|
if (PlantFormat.IgnoreUCF) return LazyLoad(ref _CompressSteps, "@CompressSteps");
|
|
bool? localvalue = null;
|
|
FormatConfig fc = PlantFormat.GetFormatConfig(MyFormat);
|
|
if (fc != null) localvalue = fc.PlantFormat.FormatData.Flags.CompressSteps;
|
|
return localvalue ?? LazyLoad(ref _CompressSteps, "@CompressSteps");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _DoSTExtraAtTop;
|
|
public bool DoSTExtraAtTop
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DoSTExtraAtTop, "@DoSTExtraAtTop");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _KeepStepsOnPage;
|
|
public bool KeepStepsOnPage
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _KeepStepsOnPage, "@KeepStepsOnPage");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NoOrphans1;
|
|
/// <summary>
|
|
/// B2017-154 Np Orphans (single sub-step left over from previous page) No Children
|
|
/// </summary>
|
|
public bool NoOrphans1
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NoOrphans1, "@NoOrphans1");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _BreakOnSections;
|
|
public bool BreakOnSections
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BreakOnSections, "@BreakOnSections");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ShowSectionTitles;
|
|
public bool ShowSectionTitles
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ShowSectionTitles, "@ShowSectionTitles");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _EndForSingle;
|
|
public bool EndForSingle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _EndForSingle, "@EndForSingle");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PaginateOnFirstSubstep3X;
|
|
public bool PaginateOnFirstSubstep3X
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PaginateOnFirstSubstep3X, "@PaginateOnFirstSubstep3X");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PaginateOnLowerStepLevel;
|
|
public bool PaginateOnLowerStepLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PaginateOnLowerStepLevel, "@PaginateOnLowerStepLevel");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CustomSpacing;
|
|
public bool CustomSpacing
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CustomSpacing, "@CustomSpacing");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SplitStepInPrntStep;
|
|
public bool SplitStepInPrntStep
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SplitStepInPrntStep, "@SplitStepInPrntStep");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _LineAboveUnderSection;
|
|
public bool LineAboveUnderSection
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LineAboveUnderSection, "@LineAboveUnderSection");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PicaIgnoreFiveSixths;
|
|
public bool PicaIgnoreFiveSixths
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PicaIgnoreFiveSixths, "@PicaIgnoreFiveSixths");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpaceForNoSecNumb;
|
|
public bool SpaceForNoSecNumb
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpaceForNoSecNumb, "@SpaceForNoSecNumb");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PageBreakOnFirstBlankLine;
|
|
public bool PageBreakOnFirstBlankLine
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PageBreakOnFirstBlankLine, "@PageBreakOnFirstBlankLine");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PutOnPageByItself;
|
|
public bool PutOnPageByItself
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PutOnPageByItself, "@PutOnPageByItself");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PaginateAtHighestPaginLevel;
|
|
public bool PaginateAtHighestPaginLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PaginateAtHighestPaginLevel, "@PaginateAtHighestPaginLevel");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseSTExtraRealValue;
|
|
public bool UseSTExtraRealValue
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseSTExtraRealValue, "@UseSTExtraRealValue");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _DoSectionSeparatorLine;
|
|
public bool DoSectionSeparatorLine
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DoSectionSeparatorLine, "@DoSectionSeparatorLine");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _TieTabToLevel;
|
|
public bool TieTabToLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TieTabToLevel, "@TieTabToLevel");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _HighLevelRNOBeforeAERSubsteps;
|
|
public bool HighLevelRNOBeforeAERSubsteps
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _HighLevelRNOBeforeAERSubsteps, "@HighLevelRNOBeforeAERSubsteps");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseStepTypeWidthOverride;
|
|
public bool UseStepTypeWidthOverride
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseStepTypeWidthOverride, "@UseStepTypeWidthOverride");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseStepTypeWidthOverrideEditPrint;
|
|
public bool UseStepTypeWidthOverrideEditPrint
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseStepTypeWidthOverrideEditPrint, "@UseStepTypeWidthOverrideEditPrint");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PartialStepCompression;
|
|
public bool PartialStepCompression
|
|
{
|
|
get
|
|
{
|
|
if (PlantFormat.IgnoreUCF) return LazyLoad(ref _PartialStepCompression, "@PartialStepCompression");
|
|
bool? localvalue = null;
|
|
FormatConfig fc = PlantFormat.GetFormatConfig(MyFormat);
|
|
if (fc != null) localvalue = fc.PlantFormat.FormatData.Flags.PartialStepCompression;
|
|
return localvalue ?? LazyLoad(ref _PartialStepCompression, "@PartialStepCompression");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _VirtualDotInHLSTab;
|
|
public bool VirtualDotInHLSTab
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _VirtualDotInHLSTab, "@VirtualDotInHLSTab");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _OverrideEnhancedTabs;
|
|
public bool OverrideEnhancedTabs
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _OverrideEnhancedTabs, "@OverrideEnhancedTabs");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _RNO;
|
|
public bool RNO
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNO, "@RNO");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _OnlySingleColumn;
|
|
public bool OnlySingleColumn
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _OnlySingleColumn, "@OnlySingleColumn");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NullBox;
|
|
public bool NullBox
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NullBox, "@NullBox");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AllowNoteCautionAdd;
|
|
public bool AllowNoteCautionAdd
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AllowNoteCautionAdd, "@AllowNoteCautionAdd");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region TopOfPage
|
|
public class TopOfPage : vlnFormatItem
|
|
{
|
|
public TopOfPage(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<float?> _Row;
|
|
public float? Row
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Row, "@Row");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _Col;
|
|
public float? Col
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Col, "@Col");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null? _Font = new VE_Font(base.XmlNode): _Font);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region Separator
|
|
public class Separator : vlnFormatItem
|
|
{
|
|
public Separator(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<int?> _Location;
|
|
public int? Location
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Location, "@Location");
|
|
//return LazyLoad(ref _SeparatorLocation, "@SeparatorLocation");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region StepSectionEditData
|
|
public class StepSectionEditData : vlnFormatItem
|
|
{
|
|
public StepSectionEditData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<float?> _ColSScreenAdj;
|
|
public float? ColSScreenAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColSScreenAdj, "@ColSScreenAdj");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _ScrnAdjRNOText;
|
|
public float? ScrnAdjRNOText
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ScrnAdjRNOText, "@ScrnAdjRNOText");
|
|
}
|
|
}
|
|
private LazyLoad<string> _ColRScreen;
|
|
public string ColRScreen
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColRScreen, "@ColRScreen");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region StepSectionPrintData
|
|
public class StepSectionPrintData : vlnFormatItem
|
|
{
|
|
public StepSectionPrintData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<float?> _ImmStepHdrCol;
|
|
public float? ImmStepHdrCol
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ImmStepHdrCol, "@ImmStepHdrCol");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _DiffContActBox;
|
|
public bool DiffContActBox
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DiffContActBox, "@DiffContActBox");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ContActBoxOnSubSteps;
|
|
public bool ContActBoxOnSubSteps
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ContActBoxOnSubSteps, "@ContActBoxOnSubSteps");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _SecColHdrforActPMode;
|
|
public int? SecColHdrforActPMode
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SecColHdrforActPMode, "@SecColHdrforActPMode");
|
|
}
|
|
}
|
|
private LazyLoad<string> _RNOSepString;
|
|
public string RNOSepString
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOSepString, "@RNOSepString");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _RNOSepLineLength;
|
|
public float? RNOSepLineLength
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOSepLineLength, "@RNOSepLineLength");
|
|
}
|
|
}
|
|
private LazyLoad<string> _HLStpSeparatorString;
|
|
public string HLStpSeparatorString
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _HLStpSeparatorString, "@HLStpSeparatorString");
|
|
}
|
|
}
|
|
private LazyLoad<string> _HLRNOStpSeparatorString;
|
|
public string HLRNOStpSeparatorString
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _HLRNOStpSeparatorString, "@HLRNOStpSeparatorString");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _LowerCaseRevNum;
|
|
public bool LowerCaseRevNum
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LowerCaseRevNum, "@LowerCaseRevNum");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseXtraRevNumber;
|
|
public bool UseXtraRevNumber
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseXtraRevNumber, "@UseXtraRevNumber");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpecialLandscapeMode;
|
|
public bool SpecialLandscapeMode
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpecialLandscapeMode, "@SpecialLandscapeMode");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _LimitWidToPageWid;
|
|
public bool LimitWidToPageWid
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LimitWidToPageWid, "@LimitWidToPageWid");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CombinedTabIncludeParenTabs;
|
|
public bool CombinedTabIncludeParenTabs
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CombinedTabIncludeParenTabs, "@CombinedTabIncludeParenTabs");
|
|
}
|
|
}
|
|
private VE_Font _ModifiedTextStyle;
|
|
public VE_Font ModifiedTextStyle
|
|
{
|
|
get
|
|
{
|
|
return (_ModifiedTextStyle == null)? _ModifiedTextStyle = new VE_Font(base.XmlNode):_ModifiedTextStyle;
|
|
}
|
|
}
|
|
private VE_Font _ImmStepHdrStyle;
|
|
public VE_Font ImmStepHdrStyle
|
|
{
|
|
get
|
|
{
|
|
return (_ImmStepHdrStyle == null)? _ImmStepHdrStyle = new VE_Font(base.XmlNode):_ImmStepHdrStyle;
|
|
}
|
|
}
|
|
private ImmStepHdrList _ImmStepHdrList;
|
|
public ImmStepHdrList ImmStepHdrList
|
|
{
|
|
get
|
|
{
|
|
return (_ImmStepHdrList == null)? _ImmStepHdrList = new ImmStepHdrList(SelectNodes("ImmStepHdrList/string")):_ImmStepHdrList;
|
|
}
|
|
set { _ImmStepHdrList = value; }
|
|
}
|
|
private LeftJustifyList _LeftJustifyList;
|
|
public LeftJustifyList LeftJustifyList
|
|
{
|
|
get
|
|
{
|
|
return (_LeftJustifyList == null) ? _LeftJustifyList = new LeftJustifyList(SelectNodes("LeftJustifyList/LeftJustify")) : _LeftJustifyList;
|
|
}
|
|
set { _LeftJustifyList = value; }
|
|
}
|
|
}
|
|
#region ImmStepHdr
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ImmStepHdr : vlnFormatItem
|
|
{
|
|
public ImmStepHdr(XmlNode xmlNode) : base(xmlNode) { }
|
|
public ImmStepHdr() : base() { }
|
|
private LazyLoad<string> _Text;
|
|
public string Text
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Text, "text()");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return "Text"; }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("ImmStepHdr '{0}'", Text); }
|
|
public override string GetPDCategory()
|
|
{ return "Imm Step Hdr"; }
|
|
public override string ToString()
|
|
{
|
|
return Text;
|
|
}
|
|
}
|
|
#endregion
|
|
#region ImmStepHdrList
|
|
[TypeConverter(typeof(vlnListConverter<ImmStepHdrList, ImmStepHdr>))]
|
|
public class ImmStepHdrList : vlnFormatList<ImmStepHdr>
|
|
{
|
|
public ImmStepHdrList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region LeftJustifyList
|
|
[TypeConverter(typeof(vlnListConverter<LeftJustifyList, LeftJustify>))]
|
|
public class LeftJustifyList : vlnFormatList<LeftJustify>
|
|
{
|
|
public LeftJustifyList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region LeftJustify
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class LeftJustify : vlnFormatItem, IVlnIndexedFormatItem
|
|
{
|
|
public LeftJustify(XmlNode xmlNode) : base(xmlNode) { }
|
|
public LeftJustify() : base() { }
|
|
private LazyLoad<int?> _Index;
|
|
public int? Index
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Index, "@Index");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _Size;
|
|
public float? Size
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Size, "@Size");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region SeqTabFmtAll
|
|
#region SeqTabFmt
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class SeqTabFmt : vlnFormatItem,IVlnIndexedFormatItem
|
|
{
|
|
public SeqTabFmt() : base() { }
|
|
private LazyLoad<int?> _Index; //not included - is it needed?
|
|
[Description("SeqTab Index")]
|
|
public int? Index
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Index, "@Index");
|
|
}
|
|
}
|
|
private LazyLoad<string> _TabToken;
|
|
public string TabToken
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TabToken, "@TabToken");
|
|
}
|
|
}
|
|
private LazyLoad<string> _TabFormat;
|
|
public string TabFormat
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TabFormat, "@TabFormat");
|
|
}
|
|
}
|
|
private LazyLoad<string> _PrintTabFormat;
|
|
public string PrintTabFormat
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TabFormat, "@PrintTabFormat");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _DontTrimParentTabBeforeAppending; // B2019-011 for Barakah Alarm format
|
|
public bool DontTrimParentTabBeforeAppending
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DontTrimParentTabBeforeAppending, "@DontTrimParentTabBeforeAppending");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return string.Format("Index [{0}]",Index); }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("Sequential Tab Format Index '{0}' Format '{1}'", Index, TabFormat); }
|
|
public override string GetPDCategory()
|
|
{ return "Sequential Tab Formatting"; }
|
|
public override string ToString()
|
|
{
|
|
return TabFormat;
|
|
}
|
|
}
|
|
#endregion
|
|
#region SeqTabFmtList
|
|
[TypeConverter(typeof(vlnIndexedListConverter<SeqTabFmtList, SeqTabFmt>))]
|
|
public class SeqTabFmtList : vlnIndexedFormatList<SeqTabFmt>
|
|
{
|
|
public SeqTabFmtList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
|
|
public override vlnIndexedFormatList<SeqTabFmt> InheritedList
|
|
{
|
|
get
|
|
{
|
|
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
|
|
if (parentFormat != null)
|
|
return parentFormat.PlantFormat.FormatData.SectData.StepSectionData.SeqTabFmtList;
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#endregion
|
|
#region AccSectionDataAll
|
|
#region AccSectionData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class AccSectionData : vlnFormatItem
|
|
{
|
|
public AccSectionData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<int?> _AutoContActSumSection;
|
|
public int? AutoContActSumSection
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AutoContActSumSection, "@AutoContActSumSection");
|
|
}
|
|
}
|
|
private TableOfContentsData _TableOfContentsData;
|
|
public TableOfContentsData TableOfContentsData
|
|
{
|
|
get
|
|
{
|
|
return (_TableOfContentsData == null ? _TableOfContentsData = new TableOfContentsData(SelectSingleNode("TableOfContentsData")) : _TableOfContentsData);
|
|
}
|
|
}
|
|
private ConitnuousActionSummaryData _ContinuousActionSummaryData;
|
|
public ConitnuousActionSummaryData ContinuousActionSummaryData
|
|
{
|
|
get
|
|
{
|
|
return (_ContinuousActionSummaryData == null? _ContinuousActionSummaryData = new ConitnuousActionSummaryData(SelectSingleNode("ConitnuousActionSummaryData")) : _ContinuousActionSummaryData);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region TableOfContentsData
|
|
public class TableOfContentsData : vlnFormatItem
|
|
{
|
|
public TableOfContentsData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<float?> _TofCSecNumPos;
|
|
public float? TofCSecNumPos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCSecNumPos, "@TofCSecNumPos");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _TofCSecTitlePos;
|
|
public float? TofCSecTitlePos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCSecTitlePos, "@TofCSecTitlePos");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TofCSecTitleLen;
|
|
public int? TofCSecTitleLen
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCSecTitleLen, "@TofCSecTitleLen");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _TofCPageNumPos;
|
|
public float? TofCPageNumPos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCPageNumPos, "@TofCPageNumPos");
|
|
}
|
|
}
|
|
private LazyLoad<string> _TofCSpaceChar;
|
|
public string TofCSpaceChar
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCSpaceChar, "@TofCSpaceChar");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _TofCLineSpacing;
|
|
public float? TofCLineSpacing
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCLineSpacing, "@TofCLineSpacing");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TofCNumLevels;
|
|
public int? TofCNumLevels
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCNumLevels, "@TofCNumLevels");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TofCStartIndentAfterLevel;
|
|
public int? TofCStartIndentAfterLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCStartIndentAfterLevel, "@TofCStartIndentAfterLevel");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _TofCUnderlineFirstLevelTitle;
|
|
public bool TofCUnderlineFirstLevelTitle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCUnderlineFirstLevelTitle, "@TofCUnderlineFirstLevelTitle");
|
|
}
|
|
}
|
|
private LazyLoad<string> _TofCPageNumAlign;
|
|
public string TofCPageNumAlign
|
|
{
|
|
get
|
|
{
|
|
string tocPgNumAlgn = LazyLoad(ref _TofCPageNumAlign, "@TofCPageNumAlign");
|
|
return (tocPgNumAlgn == null || tocPgNumAlgn == "") ? "Left" : tocPgNumAlgn;
|
|
}
|
|
}
|
|
private LazyLoad<string> _TofCProcedureStepsTitle;
|
|
public string TofCProcedureStepsTitle
|
|
{
|
|
get
|
|
{
|
|
string tocProcStepsTitle = LazyLoad(ref _TofCProcedureStepsTitle, "@TofCProcedureStepsTitle");
|
|
return (tocProcStepsTitle == null || tocProcStepsTitle == "") ? "" : tocProcStepsTitle;
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TofCLineSpacingSub;
|
|
public int? TofCLineSpacingSub
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCLineSpacingSub, "@TofCLineSpacingSub");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _TofCRemoveGrpNameInSects;
|
|
public bool TofCRemoveGrpNameInSects
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCRemoveGrpNameInSects, "@TofCRemoveGrpNameInSects");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null) ?_Font = new VE_Font(base.XmlNode):_Font;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region ConitnuousActionSummary
|
|
public class ConitnuousActionSummaryData : vlnFormatItem
|
|
{
|
|
public ConitnuousActionSummaryData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<bool> _IncludeSectionNumAndTitle;
|
|
public bool IncludeSectionNumAndTitle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IncludeSectionNumAndTitle, "@IncludeSectionNumAndTitle");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null) ? _Font = new VE_Font(base.XmlNode) : _Font;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region MetaSectionAll
|
|
#region MetaSection
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class MetaSection : vlnFormatItem,IVlnIndexedFormatItem
|
|
{
|
|
public MetaSection(XmlNode xmlNode) : base(xmlNode) { }
|
|
public MetaSection() : base() { }
|
|
private LazyLoad<int?> _Index;
|
|
public int? Index
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Index, "@Index");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _SecNumPositionAdj;
|
|
public float? SecNumPositionAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SecNumPositionAdj, "@SecNumPositionAdj");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _SecTitlePositionAdj;
|
|
public float? SecTitlePositionAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SecTitlePositionAdj, "@SecTitlePositionAdj");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _ColSByLevel;
|
|
public float? ColSByLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColSByLevel, "@ColSByLevel");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _TofCPositionAdj;
|
|
public float? TofCPositionAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCPositionAdj, "@TofCPositionAdj");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _WidSAdjByLevel;
|
|
public float? WidSAdjByLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _WidSAdjByLevel, "@WidSAdjByLevel");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return string.Format("[{0}]", Index); }
|
|
public override string GetPDCategory()
|
|
{ return "Meta Section Values"; }
|
|
public override string ToString()
|
|
{
|
|
return String.Format("{0}, {1}, {2}, {3}, {4}", SecNumPositionAdj, SecTitlePositionAdj, ColSByLevel, TofCPositionAdj, TofCPositionAdj);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
#region MetaSectionList
|
|
[TypeConverter(typeof(vlnIndexedListConverter<MetaSectionList, MetaSection>))]
|
|
public class MetaSectionList : vlnIndexedFormatList<MetaSection>
|
|
{
|
|
public MetaSectionList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
|
|
public override vlnIndexedFormatList<MetaSection> InheritedList
|
|
{
|
|
get
|
|
{
|
|
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
|
|
if (parentFormat != null)
|
|
return parentFormat.PlantFormat.FormatData.SectData.MetaSectionList;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#endregion
|
|
#region StepDataAll
|
|
#region Step
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class StepData : vlnFormatItem,IVlnIndexedFormatItem
|
|
{
|
|
public StepData() : base() { }
|
|
private LazyLoad<int?> _Index;
|
|
[Description("Step Index")]
|
|
public int? Index
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Index, "@Index");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Type;
|
|
public string Type
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Type, "@Type");
|
|
}
|
|
}
|
|
private LazyLoad<string> _ParentType;
|
|
public string ParentType
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ParentType, "@ParentType");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ReadOnly;
|
|
public bool ReadOnly
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ReadOnly, "@ReadOnly");
|
|
}
|
|
}
|
|
//private LazyLoad<bool> _SeparateWarning; // KBR: To be used for Proms Express to separate out warnings from notes/cautions on ribbon, etc
|
|
//public bool SeparateWarning
|
|
//{
|
|
// get
|
|
// {
|
|
// return LazyLoad(ref _SeparateWarning, "@SeparateWarning");
|
|
// }
|
|
//}
|
|
private LazyLoad<bool> _Inactive;
|
|
public bool Inactive
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Inactive, "@Inactive");
|
|
}
|
|
}
|
|
// F2018-022 Added step type flag to append a ".0" to the end of the high level step - put in for Westinghouse single column format (wst1)
|
|
private LazyLoad<bool> _AppendDotZero;
|
|
public bool AppendDotZero
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AppendDotZero, "@AppendDotZero");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _ColOverride;
|
|
public float? ColOverride
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColOverride, "@ColOverride");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _ColOverrideEdit;
|
|
|
|
public float? ColOverrideEdit
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColOverrideEdit, "@ColOverrideEdit");
|
|
}
|
|
}
|
|
private LazyLoad<string> _WidthOverride;
|
|
|
|
public string WidthOverride
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _WidthOverride, "@WidthOverride");
|
|
}
|
|
}
|
|
//private LazyLoad<float?> _WidthOverride;
|
|
|
|
//public float? WidthOverride
|
|
//{
|
|
// get
|
|
// {
|
|
// return LazyLoad(ref _WidthOverride, "@WidthOverride");
|
|
// }
|
|
//}
|
|
private LazyLoad<float?> _WidthOverrideEdit;
|
|
|
|
public float? WidthOverrideEdit
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _WidthOverrideEdit, "@WidthOverrideEdit");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Sep;
|
|
public string Sep
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Sep, "@Sep");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Prefix;
|
|
public string Prefix
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Prefix, "@Prefix");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Suffix;
|
|
public string Suffix
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Suffix, "@Suffix");
|
|
}
|
|
}
|
|
private LazyLoad<string> _UnderlineTheseChar;
|
|
public string UnderlineTheseChar
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UnderlineTheseChar, "@UnderlineTheseChar");
|
|
}
|
|
}
|
|
private LazyLoad<string> _VertPos;
|
|
public string VertPos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _VertPos, "@VertPos");
|
|
}
|
|
}
|
|
|
|
private LazyLoad<bool> _DoubleSpace;
|
|
public bool DoubleSpace
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DoubleSpace, "@DoubleSpace");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _EnhancedStepNumFromPrev;
|
|
public bool EnhancedStepNumFromPrev
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _EnhancedStepNumFromPrev, "@EnhancedStepNumFromPrev");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseSmartTemplate;
|
|
public bool UseSmartTemplate
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseSmartTemplate, "@UseSmartTemplate");
|
|
}
|
|
}
|
|
|
|
private LazyLoad<bool> _UseOldTemplate;
|
|
public bool UseOldTemplate
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseOldTemplate, "@UseOldTemplate");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AlwaysUseExtraLines;
|
|
public bool AlwaysUseExtraLines
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AlwaysUseExtraLines, "@AlwaysUseExtraLines");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SeparateBox;
|
|
public bool SeparateBox
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SeparateBox, "@SeparateBox");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SeparateBoxCautions;
|
|
public bool SeparateBoxCautions
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SeparateBoxCautions, "@SeparateBoxCautions");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpaceDouble;
|
|
public bool SpaceDouble
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpaceDouble, "@SpaceDouble");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ReduceLineAfter;
|
|
public bool ReduceLineAfter
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ReduceLineAfter, "@ReduceLineAfter");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SameLevel;
|
|
public bool SameLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SameLevel, "@SameLevel");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _BoldHighLevel;
|
|
public bool BoldHighLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BoldHighLevel, "@BoldHighLevel");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _OneLineBeforeTab;
|
|
public bool OneLineBeforeTab
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _OneLineBeforeTab, "@OneLineBeforeTab");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CheckOffOnAllSteps;
|
|
public bool CheckOffOnAllSteps
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOffOnAllSteps, "@CheckOffOnAllSteps");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _BoxIt;
|
|
public bool BoxIt
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BoxIt, "@BoxIt");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Boxed;
|
|
public bool Boxed
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Boxed, "@Boxed");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _XLines_StepFix;
|
|
public bool XLines_StepFix
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _XLines_StepFix, "@XLines_StepFix");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Rebox;
|
|
public bool Rebox
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Rebox, "@Rebox");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpcHdr;
|
|
public bool SpcHdr
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpcHdr, "@SpcHdr");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ContinueOnly;
|
|
public bool ContinueOnly
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ContinueOnly, "@ContinueOnly");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SepAfterAER;
|
|
public bool SepAfterAER
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SepAfterAER, "@SepAfterAER");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseAlternateStepBox;
|
|
public bool UseAlternateStepBox
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseAlternateStepBox, "@UseAlternateStepBox");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UnderlineAfterDashSpace;
|
|
public bool UnderlineAfterDashSpace
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UnderlineAfterDashSpace, "@UnderlineAfterDashSpace");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpaceIn;
|
|
public bool SpaceIn
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpaceIn, "@SpaceIn");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _PageBreakOnStep;
|
|
public bool PageBreakOnStep
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PageBreakOnStep, "@PageBreakOnStep");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AlignNullTabWSectHead;
|
|
public bool AlignNullTabWSectHead
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AlignNullTabWSectHead, "@AlignNullTabWSectHead");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ForceAlignNullTabWSectHead;
|
|
public bool ForceAlignNullTabWSectHead
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ForceAlignNullTabWSectHead, "@ForceAlignNullTabWSectHead");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AlignHLSTabWithSectOvride;
|
|
public bool AlignHLSTabWithSectOvride
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AlignHLSTabWithSectOvride, "@AlignHLSTabWithSectOvride");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _TextSubFollowsTextStyle;
|
|
public bool TextSubFollowsTextStyle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TextSubFollowsTextStyle, "@TextSubFollowsTextStyle");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _CautionOrNoteSubstepIndent;
|
|
public int? CautionOrNoteSubstepIndent
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CautionOrNoteSubstepIndent, "@CautionOrNoteSubstepIndent");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _TreatAsSequential;
|
|
public bool TreatAsSequential
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TreatAsSequential, "@TreatAsSequential");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _MatchUpRNO;
|
|
public bool MatchUpRNO
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MatchUpRNO, "@MatchUpRNO");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _InPageList;
|
|
public bool InPageList
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _InPageList, "@InPageList");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CenterOneLineOnly;
|
|
public bool CenterOneLineOnly
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CenterOneLineOnly, "@CenterOneLineOnly");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SubTableGetsUp1Level;
|
|
public bool SubTableGetsUp1Level
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SubTableGetsUp1Level, "@SubTableGetsUp1Level");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Remember;
|
|
public bool Remember
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Remember, "@Remember");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CenterOneLineAdjust;
|
|
public bool CenterOneLineAdjust
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CenterOneLineAdjust, "@CenterOneLineAdjust");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Break;
|
|
public bool Break
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Break, "@Break");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _BreakEquipmentList;
|
|
public bool BreakEquipmentList
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BreakEquipmentList, "@BreakEquipmentList");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _BreakCautionsNotesOnSubstps;
|
|
public bool BreakCautionsNotesOnSubstps
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BreakCautionsNotesOnSubstps, "@BreakCautionsNotesOnSubstps");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CenterTextWithinWidth;
|
|
public bool CenterTextWithinWidth
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CenterTextWithinWidth, "@CenterTextWithinWidth");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NewlineAfter;
|
|
public bool NewlineAfter
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NewlineAfter, "@NewlineAfter");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _StartLineWithDash;
|
|
public bool StartLineWithDash
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _StartLineWithDash, "@StartLineWithDash");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _BlankLineBeforeSubStep;
|
|
public bool BlankLineBeforeSubStep
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BlankLineBeforeSubStep, "@BlankLineBeforeSubStep");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AlwaysTab;
|
|
public bool AlwaysTab
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AlwaysTab, "@AlwaysTab");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NoSpaceMultipleRNOs;
|
|
public bool NoSpaceMultipleRNOs
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NoSpaceMultipleRNOs, "@NoSpaceMultipleRNOs");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _MixCautionsAndNotes;
|
|
public bool MixCautionsAndNotes
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MixCautionsAndNotes, "@MixCautionsAndNotes");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NumberHighLevel;
|
|
public bool NumberHighLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NumberHighLevel, "@NumberHighLevel");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NumberWithLevel;
|
|
public bool NumberWithLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NumberWithLevel, "@NumberWithLevel");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _OffsetTab;
|
|
public bool OffsetTab
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _OffsetTab, "@OffsetTab");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _AdjHighLevelTab;
|
|
public float? AdjHighLevelTab
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AdjHighLevelTab, "@AdjHighLevelTab");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _ChildIndent;
|
|
public float? ChildIndent
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ChildIndent, "@ChildIndent");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _LeftJustifyBorderless;
|
|
public bool LeftJustifyBorderless
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LeftJustifyBorderless, "@LeftJustifyBorderless");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _StepNumIfOnlyOne;
|
|
public bool StepNumIfOnlyOne
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _StepNumIfOnlyOne, "@StepNumIfOnlyOne");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _LJTabs;
|
|
public bool LJTabs
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LJTabs, "@LJTabs");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NumberSubs;
|
|
public bool NumberSubs
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NumberSubs, "@NumberSubs");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _BulletOnContinuous;
|
|
public bool BulletOnContinuous
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BulletOnContinuous, "@BulletOnContinuous");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _StepNumberForHighLevel;
|
|
public bool StepNumberForHighLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _StepNumberForHighLevel, "@StepNumberForHighLevel");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SameRowAsParent;
|
|
public bool SameRowAsParent
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SameRowAsParent, "@SameRowAsParent");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SameRowAsParentMultiLines;
|
|
public bool SameRowAsParentMultiLines
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SameRowAsParentMultiLines, "@SameRowAsParentMultiLines");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CheckOffSameAsParent;
|
|
public bool CheckOffSameAsParent
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOffSameAsParent, "@CheckOffSameAsParent");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AtLeastTwoDigits;
|
|
public bool AtLeastTwoDigits
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AtLeastTwoDigits, "@AtLeastTwoDigits");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseInAcTable;
|
|
public bool UseInAcTable
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseInAcTable, "@UseInAcTable");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Number;
|
|
public bool Number
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Number, "@Number");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _ThreeBlanksAbove;
|
|
public bool ThreeBlanksAbove
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ThreeBlanksAbove, "@ThreeBlanksAbove");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CheckOffs;
|
|
public bool CheckOffs
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOffs, "@CheckOffs");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Quoted;
|
|
public bool Quoted
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Quoted, "@Quoted");
|
|
}
|
|
}
|
|
private VE_Font GetUCFFontAsVE_Font()
|
|
{
|
|
// if formatconfig & step list, then go through to see if index exists, if so and if there is a font, use it:
|
|
if (MyFormat.PlantFormat.FormatConfig != null && MyFormat.PlantFormat.FormatConfig.PlantFormat != null && MyFormat.PlantFormat.FormatConfig.PlantFormat.FormatData != null && MyFormat.PlantFormat.FormatConfig.PlantFormat.FormatData.StepData != null)
|
|
{
|
|
foreach (FormatConfig.Step stp in MyFormat.PlantFormat.FormatConfig.PlantFormat.FormatData.StepData)
|
|
{
|
|
if (Convert.ToInt32(stp.Index) == (int)Index && stp.FontDesc != null && stp.FontDesc.Font != null && stp.FontDesc.Font != "")
|
|
{
|
|
System.Drawing.FontConverter cvt = new System.Drawing.FontConverter();
|
|
System.Drawing.Font windowsFont = cvt.ConvertFromString(stp.FontDesc.Font) as System.Drawing.Font;
|
|
|
|
E_Style myStyle = E_Style.None;
|
|
if (windowsFont.Bold) myStyle |= E_Style.Bold;
|
|
if (windowsFont.Underline) myStyle |= E_Style.Underline;
|
|
if (windowsFont.Italic) myStyle |= E_Style.Italics;
|
|
return (new VE_Font(windowsFont.Name, (int)windowsFont.Size, myStyle, windowsFont.SizeInPoints));
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
if (PlantFormat.IgnoreUCF) return (_Font == null) ?_Font = new VE_Font(base.XmlNode): _Font;
|
|
if (_Font != null) return (_Font);
|
|
VE_Font vef = GetUCFFontAsVE_Font();
|
|
if (vef != null)
|
|
{
|
|
_Font = vef;
|
|
return vef;
|
|
}
|
|
return (_Font == null) ?_Font = new VE_Font(base.XmlNode): _Font;
|
|
}
|
|
}
|
|
private StepLayoutData _StepLayoutData;
|
|
public StepLayoutData StepLayoutData
|
|
{
|
|
get
|
|
{
|
|
return (_StepLayoutData == null)? _StepLayoutData = new StepLayoutData(base.XmlNode): _StepLayoutData;
|
|
}
|
|
}
|
|
private StepEditData _StepEditData;
|
|
public StepEditData StepEditData
|
|
{
|
|
get
|
|
{
|
|
return (_StepEditData == null) ? _StepEditData = new StepEditData(base.XmlNode) : _StepEditData;
|
|
}
|
|
}
|
|
private StepPrintData _StepPrintData;
|
|
public StepPrintData StepPrintData
|
|
{
|
|
get
|
|
{
|
|
return (_StepPrintData == null) ? _StepPrintData = new StepPrintData(base.XmlNode) : _StepPrintData;
|
|
}
|
|
}
|
|
private TabData _TabData;
|
|
public TabData TabData
|
|
{
|
|
get
|
|
{
|
|
return (_TabData == null) ? _TabData = new TabData(base.XmlNode) : _TabData;
|
|
}
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0}", Type);
|
|
}
|
|
private LazyLoad<bool> _ExcludeFromContActSum;
|
|
public bool ExcludeFromContActSum
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ExcludeFromContActSum, "@ExcludeFromContActSum", true); // the default setting is true (as is yes, dont include on Continuous Action Summary)
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region StepDataList
|
|
[TypeConverter(typeof(vlnIndexedListConverter<StepDataList, StepData>))]
|
|
public class StepDataList : vlnIndexedFormatList<StepData>
|
|
{
|
|
//public new StepData this[int index]
|
|
//{
|
|
// get
|
|
// {
|
|
// foreach (StepData stepData in this)
|
|
// if (stepData.Index == index) return stepData;
|
|
// return null;
|
|
// }
|
|
//}
|
|
public override vlnIndexedFormatList<StepData> InheritedList
|
|
{
|
|
get
|
|
{
|
|
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
|
|
if (parentFormat != null)
|
|
return parentFormat.PlantFormat.FormatData.StepDataList;
|
|
return null;
|
|
}
|
|
}
|
|
public StepData this[string type]
|
|
{
|
|
get
|
|
{
|
|
foreach (StepData stepData in this)
|
|
if (stepData.Type == type) return stepData;
|
|
StepDataList ttlParent = (StepDataList) InheritedList; //Check Inherited Value
|
|
if (ttlParent != null)
|
|
return ttlParent[type]; // note that this is recursive, i.e. if doesn't get found in parent, goes to parent's parent.
|
|
return null;
|
|
}
|
|
}
|
|
// the following was commented out because it uses the vlnFormat version of the code that indexes the list.
|
|
//public StepData this[int index]
|
|
//{
|
|
// get
|
|
// {
|
|
// foreach (StepData stepData in this)
|
|
// if (stepData.Index == index) return stepData;
|
|
// StepDataList ttlParent = (StepDataList)InheritedList; //Check Inherited Value
|
|
// if (ttlParent != null)
|
|
// return ttlParent[index];
|
|
// return null;
|
|
// }
|
|
//}
|
|
public StepDataList(XmlNodeList xmlNodeList, IFormatOrFormatInfo myFormat) : base(xmlNodeList, myFormat) { }
|
|
private StepData _HLS;
|
|
public StepData HLS
|
|
{
|
|
get
|
|
{
|
|
if (_HLS!=null) return _HLS;
|
|
foreach (StepData sd in this)
|
|
{
|
|
if (sd.Type == "High")
|
|
{
|
|
_HLS = sd;
|
|
return sd;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
private StepData _Caution;
|
|
public StepData Caution
|
|
{
|
|
get
|
|
{
|
|
if (_Caution != null) return _Caution;
|
|
foreach (StepData sd in this)
|
|
{
|
|
if (sd.Type == "Caution")
|
|
{
|
|
_Caution = sd;
|
|
return sd;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
private StepData _Note;
|
|
public StepData Note
|
|
{
|
|
get
|
|
{
|
|
if (_Note != null) return _Note;
|
|
foreach (StepData sd in this)
|
|
{
|
|
if (sd.Type == "Note")
|
|
{
|
|
_Note = sd;
|
|
return sd;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
private StepData _RNO;
|
|
public StepData RNO
|
|
{
|
|
get
|
|
{
|
|
if (_RNO != null) return _RNO;
|
|
foreach (StepData sd in this)
|
|
{
|
|
if (sd.Type == "RNOType")
|
|
{
|
|
_RNO = sd;
|
|
return sd;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
private StepData _Fig;
|
|
public StepData Fig
|
|
{
|
|
get
|
|
{
|
|
if (_Fig != null) return _Fig;
|
|
foreach (StepData sd in this)
|
|
{
|
|
if (sd.Type == "Figure")
|
|
{
|
|
_Fig = sd;
|
|
return sd;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
private StepData _Table;
|
|
public StepData Table
|
|
{
|
|
get
|
|
{
|
|
if (_Table != null) return _Table;
|
|
foreach (StepData sd in this)
|
|
{
|
|
if (sd.Type == "Table")
|
|
{
|
|
_Table = sd;
|
|
return sd;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
private StepData _Substep;
|
|
public StepData Substep
|
|
{
|
|
get
|
|
{
|
|
if (_Substep != null) return _Substep;
|
|
foreach (StepData sd in this)
|
|
{
|
|
if (sd.Type == "Substep")
|
|
{
|
|
_Substep = sd;
|
|
return sd;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
// EmbeddedObject has been commented out, 'Equations' are separate top level items.
|
|
// This code was left here in case Equations , and other OLE objects, end up
|
|
// under the EmbeddedObject:
|
|
|
|
// EmbeddedObject has inheritted types that represent OLE objects.
|
|
// The first of these is 'Equation'. Another that may be implemented later is Image.
|
|
// This is a special case, since only 'Equation' exists on initial development of
|
|
// embedded objects, 'skip' the embedded object layer when creating the list and
|
|
// go right to the equations.
|
|
//private StepData _EmbeddedObject;
|
|
//public StepData EmbeddedObject
|
|
//{
|
|
// get
|
|
// {
|
|
// if (_EmbeddedObject != null) return _EmbeddedObject;
|
|
// foreach (StepData sd in this)
|
|
// {
|
|
// if (sd.Type == "EmbeddedObject")
|
|
// {
|
|
// _Equation = sd;
|
|
// return sd;
|
|
// }
|
|
// }
|
|
// return null;
|
|
// }
|
|
//}
|
|
private StepData _Equation;
|
|
public StepData Equation // equation has a parent of embedded object.
|
|
{
|
|
get
|
|
{
|
|
if (_Equation != null) return _Equation;
|
|
foreach (StepData sd in this)
|
|
{
|
|
if (sd.Type == "Equation")
|
|
{
|
|
_Equation = sd;
|
|
return sd;
|
|
}
|
|
}
|
|
// Handle inheritance (step data may not be in current format, may inherit from parents):
|
|
IFormatOrFormatInfo parentFormat = this.MyFormat.PlantFormat.FormatData.MyParentFormat;
|
|
while (parentFormat != null)
|
|
{
|
|
vlnIndexedFormatList<StepData> InheritedList = parentFormat.PlantFormat.FormatData.StepDataList;
|
|
if (InheritedList != null)
|
|
{
|
|
foreach (StepData sdi in InheritedList)
|
|
{
|
|
if (sdi.Type == "Equation")
|
|
{
|
|
_Equation = sdi;
|
|
return sdi;
|
|
}
|
|
}
|
|
}
|
|
parentFormat = parentFormat.PlantFormat.FormatData.MyParentFormat;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region StepLayoutData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class StepLayoutData : vlnFormatItem
|
|
{
|
|
public StepLayoutData(XmlNode xmlNode)
|
|
: base(xmlNode)
|
|
{
|
|
}
|
|
private LazyLoad<string> _ForeColor;
|
|
public string ForeColor
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ForeColor, "StepLayoutData/@ForeColor");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BackColor;
|
|
public string BackColor
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BackColor, "StepLayoutData/@BackColor");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _STExtraSpace;
|
|
public int? STExtraSpace
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _STExtraSpace, "StepLayoutData/@STExtraSpace");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _STBoxindex;
|
|
public int? STBoxindex
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _STBoxindex, "StepLayoutData/@STBoxindex");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _EveryNLines;
|
|
public int? EveryNLines
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _EveryNLines, "StepLayoutData/@EveryNLines");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AlignWithParentTab;
|
|
public bool AlignWithParentTab
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AlignWithParentTab, "StepLayoutData/@AlignWithParentTab");
|
|
}
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
#region StepEditData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class StepEditData : vlnFormatItem
|
|
{
|
|
public StepEditData(XmlNode xmlNode)
|
|
: base(xmlNode)
|
|
{
|
|
}
|
|
private TypeMenu _TypeMenu;
|
|
public TypeMenu TypeMenu
|
|
{
|
|
get
|
|
{
|
|
return (_TypeMenu == null) ? _TypeMenu = new TypeMenu(base.XmlNode) : _TypeMenu;
|
|
}
|
|
}
|
|
private LazyLoad<string> _ForeColor;
|
|
public string ForeColor
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ForeColor, "StepEditData/@ForeColor");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BackColor;
|
|
public string BackColor
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BackColor, "StepEditData/@BackColor");
|
|
}
|
|
}
|
|
private LazyLoad<E_AccStep?> _AcTable;
|
|
public E_AccStep? AcTable
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad<E_AccStep>(ref _AcTable, "StepEditData/@AcTable");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Searchable;
|
|
public bool Searchable
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Searchable, "StepEditData/@Searchable");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region StepPrintData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class StepPrintData : vlnFormatItem
|
|
{
|
|
public StepPrintData(XmlNode xmlNode)
|
|
: base(xmlNode)
|
|
{
|
|
}
|
|
private LazyLoad<float?> _PosAdjust;
|
|
public float? PosAdjust
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PosAdjust, "StepPrintData/@PosAdjust");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _HLSLength;
|
|
public int? HLSLength
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _HLSLength, "StepPrintData/@HLSLength");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Justify;
|
|
public string Justify
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Justify, "StepPrintData/@Justify");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region TypeMenu
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class TypeMenu : vlnFormatItem
|
|
{
|
|
public TypeMenu(XmlNode xmlNode)
|
|
: base(xmlNode)
|
|
{
|
|
}
|
|
private LazyLoad<bool> _InMenu;
|
|
public bool InMenu
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _InMenu, "StepEditData/TypeMenu/@InMenu");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _RnoInMenu;
|
|
public bool RnoInMenu
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RnoInMenu, "StepEditData/TypeMenu/@RnoInMenu");
|
|
}
|
|
}
|
|
private LazyLoad<string> _MenuItem;
|
|
public string MenuItem
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MenuItem, "StepEditData/TypeMenu/@MenuItem");
|
|
}
|
|
}
|
|
private LazyLoad<string> _RnoMenuItem;
|
|
public string RnoMenuItem
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RnoMenuItem, "StepEditData/TypeMenu/@RnoMenuItem");
|
|
}
|
|
}
|
|
private LazyLoad<string> _NoChgReason;
|
|
public string NoChgReason
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NoChgReason, "StepEditData/TypeMenu/@NoChgReason");
|
|
}
|
|
}
|
|
private LazyLoad<string> _AlternateNameList;
|
|
public string AlternateNameList
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AlternateNameList, "StepEditData/TypeMenu/@AlternateNameList");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region Bullet
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Bullet : vlnFormatItem
|
|
{
|
|
public Bullet(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<bool> _Separate;
|
|
public bool Separate
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Separate, "TabData/Bullet/@Separate");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
if (_Font == null)
|
|
{
|
|
XmlNode xn = vlnFormatDocument.LookupSingleStepNode(base.XmlNode, "Bullet[Font]");
|
|
_Font = new VE_Font(xn);
|
|
}
|
|
return _Font;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
#region StepTab
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class TabData : vlnFormatItem
|
|
{
|
|
public TabData(XmlNode xmlNode)
|
|
: base(xmlNode)
|
|
{
|
|
}
|
|
private MacroList _MacroList;
|
|
public MacroList MacroList
|
|
{
|
|
get
|
|
{
|
|
return _MacroList == null ? _MacroList = new MacroList(SelectNodes("TabData/MacroList/Macro")) : _MacroList;
|
|
}
|
|
}
|
|
private LazyLoad<string> _IdentEdit;
|
|
public string IdentEdit
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IdentEdit, "TabData/@IdentEdit");
|
|
}
|
|
}
|
|
private LazyLoad<string> _IdentPrint;
|
|
public string IdentPrint
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IdentPrint, "TabData/@Ident");
|
|
}
|
|
}
|
|
private LazyLoad<string> _IdentAltPrint;
|
|
public string IdentAltPrint
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IdentAltPrint, "TabData/@IdentAltPrint");
|
|
}
|
|
}
|
|
private LazyLoad<string> _RNOIdentEdit;
|
|
public string RNOIdentEdit
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOIdentEdit, "TabData/@RNOIdentEdit");
|
|
}
|
|
}
|
|
private LazyLoad<string> _RNOIdent;
|
|
public string RNOIdent
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOIdent, "TabData/@RNOIdent");
|
|
}
|
|
}
|
|
private LazyLoad<string> _RNOIdentPrint;
|
|
public string RNOIdentPrint
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOIdentPrint, "TabData/@RNOIdent");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _RNOExcludeMacros;
|
|
public bool RNOExcludeMacros
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOExcludeMacros, "TabData/@RNOExcludeMacros");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NoTabAlign;
|
|
public bool NoTabAlign
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NoTabAlign, "TabData/@NoTabAlign");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _IncludeStepNum;
|
|
public bool IncludeStepNum
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IncludeStepNum, "TabData/@IncludeStepNum");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _IncludeSectionNum;
|
|
public bool IncludeSectionNum
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IncludeSectionNum, "TabData/@IncludeSectionNum");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Justify;
|
|
public string Justify
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Justify, "TabData/@Justify");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UsePreviousStyle;
|
|
public bool UsePreviousStyle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UsePreviousStyle, "TabData/@UsePreviousStyle");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _IsTransition;
|
|
public bool IsTransition
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IsTransition, "TabData/@IsTransition");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _IdentWidth;
|
|
public float? IdentWidth
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _IdentWidth, "TabData/@IdentWidth");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _RNOAdjustTabSize;
|
|
public float? RNOAdjustTabSize
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOAdjustTabSize, "TabData/@RNOAdjustTabSize");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _MacroTabAdjust;
|
|
public float? MacroTabAdjust
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MacroTabAdjust, "TabData/@MacroTabAdjust");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
if (_Font == null)
|
|
{
|
|
XmlNode xn = vlnFormatDocument.LookupSingleStepNode(base.XmlNode, "TabData[Font]");
|
|
_Font = new VE_Font(xn);
|
|
}
|
|
return _Font;
|
|
}
|
|
}
|
|
private Bullet _Bullet;
|
|
public Bullet Bullet
|
|
{
|
|
get
|
|
{
|
|
return (_Bullet == null) ? _Bullet = new Bullet(base.XmlNode) : _Bullet;
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NoTrim;
|
|
public bool NoTrim
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NoTrim, "TabData/@NoTrim");
|
|
}
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
#region MacroList
|
|
[TypeConverter(typeof(vlnListConverter<MacroList, Macro>))]
|
|
public class MacroList : vlnNamedFormatList<Macro>
|
|
{
|
|
public MacroList(XmlNodeList xmlNodeList) : base(xmlNodeList, null) { }
|
|
public override vlnNamedFormatList<Macro> InheritedList
|
|
{
|
|
get
|
|
{
|
|
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region Macro
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Macro : vlnFormatItem, IVlnNamedFormatItem
|
|
{
|
|
public Macro(XmlNode xmlNode) : base(xmlNode) { }
|
|
public Macro() : base() { }
|
|
private LazyLoad<string> _Name;
|
|
public string Name
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Name, "@Name");
|
|
}
|
|
}
|
|
private LazyLoad<string> _MacroDef;
|
|
public string MacroDef
|
|
{
|
|
get
|
|
{
|
|
if (_Inherited == null) SetupStepInheritance();
|
|
return LazyLoad(ref _MacroDef, "@Macro");
|
|
}
|
|
}
|
|
private LazyLoad<string> _SingleColMacroDef;
|
|
public string SingleColMacroDef
|
|
{
|
|
get
|
|
{
|
|
if (_Inherited == null) SetupStepInheritance();
|
|
return LazyLoad(ref _SingleColMacroDef, "@SingleColMacro");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _MacroXOffSet;
|
|
public float? MacroXOffSet
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _MacroXOffSet, "@MacroXOffSet");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _SingleColWidthAdjust;
|
|
public float? SingleColWidthAdjust
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SingleColWidthAdjust, "@SingleColWidthAdjust");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _LocWithXOff;
|
|
public bool? LocWithXOff
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LocWithXOff, "@LocWithXOff");
|
|
}
|
|
}
|
|
|
|
private LazyLoad<int?> _Grouping;
|
|
public int? Grouping
|
|
{
|
|
get
|
|
{
|
|
if (_Inherited == null) SetupStepInheritance();
|
|
return LazyLoad(ref _Grouping, "@Grouping");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NotInRNO;
|
|
public bool NotInRNO
|
|
{
|
|
get
|
|
{
|
|
if (_Inherited == null) SetupStepInheritance();
|
|
return LazyLoad(ref _NotInRNO, "@NotInRNO");
|
|
}
|
|
}
|
|
|
|
private bool? _Inherited;
|
|
public bool Inherited
|
|
{
|
|
get
|
|
{
|
|
if (_Inherited == null) SetupStepInheritance();
|
|
return (bool) _Inherited;
|
|
}
|
|
}
|
|
private void SetupStepInheritance()
|
|
{
|
|
if (_Inherited != null) return;
|
|
LazyLoad<string> macroName = null;
|
|
_Inherited = (LazyLoad(ref macroName, "@Macro") == null);
|
|
// No MacroName, Find parent that has data
|
|
string path = string.Format("TabData/MacroList/Macro[@Name='{0}' and @Macro]", Name);
|
|
XmlNode xn = vlnFormatDocument.LookupSingleStepNode(XmlNode.ParentNode.ParentNode.ParentNode, path);
|
|
if (xn != null)
|
|
{
|
|
_MacroDef = new LazyLoad<string>(RetrieveString(xn.SelectSingleNode("@Macro")));
|
|
_Grouping = new LazyLoad<int?>(RetrieveInt("@Grouping" ,xn.SelectSingleNode("@Grouping")));
|
|
_NotInRNO = new LazyLoad<bool>(RetrieveBool( xn.SelectSingleNode("@NotInRNO")));
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region BoxDataAll
|
|
#region Box
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Box : vlnFormatItem,IVlnIndexedFormatItem
|
|
{
|
|
public Box(XmlNode xmlNode) : base(xmlNode) { }
|
|
public Box() : base() { }
|
|
private LazyLoad<int?> _Index;
|
|
public int? Index
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Index, "@Index");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _NumLines;
|
|
public int? NumLines // This was added to support 3 line box for VC Summer Alarms. It is only checked in 'double line' vlnbox.cs code!
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NumLines, "@NumLines");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _Start;
|
|
public float? Start
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Start, "@Start");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _End;
|
|
public float? End
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _End, "@End");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _TxtStart;
|
|
public float? TxtStart
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TxtStart, "@TxtStart");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _TxtWidth;
|
|
public float? TxtWidth
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TxtWidth, "@TxtWidth");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _Height;
|
|
public float? Height
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Height, "@Height");
|
|
}
|
|
}
|
|
private LazyLoad<float?> _TabPos;
|
|
public float? TabPos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TabPos, "@TabPos");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TxtRowAdj;
|
|
public int? TxtRowAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TxtRowAdj, "@TxtRowAdj");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BXURC;
|
|
public string BXURC
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BXURC, "@BXURC");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BXHorz;
|
|
public string BXHorz
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BXHorz, "@BXHorz");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BXULC;
|
|
public string BXULC
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BXULC, "@BXULC");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BXVert;
|
|
public string BXVert
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BXVert, "@BXVert");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BXMLS;
|
|
public string BXMLS
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BXMLS, "@BXMLS");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BXMRS;
|
|
public string BXMRS
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BXMRS, "@BXMRS");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BXLRC;
|
|
public string BXLRC
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BXLRC, "@BXLRC");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BXLLC;
|
|
public string BXLLC
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BXLLC, "@BXLLC");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BXMID;
|
|
public string BXMID
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BXMID, "@BXMID");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BXLHorz;
|
|
public string BXLHorz
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BXLHorz, "@BXLHorz");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BXUMID;
|
|
public string BXUMID
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BXUMID, "@BXUMID");
|
|
}
|
|
}
|
|
private LazyLoad<string> _BXLMID;
|
|
public string BXLMID
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BXLMID, "@BXLMID");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null) ?_Font = new VE_Font(base.XmlNode):_Font;
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return string.Format("[{0}]", Index); }
|
|
public override string GetPDCategory()
|
|
{ return "Box Definition"; }
|
|
public override string ToString()
|
|
{
|
|
return String.Format("{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}",
|
|
BXURC, BXHorz, BXULC, BXVert, BXMLS, BXMRS, BXLRC, BXLLC, BXMID, BXLHorz, BXUMID, BXLMID);
|
|
}
|
|
public string BoxStyle
|
|
{
|
|
get
|
|
{
|
|
return String.Format("{0}.{1}.{2}.{3}.{4}.{5}.{6}.{7}.{8}.{9}.{10}.{11}",
|
|
BXURC ?? " ", BXHorz ?? " ", BXULC ?? " ", BXVert ?? " ", BXMLS ?? " ", BXMRS ?? " ", BXLRC ?? " ", BXLLC ?? " ", BXMID ?? " ", BXLHorz ?? BXHorz, BXUMID ?? " ", BXLMID ?? " ");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region BoxList
|
|
[TypeConverter(typeof(vlnIndexedListConverter<BoxList, Box>))]
|
|
public class BoxList : vlnIndexedFormatList<Box>
|
|
{
|
|
public BoxList(XmlNodeList xmlNodeList, IFormatOrFormatInfo myFormat) : base(xmlNodeList, myFormat) { }
|
|
public override vlnIndexedFormatList<Box> InheritedList
|
|
{
|
|
get
|
|
{
|
|
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
|
|
if (parentFormat != null)
|
|
return parentFormat.PlantFormat.FormatData.BoxList;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region TransDataAll
|
|
#region TransData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class TransData : vlnFormatItem
|
|
{
|
|
private TransTypeList _TransTypeList;
|
|
public TransTypeList TransTypeList
|
|
{
|
|
get
|
|
{
|
|
return(_TransTypeList == null || _TransTypeList.MaxIndex==0)? _TransTypeList = new TransTypeList(SelectNodes("TransTypeData/TransTypes"),MyFormat): _TransTypeList;
|
|
}
|
|
}
|
|
public TransData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<string> _DelimiterForTransitionTitle;
|
|
public string DelimiterForTransitionTitle
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DelimiterForTransitionTitle, "@DelimiterForTransitionTitle");
|
|
}
|
|
}
|
|
private LazyLoad<string> _StepSubstepDelimeter;
|
|
public string StepSubstepDelimeter
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _StepSubstepDelimeter, "@StepSubstepDelimeter");
|
|
}
|
|
}
|
|
private LazyLoad<string> _ThroughString;
|
|
public string ThroughString
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ThroughString, "@ThroughString");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SpecifiedSubstepsOnly;
|
|
public bool SpecifiedSubstepsOnly
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SpecifiedSubstepsOnly, "@SpecifiedSubstepsOnly");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CapsTransitions;
|
|
public bool CapsTransitions
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CapsTransitions, "@CapsTransitions");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CapsTransitionsSection;
|
|
public bool CapsTransitionsSection
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CapsTransitionsSection, "@CapsTransitionsSection");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CapTranStep;
|
|
public bool CapTranStep
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CapTranStep, "@CapTranStep");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Underline;
|
|
public bool Underline
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Underline, "@Underline");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _TStepNoFlag;
|
|
public bool TStepNoFlag
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TStepNoFlag, "@TStepNoFlag");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _LowerCaseTranNumber;
|
|
public bool LowerCaseTranNumber
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LowerCaseTranNumber, "@LowerCaseTranNumber");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UpcaseTranAnd;
|
|
public bool UpcaseTranAnd
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UpcaseTranAnd, "@UpcaseTranAnd");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _SuppressAndInTran;
|
|
public bool SuppressAndInTran
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SuppressAndInTran, "@SuppressAndInTran");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Cap1stCharTrans;
|
|
public bool Cap1stCharTrans
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Cap1stCharTrans, "@Cap1stCharTrans");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _Cap1stCharTransSection;
|
|
public bool Cap1stCharTransSection
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Cap1stCharTransSection, "@Cap1stCharTransSection");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseTransitionModifier;
|
|
public bool UseTransitionModifier
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseTransitionModifier, "@UseTransitionModifier");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseSpecificTransitionModifier;
|
|
public bool UseSpecificTransitionModifier
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseSpecificTransitionModifier, "@UseSpecificTransitionModifier");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseSpecificPageNo;
|
|
public bool UseSpecificPageNo
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseSpecificPageNo, "@UseSpecificPageNo");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UseSecTitles;
|
|
public bool UseSecTitles
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseSecTitles, "@UseSecTitles");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _DoSectionTransitions;
|
|
public bool DoSectionTransitions
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _DoSectionTransitions, "@DoSectionTransitions");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _NoDefaultSectReq;
|
|
public bool NoDefaultSectReq
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _NoDefaultSectReq, "@NoDefaultSectReq");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AllowTransitionFromSection;
|
|
public bool AllowTransitionFromSection
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AllowTransitionFromSection, "@AllowTransitionFromSection");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _HardSpTranProcNumb;
|
|
public bool HardSpTranProcNumb
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _HardSpTranProcNumb, "@HardSpTranProcNumb");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _XchngTranSpForHard;
|
|
public bool XchngTranSpForHard
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _XchngTranSpForHard, "@XchngTranSpForHard");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AbsoluteTransitionUpdate;
|
|
public bool AbsoluteTransitionUpdate
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AbsoluteTransitionUpdate, "@AbsoluteTransitionUpdate");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _LowerCaseStepInTran;
|
|
public bool LowerCaseStepInTran
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LowerCaseStepInTran, "@LowerCaseStepInTran");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _BoldTransition;
|
|
public bool BoldTransition
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BoldTransition, "@BoldTransition");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _BoldTransitionExceptHLS;
|
|
public bool BoldTransitionExceptHLS
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BoldTransitionExceptHLS, "@BoldTransitionExceptHLS");
|
|
}
|
|
}
|
|
// B2017-269 Don't bold transition if font for step is bold
|
|
private LazyLoad<bool> _BoldTransitionExceptBoldHLS;
|
|
public bool BoldTransitionExceptBoldHLS
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _BoldTransitionExceptBoldHLS, "@BoldTransitionExceptBoldHLS");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _AdjustStepTransitionText;
|
|
public bool AdjustStepTransitionText
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AdjustStepTransitionText, "@AdjustStepTransitionText");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region TransType
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class TransType : vlnFormatItem,IVlnIndexedFormatItem
|
|
{
|
|
public TransType(XmlNode xmlNode) : base(xmlNode) { }
|
|
public TransType() : base() { }
|
|
private LazyLoad<int?> _Index;
|
|
public int? Index
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Index, "@Index");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _Type;
|
|
public int? Type
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Type, "@TransType");
|
|
}
|
|
}
|
|
private LazyLoad<string> _TransFormat;
|
|
public string TransFormat
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TransFormat, "@TransFormat");
|
|
}
|
|
}
|
|
private LazyLoad<E_TransUI?> _TransUI;
|
|
public E_TransUI? TransUI
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad<E_TransUI>(ref _TransUI, "@TransUI");
|
|
}
|
|
}
|
|
private LazyLoad<string> _TransMenu;
|
|
public string TransMenu
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TransMenu, "@TransMenu");
|
|
}
|
|
}
|
|
private LazyLoad<string> _UnitProcSetString; //B2019-072: For AEP, use PSI & SI for outside transition text
|
|
public string UnitProcSetString // this is format of string to preface transition with
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UnitProcSetString, "@UnitProcSetString");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return string.Format("[{0}] - Type {1}", Index, Type); }
|
|
public override string GetPDCategory()
|
|
{ return "Transition Type Data"; }
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0} - {1}",TransFormat, TransMenu);
|
|
}
|
|
}
|
|
#endregion
|
|
#region TransTypeList
|
|
[TypeConverter(typeof(vlnIndexedListConverter<TransTypeList, TransType>))]
|
|
public class TransTypeList : vlnIndexedFormatList<TransType>
|
|
{
|
|
public TransTypeList(XmlNodeList xmlNodeList, IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
|
|
public override vlnIndexedFormatList<TransType> InheritedList
|
|
{
|
|
get
|
|
{
|
|
IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
|
|
if (parentFormat != null)
|
|
return parentFormat.PlantFormat.FormatData.TransData.TransTypeList;
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region RoData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ROData : vlnFormatItem
|
|
{
|
|
public ROData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<bool> _AllUnits;
|
|
public bool AllUnits
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AllUnits, "@AllUnits");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UpRoAftrDash;
|
|
public bool UpRoAftrDash
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UpRoAftrDash, "@UpRoAftrDash");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UpRoImmAftrDashSpace;
|
|
public bool UpRoImmAftrDashSpace
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UpRoImmAftrDashSpace, "@UpRoImmAftrDashSpace");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UpcaseAllRoUnits;
|
|
public bool UpcaseAllRoUnits
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UpcaseAllRoUnits, "@UpcaseAllRoUnits");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CapHighRo;
|
|
public bool CapHighRo
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CapHighRo, "@CapHighRo");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CapRoIfLastLower;
|
|
public bool CapRoIfLastLower
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CapRoIfLastLower, "@CapRoIfLastLower");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CapSPIfLastLower;
|
|
public bool CapSPIfLastLower
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CapSPIfLastLower, "@CapSPIfLastLower");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UpRoIfPrevUpper;
|
|
public bool UpRoIfPrevUpper
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UpRoIfPrevUpper, "@UpRoIfPrevUpper");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _UnderlineRo;
|
|
public bool UnderlineRo
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UnderlineRo, "@UnderlineRo");
|
|
}
|
|
}
|
|
private LazyLoad<bool> _CapFirstLetterInHighRO;
|
|
public bool CapFirstLetterInHighRO
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CapFirstLetterInHighRO, "@CapFirstLetterInHighRO");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region SupportClasses
|
|
public class StepDataRetval
|
|
{
|
|
private string _Name;
|
|
public string Name
|
|
{
|
|
get { return _Name; }
|
|
set { _Name = value; }
|
|
}
|
|
private int _Index;
|
|
public int Index
|
|
{
|
|
get { return _Index; }
|
|
set { _Index = value; }
|
|
}
|
|
public StepDataRetval(string name, int index)
|
|
{
|
|
Name = name;
|
|
Index = index;
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
|