using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Xml;
using System.IO;
using System.Windows.Forms;
using VEPROMS.CSLA.Library;
using System.Text.RegularExpressions;
using System.Xml.Xsl;


namespace VEPROMS
{
	// frmUCF is the main form for User Control of Format.  It is accessible by Administrator & Set Administrator from the V button Administration 
	// menu. It uses the FormatConfig structure whose data is stored in the Config field of the Formats table.  It uses XmlSerialization to 
	// store/retrieve the data from the database field and uses a Windows Property Grid to present the data, the data is tied to the 
	// Property Grid by setting the SelectedObject of the Property Grid to the FormatConfig. FormatConfig objects use TypeConverter(typeof(ExpandableObjectConverter)) on the 
	// fields to allow for accessing the data structures below the FormatConfig level (by default, fields are shown in the grid, Browsable(false) does 
	// not show the fields.  NOTE that collection data uses the PropGridCollEditor, see that file for further information (in Volian.Base.Library)
	//
	public partial class frmUCF : Form
	{
		private bool _UcfForRepWords = false;
		public bool UcfForRepWords			// flags that UCF has changes to replace words - use for Reset button enabling
		{
			get { return _UcfForRepWords; }
			set { _UcfForRepWords = value; }
		}
		private FormatConfig MyFormatConfig = new FormatConfig();
		private PlantFormat OriginalPlantFormat;
		private FormatInfo OriginalFormatInfo;
		public frmUCF()
		{
			InitializeComponent();
		}
		private bool _Initializing = false;
		private void frmUCF_Load(object sender, EventArgs e)
		{
			_Initializing = true;
			PlantFormat.DoingUCFCheckOffs = true;
			PlantFormat.DoingUCFCheckOffsUse = MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF ?? false;
			cbxFormatList.DataSource = null;
			cbxFormatList.DisplayMember = "FullName";
			cbxFormatList.ValueMember = "FullName";
			cbxFormatList.DataSource = FormatInfoList.GetFormatInfoListUsed();
			cbxFormatList.SelectedIndex = -1;
			MyFormatConfig = new FormatConfig();
			PG.SelectedObject = MyFormatConfig;
			PG.Enabled = false;
			PG.SelectedGridItemChanged += PG_SelectedGridItemChanged;
			PG.PropertyValueChanged += PG_PropertyValueChanged;
			btnSaveAs.Enabled = false;
			btnSaveClose.Enabled = false;
			btnSave.Enabled = false;
			btnReset.Enabled = false;
			btnDelete.Enabled = false;
			_Initializing = false;
		}
		void PG_PropertyValueChanged(object s, PropertyValueChangedEventArgs e)
		{
			if (SelectedGridField.EndsWith("Flags:UCF CheckOffs"))
			{
				// when changing whether the UCF format has the UCF checkoffs (there is a list of checkoffs/headers in the base format, when this
				// flag is true, they get added to the list from the starting format), refresh the checkoff header & checkoff lists
				if ((bool)e.OldValue != MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF)
				{
					// refresh the checkoff data in myformatconfig.  Need to clear the checkoff header list & checkoff list before
					// getting new data.
					PlantFormat.DoingUCFCheckOffsUse = (bool)MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF;
					GetUCFCheckOffDataForUCFGrid((bool)MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF);
					PG.Refresh();
				}
			}
			else if (SelectedGridField.EndsWith(" Name"))		// B2019-012: don't allow removal of '_UCF' from name.
			{
				if ((string)e.OldValue != MyFormatConfig.Name)
				{
					if (((string)e.OldValue).EndsWith("_UCF") && !MyFormatConfig.Name.EndsWith("_UCF"))
					{
						MessageBox.Show(this, "Cannot remove '_UCF' from User Controlled Format name", "UCF Name", MessageBoxButtons.OK);
						MyFormatConfig.Name = MyFormatConfig.Name + ("_UCF");
						PG.Refresh();
					}
				}
			}
		}
		private string SelectedGridField = "Identification: Name"; // first field sectioned upon creation of form
		void PG_SelectedGridItemChanged(object sender, SelectedGridItemChangedEventArgs e)
		{
			if (_Initializing || _formatListIndexChanging) return;

			// refresh the summary data textbox data to show summary of what is in this UCF.  This occurs when move off of a field which
			// actually 'stores' the change.
			FormatConfig tmpfc = GetChangesUCFForSave();
			string scf = tmpfc.ConvertToString();
			scf = Regex.Replace(scf, " *<[a-zA-Z ]+/>\r\n", "");
			SetUCFSummary(scf);

			// see if data has changed, and if so, enable the Reset button.
			// Upon selection of a grid item, see if the grid item has data associated with it & if so, see if there has been
			// a change.  Code needs added here for any value listed on the main property grid, i.e. not part of a collection, or
			// if the collection is reset in its entirety (replace words is an example of this).
			bool enabled = false;
			btnReset.Text = "Reset";
			string previousSelectedGridField = SelectedGridField;
			SelectedGridField = LabelPath(PG.SelectedGridItem);
			// remove the following line before release:
			lblPGItem.Text = SelectedGridField;

			if (previousSelectedGridField.EndsWith("Identification: Name") && !SelectedGridField.EndsWith("Identification: Name")) SetButtonSaveAsEnabled();
			if (previousSelectedGridField.EndsWith("Data:Plant Format:Step Settings:Replace Words List"))
			{
				// if moving off of the replace words, see if any changes exist so that Reset List button is enabled:
				FormatConfig.ReplaceStrData rps = GetChangedReplaceListForSave();
				UcfForRepWords = (rps != null && rps.Count > 0);
			}
			if (SelectedGridField.EndsWith("Identification: Name")) enabled = false;
			else if (SelectedGridField.EndsWith("Data:Plant Format")) enabled = false;
			else if (SelectedGridField.EndsWith("Data:Plant Format:Section Type Settings")) enabled = false;
			else if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings")) enabled = false;
			else if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings:Flags")) enabled = false;
			else if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings:Flags:Compress Steps"))
			{
				if (MyFormatConfig.PlantFormat.FormatData.Flags.CompressSteps != null && MyFormatConfig.PlantFormat.FormatData.Flags.CompressSteps != OriginalPlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.CompressSteps)
				{
					btnReset.Text = "Reset to " + OriginalPlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.CompressSteps;
					enabled = true;
				}
			}
			else if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings:Flags:Partial Step Compression"))
			{
				if (MyFormatConfig.PlantFormat.FormatData.Flags.PartialStepCompression != null && MyFormatConfig.PlantFormat.FormatData.Flags.PartialStepCompression != OriginalPlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PartialStepCompression)
				{
					btnReset.Text = "Reset to " + OriginalPlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PartialStepCompression;
					enabled = true;
				}
			}
			else if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings:Flags:UCF CheckOffs"))
			{
				if (MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF != null && MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF != OriginalPlantFormat.FormatData.ProcData.CheckOffUCF)
				{
					btnReset.Text = "Reset to " + OriginalPlantFormat.FormatData.ProcData.CheckOffUCF;
					enabled = true;
				}
			}
			else if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings:Replace Words List"))
			{
				if (UcfForRepWords)     // flags that ucf data exists for replace words.
				{
					btnReset.Text = "Reset List";
					enabled = true;
				}
			}
			else if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings:CheckOff XOffset"))
			{
				if (MyFormatConfig.PlantFormat.FormatData.CheckOffXOffAdj != null && MyFormatConfig.PlantFormat.FormatData.CheckOffXOffAdj != 0)     // flags that ucf data exists for replace words.
				{
					btnReset.Text = "Reset to 0";
					enabled = true;
				}
			}
			else if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings:Step List")) enabled = false;
			else enabled = false;

			btnReset.Enabled = enabled;
		}
		// remove the following method for release:
		private string LabelPath(GridItem gi)
		{
			return (gi.Parent == null ? "" : LabelPath(gi.Parent) + ":" + gi.Label);
		}
		private void btnSaveClose_Click(object sender, EventArgs e)
		{
			// get a FormatConfig structure that only has differences from the original format. This is what gets saved.
			FormatConfig tmpForSave = GetChangesUCFForSave();
			string scf = tmpForSave.ConvertToString();
			scf = Regex.Replace(scf, " *<[a-zA-Z ]+/>\r\n", "");
			int fmtid = OriginalPlantFormat.MyFormat is Format ? (OriginalPlantFormat.MyFormat as Format).FormatID : (OriginalPlantFormat.MyFormat as FormatInfo).FormatID;
			// for now, tell the user that changes don't take affect until reentry.  This was done since the 'refresh' of FormatConfig was not
			// working.
			using (Format fmt = Format.Get(fmtid))
			{
				FormatInfo fi = FormatInfo.GetFormatNoUCFByFormatID(OriginalFormatInfo.FormatID);
				if (fi.Data == "")
				{
					fmt.Data = "";
					fmt.GenMac = "";
				}
				fmt.Config = scf;
				fmt.Name = MyFormatConfig.Name;
				fmt.Description = MyFormatConfig.Description;
				fmt.Save(true);
				MessageBox.Show(this, "Restart PROMS to have format changes take effect.", "", MessageBoxButtons.OK);
			}
			OriginalPlantFormat.FormatData.ProcData.CheckOffData.ClearCheckOffAndHeaderLists();
			PlantFormat.IgnoreUCF = false;
			PlantFormat.DoingUCFCheckOffs = false;
		}
		private void btnCancel_Click(object sender, EventArgs e)
		{
			if (OriginalPlantFormat != null) OriginalPlantFormat.FormatData.ProcData.CheckOffData.ClearCheckOffAndHeaderLists();
			PlantFormat.IgnoreUCF = false;
			PlantFormat.DoingUCFCheckOffs = false;
		}
		private bool _formatListIndexChanging = false;		// don't change other selections when changing this index
		private void cbxFormatList_SelectedIndexChanged(object sender, EventArgs e)
		{
			if (_Initializing) return;
			if (cbxFormatList.SelectedIndex > -1)
			{
				_formatListIndexChanging = true;
				FormatInfoList fl = FormatInfoList.GetFormatInfoListUsed();
				// Get the format data, the query in GetFormatInfoListUsed may have null for data/genmac which causes a
				// problem when reading the 'parent' data for UCF saved as formats.
				int i = -1;
				FormatInfo finfo = cbxFormatList.SelectedItem as FormatInfo;
				if (finfo == null) finfo = fl[cbxFormatList.SelectedIndex];
				OriginalFormatInfo = FormatInfo.Get(finfo.FormatID);
				OriginalPlantFormat = OriginalFormatInfo.PlantFormat;

				// get original data when accessing the plant format data (not UCF because it UCF data is being modified):
				PlantFormat.IgnoreUCF = true;
				int formatid = OriginalPlantFormat.MyFormat is Format ? (OriginalPlantFormat.MyFormat as Format).FormatID : (OriginalPlantFormat.MyFormat as FormatInfo).FormatID;
				FormatInfo fi = FormatInfo.Get(formatid);
				// if this has config data it is a UCF format, the MyFormatConfig has the config data & see if doing additional checkoffs.
				// Also, put out the summary of the changes if it is a 'UCF' and if no differences just state that.  
				btnDetails.Visible = true;
				lblSummary.Visible = true;
				tbUCFSummary.Visible = true;
				if (fi.Config != null && fi.Config != "")
				{
					MyFormatConfig = FormatConfig.Get(fi.Config);
					PlantFormat.DoingUCFCheckOffsUse = MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF ?? false;
					btnSaveClose.Enabled = true;             // UCF formats can be modified and saved.
					btnSave.Enabled = true; 
					SetUCFSummary(fi.Config);
				}
				else
				{
					MyFormatConfig = new FormatConfig();
					btnSaveClose.Enabled = false;
					btnSave.Enabled = false;
					tbUCFSummary.Text = "No differences from original";
				}
				// initialize the data based on the selected format with any changes from the FormatConfig.
				GetUCFDataForUCFGrid();
				PG.Enabled = true;
				PG.SelectedObject = MyFormatConfig;
				btnSaveAs.Enabled = false;
				SetDeleteOrResetAllButton();

				// set derived from if there is a parent:
				if (OriginalFormatInfo.MyParent.FormatID == 1)
				{
					lblDerFrom.Visible = false;
					lblDerivedFrom.Visible = false;
				}
				else
				{
					// get to top parent format:
					FormatInfo p = OriginalFormatInfo;
					while (p.MyParent.FormatID != 1) p = p.MyParent;
					lblDerFrom.Visible = true;
					lblDerivedFrom.Visible = true;
					lblDerivedFrom.Text = p.Name.Replace("_UCF", "") + "->" + OriginalFormatInfo.MyParent.Name.Replace("_UCF", "") + ":" + OriginalFormatInfo.MyParent.Description;
				}
				_formatListIndexChanging = false;
			}

		}

