792 lines
20 KiB
C#
792 lines
20 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Text;
|
|
using System.ComponentModel;
|
|
using DescriptiveEnum;
|
|
using System.Xml;
|
|
using System.Xml.Serialization;
|
|
using System.Xml.Schema;
|
|
using System.Windows.Forms;
|
|
using Volian.Base.Library;
|
|
using System.Drawing;
|
|
|
|
namespace VEPROMS.CSLA.Library
|
|
{
|
|
#region FormatConfig
|
|
// FormatConfig is the data structure that holds the UCF (User Control Of Format) data. It is stored in the database as xml in the
|
|
// Formats table's Config field. This uses Xml Serialization to translate the data from these data structures back/forth from the
|
|
// xml stored in the database. Note that fields that the user can change have an associate 'Orig' field which contains the original
|
|
// data from the format this is derived from. This is used for the 'Reset' to the original value.
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class FormatConfig : ConfigDynamicTypeDescriptor, INotifyPropertyChanged
|
|
{
|
|
#region DynamicTypeDescriptor
|
|
internal override bool IsReadOnly
|
|
{
|
|
get { return false; }
|
|
}
|
|
#endregion
|
|
#region XML
|
|
private XMLProperties _Xp;
|
|
private XMLProperties Xp
|
|
{
|
|
get { return _Xp; }
|
|
}
|
|
#endregion
|
|
#region Attributes
|
|
[XmlAttribute("Name")]
|
|
private string _Name;
|
|
[Category(" Identification")]
|
|
[DisplayName(" Name")]
|
|
[Description("Names user control of format")]
|
|
[XmlIgnore] // ignore it when doing serialization
|
|
public string Name
|
|
{
|
|
get { return _Name; }
|
|
set { _Name = value; }
|
|
}
|
|
[XmlAttribute("Description")]
|
|
private string _Description;
|
|
[Category(" Identification")]
|
|
[Description("Describes user control of format")]
|
|
[XmlIgnore] // ignore it when doing serialization
|
|
public string Description
|
|
{
|
|
get { return _Description; }
|
|
set { _Description = value; }
|
|
}
|
|
#endregion Attributes
|
|
#region Elements
|
|
private PlantFormatx _PlantFormat;
|
|
[DisplayName("Plant Format")]
|
|
[Description("Format values and settings that be modified for the selected format")]
|
|
public PlantFormatx PlantFormat
|
|
{
|
|
get { return _PlantFormat; }
|
|
set { _PlantFormat = value; }
|
|
}
|
|
#endregion Elements
|
|
#region Constructors
|
|
private Format _Format;
|
|
private FormatInfo _FormatInfo;
|
|
public FormatConfig(string xml)
|
|
{
|
|
if (xml == string.Empty) xml = "<FormatConfig/>";
|
|
}
|
|
public FormatConfig(FormatInfo fi)
|
|
{
|
|
_FormatInfo = fi;
|
|
}
|
|
public FormatConfig(Format f)
|
|
{
|
|
_Format = f;
|
|
}
|
|
public FormatConfig()
|
|
{
|
|
PlantFormat = new PlantFormatx();
|
|
}
|
|
#endregion Constructors
|
|
#region Serialize
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<FormatConfig>.StringSerialize(this);
|
|
}
|
|
public static FormatConfig Get(string xml)
|
|
{
|
|
return GenericSerializer<FormatConfig>.StringDeserialize(xml);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return "PlantFormat";
|
|
}
|
|
#endregion
|
|
#endregion FormatConfig
|
|
#region PlantFormat
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
[Category("Data")]
|
|
public class PlantFormatx
|
|
{
|
|
[XmlElement]
|
|
private FormatData _FormatData = new FormatData();
|
|
[DisplayName("Step Settings")]
|
|
[Description("Values used when formatting of steps (edit and print)")]
|
|
public FormatData FormatData
|
|
{
|
|
get { return _FormatData; }
|
|
set { _FormatData = value; }
|
|
}
|
|
[XmlElement]
|
|
private DocStyles _DocStyles;
|
|
[DisplayName("Section Type Settings")]
|
|
[Description("Values used when printing sections")]
|
|
public DocStyles DocStyles
|
|
{
|
|
get { return _DocStyles; }
|
|
set { _DocStyles = value; }
|
|
}
|
|
public PlantFormatx()
|
|
{
|
|
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return "Plant Format";
|
|
}
|
|
}
|
|
#endregion PlantFormat
|
|
#region FormatData
|
|
// FormatData maps to the PlantFormat/Format data and contains properties & data objects that are implemented for the user to
|
|
// control of the format. NOTE that any additional format items must be added here or in docstyles.
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class FormatData
|
|
{
|
|
[XmlElement]
|
|
private Flags _Flags = new Flags();
|
|
[Description("Various flags that affect editing and printing")]
|
|
public Flags Flags
|
|
{
|
|
get { return _Flags; }
|
|
set { _Flags = value; }
|
|
}
|
|
[XmlElement]
|
|
private CheckOffHeaderList _CheckOffHeaderList;
|
|
[DisplayName("CheckOff Headers List")]
|
|
[Description("CheckOff Headers Usage")]
|
|
public CheckOffHeaderList CheckOffHeaderList
|
|
{
|
|
get { return _CheckOffHeaderList; }
|
|
set { _CheckOffHeaderList = value; }
|
|
}
|
|
[XmlElement]
|
|
private CheckOffList _CheckOffList;
|
|
[DisplayName("CheckOff List")]
|
|
[Description("CheckOff Usage")]
|
|
public CheckOffList CheckOffList
|
|
{
|
|
get { return _CheckOffList; }
|
|
set { _CheckOffList = value; }
|
|
}
|
|
[XmlElement]
|
|
private float? _CheckOffXOffAdj;
|
|
//[XmlAttribute("CheckOffXOff")]
|
|
[DisplayName("CheckOff XOffset Adjust")]
|
|
[Description("Check Off X Offset Adjustment (in)")]
|
|
public float? CheckOffXOffAdj
|
|
{
|
|
get { return _CheckOffXOffAdj; }
|
|
set { _CheckOffXOffAdj = value; }
|
|
}
|
|
[XmlElement]
|
|
private ReplaceStrData _ReplaceStrData;
|
|
[DisplayName("Replace Words List")]
|
|
[Description("Replace Words with Other Text and/or attributes")]
|
|
public ReplaceStrData ReplaceStrData
|
|
{
|
|
get { return _ReplaceStrData; }
|
|
set { _ReplaceStrData = value; }
|
|
}
|
|
[XmlElement]
|
|
private StepData _StepData;
|
|
[DisplayName("Step List")]
|
|
[Description("List of step types for which formatting can be set")]
|
|
public StepData StepData
|
|
{
|
|
get { return _StepData; }
|
|
set { _StepData = value; }
|
|
}
|
|
public FormatData()
|
|
{
|
|
ReplaceStrData = new ReplaceStrData();
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return "Format Data";
|
|
}
|
|
}
|
|
#endregion FormatData
|
|
#region Flags
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Flags
|
|
{
|
|
|
|
private bool? _PartialStepCompression;
|
|
[DisplayName("Partial Step Compression")]
|
|
[Description("Automatically compress last sub-steps to fit on page")]
|
|
public bool? PartialStepCompression
|
|
{
|
|
get { return _PartialStepCompression; }
|
|
set { _PartialStepCompression = value; }
|
|
}
|
|
private bool? _CompressSteps;
|
|
[DisplayName("Compress Steps")]
|
|
[Description("Automatically compress entire step to fit on page")]
|
|
public bool? CompressSteps
|
|
{
|
|
get { return _CompressSteps; }
|
|
set { _CompressSteps = value; }
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return " ";
|
|
}
|
|
}
|
|
#endregion Flags
|
|
#region ReplaceStrData (list)
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
[Editor(typeof(PropGridCollEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public class ReplaceStrData : List<ReplaceStr>
|
|
{
|
|
[Browsable(false)]
|
|
public int Capacity { get { return base.Capacity; } }
|
|
[Browsable(false)]
|
|
public int Count { get { return base.Count; } }
|
|
public ReplaceStr this[int index]
|
|
{
|
|
get { return (ReplaceStr)base[index]; }
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<ReplaceStrData>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return "Replace Words List Count = " + base.Count.ToString();
|
|
}
|
|
public static ReplaceStrData Get(string xml)
|
|
{
|
|
return GenericSerializer<ReplaceStrData>.StringDeserialize(xml);
|
|
}
|
|
}
|
|
#endregion ReplaceStrData
|
|
#region ReplaceStr
|
|
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ReplaceStr
|
|
{
|
|
private int _State = 0; // 0 = no change, -1 deleted, 1 added, 2 modified
|
|
[XmlAttribute("State")]
|
|
[Browsable(false)] // Don't show in the property grid
|
|
public int State
|
|
{
|
|
get { return _State; }
|
|
set { _State = value; }
|
|
}
|
|
|
|
private string _ReplaceWord;
|
|
[XmlAttribute("ReplaceWord")]
|
|
[DisplayName("Replace Word")]
|
|
public string ReplaceWord
|
|
{
|
|
get { return _ReplaceWord; }
|
|
set
|
|
{
|
|
if (this._ReplaceWith == null) _ReplaceWith = value;
|
|
_ReplaceWord = value;
|
|
}
|
|
}
|
|
private string _ReplaceWith;
|
|
|
|
[XmlAttribute("ReplaceWith")]
|
|
[DisplayName("With")]
|
|
public string ReplaceWith
|
|
{
|
|
get { return _ReplaceWith; }
|
|
set { _ReplaceWith = value; }
|
|
}
|
|
public ReplaceStr()
|
|
{
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<ReplaceStr>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return ReplaceWord;
|
|
}
|
|
public static ReplaceStr Get(string xml)
|
|
{
|
|
return GenericSerializer<ReplaceStr>.StringDeserialize(xml);
|
|
}
|
|
}
|
|
#endregion ReplaceStr
|
|
#region CheckOffHeaders (list)
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
[Editor(typeof(PropGridCollEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public class CheckOffHeaderList : List<CheckOffHeader>
|
|
{
|
|
[Browsable(false)]
|
|
public int Capacity { get { return base.Capacity; } }
|
|
[Browsable(false)]
|
|
public int Count { get { return base.Count; } }
|
|
public CheckOffHeader this[int index]
|
|
{
|
|
get { return (CheckOffHeader)base[index]; }
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<CheckOffHeaderList>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return "CheckOffHeader Count = " + base.Count.ToString();
|
|
}
|
|
}
|
|
#endregion CheckOffHeaders
|
|
#region CheckOffHeader
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class CheckOffHeader
|
|
{
|
|
private string _CheckOffHeading;
|
|
[XmlAttribute("CheckOffHeading")]
|
|
[Browsable(false)]
|
|
public string CheckOffHeading
|
|
{
|
|
get { return _CheckOffHeading; }
|
|
set { _CheckOffHeading = value; }
|
|
}
|
|
private string _Index;
|
|
[XmlAttribute("Index")]
|
|
[Browsable(false)] // Don't show in the property grid
|
|
public string Index
|
|
{
|
|
get { return _Index; }
|
|
set { _Index = value; }
|
|
}
|
|
|
|
private bool? _Active;
|
|
[DisplayName("Active CheckOff Header")]
|
|
[Description("Allow use of this CheckOff Header")]
|
|
public bool? Active
|
|
{
|
|
get { return _Active; }
|
|
set { _Active = value; }
|
|
}
|
|
private bool? _OrigActive;
|
|
[XmlIgnore]
|
|
[Browsable(false)]
|
|
public bool? OrigActive
|
|
{
|
|
get { return _OrigActive; }
|
|
set { _OrigActive = value; }
|
|
}
|
|
public CheckOffHeader()
|
|
{
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<CheckOffHeader>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return CheckOffHeading;
|
|
}
|
|
}
|
|
#endregion CheckOffHeader
|
|
#region CheckOffs (list)
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
[Editor(typeof(PropGridCollEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public class CheckOffList : List<CheckOff>
|
|
{
|
|
[Browsable(false)]
|
|
public int Capacity { get { return base.Capacity; } }
|
|
[Browsable(false)]
|
|
public int Count { get { return base.Count; } }
|
|
public CheckOff this[int index]
|
|
{
|
|
get { return (CheckOff)base[index]; }
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<CheckOffList>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return "CheckOff Count = " + base.Count.ToString();
|
|
}
|
|
}
|
|
#endregion CheckOffs
|
|
#region CheckOff
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class CheckOff
|
|
{
|
|
private string _MenuItem;
|
|
[XmlAttribute("MenuItem")]
|
|
[Browsable(false)]
|
|
public string MenuItem
|
|
{
|
|
get { return _MenuItem; }
|
|
set { _MenuItem = value; }
|
|
}
|
|
private string _Index;
|
|
[XmlAttribute("Index")]
|
|
[Browsable(false)] // Don't show in the property grid
|
|
public string Index
|
|
{
|
|
get { return _Index; }
|
|
set { _Index = value; }
|
|
}
|
|
|
|
private bool? _Active;
|
|
[DisplayName("Active CheckOff")]
|
|
[Description("Allow use of this CheckOff")]
|
|
public bool? Active
|
|
{
|
|
get { return _Active; }
|
|
set { _Active = value; }
|
|
}
|
|
private bool? _OrigActive;
|
|
[XmlIgnore]
|
|
[Browsable(false)]
|
|
public bool? OrigActive
|
|
{
|
|
get { return _OrigActive; }
|
|
set { _OrigActive = value; }
|
|
}
|
|
public CheckOff()
|
|
{
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<CheckOff>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return MenuItem;
|
|
}
|
|
}
|
|
#endregion CheckOff
|
|
#region ShwRplWds
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class ShwRplWds
|
|
{
|
|
private string _MenuItem;
|
|
[XmlAttribute("MenuItem")]
|
|
[Browsable(false)]
|
|
public string MenuItem
|
|
{
|
|
get { return _MenuItem; }
|
|
set { _MenuItem = value; }
|
|
}
|
|
private string _Index;
|
|
[XmlAttribute("Index")]
|
|
[Browsable(false)] // Don't show in the property grid
|
|
public string Index
|
|
{
|
|
get { return _Index; }
|
|
set { _Index = value; }
|
|
}
|
|
|
|
private bool? _Active;
|
|
[DisplayName("Active ShwRplWds")]
|
|
[Description("Allow use of this ShwRplWds")]
|
|
public bool? Active
|
|
{
|
|
get { return _Active; }
|
|
set { _Active = value; }
|
|
}
|
|
private bool? _OrigActive;
|
|
[XmlIgnore]
|
|
[Browsable(false)]
|
|
public bool? OrigActive
|
|
{
|
|
get { return _OrigActive; }
|
|
set { _OrigActive = value; }
|
|
}
|
|
public ShwRplWds()
|
|
{
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<ShwRplWds>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return MenuItem;
|
|
}
|
|
}
|
|
#endregion ShwRplWds
|
|
#region StepData (list)
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
[Editor(typeof(PropGridCollEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public class StepData : List<Step>
|
|
{
|
|
[Browsable(false)]
|
|
public int Capacity { get { return base.Capacity; } }
|
|
[Browsable(false)]
|
|
public int Count { get { return base.Count; } }
|
|
public Step this[int index]
|
|
{
|
|
get { return (Step)base[index]; }
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<StepData>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return "Step Count = " + base.Count.ToString();
|
|
}
|
|
public static StepData Get(string xml)
|
|
{
|
|
return GenericSerializer<StepData>.StringDeserialize(xml);
|
|
}
|
|
}
|
|
#endregion StepData
|
|
#region Step
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Step
|
|
{
|
|
private string _Index;
|
|
[XmlAttribute("Index")]
|
|
[Browsable(false)] // Don't show in the property grid
|
|
public string Index
|
|
{
|
|
get { return _Index; }
|
|
set { _Index = value; }
|
|
}
|
|
private string _Type;
|
|
[XmlAttribute("Type")]
|
|
[Browsable(false)] // Don't show in the property grid
|
|
public string Type
|
|
{
|
|
get { return _Type; }
|
|
set { _Type = value; }
|
|
}
|
|
private FontDesc _FontDesc;
|
|
[XmlElement("FontDesc")]
|
|
public FontDesc FontDesc
|
|
{
|
|
get { return _FontDesc; }
|
|
set { _FontDesc = value; }
|
|
}
|
|
public Step()
|
|
{
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<Step>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return Type;
|
|
}
|
|
public static Step Get(string xml)
|
|
{
|
|
return GenericSerializer<Step>.StringDeserialize(xml);
|
|
}
|
|
}
|
|
#endregion Step
|
|
#region FontDesc
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class FontDesc
|
|
{
|
|
// The Font object allows the conversion from a windows font back/forth from a string. This is how the
|
|
// data is stored in the database, i.e. a string representing the font.
|
|
private Font _Font;
|
|
[XmlAttribute("Font")]
|
|
[Browsable(false)]
|
|
public string Font
|
|
{
|
|
get
|
|
{
|
|
System.Drawing.FontConverter cvt = new System.Drawing.FontConverter();
|
|
return cvt.ConvertToString(_WindowsFont);
|
|
}
|
|
set
|
|
{
|
|
System.Drawing.FontConverter cvt = new System.Drawing.FontConverter();
|
|
_WindowsFont = cvt.ConvertFromString(value ?? "Arial, 10pt") as System.Drawing.Font;
|
|
|
|
}
|
|
}
|
|
private System.Drawing.Font _OrigWindowsFont;
|
|
[XmlIgnore]
|
|
[Browsable(false)]
|
|
public System.Drawing.Font OrigWindowsFont
|
|
{
|
|
get { return _OrigWindowsFont; }
|
|
set { _OrigWindowsFont = value; }
|
|
}
|
|
private System.Drawing.Font _WindowsFont;
|
|
[XmlIgnore]
|
|
public System.Drawing.Font WindowsFont
|
|
{
|
|
get { return _WindowsFont; }
|
|
set { _WindowsFont = value; }
|
|
}
|
|
public FontDesc()
|
|
{
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<FontDesc>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return "FontDescription";
|
|
}
|
|
public static FontDesc Get(string xml)
|
|
{
|
|
return GenericSerializer<FontDesc>.StringDeserialize(xml);
|
|
}
|
|
}
|
|
#endregion Font
|
|
#region DocStyles
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
[Editor(typeof(PropGridCollEditor), typeof(System.Drawing.Design.UITypeEditor))]
|
|
public class DocStyles : List<DocStyle>
|
|
{
|
|
[Browsable(false)]
|
|
public int Capacity { get { return base.Capacity; } }
|
|
[Browsable(false)]
|
|
public int Count { get { return base.Count; } }
|
|
public DocStyle this[int index]
|
|
{
|
|
get { return (DocStyle)base[index]; }
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<DocStyles>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return "Section Type Count = " + base.Count.ToString();
|
|
}
|
|
}
|
|
#endregion DocStyles
|
|
#region DocStyle
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class DocStyle
|
|
{
|
|
private string _Name;
|
|
[XmlAttribute("Name")]
|
|
[Browsable(false)]
|
|
public string Name
|
|
{
|
|
get { return _Name; }
|
|
set { _Name = value; }
|
|
}
|
|
private string _Index;
|
|
[Browsable(false)]
|
|
[XmlAttribute("Index")]
|
|
public string Index
|
|
{
|
|
get { return _Index; }
|
|
set { _Index = value; }
|
|
}
|
|
private Layout _Layout;
|
|
[XmlElement("Layout")]
|
|
public Layout Layout
|
|
{
|
|
get { return _Layout; }
|
|
set { _Layout = value; }
|
|
}
|
|
public DocStyle()
|
|
{
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<DocStyle>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return Name;
|
|
}
|
|
}
|
|
#endregion DocStyle
|
|
#region Layout
|
|
[Serializable]
|
|
[TypeConverter(typeof(ExpandableObjectConverter))]
|
|
public class Layout : IXmlSerializable
|
|
{
|
|
private float? _PageLength;
|
|
[XmlAttribute("PageLength")]
|
|
[DisplayName("Page Length (in)")]
|
|
public float? PageLength
|
|
{
|
|
get { return _PageLength; }
|
|
set { _PageLength = value; }
|
|
}
|
|
private float? _OrigPageLength;
|
|
[XmlIgnore]
|
|
[Browsable(false)]
|
|
public float? OrigPageLength
|
|
{
|
|
get { return _OrigPageLength; }
|
|
set { _OrigPageLength = value; }
|
|
}
|
|
private float? _LeftMargin;
|
|
[XmlAttribute("LeftMargin")]
|
|
[DisplayName("Left Margin (in)")]
|
|
public float? LeftMargin
|
|
{
|
|
get { return _LeftMargin; }
|
|
set { _LeftMargin = value; }
|
|
}
|
|
private float? _OrigLeftMargin;
|
|
[XmlIgnore]
|
|
[Browsable(false)]
|
|
public float? OrigLeftMargin
|
|
{
|
|
get { return _OrigLeftMargin; }
|
|
set { _OrigLeftMargin = value; }
|
|
}
|
|
public Layout()
|
|
{
|
|
}
|
|
public string ConvertToString()
|
|
{
|
|
return GenericSerializer<Layout>.StringSerialize(this);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return "Layout";
|
|
}
|
|
#region IXmlSerializable members
|
|
// The read & write for these is necessary since they are within same xml element, and one may be empty, so
|
|
// no attribute should be listed in the xml.
|
|
public void WriteXml(XmlWriter writer)
|
|
{
|
|
if (LeftMargin != null) writer.WriteAttributeString("LeftMargin", LeftMargin.ToString());
|
|
if (PageLength != null) writer.WriteAttributeString("PageLength", PageLength.ToString());
|
|
}
|
|
|
|
public void ReadXml(XmlReader reader)
|
|
{
|
|
if (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "Layout")
|
|
{
|
|
string str = reader["PageLength"];
|
|
if (str != null && str != "") PageLength = float.Parse(str);
|
|
str = reader["LeftMargin"];
|
|
if (str != null && str != "") LeftMargin = float.Parse(str);
|
|
}
|
|
}
|
|
|
|
public XmlSchema GetSchema()
|
|
{
|
|
return (null);
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion Layout
|
|
}
|
|
}
|