2675 lines
62 KiB
C#
2675 lines
62 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(Format format)
|
|
{
|
|
_MyFormat = format;
|
|
}
|
|
private Format _MyFormat;
|
|
public Format 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;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region VE_Font
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class VE_Font : vlnFormatItem
|
|
{
|
|
public VE_Font(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<string> _Family;
|
|
private Font _WindowsFont;
|
|
public Font WindowsFont
|
|
{
|
|
get
|
|
{
|
|
// TODO: eventually want styles
|
|
if (_WindowsFont == _WindowsFont) _WindowsFont = new Font(Family, (float)Size);
|
|
return _WindowsFont;
|
|
}
|
|
}
|
|
[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");
|
|
}
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0}, {1} pt, {2}", Family, Size, Style);
|
|
}
|
|
}
|
|
#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<string> _XtraFlags;
|
|
public string XtraFlags
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _XtraFlags, "XtraFlags");
|
|
}
|
|
}
|
|
public bool XtraOptions(string attr)
|
|
{
|
|
XmlNode nd = this.SelectSingleNode("XtraFlags/@" + attr);
|
|
if (nd == null) return false;
|
|
if (nd.InnerText.ToUpper() == "TRUE") return true;
|
|
return false;
|
|
}
|
|
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 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")):_BoxList;
|
|
}
|
|
set { _BoxList = value; }
|
|
}
|
|
private TransData _TransData;
|
|
public TransData TransData
|
|
{
|
|
get
|
|
{
|
|
return _TransData == null? _TransData = new TransData(SelectSingleNode("TransData")):_TransData;
|
|
}
|
|
}
|
|
private StepDataList _StepDataList;
|
|
public StepDataList StepDataList
|
|
{
|
|
get
|
|
{
|
|
return _StepDataList == null? _StepDataList = new StepDataList(SelectNodes("StepData/Step")):_StepDataList;
|
|
}
|
|
set { _StepDataList = value; }
|
|
}
|
|
}
|
|
#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");
|
|
}
|
|
}
|
|
}
|
|
#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<string> _TopOfPageThing;
|
|
public string TopOfPageThing
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TopOfPageThing, "@TopOfPageThing");
|
|
}
|
|
}
|
|
}
|
|
#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 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<string> _PSInfFile;
|
|
public string PSInfFile
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PSInfFile, "@PSInfFile");
|
|
}
|
|
}
|
|
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 CheckOffAll
|
|
#region CheckOffData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class CheckOffData : vlnFormatItem
|
|
{
|
|
public CheckOffData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private RightCheckOffBoxList _RightCheckOffBoxList;
|
|
public RightCheckOffBoxList RightCheckOffBoxList
|
|
{
|
|
get
|
|
{
|
|
return _RightCheckOffBoxList == null? _RightCheckOffBoxList = new RightCheckOffBoxList(SelectNodes("RightCheckOffBoxList/RightCheckOffBox")):_RightCheckOffBoxList;
|
|
}
|
|
}
|
|
private CheckOffList _CheckOffList;
|
|
public CheckOffList CheckOffList
|
|
{
|
|
get
|
|
{
|
|
return _CheckOffList == null? _CheckOffList = new CheckOffList(SelectNodes("CheckOffList/CheckOff")):_CheckOffList;
|
|
}
|
|
}
|
|
private CheckOffHeaderList _CheckOffHeaderList;
|
|
public CheckOffHeaderList CheckOffHeaderList
|
|
{
|
|
get
|
|
{
|
|
return _CheckOffHeaderList == null? _CheckOffHeaderList = new CheckOffHeaderList(SelectNodes("CheckOffHeaderList/CheckOffHeader")): _CheckOffHeaderList;
|
|
}
|
|
}
|
|
private LazyLoad<int?> _UseCheckOffsIn;
|
|
public int? UseCheckOffsIn
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _UseCheckOffsIn, "@UseCheckOffsIn");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _CheckOffAdjustment;
|
|
public int? CheckOffAdjustment
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOffAdjustment, "@CheckOffAdjustment");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region RightCheckOffBox
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class RightCheckOffBox : vlnFormatItem
|
|
{
|
|
public RightCheckOffBox(XmlNode xmlNode) : base(xmlNode) { }
|
|
public RightCheckOffBox() : base() { }
|
|
private LazyLoad<int?> _Index;
|
|
public int? Index
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Index, "@Index");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _RightCheckOffBoxChar;
|
|
public int? RightCheckOffBoxChar
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RightCheckOffBoxChar, "@RightCheckOffBoxChar");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return string.Format("[{0}]", Index); }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("[{0}] - {1}", Index, RightCheckOffBoxChar); }
|
|
public override string GetPDCategory()
|
|
{ return "RightCheckOffBox Data"; }
|
|
public override string ToString()
|
|
{
|
|
return RightCheckOffBoxChar.ToString();
|
|
}
|
|
}
|
|
#endregion
|
|
#region RightCheckOffBoxList
|
|
[TypeConverter(typeof(vlnListConverter<RightCheckOffBoxList, RightCheckOffBox>))]
|
|
public class RightCheckOffBoxList : vlnFormatList<RightCheckOffBox>
|
|
{
|
|
public RightCheckOffBoxList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region CheckOff
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class CheckOff : vlnFormatItem
|
|
{
|
|
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?> _RightCheckOffChars;
|
|
public int? RightCheckOffChars
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RightCheckOffChars, "@RightCheckOffChars");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _CheckOffWidAdjust;
|
|
public int? CheckOffWidAdjust
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOffWidAdjust, "@CheckOffWidAdjust");
|
|
}
|
|
}
|
|
private LazyLoad<string> _RightCheckOffPrompt;
|
|
public string RightCheckOffPrompt
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RightCheckOffPrompt, "@RightCheckOffPrompt");
|
|
}
|
|
}
|
|
public override string GetPDDisplayName()
|
|
{ return string.Format("[{0}]",Index); }
|
|
public override string GetPDDescription()
|
|
{ return string.Format("[{0}] - {1}", Index, RightCheckOffPrompt); }
|
|
public override string GetPDCategory()
|
|
{ return "Checkoff Data"; }
|
|
public override string ToString()
|
|
{
|
|
return RightCheckOffPrompt;
|
|
}
|
|
}
|
|
#endregion
|
|
#region CheckOffList
|
|
[TypeConverter(typeof(vlnListConverter<CheckOffList, CheckOff>))]
|
|
public class CheckOffList : vlnFormatList<CheckOff>
|
|
{
|
|
public CheckOffList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#region CheckOffHeader
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class CheckOffHeader : vlnFormatItem
|
|
{
|
|
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(vlnListConverter<CheckOffHeaderList, CheckOffHeader>))]
|
|
public class CheckOffHeaderList : vlnFormatList<CheckOffHeader>
|
|
{
|
|
public CheckOffHeaderList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region ChangeBarData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ChangeBarData : vlnFormatItem
|
|
{
|
|
public ChangeBarData(XmlNode xmlNode) : base(xmlNode) { }
|
|
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");
|
|
}
|
|
}
|
|
}
|
|
#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 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"));
|
|
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 LazyLoad<int?> _SectionTitleLength;
|
|
public int? SectionTitleLength
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SectionTitleLength, "@SectionTitleLength");
|
|
}
|
|
}
|
|
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 SectionNumber
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class SectionNumber : vlnFormatItem
|
|
{
|
|
public SectionNumber(XmlNode xmlNode) : base(xmlNode) { }
|
|
public SectionNumber() : base() { }
|
|
private LazyLoad<int?> _Pos;
|
|
public int? Pos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Pos, "@Pos");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Just;
|
|
public string Just
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Just, "@Just");
|
|
}
|
|
}
|
|
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<int?> _Pos;
|
|
public int? Pos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Pos, "@Pos");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Just;
|
|
public string Just
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Just, "@Just");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
|
|
}
|
|
}
|
|
}
|
|
#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")) : _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");
|
|
}
|
|
}
|
|
}
|
|
#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 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<int?> _LastLineToStartStep;
|
|
public int? LastLineToStartStep
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LastLineToStartStep, "@LastLineToStartStep");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _LineDrawingOption;
|
|
public int? LineDrawingOption
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LineDrawingOption, "@LineDrawingOption");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _ColS;
|
|
public int? ColS
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColS, "@ColS");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _ColT;
|
|
public int? ColT
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColT, "@ColT");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _ColAbs;
|
|
public int? ColAbs
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColAbs, "@ColAbs");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _WidT;
|
|
public int? WidT
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _WidT, "@WidT");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _PMode;
|
|
public int? PMode
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _PMode, "@PMode");
|
|
}
|
|
}
|
|
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<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<int?> _AdjRNOCol;
|
|
public int? 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?> _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");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region TopOfPage
|
|
public class TopOfPage : vlnFormatItem
|
|
{
|
|
public TopOfPage(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<int?> _Row;
|
|
public int? Row
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Row, "@Row");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _Col;
|
|
public int? 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?> _SeparatorLocation;
|
|
public int? SeparatorLocation
|
|
{
|
|
get
|
|
{
|
|
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<int?> _ColSScreenAdj;
|
|
public int? ColSScreenAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColSScreenAdj, "@ColSScreenAdj");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _ScrnAdjRNOText;
|
|
public int? 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<int?> _ImmStepHdrCol;
|
|
public int? ImmStepHdrCol
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ImmStepHdrCol, "@ImmStepHdrCol");
|
|
}
|
|
}
|
|
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<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 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; }
|
|
}
|
|
}
|
|
#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
|
|
#endregion
|
|
#region SeqTabFmtAll
|
|
#region SeqTabFmt
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class SeqTabFmt : vlnFormatItem
|
|
{
|
|
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<int?> _LeftJustify;
|
|
public int? LeftJustify
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _LeftJustify, "@LeftJustify");
|
|
}
|
|
}
|
|
private LazyLoad<string> _TabFormat;
|
|
public string TabFormat
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TabFormat, "@TabFormat");
|
|
}
|
|
}
|
|
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(vlnListConverter<SeqTabFmtList, SeqTabFmt>))]
|
|
public class SeqTabFmtList : vlnFormatList<SeqTabFmt>
|
|
{
|
|
public new SeqTabFmt this[int index]
|
|
{
|
|
get
|
|
{
|
|
foreach (SeqTabFmt seqTabFmt in this)
|
|
if (seqTabFmt.Index == index) return seqTabFmt;
|
|
return null;
|
|
}
|
|
}
|
|
public SeqTabFmtList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#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);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region TableOfContentsData
|
|
public class TableOfContentsData : vlnFormatItem
|
|
{
|
|
public TableOfContentsData(XmlNode xmlNode) : base(xmlNode) { }
|
|
private LazyLoad<int?> _TofCSecNumPos;
|
|
public int? TofCSecNumPos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCSecNumPos, "@TofCSecNumPos");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TofCSecTitlePos;
|
|
public int? TofCSecTitlePos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCSecTitlePos, "@TofCSecTitlePos");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TofCSecTitleLen;
|
|
public int? TofCSecTitleLen
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCSecTitleLen, "@TofCSecTitleLen");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TofCPageNumPos;
|
|
public int? TofCPageNumPos
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCPageNumPos, "@TofCPageNumPos");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TofCSpaceChar;
|
|
public int? TofCSpaceChar
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCSpaceChar, "@TofCSpaceChar");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TofCLineSpacing;
|
|
public int? TofCLineSpacing
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCLineSpacing, "@TofCLineSpacing");
|
|
}
|
|
}
|
|
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
|
|
{
|
|
public MetaSection(XmlNode xmlNode) : base(xmlNode) { }
|
|
public MetaSection() : base() { }
|
|
private LazyLoad<int?> _Index;
|
|
public int? Index
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Index, "@Index");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _SecNumPositionAdj;
|
|
public int? SecNumPositionAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SecNumPositionAdj, "@SecNumPositionAdj");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _SecTitlePositionAdj;
|
|
public int? SecTitlePositionAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _SecTitlePositionAdj, "@SecTitlePositionAdj");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _ColSByLevel;
|
|
public int? ColSByLevel
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _ColSByLevel, "@ColSByLevel");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TofCPositionAdj;
|
|
public int? TofCPositionAdj
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TofCPositionAdj, "@TofCPositionAdj");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _WidSAdjByLevel;
|
|
public int? 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(vlnListConverter<MetaSectionList, MetaSection>))]
|
|
public class MetaSectionList : vlnFormatList<MetaSection>
|
|
{
|
|
public MetaSectionList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#endregion
|
|
#region StepDataAll
|
|
#region Step
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class StepData : vlnFormatItem
|
|
{
|
|
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<string> _StepTypeColOverride;
|
|
public string StepTypeColOverride
|
|
{
|
|
get
|
|
{
|
|
|
|
return LazyLoad(ref _StepTypeColOverride, "@StepTypeColOverride");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Sep;
|
|
public string Sep
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Sep, "@Sep");
|
|
}
|
|
}
|
|
private LazyLoad<string> _AlternateName;
|
|
public string AlternateName
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AlternateName, "@AlternateName");
|
|
}
|
|
}
|
|
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 VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
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 TabData _TabData;
|
|
public TabData TabData
|
|
{
|
|
get
|
|
{
|
|
return (_TabData == null) ? _TabData = new TabData(base.XmlNode) : _TabData;
|
|
}
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0}", Type);
|
|
}
|
|
}
|
|
#endregion
|
|
#region StepDataList
|
|
[TypeConverter(typeof(vlnListConverter<StepDataList, StepData>))]
|
|
public class StepDataList : vlnFormatList<StepData>
|
|
{
|
|
public new StepData this[int index]
|
|
{
|
|
get
|
|
{
|
|
foreach (StepData stepData in this)
|
|
if (stepData.Index == index) return stepData;
|
|
return null;
|
|
}
|
|
}
|
|
public StepData this[string type]
|
|
{
|
|
get
|
|
{
|
|
foreach (StepData stepData in this)
|
|
if (stepData.Type == type) return stepData;
|
|
return null;
|
|
}
|
|
}
|
|
public StepDataList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#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?> _STExtralines;
|
|
public int? STExtralines
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _STExtralines, "StepLayoutData/@STExtralines");
|
|
}
|
|
}
|
|
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");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region StepEditData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class StepEditData : vlnFormatItem
|
|
{
|
|
public StepEditData(XmlNode xmlNode)
|
|
: base(xmlNode)
|
|
{
|
|
}
|
|
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");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region StepTab
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class TabData : vlnFormatItem
|
|
{
|
|
public TabData(XmlNode xmlNode)
|
|
: base(xmlNode)
|
|
{
|
|
}
|
|
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> _AltPrintTBIdent;
|
|
public string AltPrintTBIdent
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _AltPrintTBIdent, "TabData/@AltPrintTBIdent");
|
|
}
|
|
}
|
|
private LazyLoad<string> _RNOIdentEdit;
|
|
public string RNOIdentEdit
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOIdentEdit, "TabData/@RNOIdentEdit");
|
|
}
|
|
}
|
|
private LazyLoad<string> _RNOIdentPrint;
|
|
public string RNOIdentPrint
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _RNOIdentPrint, "TabData/@RNOIdent");
|
|
}
|
|
}
|
|
private LazyLoad<string> _Justify;
|
|
public string Justify
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Justify, "TabData/@Justify");
|
|
}
|
|
}
|
|
private LazyLoad<string> _CheckOff;
|
|
public string CheckOff
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _CheckOff, "TabData/@CheckOff");
|
|
}
|
|
}
|
|
private VE_Font _Font;
|
|
public VE_Font Font
|
|
{
|
|
get
|
|
{
|
|
return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region BoxDataAll
|
|
#region Box
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Box : vlnFormatItem
|
|
{
|
|
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?> _Start;
|
|
public int? Start
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Start, "@Start");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _End;
|
|
public int? End
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _End, "@End");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TxtStart;
|
|
public int? TxtStart
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TxtStart, "@TxtStart");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TxtWidth;
|
|
public int? TxtWidth
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _TxtWidth, "@TxtWidth");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _Height;
|
|
public int? Height
|
|
{
|
|
get
|
|
{
|
|
return LazyLoad(ref _Height, "@Height");
|
|
}
|
|
}
|
|
private LazyLoad<int?> _TabPos;
|
|
public int? 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);
|
|
}
|
|
}
|
|
#endregion
|
|
#region BoxList
|
|
[TypeConverter(typeof(vlnListConverter<BoxList, Box>))]
|
|
public class BoxList : vlnFormatList<Box>
|
|
{
|
|
public BoxList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region TransDataAll
|
|
#region TransData
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class TransData : vlnFormatItem
|
|
{
|
|
private TransTypeList _TransTypeList;
|
|
public TransTypeList TransTypeList
|
|
{
|
|
get
|
|
{
|
|
return(_TransTypeList == null || _TransTypeList.Count==0)? _TransTypeList = new TransTypeList(SelectNodes("TransTypeData/TransTypes")): _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");
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region TransType
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class TransType : vlnFormatItem
|
|
{
|
|
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");
|
|
}
|
|
}
|
|
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(vlnListConverter<TransTypeList, TransType>))]
|
|
public class TransTypeList : vlnFormatList<TransType>
|
|
{
|
|
public TransTypeList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
|
|
}
|
|
#endregion
|
|
#endregion
|
|
}
|
|
|