		private void SetUCFSummary(string formatConfig)
		{
			try
			{
				string sXSLSummary = System.IO.File.ReadAllText(Application.StartupPath + "\\" + "UCFSummary.xsl");
				StringWriter sw = new StringWriter();
				using (XmlReader xrt = XmlReader.Create(new StringReader(sXSLSummary)))
				{
					using (XmlReader xri = XmlReader.Create(new StringReader(formatConfig)))
					{
						using (XmlWriter xwo = XmlWriter.Create(sw))
						{
							XslCompiledTransform xsl = new XslCompiledTransform();
							xsl.Load(xrt);
							xsl.Transform(xri, null, sw);
						}
						if (sw == null || sw.ToString() == "")
							tbUCFSummary.Text = "No differences from original";
						else
							tbUCFSummary.Text = sw.ToString();
					}
				}
			}
			catch (Exception ex)
			{
				MessageBox.Show(ex.Message, "Error getting summary for UCF differences", MessageBoxButtons.OK);
			}
		}
		// The SaveAs Button should only be enabled if the user has given this format change a unique 'Name'.  
		private void SetButtonSaveAsEnabled()
		{
			btnSaveAs.Enabled = false;
			if (MyFormatConfig.Name == null || MyFormatConfig.Name == "") return;
			// See if Name has been changed:
			if (MyFormatConfig.Name == OriginalFormatInfo.Name) return;

			// See if the Name is unique
			foreach (FormatInfo fi in FormatInfoList.SortedFormatInfoList)
			{
				if (MyFormatConfig.Name == fi.Name && MyFormatConfig.Name != savDBFormatConfig.Name)
				{
					MessageBox.Show("A format with Name " + MyFormatConfig.Name + " already exists.  Name must be unique.  Change the name before a Save As can be done.");
				}
			}
			btnSaveAs.Enabled = true;
			return;
		}
		// If the selected format is a UCF 'Save As', then possibly allow delete (if not used).  Otherwise, if selected format
		// has Config data, i.e. UCF data, then change button text to 'Revert to Original'.  In both cases, enable button, otherwise it is disabled.
		private void SetDeleteOrResetAllButton()
		{
			btnDelete.Enabled = false;
			// See if UCF Save As, i.e. Data/Genmac are null and that the format is not used.
			FormatInfo fi = FormatInfo.GetFormatNoUCFByFormatID(OriginalFormatInfo.FormatID);
			if (fi.Data == "")
			{
				if (OriginalFormatInfo.ChildFormatCount == 0 && OriginalFormatInfo.FormatContentCount == 0 && OriginalFormatInfo.FormatDocVersionCount == 0 && OriginalFormatInfo.FormatFolderCount == 0)
				{
					btnDelete.Enabled = true;
					btnDelete.Text = "Delete";
				}
			}
			else
			{
				if (OriginalFormatInfo.Config != null && OriginalFormatInfo.Config != "")
				{
					btnDelete.Enabled = true;
					btnDelete.Text = "Revert to Original";
				}
			}
		}
		// GetChangeUCFForSave compares UCF data in FormatConfig to the original PlantFormat data to see if there
		// are changes that need to be saved to the database.
		private FormatConfig savDBFormatConfig;
		private FormatConfig GetChangesUCFForSave()
		{
			FormatConfig changesOnly = new FormatConfig();

			// Flags
			if (MyFormatConfig.PlantFormat.FormatData.Flags.CompressSteps != null && MyFormatConfig.PlantFormat.FormatData.Flags.CompressSteps != OriginalPlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.CompressSteps)
				changesOnly.PlantFormat.FormatData.Flags.CompressSteps = MyFormatConfig.PlantFormat.FormatData.Flags.CompressSteps;
			if (MyFormatConfig.PlantFormat.FormatData.Flags.PartialStepCompression != null && MyFormatConfig.PlantFormat.FormatData.Flags.PartialStepCompression != OriginalPlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PartialStepCompression)
				changesOnly.PlantFormat.FormatData.Flags.PartialStepCompression = MyFormatConfig.PlantFormat.FormatData.Flags.PartialStepCompression;
			if (MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF != null && MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF == true)	// save if true (original format is always false)
				changesOnly.PlantFormat.FormatData.Flags.CheckOffUCF = MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF;

			// CheckOff Headers
			if (MyFormatConfig.PlantFormat.FormatData.CheckOffHeaderList != null) changesOnly.PlantFormat.FormatData.CheckOffHeaderList = GetChangeCheckOffHeaderListForSave();

			// CheckOffs
			if (MyFormatConfig.PlantFormat.FormatData.CheckOffList != null) changesOnly.PlantFormat.FormatData.CheckOffList = GetChangeCheckOffListForSave();

			// Checkoff xoffset adjustment
			if (MyFormatConfig.PlantFormat.FormatData.CheckOffXOffAdj != null && MyFormatConfig.PlantFormat.FormatData.CheckOffXOffAdj != 0)	// save if not zero (original format is always zero)
				changesOnly.PlantFormat.FormatData.CheckOffXOffAdj = MyFormatConfig.PlantFormat.FormatData.CheckOffXOffAdj;

			// steps
			if (MyFormatConfig.PlantFormat.FormatData.StepData != null) changesOnly.PlantFormat.FormatData.StepData = GetChangeStepListForSave();

			// replace words - just store them all, if there are differences... can't handle deleted unless doing this.
			if (MyFormatConfig.PlantFormat.FormatData.ReplaceStrData != null) changesOnly.PlantFormat.FormatData.ReplaceStrData = GetChangedReplaceListForSave();

			// docstyles
			FormatConfig.DocStyles retds = new FormatConfig.DocStyles();
			foreach (DocStyle dsorig in OriginalPlantFormat.DocStyles.DocStyleList)
			{
				if (!dsorig.Inactive && dsorig.IsStepSection)
				{
					FormatConfig.DocStyle ds = new FormatConfig.DocStyle();
					ds.Index = dsorig.Index.ToString();
					ds.Name = dsorig.Name;
					if (ds.Layout == null) ds.Layout = new FormatConfig.Layout();
					// See if in the FormatConfig, use it
					FormatConfig.DocStyle found = null;
					if (MyFormatConfig.PlantFormat.DocStyles != null)
					{
						foreach (FormatConfig.DocStyle fcds in MyFormatConfig.PlantFormat.DocStyles)
						{
							float? difl = Math.Abs((float)((fcds.Layout.LeftMargin * 72) - dsorig.Layout.LeftMargin));
							float? difp = Math.Abs((float)((fcds.Layout.PageLength * 72) - dsorig.Layout.PageLength));
							if (fcds.Index == dsorig.Index.ToString() && (difl > 1 || difp > 1))
							{
								found = fcds;
								break;
							}
						}
					}
					if (found != null)		// save it values are different.
					{
						if ((found.Layout.LeftMargin * 72) != dsorig.Layout.LeftMargin) ds.Layout.LeftMargin = found.Layout.LeftMargin * 72;
						else ds.Layout.LeftMargin = null;
						if ((found.Layout.PageLength * 72) != dsorig.Layout.PageLength) ds.Layout.PageLength = found.Layout.PageLength * 72;
						else ds.Layout.PageLength = null;
						retds.Add(ds);
					}
				}
			}
			if (retds.Count > 0) changesOnly.PlantFormat.DocStyles = retds;
			return changesOnly;
		}
		// Check for differences in the checkoffheaderlist & checkofflist.  Only Active flag is used:
		private FormatConfig.CheckOffHeaderList GetChangeCheckOffHeaderListForSave()
		{
			FormatConfig.CheckOffHeaderList cohlist = new FormatConfig.CheckOffHeaderList();
			foreach (FormatConfig.CheckOffHeader coh in MyFormatConfig.PlantFormat.FormatData.CheckOffHeaderList)
			{
				if (!(bool)coh.Active) cohlist.Add(coh);
			}
			return cohlist;
		}
		private FormatConfig.CheckOffList GetChangeCheckOffListForSave()
		{
			FormatConfig.CheckOffList colist = new FormatConfig.CheckOffList();
			foreach (FormatConfig.CheckOff co in MyFormatConfig.PlantFormat.FormatData.CheckOffList)
			{
				if (!(bool)co.Active) colist.Add(co);
			}
			return colist;
		}
		// Check for differences in the StepDataList between UCF and original data for saving of data to database:
		private FormatConfig.StepData GetChangeStepListForSave()
		{
			FormatConfig.StepData sdlist = new FormatConfig.StepData();
			foreach (StepData sdorig in OriginalPlantFormat.FormatData.StepDataList)
			{
				if (!sdorig.Inactive)
				{
					// find this step in the config data:
					foreach (FormatConfig.Step fcstp in MyFormatConfig.PlantFormat.FormatData.StepData)
					{
						if (fcstp.Index == sdorig.Index.ToString())
						{
							// see if data is different and if so, add it to the return list:
							System.Drawing.FontConverter cvt = new System.Drawing.FontConverter();
							string origFont = cvt.ConvertToString(sdorig.Font.WindowsFont);
							string newFont = cvt.ConvertToString(fcstp.FontDesc.WindowsFont);
							if (origFont != newFont)
							{
								FormatConfig.Step stp = fcstp;
								sdlist.Add(stp);
							}
							break;
						}
					}
				}
			}
			return sdlist;
		}
		// Check for differences in the ReplaceWords between UCF and original data for saving of data to database:
		private FormatConfig.ReplaceStrData GetChangedReplaceListForSave()
		{
			// only saving the differences
			// need to compare the original format list with the list as it is stored for UCF, i.e.working with property grid and save differences.  
			// Note that check for 'bad' data such as no flags, or null/empty replace with/word strings - don't use those.
			// States for replacewords: 0 = no change, -1 deleted, 1 added, 2 modified
			FormatConfig.ReplaceStrData retlist = new FormatConfig.ReplaceStrData();        //  list of changes
			foreach (FormatConfig.ReplaceStr ucfrepstr in MyFormatConfig.PlantFormat.FormatData.ReplaceStrData)
			{
				// Modified 
				foreach (ReplaceStr origrepstr in OriginalPlantFormat.FormatData.SectData.ReplaceStrList)
				{
					// B2019-113: consider replace word AND flags to determine if there was a modification
					if (origrepstr.ReplaceWord.Replace("{Backspace}", "") == ucfrepstr.ReplaceWord.Replace("{Backspace}", "") && (E_ReplaceFlags)ucfrepstr.Flag == origrepstr.Flag)
					{
						if ((ucfrepstr.ReplaceWith != origrepstr.ReplaceWith) && ucfrepstr.Flag != 0 && ucfrepstr.ReplaceWith != "")
						{
							ucfrepstr.State = 2;
							retlist.Add(ucfrepstr);
							break;
						}
					}
				}
			}
			// Added:
			List<string> origstrList = new List<string>();      // used to find added, (see later in this method)
			foreach (ReplaceStr origrepstr in OriginalPlantFormat.FormatData.SectData.ReplaceStrList) origstrList.Add(origrepstr.ReplaceWord);
			foreach (FormatConfig.ReplaceStr ucfrepstr in MyFormatConfig.PlantFormat.FormatData.ReplaceStrData)
			{
				if (!origstrList.Contains(ucfrepstr.ReplaceWord))
				{
					// check for valid data, i.e. flag set & both replaceword & with not blank
					if (ucfrepstr.Flag != 0 && ucfrepstr.ReplaceWith != null && ucfrepstr.ReplaceWith != "" && ucfrepstr.ReplaceWord != null && ucfrepstr.ReplaceWord != "")
					{
						ucfrepstr.State = 1;
						retlist.Add(ucfrepstr);
					}
				}
				else   // B2019-113: replace word is in the original list, see if this word was added with different flags
				{
					if (!RepWrdSameWordSameFlags(OriginalPlantFormat.FormatData.SectData.ReplaceStrList, ucfrepstr))
					{
						ucfrepstr.State = 1;
						retlist.Add(ucfrepstr);
					}
				}
			}
			//Deleted:
			List<string> ucfList = new List<string>();          // used to find deleted
			foreach (FormatConfig.ReplaceStr ucfrepstr in MyFormatConfig.PlantFormat.FormatData.ReplaceStrData) ucfList.Add(ucfrepstr.ReplaceWord);
			foreach (ReplaceStr origrepstr in OriginalPlantFormat.FormatData.SectData.ReplaceStrList)
			{
				bool addtodeletelist = false;
				if (!ucfList.Contains(origrepstr.ReplaceWord) )
				{
					if (!((origrepstr.ReplaceWith.Contains("$1") && origrepstr.ReplaceWord.Contains("w*")) || origrepstr.ReplaceWith.Contains("{Backspace}")))
					{
						addtodeletelist = true;
					}
				}
				else  // // B2019-113: for this ucf replaceword, see if its flag is in the original list
				{
					foreach (FormatConfig.ReplaceStr ucfrepstruct in MyFormatConfig.PlantFormat.FormatData.ReplaceStrData)
					{
						if (origrepstr.ReplaceWord.Replace("{Backspace}", "") == ucfrepstruct.ReplaceWord.Replace("{Backspace}", ""))
						{
							// only deleted if replace word AND flags match:
							if (!RepWrdSameWordSameFlags(OriginalPlantFormat.FormatData.SectData.ReplaceStrList, ucfrepstruct))
							{
								addtodeletelist = true;
								break;
							}
						}
					}
				}
				if (addtodeletelist)
				{
						// make a deleted replacestr to save
						FormatConfig.ReplaceStr del = new FormatConfig.ReplaceStr();
						del.State = -1;
						del.Flag = (FormatConfig.E_ReplaceFlagsUCF)origrepstr.Flag;
						del.ReplaceWord = origrepstr.ReplaceWord;
						del.ReplaceWith = origrepstr.ReplaceWith;
						retlist.Add(del);
				}
			}
			return retlist;
		}

		private bool RepWrdSameWordSameFlags(ReplaceStrList replaceStrList, FormatConfig.ReplaceStr ucfrepstr)
		{
			// B2019-133: if the replace word is the same, see if the UCF flag is different.  The Replace Word & the flags need to be the same for it to be a match.
			List<FormatConfig.E_ReplaceFlagsUCF> flags = new List<FormatConfig.E_ReplaceFlagsUCF>();
			foreach (ReplaceStr origrepstr in replaceStrList)
			{
				if (origrepstr.ReplaceWord.Replace("{Backspace}", "") == ucfrepstr.ReplaceWord.Replace("{Backspace}", "")) flags.Add(ucfrepstr.Flag);
			}
			return (flags.Contains(ucfrepstr.Flag));
		}
		// The following uses the original format's ReplaceWords list and applies any changes made from the UCF ReplaceWords list.
		private FormatConfig.ReplaceStrData GetMergedReplaceList()
		{
			// 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
				foreach (FormatConfig.ReplaceStr ucfrepstr in MyFormatConfig.PlantFormat.FormatData.ReplaceStrData)
				{
					if (ucfrepstr.ReplaceWord == origrepstr.ReplaceWord && (E_ReplaceFlags)ucfrepstr.Flag == origrepstr.Flag)
					{
						if (ucfrepstr.State == -1) deleted = true;
						else usethisone = ucfrepstr;
						ucfrepstr.State = 2;
						inoriglist.Add(origrepstr.ReplaceWord);
						UcfForRepWords = true;
						break;
					}
				}
				// don't add in the replacewords that use 'Backspace' and regular expressions:
				bool supported = true;
				if (!deleted && usethisone == null)
				{
					if ((origrepstr.ReplaceWith.Contains("$1") || origrepstr.ReplaceWord.Contains("w*")) || origrepstr.ReplaceWith.Contains("{Backspace}"))
						supported = false;
					else
					{
						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 && supported) retlist.Add(usethisone);
			}
			// now add in any ucf only replacements, any that are not in the inoriglist
			foreach (FormatConfig.ReplaceStr ucfrepstr in MyFormatConfig.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.ReplaceWith = ucfrepstr.ReplaceWith;
					newone.ReplaceWord = ucfrepstr.ReplaceWord;
					retlist.Add(newone);
					UcfForRepWords = true;
				}
			}
			return (retlist);
		}
		// This method reads in the format items, merging any changes from UCF into original format. It sets MyFormatConfig, which
		// is the structure that gets used by the PropertyGrid
		private void GetUCFDataForUCFGrid()
		{
			// name/description is only stored as format record fields.  There are attributes in formatconfig xml that are used for defining these
			//  when new UCFs are defined or allowing for updates.
			MyFormatConfig.Name = OriginalFormatInfo.Name;
			MyFormatConfig.Description = OriginalFormatInfo.Description;

			// Store original (currently saved FormatConfig) to be used for comparison when saving.
			savDBFormatConfig = MyFormatConfig;

			// Flags
			if (MyFormatConfig.PlantFormat.FormatData.Flags.CompressSteps == null) MyFormatConfig.PlantFormat.FormatData.Flags.CompressSteps = OriginalPlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.CompressSteps;
			if (MyFormatConfig.PlantFormat.FormatData.Flags.PartialStepCompression == null) MyFormatConfig.PlantFormat.FormatData.Flags.PartialStepCompression = OriginalPlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PartialStepCompression;
			if (MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF == null) MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF = OriginalPlantFormat.FormatData.ProcData.CheckOffUCF;

			// checkoff xoffset adjustment
			if (MyFormatConfig.PlantFormat.FormatData.CheckOffXOffAdj == null) MyFormatConfig.PlantFormat.FormatData.CheckOffXOffAdj = 0;

			GetUCFCheckOffDataForUCFGrid((bool)MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF);

			// StepData: If there is no UCF data for steps, copy over from selected format
			FormatConfig.StepData sdlMerged = new FormatConfig.StepData();
			if (MyFormatConfig.PlantFormat.FormatData.StepData == null || MyFormatConfig.PlantFormat.FormatData.StepData.Count == 0)
			{
				foreach (StepData sdorig in OriginalPlantFormat.FormatData.StepDataList)
				{
					if (!sdorig.Inactive && sdorig.Index != 0)
					{
						FormatConfig.Step stp = new FormatConfig.Step();
						stp.Index = sdorig.Index.ToString();
						stp.Type = sdorig.Type;
						stp.FontDesc = new FormatConfig.FontDesc();
						stp.FontDesc.OrigWindowsFont = sdorig.Font.WindowsFont;
						stp.FontDesc.WindowsFont = sdorig.Font.WindowsFont;
						if (MyFormatConfig.PlantFormat.FormatData.StepData == null) MyFormatConfig.PlantFormat.FormatData.StepData = new FormatConfig.StepData();
						sdlMerged.Add(stp);
					}
				}
			}
			else
			{
				foreach (StepData sdorig in OriginalPlantFormat.FormatData.StepDataList)
				{
					if (!sdorig.Inactive && sdorig.Index != 0)
					{
						FormatConfig.Step stp = new FormatConfig.Step();
						stp.Index = sdorig.Index.ToString();
						stp.Type = sdorig.Type;
						stp.FontDesc = new FormatConfig.FontDesc();
						// See if in the FormatConfig, use it
						FormatConfig.Step foundinFC = null;
						foreach (FormatConfig.Step fcstp in MyFormatConfig.PlantFormat.FormatData.StepData)
						{
							if (fcstp.Index == sdorig.Index.ToString())
							{
								foundinFC = fcstp;
								break;
							}
						}
						stp.FontDesc.OrigWindowsFont = new System.Drawing.Font(sdorig.Font.Family, (float)sdorig.Font.Size, sdorig.Font.WindowsFont.Style);
						if (foundinFC != null)
							stp.FontDesc.WindowsFont = new System.Drawing.Font(foundinFC.FontDesc.WindowsFont.Name, foundinFC.FontDesc.WindowsFont.Size, foundinFC.FontDesc.WindowsFont.Style);
						else
							stp.FontDesc.WindowsFont = new System.Drawing.Font(sdorig.Font.Family, (float)sdorig.Font.Size, sdorig.Font.WindowsFont.Style);
						sdlMerged.Add(stp);
					}
				}
			}
			MyFormatConfig.PlantFormat.FormatData.StepData = sdlMerged;

			// ReplacWords
			// if there are no replace str entries in sc, add from the selected format:
			if (MyFormatConfig.PlantFormat.FormatData.ReplaceStrData == null || MyFormatConfig.PlantFormat.FormatData.ReplaceStrData.Count == 0)
			{
				foreach (ReplaceStr repstrorig in OriginalPlantFormat.FormatData.SectData.ReplaceStrList)
				{
					if (!((repstrorig.ReplaceWith.Contains("$1") && repstrorig.ReplaceWord.Contains("w*")) || repstrorig.ReplaceWith.Contains("{Backspace}")))
					{
						FormatConfig.ReplaceStr rsfc = new FormatConfig.ReplaceStr();
						rsfc.Flag = (FormatConfig.E_ReplaceFlagsUCF)repstrorig.Flag;
						rsfc.State = 0;
						rsfc.ReplaceWith = repstrorig.ReplaceWith;
						rsfc.ReplaceWord = repstrorig.ReplaceWord;
						MyFormatConfig.PlantFormat.FormatData.ReplaceStrData.Add(rsfc);
					}
				}
			}
			else
			{
				MyFormatConfig.PlantFormat.FormatData.ReplaceStrData = GetMergedReplaceList();
			}
			// Document Style (section) Data (docstyles).   Get step editor type only 
			if (MyFormatConfig.PlantFormat.DocStyles == null || MyFormatConfig.PlantFormat.DocStyles.Count == 0)
			{
				foreach (DocStyle dsorig in OriginalPlantFormat.DocStyles.DocStyleList)
				{
					if (!dsorig.Inactive && dsorig.IsStepSection)
					{
						FormatConfig.DocStyle ds = new FormatConfig.DocStyle();
						ds.Index = dsorig.Index.ToString();
						ds.Name = dsorig.Name;
						if (ds.Layout == null) ds.Layout = new FormatConfig.Layout();
						ds.Layout.PageLength = (float)Math.Round((float)dsorig.Layout.PageLength / 72, 2);
						ds.Layout.OrigPageLength = ds.Layout.PageLength;
						ds.Layout.LeftMargin = (float)Math.Round((float)dsorig.Layout.LeftMargin / 72, 2);
						ds.Layout.OrigLeftMargin = ds.Layout.LeftMargin;
						if (MyFormatConfig.PlantFormat.DocStyles == null) MyFormatConfig.PlantFormat.DocStyles = new FormatConfig.DocStyles();
						MyFormatConfig.PlantFormat.DocStyles.Add(ds);
					}
				}
			}
			else
			{
				foreach (DocStyle dsorig in OriginalPlantFormat.DocStyles.DocStyleList)
				{
					if (!dsorig.Inactive && dsorig.IsStepSection)
					{
						FormatConfig.DocStyle ds = new FormatConfig.DocStyle();
						ds.Index = dsorig.Index.ToString();
						ds.Name = dsorig.Name;
						if (ds.Layout == null) ds.Layout = new FormatConfig.Layout();
						// See if in the FormatConfig, use it
						FormatConfig.DocStyle foundinFC = null;
						foreach (FormatConfig.DocStyle fcds in MyFormatConfig.PlantFormat.DocStyles)
						{
							if (fcds.Index == dsorig.Index.ToString())
							{
								foundinFC = fcds;
								break;
							}
						}
						if (foundinFC != null)
						{
							if (foundinFC.Layout.LeftMargin == null) foundinFC.Layout.LeftMargin = (float)Math.Round((float)dsorig.Layout.LeftMargin / 72, 2);
							else foundinFC.Layout.LeftMargin = (float)Math.Round((float)foundinFC.Layout.LeftMargin / 72, 2);
							foundinFC.Layout.OrigLeftMargin = (float)Math.Round((float)dsorig.Layout.LeftMargin / 72, 2);
							if (foundinFC.Layout.PageLength == null) foundinFC.Layout.PageLength = (float)Math.Round((float)dsorig.Layout.PageLength / 72, 2);
							else foundinFC.Layout.PageLength = (float)Math.Round((float)foundinFC.Layout.PageLength / 72, 2);
							foundinFC.Layout.OrigPageLength = (float)Math.Round((float)dsorig.Layout.PageLength / 72, 2);
						}
						else
						{
							ds.Layout.OrigLeftMargin = (float)Math.Round((float)dsorig.Layout.LeftMargin / 72, 2);
							ds.Layout.OrigPageLength = (float)Math.Round((float)dsorig.Layout.PageLength / 72, 2);
							ds.Layout.LeftMargin = (float)Math.Round((float)dsorig.Layout.LeftMargin / 72, 2);
							ds.Layout.PageLength = (float)Math.Round((float)dsorig.Layout.PageLength / 72, 2);
							MyFormatConfig.PlantFormat.DocStyles.Add(ds);
						}
					}
				}
			}
		}

		private void GetUCFCheckOffDataForUCFGrid(bool ucfcheckof)
		{
			OriginalPlantFormat.FormatData.ProcData.CheckOffData.ClearCheckOffAndHeaderLists();
			// CheckOffHeaders: If there is no UCF data, use from the selected format, otherwise merge:
			FormatConfig.CheckOffHeaderList cohdrsMerged = new FormatConfig.CheckOffHeaderList();
			if (MyFormatConfig.PlantFormat.FormatData.CheckOffHeaderList == null || MyFormatConfig.PlantFormat.FormatData.CheckOffHeaderList.Count == 0)
			{
				foreach (CheckOffHeader cohorig in OriginalPlantFormat.FormatData.ProcData.CheckOffData.CheckOffHeaderList)
				{
					// do inactive::
					FormatConfig.CheckOffHeader coh = new FormatConfig.CheckOffHeader();
					coh.Index = cohorig.Index.ToString();
					coh.CheckOffHeading = cohorig.CheckOffHeading;
					coh.Active = true;
					coh.OrigActive = true;
					cohdrsMerged.Add(coh);
				}
			}
			else
			{
				foreach (CheckOffHeader cohorig in OriginalPlantFormat.FormatData.ProcData.CheckOffData.CheckOffHeaderList)
				{
					FormatConfig.CheckOffHeader coh = new FormatConfig.CheckOffHeader();
					coh.Index = cohorig.Index.ToString();
					coh.CheckOffHeading = cohorig.CheckOffHeading;
					coh.Active = true;
					coh.OrigActive = true;
					// See if in the FormatConfig, to check its inactive flag:
					foreach (FormatConfig.CheckOffHeader fccoh in MyFormatConfig.PlantFormat.FormatData.CheckOffHeaderList)
					{
						if (fccoh.Index == cohorig.Index.ToString())
						{
							coh.Active = fccoh.Active;
							coh.OrigActive = true;
							break;
						}
					}
					cohdrsMerged.Add(coh);
				}
			}
			MyFormatConfig.PlantFormat.FormatData.CheckOffHeaderList = cohdrsMerged;

			// CheckOffs: If there is no UCF data, use from the selected format, otherwise merge:
			FormatConfig.CheckOffList cosMerged = new FormatConfig.CheckOffList();
			// clear the lists so that correct lists will be initialized
			foreach (CheckOff coorig in OriginalPlantFormat.FormatData.ProcData.CheckOffData.CheckOffList)
			{
				FormatConfig.CheckOff co = new FormatConfig.CheckOff();
				co.Index = coorig.Index.ToString();
				co.MenuItem = coorig.MenuItem;
				co.Active = true;
				co.OrigActive = true;
				// See if in the FormatConfig, to check its inactive flag:
				if (MyFormatConfig.PlantFormat.FormatData.CheckOffList != null)
				{
					foreach (FormatConfig.CheckOff fcco in MyFormatConfig.PlantFormat.FormatData.CheckOffList)
					{
						if (fcco.Index == coorig.Index.ToString())
						{
							co.Active = fcco.Active;
							co.OrigActive = true;
							break;
						}
					}
				}
				cosMerged.Add(co);
			}
			MyFormatConfig.PlantFormat.FormatData.CheckOffList = cosMerged;
		}
		// The Reset button is used to reset a UCF change from the original data.  If a field is added to UCF, code needs
		// added here for the field:
		private void btnReset_Click(object sender, EventArgs e)
		{
			// The code that enables the Reset button checks if a change (UCF) exists.  So no need to check here.
			if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings:Flags:Compress Steps"))
			{
				MyFormatConfig.PlantFormat.FormatData.Flags.CompressSteps = OriginalPlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.CompressSteps;
			}
			else if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings:Flags:Partial Step Compression"))
			{
				MyFormatConfig.PlantFormat.FormatData.Flags.PartialStepCompression = OriginalPlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.PartialStepCompression;
			}
			else if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings:Flags:UCF CheckOffs"))
			{
				MyFormatConfig.PlantFormat.FormatData.Flags.CheckOffUCF = OriginalPlantFormat.FormatData.ProcData.CheckOffUCF;
			}
			else if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings:CheckOff XOffset"))
			{
				MyFormatConfig.PlantFormat.FormatData.CheckOffXOffAdj = 0;
			}
			else if (SelectedGridField.EndsWith("Data:Plant Format:Step Settings:Replace Words List"))
			{
				MyFormatConfig.PlantFormat.FormatData.ReplaceStrData.Clear();
				foreach (ReplaceStr repstrorig in OriginalPlantFormat.FormatData.SectData.ReplaceStrList)
				{
					if (!((repstrorig.ReplaceWith.Contains("$1") && repstrorig.ReplaceWord.Contains("w*")) || repstrorig.ReplaceWith.Contains("{Backspace}")))
					{
						FormatConfig.ReplaceStr rsfc = new FormatConfig.ReplaceStr();
						rsfc.Flag = (FormatConfig.E_ReplaceFlagsUCF)repstrorig.Flag;
						rsfc.State = 0;
						rsfc.ReplaceWith = repstrorig.ReplaceWith;
						rsfc.ReplaceWord = repstrorig.ReplaceWord;
						MyFormatConfig.PlantFormat.FormatData.ReplaceStrData.Add(rsfc);
						UcfForRepWords = false;
					}
				}
			}
			btnReset.Enabled = false;
			btnReset.Text = "Reset";
		}

		private void btnSaveAs_Click(object sender, EventArgs e)
		{
			// Name must be unique - description can be null.
			// Append a '_UCF' at end of all user control of format formats.
			// add a format record for this:
			//      FormatID - next ID, db creates on new format
			//      ParentID - format id of the format that was used as a base for this user control of format
			//      Name - user defined
			//      Description - user defined - if none specified by user, use the original's description
			//      Data - null:  flags that a UCF was saved as and use the parent and config from this.
			//      

			// check for unique name.
			foreach (FormatInfo fi in FormatInfoList.SortedFormatInfoList)
			{
				if (MyFormatConfig.Name == fi.Name || MyFormatConfig.Name + "_UCF" == fi.Name)
				{
					MessageBox.Show("A format with Name " + MyFormatConfig.Name + " already exists.  Name must be unique.  Save As cannot be done.");
					return;
				}
			}
			using (Format tmp = Format.Get(OriginalFormatInfo.FormatID))
			{
				string fname = MyFormatConfig.Name + (MyFormatConfig.Name.EndsWith("_UCF") ? "" : "_UCF");
				Format fmt = Format.MakeFormat(tmp, fname, MyFormatConfig.Description == OriginalFormatInfo.Description || MyFormatConfig.Description == "" || MyFormatConfig.Description == null ? OriginalFormatInfo.Description : MyFormatConfig.Description, null, null, DateTime.Now, Volian.Base.Library.VlnSettings.UserID);
				FormatConfig tmpForSave = GetChangesUCFForSave();
				string scf = tmpForSave.ConvertToString();
				scf = Regex.Replace(scf, " *<[a-zA-Z ]+/>\r\n", "");
				// for now, tell the user that changes don't take affect until reentry.  This was done since the 'refresh' of FormatConfig was not
				// working.
				fmt.Config = scf;
				fmt.Description = MyFormatConfig.Description;
				fmt.Save(true);
				MessageBox.Show(this, "Restart PROMS to have format changes take effect.", "", MessageBoxButtons.OK);
				btnSaveAs.Enabled = false;
			}
		}

		private void btnDelete_Click(object sender, EventArgs e)
		{
			// delete this format OR  (the button text is set to 'delete...' if no item or version uses it)
			// revert to the original
			string msg = btnDelete.Text == "Revert to Original" ? "revert to the original?" : "delete this format?";
			if (MessageBox.Show(this, "Are you sure you want to " + msg, "Confirm", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
			{
				PlantFormat.IgnoreUCF = true;
				// the button is either 'Revert to Original' for a format that is the original and has config data, or 'Delete' for a UCF that 
				// was created by a 'Save As'.
				// so do either a clear of the config data, or delete the format record depending on button's text
				if (btnDelete.Text == "Revert to Original")
				{
					using (Format fmt = Format.Get(OriginalFormatInfo.FormatID))
					{
						fmt.Config = "";
						fmt.Save(true);
						MessageBox.Show(this, "The changes that have been made to the format will take affect after reentry to PROMS", "", MessageBoxButtons.OK);
						MyFormatConfig = new FormatConfig();
						PG.SelectedObject = MyFormatConfig;
						PG.Enabled = false;
						btnSaveAs.Enabled = false;
						btnDelete.Enabled = false;
						btnSaveClose.Enabled = false;
						btnSave.Enabled = false;
						btnReset.Enabled = false;
					}
				}
				else
				{
					try
					{
						Format.Delete(OriginalFormatInfo.FormatID);
					}
					catch (Exception ex)
					{
						MessageBox.Show("Could not delete the format");
						return;
					}
					cbxFormatList.DataSource = FormatInfoList.GetFormatInfoListUsed();
					cbxFormatList.SelectedIndex = -1;
					MyFormatConfig = new FormatConfig();
					PG.SelectedObject = MyFormatConfig;
					PG.Enabled = false;
					btnSaveAs.Enabled = false;
					btnDelete.Enabled = false;
					btnSaveClose.Enabled = false;
					btnSave.Enabled = false;
					btnReset.Enabled = false;
				}
				PlantFormat.IgnoreUCF = false;
				PlantFormat.DoingUCFCheckOffs = false;
			}
		}

		private void btnDetails_Click(object sender, EventArgs e)
		{
			FormatConfig tmpfc = GetChangesUCFForSave();
			string scf = tmpfc.ConvertToString();
			scf = Regex.Replace(scf, " *<[a-zA-Z ]+/>\r\n", "");
			dlgUCFDetail dtl = new dlgUCFDetail(scf, MyFormatConfig.Name, MyFormatConfig.Description);
			dtl.ShowDialog();
		}

		private void btnSave_Click(object sender, EventArgs e)
		{
			// get a FormatConfig structure that only has differences from the original format. This is what gets saved.
			FormatConfig tmpForSave = GetChangesUCFForSave();
			string scf = tmpForSave.ConvertToString();
			scf = Regex.Replace(scf, " *<[a-zA-Z ]+/>\r\n", "");
			int fmtid = OriginalPlantFormat.MyFormat is Format ? (OriginalPlantFormat.MyFormat as Format).FormatID : (OriginalPlantFormat.MyFormat as FormatInfo).FormatID;
			// for now, tell the user that changes don't take affect until reentry.  This was done since the 'refresh' of FormatConfig was not
			// working.
			using (Format fmt = Format.Get(fmtid))
			{
				FormatInfo fi = FormatInfo.GetFormatNoUCFByFormatID(OriginalFormatInfo.FormatID);
				if (fi.Data == "")
				{
					fmt.Data = "";
					fmt.GenMac = "";
				}
				fmt.Config = scf;
				fmt.Name = MyFormatConfig.Name;
				fmt.Description = MyFormatConfig.Description;
				fmt.Save(true);
			}
		}
	}
}