using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using VEPROMS.CSLA.Library;
using Volian.Controls.Library;
using Volian.Base.Library;
using System.Xml;
using System.IO;
using Ionic.Zip;
using System.Text.RegularExpressions;
using JR.Utils.GUI.Forms;

namespace VEPROMS
{
	public partial class dlgExportImport : Form
	{
		#region Log4Net
		private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
		#endregion
		frmVEPROMS _MyFrmVEPROMS = null;// Save frmVEPROMS for Import to shutoff SessionPing
		public frmVEPROMS MyFrmVEPROMS
		{
			get { return _MyFrmVEPROMS; }
			set { _MyFrmVEPROMS = value; }
		}
		private bool _ConvertROsToTextDuringImport = false;
		private bool _ConvertROsAndTransitionsToText = false; // set to true when Approval creates an Export file

		// B2016-225 notify user when Transitions and/or ROs are converted to text
		private bool _DidConvertTransitionsToText = false;
		private bool _DidConvertROsToText = false;
		private bool _DidUCF = false;

		private ItemInfo _ExternalTransitionItem = null;
		public ItemInfo ExternalTransitionItem
		{
			get { return _ExternalTransitionItem; }
			set { _ExternalTransitionItem = value; }
		}
		private Dictionary<int, int> floatFoldout;
		private Dictionary<int, string> importedFormat;
		private Dictionary<string, int> existingFormat;
		private Dictionary<string, string> renamedUCFFormatName;		// if format is renamed, this is its new name so references to it can be made
		private Dictionary<int, int> renamedUCFFormatId;				// if format is renamed, this is its old->new formatid
		private int oldRODbID;
		private int newRODbID;
		private FolderInfo _MyNewFolder;
		public FolderInfo MyNewFolder
		{
			get { return _MyNewFolder; }
		}
		private ProcedureInfo _MyNewProcedure;
		public ProcedureInfo MyNewProcedure
		{
			get { return _MyNewProcedure; }
			set { _MyNewProcedure = value; }
		}
		private string PEIPath;
		private string _MyMode;
		private FolderInfo MyFolder = null;
		private DocVersionInfo MyDocVersion = null;
		private ProcedureInfo MyProcedure = null;
		private XmlAttribute AddAttribute(XmlDocument xd, string name, string value)
		{
			XmlAttribute xa = xd.CreateAttribute(name);
			xa.InnerText = value;
			return xa;
		}
		public dlgExportImport(string mode, FolderInfo folderInfo, frmVEPROMS myFrmVEPROMS, E_UCFImportOptions frset)
		{
			UCFImportDefaultFromSettings = frset;
			MyFrmVEPROMS = myFrmVEPROMS;// Save frmVEPROMS for Import to shutoff SessionPing
			_MyMode = mode;
			MyFolder = folderInfo;
			InitializeComponent();
			this.Text = mode + " Dialog for " + folderInfo.Name;
		}
		public dlgExportImport(string mode, DocVersionInfo docVersionInfo, frmVEPROMS myFrmVEPROMS, E_UCFImportOptions frset)
		{
			UCFImportDefaultFromSettings = frset;
			MyFrmVEPROMS = myFrmVEPROMS;// Save frmVEPROMS for Import to shutoff SessionPing
			_MyMode = mode;
			MyDocVersion = docVersionInfo;
			InitializeComponent();
			if (mode.ToUpper().Contains("FORMAT"))
				this.Text = mode;
			else
				this.Text = mode + " Dialog for " + docVersionInfo.Name + " of " + docVersionInfo.MyFolder.Name;
		}
		public dlgExportImport(string mode, ProcedureInfo procedureInfo, frmVEPROMS myFrmVEPROMS, E_UCFImportOptions frset)
		{
			UCFImportDefaultFromSettings = frset;
			MyFrmVEPROMS = myFrmVEPROMS;// Save frmVEPROMS for Import to shutoff SessionPing
			_MyMode = mode;
			MyProcedure = procedureInfo;
			InitializeComponent();
			this.Text = mode + " Dialog for " + procedureInfo.DisplayNumber;
		}
		private void dlgExportImport_Load(object sender, EventArgs e)
		{
			PEIPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + @"\VEPROMS\PEI_" + Database.VEPROMS_SqlConnection.Database;
			if (!Directory.Exists(PEIPath))
				Directory.CreateDirectory(PEIPath);
			if (_MyMode == "Import")
			{
				//If you try to import a procedure into an empty PROMS folder, the code was deleting the File System Folder including the import file.  This happened during D.C. Cook training (12/3/2015).
				//if (MyFolder != null && MyFolder.ChildFolderCount == 0 )
				//{
				//	Directory.Delete(PEIPath, true);
				//	Directory.CreateDirectory(PEIPath);
				//}
			}
			pnlExport.Dock = DockStyle.Fill;
			pnlImport.Dock = DockStyle.Fill;
			int formsize = 2;
			if (_MyMode.ToLower().Contains("export"))
			{
				// if doing formats, make various controls invisible:
				if (_MyMode.ToUpper().Contains("FORMAT"))
				{
					cbxExportAudits.Visible = false;
					lblExportProcedure.Visible = lblExportSection.Visible = lblExportStep.Visible = false;
					pbExportProcedure.Visible = pbExportSection.Visible = pbExportStep.Visible = false;
					lblExportTime.Visible = false;
					formsize = 4;
				}
				sfd.InitialDirectory = PEIPath;
				pnlExport.BringToFront();
			}
			else
			{
				if (_MyMode.ToUpper().Contains("FORMAT"))
				{
					cbxImportAudits.Visible = false;
					lblImportProcedure.Visible = lblImportSection.Visible = lblImportStep.Visible = false;
					pbImportProcedure.Visible = pbImportSection.Visible = pbImportStep.Visible = false;
					lblExportTime.Visible = false;
					formsize = 4;
				}
				ofd.InitialDirectory = PEIPath;
				pnlImport.BringToFront();
			}
			this.Height = this.Height / formsize;
		}
		private void btnExport_Click(object sender, EventArgs e)
		{
			if (_MyMode.ToUpper().Contains("FORMAT"))
			{
				txtExport.Text = string.Format(@"{0}\{1}.pxml", PEIPath, "UCF");
				return;
			}
			if (MyFolder != null)
			{
				//Database.SelectedDatabase
				//sfd.FileName = string.Format("{0}.expx", MyFolder.Name);
				sfd.FileName = string.Format("{0}-{1}.expx", Database.ActiveDatabase, MyFolder.Name);
				if (sfd.ShowDialog(this) == DialogResult.OK)
				{
					if (sfd.FileName != string.Empty)
					{
						txtExport.Text = sfd.FileName;
						if (File.Exists(txtExport.Text))
							File.Delete(txtExport.Text);
						MyExpxZipFile = new ZipFile(txtExport.Text, Encoding.UTF8);
						MyExpxZipFile.Save();
					}
				}
			}
			else if (MyProcedure != null)
			{
				txtExport.Text = string.Format(@"{0}\{1}.pxml", PEIPath, MyProcedure.DisplayNumber.Replace("/", "_").Replace("\\", "_"));
			}
		}
		private void txtExport_TextChanged(object sender, EventArgs e)
		{
			btnDoExport.Enabled = txtExport.TextLength > 0;
			if (btnDoExport.Enabled)
				lblExportStatus.Text = "Ready To Perform Export";
			else
				lblExportStatus.Text = "Awaiting Export File Name:";
		}
		private XmlWriter MyWriter = null;
		private ZipFile MyExpxZipFile = null;
		private ZipFile MyImpxZipFile = null;
		private DateTime MyStart;
		private bool successfullExport = true;
		private void btnDoExport_Click(object sender, EventArgs e)
		{
			btnExport.Enabled = false;
			string msg = "Finished Exporting:\n\n";
			if (_MyMode.ToUpper().Contains("FORMAT"))
			{
				this.Cursor = Cursors.WaitCursor;
				MyStart = DateTime.Now;
				btnDoExport.Enabled = false;
				lblExportStatus.Text = "Performing Export of UC Formats";
				SaveExportUCF();

				TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
				lblExportStatus.Text = "Format Export Completed in " + elapsed.ToString();
				this.Cursor = Cursors.Default;
			}
			else if (MyFolder != null)
			{
				this.Cursor = Cursors.WaitCursor;
				MyStart = DateTime.Now;
				btnDoExport.Enabled = false;
				lblExportStatus.Text = "Performing Export";
				SaveExportData();
				//SaveExportDataWriter();

				TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
				lblExportStatus.Text = "Export Completed in " + elapsed.ToString();
				this.Cursor = Cursors.Default;
				msg += MyFolder.Name;
			}
			else if (MyProcedure != null)
			{
				this.Cursor = Cursors.WaitCursor;
				MyStart = DateTime.Now;
				btnDoExport.Enabled = false;
				lblExportStatus.Text = "Performing Export";
				pbExportProcedure.Maximum = 1;
				XmlDocument xd = new XmlDocument();
				ExportItem(xd, MyProcedure, "procedure");
				XmlElement xe = xd.CreateElement("formats");
				xd.DocumentElement.AppendChild(xe);
				ExportFormats(FormatInfoList.GetFormatInfoListUsed(), xe, "formats", false);
				xd.Save(txtExport.Text);
				TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
				lblExportStatus.Text = "Export Completed in " + elapsed.ToString();
				this.Cursor = Cursors.Default;
			}
			// added message to user when export of a procedure or procedure set has completed
			if (successfullExport)
			{
				if (!_MyMode.ToUpper().Contains("FORMAT"))
					msg += MyProcedure;
				else
					msg += "Formats";
			}
			else
				msg = "Could not complete export";
			MessageBox.Show(msg, "Export Completed", MessageBoxButtons.OK, MessageBoxIcon.Information); // C2020-042 changed mesage box title
			btnCloseExport.Enabled = true;
		}

		private void SaveExportUCF()
		{
			lblExportStatus.Text = "Exporting UC Formats...";
			Application.DoEvents();
			XmlDocument xd = new XmlDocument();
			XmlElement xe = xd.CreateElement("ucformats");
			xd.AppendChild(xe);
			FormatInfoList fil = FormatInfoList.Get();
			foreach (FormatInfo fi in fil)
			{
				if (fi.Config != null && fi.Config != "")
					ExportFormat(xe, fi, "ucformat");
			}
			xd.Save(txtExport.Text);
		}
		private void SaveExportData()
		{
			XmlDocument xd = new XmlDocument();
			MyFrmVEPROMS.DisablePing = true;//B2018-030 Shutoff ping when doing Export
			ExportFolder(xd, MyFolder, "folder");
			MyFrmVEPROMS.DisablePing = false;//B2018-030 turn on ping Export is done
		}

		// appears to not be used -jsj 4-29-2016
		//private void SaveExportDataWriter()
		//{
		//	XmlWriterSettings ws = new XmlWriterSettings();
		//	ws.Indent = true;
		//	ws.NewLineHandling = NewLineHandling.Entitize;
		//	ws.CheckCharacters = false;
		//	MyWriter = XmlWriter.Create(txtExport.Text, ws);
		//	ExportFolder(MyFolder, "folder");
		//	MyWriter.Close();
		//}

		private void btnDoImport_Click(object sender, EventArgs e)
		{
			bool isImported = false;
			bool canceledPressed = false;
			btnImport.Enabled = false;
			this.Cursor = Cursors.WaitCursor;
			MyStart = DateTime.Now;
			btnDoImport.Enabled = false;
			lblImportStatus.Text = "Performing Import";
			_DidConvertTransitionsToText = false;
			_DidConvertROsToText = false;
			_DidProcessTransitions = false;  // B2017-076 to know if we processed any transition (used in status message at the end of importing)
			_DidProcessROs = false;  // B2017-076 to know if we processed any transition (used in status message at the end of importing)
			//LoadImportDataReader();
			if (_MyMode.ToUpper().Contains("FORMAT"))
			{
				TurnChangeManagerOff.Execute();
				MyFrmVEPROMS.DisablePing = true;// Turn-off SessionPing
				bool result = TryToImportUCFs(ref isImported, ref canceledPressed);
				MyFrmVEPROMS.DisablePing = false;// Turn-on SessionPing
				TurnChangeManagerOn.Execute();
				if (!result)		// B2019-006: let user know there was an error during import:
				{
					MessageBox.Show("Error occurred during import. Format(s) not imported.");
					this.Cursor = Cursors.Default;
					btnCloseImport.Enabled = true;
					return;
				}
				if (isImported)
				{
					TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
					lblImportStatus.Text = "Format Import Completed in " + elapsed.ToString();
				}
				else
				{
					btnImport.Enabled = true;
					btnDoImport.Enabled = true;
				}
			}
			else if (MyFolder != null)  // import a folder - a .expx file
			{
				TurnChangeManagerOff.Execute();
				MyFrmVEPROMS.DisablePing = true;// Turn-off SessionPing
				// B2019-046: improved error handling (added return value)
				isImported = TryToLoadImportDataDocument();// Added Try Catch Error Handling to assure that the Change Manager is tuned-on
				MyDocVersion = null;
				MyFrmVEPROMS.DisablePing = false;// Turn-on SessionPing
				TurnChangeManagerOn.Execute();
			}
			if (MyDocVersion != null) // import a procedure - a .pxml file
			{
				// compare the ROPath of MyDocVerion
				// if no path set, display Pick RO Folder dialog
				// if MyDocVersion ROPath is different than the import file ROPath, then ask user:
				//  - use MyDocVersion ROPath (warn resulting RO values may be be correct)
				//    * set oldRODbID to id in import file
				//    * set newRODbid to MyDocVersion rodbid
				//  - or convert ROs to text
				TurnChangeManagerOff.Execute();
				// Added Try Catch Error Handling to assure that the Change Manager is tuned-off
				MyFrmVEPROMS.DisablePing = true;// Turn-off SessionPing B2017-157
				bool result = TryToImportProcedure(ref isImported, ref canceledPressed);
				MyFrmVEPROMS.DisablePing = false;// Turn-on SessionPing
				TurnChangeManagerOn.Execute();
				if (!result) return;
				if (isImported)
				{
					TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
					lblImportStatus.Text = "Import Completed in " + elapsed.ToString();
				}
				else
				{
					btnImport.Enabled = true;
					btnDoImport.Enabled = true;
				}
			}
			this.Cursor = Cursors.Default;
			btnCloseImport.Enabled = true;
			if (isImported)
			{
				string msg = string.Format("Finished Importing:\n\n{0}", txtImport.Text.Substring(txtImport.Text.LastIndexOf("\\") + 1));
				if (_DidUCF)		// B2019-015: add a message to state to exit re-enter on format imports
				{
					msg += "\n\nRestart PROMS to have user controlled formats become available.";
				}
				else if (_DidConvertTransitionsToText || _DidConvertROsToText)
				{
					string msg1 = (_DidConvertTransitionsToText && _DidConvertROsToText) ? "Transitions and Referenced Objects" : (_DidConvertTransitionsToText) ? "Transitions" : "Referenced Objects";
					msg += string.Format("\n\n{0} converted to text.\n\nThe locations can be found by doing a Global Search for the \"Link Converted To Text\" annotation type", msg1);
				}
				else if (_ImportingApprovedExportFile) // B2020-095 An approved version of a procedure was imported, all ROs and Transitions are unlinked.
				{
					msg += "\n\nYou had imported an Approved Version of a procedure.\n\nAll Transition and Referenced Object values are text.";  // B2017-076 Approved import file does not have ROs nor Transition
				}
				// B2016-225 added more information to the finish import message to tell the user when ROs or Transitions are converted to text.
				MessageBox.Show(msg, "Import Completed", MessageBoxButtons.OK, MessageBoxIcon.Information); // C2020-042 changed mesage box title
																											//MessageBox.Show(string.Format("Finished Importing:\n\n{0}", txtImport.Text.Substring(txtImport.Text.LastIndexOf("\\") + 1)), "Import", MessageBoxButtons.OK, MessageBoxIcon.Information);
			}
			if (canceledPressed)
			{
				MessageBox.Show(string.Format("Canceling the import of:\n\n{0}", txtImport.Text.Substring(txtImport.Text.LastIndexOf("\\") + 1)), "Import", MessageBoxButtons.OK, MessageBoxIcon.Information);
				btnCloseImport.PerformClick();
			}
		}

		private bool TryToImportUCFs(ref bool isImported, ref bool canceledPressed)
		{
			try
			{
				existingFormat = new Dictionary<string, int>();
				FormatInfoList fil = FormatInfoList.Get();
				foreach (FormatInfo fi in fil)
					existingFormat.Add(fi.Name, fi.FormatID);
				XmlDocument xd = new XmlDocument();
				xd.Load(txtImport.Text);
				XmlNodeList nl = xd.SelectNodes("ucformats/ucformat");
				if (nl == null || nl.Count == 0)		// B2019-014: Check contents of import file for compatible operation
				{
					MessageBox.Show("A Procedure export file can only be imported from the Tree View.", "Import Failed", MessageBoxButtons.OK);
					this.Close();
					isImported = false;
					return false;
				}
				foreach (XmlNode nd in nl)
				{
					int formatid = int.Parse(nd.Attributes.GetNamedItem("formatid").InnerText);
					string name = nd.Attributes.GetNamedItem("name").InnerText;
					string config = null;
					XmlNode cfg = nd.Attributes.GetNamedItem("config");
					if (cfg != null) config = cfg.InnerText;
					string pname = nd.Attributes.GetNamedItem("pname").InnerText;
					string description = null;
					XmlNode descript = nd.Attributes.GetNamedItem("description");
					if (descript != null) description = descript.InnerText;
					string userid = nd.Attributes.GetNamedItem("userid").InnerText;
					DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
					if (!existingFormat.ContainsKey(pname)) return false;
					int pid = existingFormat[pname];
					Format pformat = Format.Get(pid);
					if (existingFormat.ContainsKey(name))           // this UCF already exists in database, just update the record.
					{
						FormatInfo exFI = FormatInfo.Get(existingFormat[name]);
						if (exFI.Config != config)
						{
							using (Format f = Format.Get(exFI.FormatID))
							{
								f.Name = name;
								f.MyParent = pformat;
								f.Description = description;
								f.UserID = userid;
								f.DTS = dts;
								f.Config = config;
								f.Save();
							}
						}
					}
					else        // doesn't exist in the database, add it
					{

						Format rec = Format.MakeFormat(pformat, name, description, null, null, dts, userid);
						rec.Config = config;
						rec.Save();
						existingFormat.Add(name, rec.FormatID);   // B2019-006: add imported format to existing so derived format can find parent
					}
				}
				isImported = true;
				_DidUCF = true;
				return true;
			}
			catch (Exception ex)
			{
				MessageBox.Show(ex.StackTrace, ex.Message, MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
				_MyLog.Warn("Failed during UC Formats Import", ex);
				this.Close();
				isImported = false;
				return false;
			}
		}
		private bool TryToImportProcedure(ref bool isImported, ref bool canceledPressed)
		{
			try
			{
				return ImportProcedure(ref isImported, ref canceledPressed);
			}
			catch (Exception ex)
			{
				MessageBox.Show(ex.StackTrace, ex.Message, MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
				_MyLog.Warn("Failed during Procedure Import", ex);
				this.Close();
				return false;
			}
		}
		// B2020-095 exported files generated from approval has "APPROVED_REV_" in the file name
		//           if found, then sent the ImportingApprovedExportFile flag to true.
		private bool _ImportingApprovedExportFile = false;
		private bool ImportingApprovedExport(string fnAndPath)
		{
			bool rtnval = false;
			int idx = fnAndPath.LastIndexOf("//") + 1;
			string tmp = fnAndPath.Substring(idx);
			rtnval = tmp.ToUpper().Contains("APPROVED_REV_");
			return rtnval;
		}
		private bool ImportProcedure(ref bool isImported, ref bool canceledPressed)
		{
			_ImportingApprovedExportFile = ImportingApprovedExport(txtImport.Text); //B2020-095 see if import file was generated from Approved (versions) menu
			XmlDocument xd = new XmlDocument();
			xd.Load(txtImport.Text);
			pbImportProcedure.Maximum = 1;
			XmlNode ucf = xd.SelectSingleNode("ucformats");	// B2019-014: Check contents of import file for compatible operation
			if (ucf != null)
			{
				MessageBox.Show("A User Control of Format export file can only be imported from Administration on the V-Button.", "Import Failed", MessageBoxButtons.OK);
				this.Cursor = Cursors.Default;
				this.btnImport.Enabled = true; // allow user to select a different export file to import
				this.btnCloseImport.Enabled = true;  // allow user to close import dialog
				return false;
			}
			string rofolderpath = xd.DocumentElement.Attributes.GetNamedItem("rofolderpath").InnerText;
			int rodbid = int.Parse(xd.DocumentElement.Attributes.GetNamedItem("rodbid").InnerText);
			int rofstid = int.Parse(xd.DocumentElement.Attributes.GetNamedItem("rofstid").InnerText);
			if (MyDocVersion.DocVersionAssociationCount > 0)
			{
				// use current ROPath
				MyRODb = RODb.GetJustRoDb(MyDocVersion.DocVersionAssociations[0].MyROFst.MyRODb.RODbID);
				// if the current RO Path and the import file RO Path are not the same
				//  then ask if we should import using the current workingdraft RO Path, convert the ROs to text, or cancel the import
				if (MyRODb.FolderPath != rofolderpath && !_ImportingApprovedExportFile) //B2020-095 don't display dialog if importing approved procedure export file
				{
					dlgImpHowToHandleROs dlg = new dlgImpHowToHandleROs();
					dlg.ImportedROFolder = rofolderpath;
					dlg.WorkingDraftROFolder = MyRODb.FolderPath;
					dlg.ShowDialog(this);
					if (dlg.CancelImport)
					{
						this.Cursor = Cursors.Default;
						this.btnImport.Enabled = true; // allow user to select a different export file to import
						this.btnDoImport.Enabled = true; // allow user to change mind and perform the import
						return false; // Return False to Indicate that the Import did not succeed
					}
					_ConvertROsToTextDuringImport = dlg.ConvertROsToText;
				}
				// this saves the old RO database ID and the current RO database ID so that we can change the RODBIDs in the RO links
				newRODbID = MyRODb.RODbID;
				oldRODbID = rodbid;
			}
			else
			{
				#region NeedToSelectROPath
				// MyDocVersion does not have an RO database (ro folder path) assigned to it so we need to select an RO Path
				List<string> localROPaths = new List<string>();
				RODbInfoList rolist = RODbInfoList.Get();
				foreach (RODbInfo dbi in rolist)
				{
					if (dbi.FolderPath == rofolderpath && dbi.RODbID == rodbid)
					{
						MyRODb = RODb.GetJustRoDb(rodbid);
						oldRODbID = newRODbID = rodbid;
						break;
					}
					// B2016-175 have the correct (matching) RO Path but the rodbid is different (procedure came from a different SQL database)
					// We can use the RO Path but we need to change the rodbid in the RO links of the procedure we are importing
					else if (dbi.FolderPath == rofolderpath && dbi.RODbID != rodbid)
					{
						MyRODb = RODb.GetByFolderPath(rofolderpath);
						newRODbID = MyRODb.RODbID;
						oldRODbID = rodbid;
						break;
					}
					else
					{
						DirectoryInfo di = new DirectoryInfo(dbi.FolderPath);
						if (di.Exists)
							localROPaths.Add(dbi.FolderPath);
					}
				}
				if (MyRODb == null)
				{
					if (localROPaths.Count == 0)
					{
						MessageBox.Show("There has been no RO folder defined for this database.\r\n\r\nIn order to import a procedure, you need to assign a RO folder path.\r\n\r\nImport process will terminate.");
						this.Cursor = Cursors.Default;
						return false;// Return False to Indicate that the Import did not succeed
					}
					else
					{
						this.Cursor = Cursors.Default;
						dlgPickROFolder dlg = new dlgPickROFolder();
						dlg.ImportedROFolder = rofolderpath;
						dlg.LocalROFolders = localROPaths;
						dlg.ShowDialog(this);
						if ((dlg.SelectedROFolder ?? string.Empty) != string.Empty) // B2015-216 If the return value is null treat it like an empty string
						{
							MyRODb = RODb.GetByFolderPath(dlg.SelectedROFolder);
							RODbInfo myRODBInfo = RODbInfo.Get(MyRODb.RODbID);
							oldRODbID = newRODbID = MyRODb.RODbID;
							ROFstInfo fstInfo = null;
							foreach (ROFstInfo tmp in myRODBInfo.RODbROFsts)
								if (fstInfo == null || tmp.ROFstID > fstInfo.ROFstID)
									fstInfo = tmp;
							using (DocVersion dv = MyDocVersion.Get())
							{
								using (ROFst fst = fstInfo.Get())
								{
									dv.DocVersionAssociations.Add(fst);
									dv.Save();
								}
								dv.Reset_DocVersionAssociations();
								MyDocVersion.RefreshDocVersionAssociations();
							}
						}
						else
						{
							MessageBox.Show("Since you did not pick an existing RO folder defined for this database, the import process will terminate.");
							this.Close();// Close the Import Window
							return false;// Return False to Indicate that the Import did not succeed
						}
					}
				}
				#endregion
			} // end - need to select RO Path
			bool didImp = LoadFormats(xd, "procedure/formats/format");
			if (!didImp)
			{
				this.Cursor = Cursors.Default;
				this.btnImport.Enabled = true; // allow user to select a different export file to import
				this.btnDoImport.Enabled = true; // allow user to change mind and perform the import
				return false; // Return False to Indicate that the Import did not succeed
			}
			// use resolvedProcNum to determine if procedure is 'unique', i.e. if the procedure number exists
			// and user does not overwrite or copy, then the procedure should NOT be imported. Fix for B2016-045
			bool resolvedProcNum = true;
			foreach (ProcedureInfo pi in MyDocVersion.Procedures)
			{
				// procedure numbers that contain a hyphen may have the hyphen represented as the unicode character
				// '\u8209?' or the '-' character.  If proc number is same except for hyphen representation, they
				//  should be considered the same procedure (fix for B2016-084)
				string hyphenNum = pi.MyContent.Number == null ? "" : pi.MyContent.Number.Replace(@"\u8209?", "-").Replace("\u2011", "-").Replace(@"\u9586?", @"\").Replace("\u2572", @"\");
				string hyphenImpNum = xd.SelectSingleNode("procedure/content/@number").InnerText;
				// bug fix C2015-044 - jsj
				// - the cancel button would ignor the user's wishes and proceed with the import (overwriting the existing procedure)
				// - also found that the message about overwriting or making a copy wasn't appearing because we where not converting the import procedure number
				// - our standard unicode dash (\u8209?) before conparing the existing and imported
				// - also found the Overrite and make a copy of messages looked too similar - fixed that as well.
				//hyphenImpNum = hyphenImpNum == null ? "" : hyphenImpNum.Replace("\u8030?", "-"); -did not find any reason to have this \u8030? - note retested sourcesafe doc for B2016-084 without this logic and it was fine
				hyphenImpNum = hyphenImpNum == null ? "" : hyphenImpNum.Replace(@"\u8209?", "-").Replace("\u2011", "-").Replace(@"\u9586?", @"\").Replace("\u2572", @"\");

				if (hyphenNum == hyphenImpNum)
				{
					string msg = string.Format("The procedure you are importing{0}already exists in this procedure set.\n\nDo you want to OVERWRITE the existing procedure?", !hyphenImpNum.Equals("") ? string.Format(" ({0}) ", hyphenImpNum) : " ");
					DialogResult dr = MessageBox.Show(this, msg, "Overwrite Existing Procedure", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Stop);
					if (dr == DialogResult.Yes)
					{
						bool success = ImportProcedureOverwrite(xd, pi);		// C2018-020: check for successful Import
						if (!success)
						{
							canceledPressed = true;
							resolvedProcNum = false;
							break;
						}
						isImported = true;
						break;
					}
					if (dr == DialogResult.No)
					{
						msg = string.Format("Do you want to import {0} as a COPY of the existing procedure?\n\nThis will prefix the procedure number with \"Copy of\"", !hyphenImpNum.Equals("") ? string.Format("({0})", hyphenImpNum) : "the procedure");
						dr = MessageBox.Show(this, msg, "Create Copy Of Existing Procedure", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Stop);
						if (dr == DialogResult.Yes)
						{
							ImportProcedureCopy(xd);
							isImported = true;
							break;
						}
						else
							resolvedProcNum = false;
					}
					if (dr == System.Windows.Forms.DialogResult.Cancel)
					{
						canceledPressed = true;
						resolvedProcNum = false;
					}
					break; // user selected No or Cancel so break out of the foreach loop
				}
			}
			if (!canceledPressed && !isImported && resolvedProcNum)
			{
				ImportProcedureNew(xd);
				isImported = true;
			}
			if (isImported && UCFImportCase == E_UCFImportOptions.LoadForSetOnly) UpdateFormatForUCFInSet();
			return true;// Import Suceeded
		}
		private void UpdateFormatForUCFInSet()
		{
			// this gets called if the UCFImportCase == LoadForSetOnly, i.e. only items in this PROCEDURE Set whose formats point to a
			// UCF format should point to the updated (copied) UCF format.
			if (renamedUCFFormatId == null) return;
			foreach (int key in renamedUCFFormatId.Keys)
			{
				using (ContentInfoList cil = ContentInfoList.FixFormatIDAfterImport(MyDocVersion.VersionID.ToString(), renamedUCFFormatId[key], key))
				{
					foreach (ContentInfo ci in cil)
					{
						using (Content c = ci.Get())
						{
							ContentInfo.Refresh(c);
						}
					}
				}
			}
		}
		// Added Error Handling to assure that Change Manager is turned-on regardless of success or failure of the import
		// B2019-046: improved error handling (added return value & error message)
		private bool TryToLoadImportDataDocument()
		{
			try
			{
				bool retval = LoadImportDataDocument();
				return retval;
			}
			catch (Exception ex)
			{
				FlexibleMessageBox.Show("The import failed, check the error log for more information.", "Import Failed", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
				_MyLog.Warn("Failure During Import", ex);
			}
			return false;
		}
		private void ImportProcedureNew(XmlDocument xd)
		{
			//add imported procedure
			floatFoldout = new Dictionary<int, int>();
			importedFormat = new Dictionary<int, string>();
			existingFormat = new Dictionary<string, int>();
			FormatInfoList fil = FormatInfoList.Get();
			foreach (FormatInfo fi in fil)
			{
				importedFormat.Add(fi.FormatID, fi.Name);
				existingFormat.Add(fi.Name, fi.FormatID);
			}
			Old2NewItem = new Dictionary<int, int>();
			Old2NewContent = new Dictionary<int, int>();
			Old2NewLibDoc = new Dictionary<int, int>();
			GetExistingLibDocsList(); // B2019-035 better memory management
			PendingTransitions = new XmlDocument();
			XmlElement xe = PendingTransitions.CreateElement("transitions");
			PendingTransitions.AppendChild(xe);
			string fn = PEIPath + @"\transitions.xml";
			PendingTransitions.Save(fn);
			ProcedureInfo lastProcedure = null;
			foreach (ProcedureInfo pi in MyDocVersion.Procedures)
				lastProcedure = pi;
			_MyNewProcedure = AddProcedure(xd.DocumentElement, MyDocVersion, lastProcedure);
			//update transitions
			AddTransitions(PendingTransitions);
			PendingTransitions.Save(fn);
			FixFloatingFoldouts();
			//File.Delete(fn);
		}
		private void ImportProcedureCopy(XmlDocument xd)
		{
			floatFoldout = new Dictionary<int, int>();
			importedFormat = new Dictionary<int, string>();
			existingFormat = new Dictionary<string, int>();
			FormatInfoList fil = FormatInfoList.Get();
			foreach (FormatInfo fi in fil)
			{
				importedFormat.Add(fi.FormatID, fi.Name);
				existingFormat.Add(fi.Name, fi.FormatID);
			}
			Old2NewItem = new Dictionary<int, int>();
			Old2NewContent = new Dictionary<int, int>();
			Old2NewLibDoc = new Dictionary<int, int>();
			GetExistingLibDocsList(); // B2019-035 better memory management
			PendingTransitions = new XmlDocument();
			XmlElement xe = PendingTransitions.CreateElement("transitions");
			PendingTransitions.AppendChild(xe);
			string fn = PEIPath + @"\transitions.xml";
			PendingTransitions.Save(fn);
			ProcedureInfo lastProcedure = null;
			//determine count of existing procedures with same number
			string number = xd.SelectSingleNode("procedure/content/@number").InnerText;

			// kbr - could replace '-' with unicode in number, here.
			int count = 0;
			foreach (ProcedureInfo pi in MyDocVersion.Procedures)
			{
				lastProcedure = pi;
				if (pi.MyContent.Number.EndsWith(number))
					count++;
			}
			xd.SelectSingleNode("procedure/content/@number").InnerText = string.Format("Copy({0}) of {1}", count.ToString(), number);
			//add imported procedure and copy count
			_MyNewProcedure = AddProcedure(xd.DocumentElement, MyDocVersion, lastProcedure);
			//update transitions
			AddTransitions(PendingTransitions);
			FixFloatingFoldouts();
			File.Delete(fn);
		}
		private bool ImportProcedureOverwrite(XmlDocument xd, ProcedureInfo pi)
		{
			floatFoldout = new Dictionary<int, int>();
			importedFormat = new Dictionary<int, string>();
			existingFormat = new Dictionary<string, int>();
			FormatInfoList fil = FormatInfoList.Get();
			foreach (FormatInfo fi in fil)
			{
				importedFormat.Add(fi.FormatID, fi.Name);
				existingFormat.Add(fi.Name, fi.FormatID);
			}
			Old2NewItem = new Dictionary<int, int>();
			Old2NewContent = new Dictionary<int, int>();
			Old2NewLibDoc = new Dictionary<int, int>();
			GetExistingLibDocsList(); // B2019-035 better memory management
			PendingTransitions = new XmlDocument();
			XmlElement xe = PendingTransitions.CreateElement("transitions");
			PendingTransitions.AppendChild(xe);
			string fn = PEIPath + @"\transitions.xml";
			PendingTransitions.Save(fn);
			ProcedureInfo lastProcedure = null;
			//delete old procedure
			foreach (ProcedureInfo lp in MyDocVersion.Procedures)
				lastProcedure = lp;
			//delete opi
			try
			{
				TurnChangeManagerOn.Execute(); // Import Turns off the Change Manager - Delete needs to have it on
				Item.DeleteItemAndChildren(pi);
				TurnChangeManagerOff.Execute(); // Assure that the Change Manager is off
			}
			catch (Exception ex)
			{
				// C2018-020: cannot overwrite the procedure because transitions point to this.  Show dialog listing transitions and then
				//   return false to flag that import was not successful.
				if (ex.Message.Contains("has External Transitions"))
				{
					using (TransitionInfoList exTrans = TransitionInfoList.GetExternalTransitionsToChildren(pi.ItemID))
					{
						DialogResult ans = MessageBox.Show("Transitions exist to this procedure and cannot be adjusted automatically." +
							"\r\nSteps with Problem Transitions:" +
							exTrans.Summarize(),
							"Cannot Overwrite Procedure", MessageBoxButtons.OK, MessageBoxIcon.Question);
					}
				}
				else
					MessageBox.Show(ex.Message, "SQL Exception", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
				File.Delete(fn);
				TurnChangeManagerOff.Execute(); // Assure that the Change Manager is off
				return false;
			}
			//add imported procedure
			_MyNewProcedure = AddProcedure(xd.DocumentElement, MyDocVersion, lastProcedure);
			//update transitions
			AddTransitions(PendingTransitions);
			FixFloatingFoldouts();
			return true;
		}
		private bool LoadImportDataDocument()
		{
			floatFoldout = new Dictionary<int, int>();
			ZipEntry ze = MyExpxZipFile[0];
			string fn = PEIPath + @"\" + ze.FileName;
			ze.Extract(PEIPath, ExtractExistingFileAction.OverwriteSilently);
			XmlDocument xd = new XmlDocument();
			xd.Load(fn);
			bool didImp = LoadFormats(xd, "folder/formats/format");
			if (!didImp)
			{
				this.Cursor = Cursors.Default;
				this.btnImport.Enabled = true; // allow user to select a different export file to import
				this.btnDoImport.Enabled = true; // allow user to change mind and perform the import
				return false; // Return False to Indicate that the Import did not succeed
			}
			string name = xd.DocumentElement.Attributes.GetNamedItem("name").InnerText;
			Folder ff = AddFolder(Folder.Get(MyFolder.FolderID), xd, name);
			if (ff == null)
			{
				// C2020-032: Import Procedure set when existing name exists, allow user to import with 'Copy (#) of'. 
				//	This is similar functionality to the import of a procedure without the overwrite part.
				string msg = string.Format("The procedure set you are importing, {0}, already exists.\n\nDo you want to import {0} as a COPY of the existing set?\n\nThis will prefix the name with \"Copy (#) of\"", name);
				DialogResult dr = MessageBox.Show(this, msg, "Create Copy Of Existing Procedure Set", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Stop);
				if (dr == DialogResult.Yes)
				{
					string number = "";
					int max = -1;
					// get maximum number of existing copies.
					foreach (FolderInfo fi in MyFolder.ChildFolders)
					{
						int indx = fi.Name.IndexOf("Copy (");
						if (indx > -1)
						{
							int indxend = fi.Name.IndexOf(")", indx);
							if (indxend > indx)
							{
								string tmp = fi.Name.Substring(indx + 6, indxend - (indx + 6));
								int ii = Convert.ToInt32(tmp);
								if (ii > max) max = ii;
							}
						}
					}
					number = max > -1 ? (max + 1).ToString() : "1";
					name = string.Format("Copy ({0}) of {1}", number, name);

					ff = AddFolder(Folder.Get(MyFolder.FolderID), xd, name);
				}
				else
					return false;
			}
			_MyNewFolder = FolderInfo.Get(ff.FolderID);
			AddAnnotationTypes(xd);
			DocVersionInfo dvi = AddDocVersion(ff, xd);
			MyDocVersion = dvi;
			xd = null;
			lblImportStatus.Text = "Creating Procedures...";
			Application.DoEvents();
			ProcedureInfo pi = null;
			pbImportProcedure.Value = 0;
			pbImportProcedure.Maximum = MyExpxZipFile.Entries.Count - 1;
			for (int i = 1; i < MyExpxZipFile.Entries.Count; i++)
			{
				ze = MyExpxZipFile[i];
				fn = PEIPath + @"\" + ze.FileName;
				ze.Extract(PEIPath, ExtractExistingFileAction.OverwriteSilently);
				xd = new XmlDocument();
				xd.Load(fn);
				pi = AddProcedure(xd.DocumentElement, dvi, pi);
				GC.Collect(); // need to cleanup memory after importing each procedure due to use of Regular Expressions in processing RO and Transition links
			}
			DirectoryInfo di = new DirectoryInfo(PEIPath);
			DirectoryInfo[] dis = di.GetDirectories();
			for (int d = 0; d < dis.Length; d++)
				dis[d].Delete(true);
			lblImportStatus.Text = "Updating Transitions";
			AddTransitions();
			FixFloatingFoldouts();
			SaveTransitionAndItemContentIDs();
			return true;
		}
		private void FixSectionStart(ProcedureInfo pi)
		{
			Content c = Content.Get(pi.MyContent.ContentID);
			XmlDocument xd = new XmlDocument();
			// If the config field is empty, add an empty xml node.
			if (c.Config == "") c.Config = "<Config/>";
			xd.LoadXml(c.Config);
			XmlNode xn = xd.SelectSingleNode("Config/Procedure/@SectionStart");
			if (xn != null)
			{
				int iid = int.Parse(xn.InnerText);
				if (Old2NewItem.ContainsKey(iid))
					iid = Old2NewItem[iid];
				else
				{
					int oldid = iid;
					iid = pi.ItemID;
					XmlAttribute xa = xd.CreateAttribute("ErrorSectionStart");
					xa.InnerText = oldid.ToString();
					XmlNode xp = xd.SelectSingleNode("Config/Procedure");
					xp.Attributes.SetNamedItem(xa);
				}
				xn.InnerText = iid.ToString();
				c.Config = xd.OuterXml;
				c.Save();
			}
		}
		private void FixFloatingFoldouts()
		{
			foreach (int key in floatFoldout.Keys)
			{
				lblImportStatus.Text = "Updating Floating Foldouts";
				int cid = Old2NewContent[key];
				int iid = Old2NewItem[floatFoldout[key]];
				Content c = Content.Get(cid);
				XmlDocument xd = new XmlDocument();
				xd.LoadXml(c.Config);
				XmlNode xn = xd.SelectSingleNode("Config/Step/@FloatingFoldout");
				xn.InnerText = iid.ToString();
				c.Config = xd.OuterXml;
				c.Save();
			}
		}
		private E_UCFImportOptions UCFImportDefaultFromSettings;
		private E_UCFImportOptions UCFImportCase = E_UCFImportOptions.LoadOnlyImported;
		Dictionary<string, string> existingCopyFCName = new Dictionary<string, string>();
		// note that this is used when importing a folder or a procedure (procedure was added for UCF changes)
		private bool LoadFormats(XmlDocument xd, string xmlpath)
		{
			existingFormat = new Dictionary<string, int>();
			FormatInfoList fil = FormatInfoList.Get();
			foreach (FormatInfo fi in fil)
				existingFormat.Add(fi.Name, fi.FormatID);

			importedFormat = new Dictionary<int, string>();
			XmlNodeList nl = xd.SelectNodes(xmlpath);

			bool conflictingUCFdata = false;
			List<string> existingFC = new List<string>();
			List<string> importedFC = new List<string>();
			List<string> fname = new List<string>();

			foreach (XmlNode nd in nl)
			{
				string copyOfUCF = null;
				// see if any of the imported formats are 'UCF' formats, i.e. have config data.  If they are UCF,
				// see if this is different that what is in the database.  If it is, the user needs to decide 
				// whether to associate sections with existing UCF format or the new one.  All UCF formats will be
				// connected the same way, i.e. existing or new.
				int formatid = int.Parse(nd.Attributes.GetNamedItem("formatid").InnerText);
				string name = nd.Attributes.GetNamedItem("name").InnerText;
				string config = null;
				XmlNode cfg = nd.Attributes.GetNamedItem("config");
				if (cfg != null) config = cfg.InnerText;
				if (existingFormat.ContainsKey(name) && config != null && config != "")
				{
					FormatInfo exFI = FormatInfo.Get(existingFormat[name]);
					if (exFI.Config != config && exFI.Config != "" && exFI.Config != null && config != "" && config != null)
					{
						// See if there are copies of this UCF format, if so, this may match (have same config) one of those and should
						// use it before stating there is conflicting data.
						copyOfUCF = ContentsOfUCFExists(name, config);
						if (copyOfUCF == null)
						{
							existingFC.Add(exFI.Config);
							importedFC.Add(config);
							conflictingUCFdata = true;
							fname.Add(name);
						}
						else
							existingCopyFCName.Add(name, copyOfUCF);
					}
				}
			}

			// there is a difference in UCF data, see if user wants sections to use the existing or new ucf data:
			if (conflictingUCFdata)
			{
				// Bring up dialog to allow user to choose how the UCF data is handled:
				// Importing of a procedure(s) (names of UCF exist in current DB and in exported DB)
				//Case 0 - ignore (don't bring in new UCF)
				//Case 1 - bringing in new UCF and not using it
				//Case 2 - bringing in new UCF and only using it for imported data
				//Case 3 - bringing in new UCF and using it across the board
				//Case 4 - bringing in new UCF and using it for the current procedure set  (not applicable for procedure sets)
				UCFImportCase = UCFImportDefaultFromSettings;		// from the options/settings
				dlgUCFImportOptions ucfoptDlg = new dlgUCFImportOptions(fname, existingFC, importedFC, UCFImportCase, xmlpath);
				DialogResult dr = ucfoptDlg.ShowDialog();
				if (dr != DialogResult.OK) return false;
				UCFImportCase = ucfoptDlg.UCFImportOptionsCase;	// may be reset from dialog.
			}
			// first see if any of the imported formats have different data.  If so, 
			foreach (XmlNode nd in nl)
			{
				int formatid = int.Parse(nd.Attributes.GetNamedItem("formatid").InnerText);
				string name = nd.Attributes.GetNamedItem("name").InnerText;
				string config = null;
				XmlNode cfg = nd.Attributes.GetNamedItem("config");
				if (cfg != null) config = cfg.InnerText;
				// B2020-084 GetNmaedItems was returning a null for pname.
				//           Only get the pname text if the pname attribute is found
				//           If there is no pname, then don't try to process and continue on with the next XML Node in the node list
				string pname = null;
				XmlNode pnameAttrib = nd.Attributes.GetNamedItem("pname");
				if (pnameAttrib != null)
					pname = pnameAttrib.InnerText;
				if (pname == null) continue;
				string description = null;
				XmlNode descript = nd.Attributes.GetNamedItem("description");
				if (descript != null) description = descript.InnerText;
				string userid = nd.Attributes.GetNamedItem("userid").InnerText;
				DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
				// If the format that is being imported exists as a copy (already was imported and a 'Copy x of name' was created) and the imported and 
				// existing config match, use the existing (copied) format's name rather than importing it again (the dictionary was set up during
				// the import formats process.
				if (existingCopyFCName.ContainsKey(name)) name = existingCopyFCName[name];

				// compare this imported format to the original in the database.
				// If format name exists, or if it has same config data, just use it.  
				if (existingFormat.ContainsKey(name))
				{
					// Note that Data & Genmac fields can have different contents.  The format information should always be used from
					// the original database, not the export file.  So no processing is done on these fields when exporting & importing.
					// Data or Genmac can be different if formats were updated in one database & not the other.
					FormatInfo exFI = FormatInfo.Get(existingFormat[name]);
					if ((exFI.Config == config || ((exFI.Config == "" || exFI.Config == null) && (config == "" || config == null))))
					{
						// importedFormat is used to set correct formatid on imported sections (if different formatid <-> name between 
						// the current database and the one from which export came)
						importedFormat.Add(formatid, name);
						continue;		// go on to next format in import list
					}
				}
				// parent format will always be in there, if it is a new format, it will be added before the child.  Check just in case (no null reference).
				if (!existingFormat.ContainsKey(pname)) break;
				int pid = existingFormat[pname];
				Format pformat = Format.Get(pid);

				// if the new format doesn't exist, it will be added (after these other checks).  Otherwise, handle the
				// various cases listed above:
				if (existingFormat.ContainsKey(name))
				{
					// if case 0 and this ucf already exists, ignore it:
					if (UCFImportCase == E_UCFImportOptions.Ignore) continue;

					// if case 1, 2, 4 and the name exists, make a 'copy' of the newly imported format:
					// need to add this format - name must be unique so add 'COPY(x) of 'original name'' where x is unique number:
					if (UCFImportCase == E_UCFImportOptions.LoadNotUsed || UCFImportCase == E_UCFImportOptions.LoadOnlyImported || UCFImportCase == E_UCFImportOptions.LoadForSetOnly)
					{
						int count = 0;
						foreach (FormatInfo fi in fil) if (fi.Name.EndsWith(name)) count++;
						if (count > 0)
						{
							string origname = name;
							name = string.Format("Copy {0} of {1}", count.ToString(), name);
							if (UCFImportCase == E_UCFImportOptions.LoadOnlyImported || UCFImportCase == E_UCFImportOptions.LoadForSetOnly)
							{
								if (renamedUCFFormatName == null) renamedUCFFormatName = new Dictionary<string, string>();
								renamedUCFFormatName.Add(origname, name);
							}
						}
					}
					// if case 3, take the existing config data and create in a record whose name is Old(x) of 'original name' (the record
					// creation gets done below).  Then modify the existing record to have the config data.  The result is that any
					// sections that used this UCF throughout the database will have the new config data.
					if (UCFImportCase == E_UCFImportOptions.LoadUseAll)
					{
						string savname = name;
						int count = 0;
						foreach (FormatInfo fi in fil) if (fi.Name.EndsWith(name)) count++;
						if (count > 0)
						{
							name = string.Format("Old {0} of {1}", count.ToString(), name);
						}
						// update the 'old' record by getting the original config data.
						string savdesc = null;
						DateTime savdts = DateTime.Now;
						string savuid = null;
						int savpar = 0;
						string savconfig = null;
						using (Format origRecord = Format.Get(existingFormat[savname]))
						{
							savdesc = origRecord.Description;
							savdts = origRecord.DTS;
							savuid = origRecord.UserID;
							savpar = origRecord.ParentID;
							savconfig = origRecord.Config;
							origRecord.Name = savname;
							origRecord.Description = description;
							origRecord.DTS = dts;
							origRecord.UserID = userid;
							origRecord.MyParent = pformat;
							origRecord.Config = config;
							origRecord.Save();
							description = savdesc;
							dts = savdts;
							userid = savuid;
							pformat = Format.Get(savpar);
							config = savconfig;

						}
					}

				}
				if (UCFImportCase == 0)		// ignore it
				{
					importedFormat.Add(formatid, name);
				}
				else
				{
					Format rec = Format.MakeFormat(pformat, name, description, null, null, dts, userid);
					rec.Config = config;
					rec.Save();
					if (UCFImportCase == E_UCFImportOptions.LoadNotUsed || UCFImportCase == E_UCFImportOptions.LoadUseAll)   // don't reset format id (case 1 don't use it, case 3 copies new data into original record
						importedFormat.Add(formatid, name);
					else if (UCFImportCase == E_UCFImportOptions.LoadOnlyImported || UCFImportCase == E_UCFImportOptions.LoadForSetOnly)		// case 2 uses it for any items imported, case 4 uses it for any sections within current set
					{
						existingFormat.Add(name, rec.FormatID);		// change to original name?
						importedFormat.Add(rec.FormatID, name);

						// get format id for the original named format
						if (UCFImportCase == E_UCFImportOptions.LoadForSetOnly && renamedUCFFormatName != null)
						{
							int origformatid = -1;
							foreach (var kvp in renamedUCFFormatName)
							{
								if (kvp.Value == name)
								{
									origformatid = existingFormat[kvp.Key];
									break;
								}
							}
							if (origformatid != -1)
							{
								if (renamedUCFFormatId == null) renamedUCFFormatId = new Dictionary<int, int>();
								renamedUCFFormatId.Add(rec.FormatID, origformatid);
							}
						}
					}
				}
			}
			FormatInfoList.Reset();
			return true;
		}

		private string ContentsOfUCFExists(string name, string config)
		{
			// See if there is an existing format file that was created as a copy.  If so, check if the passed in format's
			// config is the same as an existing 'Copy of' format - if so, use rather than importing the same format as
			// defined by config.
			foreach (var existname in existingFormat)
			{
				if (existname.Key.Contains(name))
				{
					string cpy = existname.Key;
					if (cpy.StartsWith("Copy") && cpy.Contains("of " + name))
					{
						FormatInfo exFI = FormatInfo.Get(existingFormat[cpy]);
						if (exFI.Config == config) return cpy;
					}
				}
			}
			return null;
		}

		//jsj 4-29-2016 appears to not be used
		//Dictionary<int, ItemInfo> dicParentItem = null;
		//private void UpdateParentItem(int depth, ItemInfo ii)
		//{
		//	if (dicParentItem == null) dicParentItem = new Dictionary<int, ItemInfo>();
		//	if (!dicParentItem.ContainsKey(depth)) dicParentItem.Add(depth, null);
		//	dicParentItem[depth] = ii;
		//}

		//jsj 4-29-2016 appears to not be used
		//Dictionary<int, ItemInfo> dicPreviousItem = null;
		//private void UpdatePreviousItem(int depth, ItemInfo ii)
		//{
		//	if (dicPreviousItem == null) dicPreviousItem = new Dictionary<int, ItemInfo>();
		//	if (!dicPreviousItem.ContainsKey(depth)) dicPreviousItem.Add(depth, null);
		//	dicPreviousItem[depth] = ii;
		//}

		Dictionary<int, int> dicItemDepth = null;

		// jsj 4-29-2016 appears to not be used
		//private void UpdateItemDepth(int depth, int id)
		//{
		//	if (dicItemDepth == null) dicItemDepth = new Dictionary<int, int>();
		//	if (!dicItemDepth.ContainsKey(depth)) dicItemDepth.Add(depth, 0);
		//	dicItemDepth[depth] = id;
		//}
		// jsj 2016Feb17 - this appears to not be used
		//private void LoadImportDataReader()
		//{
		//	int pCount = 0;
		//	int sCount = 0;
		//	Folder folder = null;
		//	DocVersion docversion = null;
		//	Dictionary<string, string> dicRofst = null;
		//	Dictionary<string, string> dicEntry = null;
		//	ROFst rofst = null;
		//	GetImportDataCounts();
		//	pbImportProcedure.Maximum = MyCounts.Count;
		//	pbImportProcedure.Value = 0;
		//	Application.DoEvents();
		//	FileStream fs = File.OpenRead(txtImport.Text);
		//	XmlReaderSettings rs = new XmlReaderSettings();
		//	rs.CheckCharacters = false;
		//	XmlReader xr = XmlReader.Create(fs, rs);
		//	while (xr.Read())
		//	{
		//		if (xr.IsStartElement())
		//		{
		//			switch (xr.Name)
		//			{
		//				case "annotation":
		//					AddAnnotation(xr);
		//					break;
		//				//case "association":
		//				//  break;
		//				case "content":
		//					{
		//						if (xr.Depth == 3)	//content for procedure
		//						{
		//							ItemInfo ii = AddProcedure(xr, docversion, dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
		//							UpdatePreviousItem(xr.Depth, ii);
		//							UpdateParentItem(xr.Depth, ii);
		//						}
		//						else
		//						{

		//							int fromtype = dicItemDepth.ContainsKey(xr.Depth - 2) ? dicItemDepth[xr.Depth - 2] : 0;
		//							switch (fromtype)
		//							{
		//								case 2:
		//									{	//sections
		//										ItemInfo ii = AddSection(xr, dicParentItem[xr.Depth], dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
		//										UpdatePreviousItem(xr.Depth, ii);
		//										UpdateParentItem(xr.Depth, ii);
		//										break;
		//									}
		//								case 3:
		//									{	//cautions
		//										ItemInfo ii = AddCaution(xr, dicParentItem[xr.Depth], dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
		//										UpdatePreviousItem(xr.Depth, ii);
		//										UpdateParentItem(xr.Depth, ii);
		//										break;
		//									}
		//								case 4:
		//									{	//notes
		//										ItemInfo ii = AddNote(xr, dicParentItem[xr.Depth], dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
		//										UpdatePreviousItem(xr.Depth, ii);
		//										UpdateParentItem(xr.Depth, ii);
		//										break;
		//									}
		//								case 5:
		//									{	//rnos
		//										ItemInfo ii = AddRNO(xr, dicParentItem[xr.Depth], dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
		//										UpdatePreviousItem(xr.Depth, ii);
		//										UpdateParentItem(xr.Depth, ii);
		//										break;
		//									}
		//								case 6:
		//									{	//steps
		//										ItemInfo ii = AddStep(xr, dicParentItem[xr.Depth], dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
		//										UpdatePreviousItem(xr.Depth, ii);
		//										UpdateParentItem(xr.Depth, ii);
		//										break;
		//									}
		//								case 7:
		//									{	//tables
		//										ItemInfo ii = AddTable(xr, dicParentItem[xr.Depth], dicPreviousItem[xr.Depth], dicItemDepth[xr.Depth]);
		//										UpdatePreviousItem(xr.Depth, ii);
		//										UpdateParentItem(xr.Depth, ii);
		//										break;
		//									}
		//								default:
		//									break;
		//							}
		//						}
		//						break;
		//					}
		//				case "document":
		//					AddDocument(xr, dicEntry);
		//					break;
		//				case "docversion":
		//					{
		//						docversion = AddDocVersion(folder, xr);
		//						UpdatePreviousItem(xr.Depth + 2, null);
		//						break;
		//					}
		//				case "entry":
		//					dicEntry = AddEntry(xr);
		//					break;
		//				case "folder":
		//					folder = AddFolder(Folder.Get(MyFolder.FolderID), xr);
		//					break;
		//				case "grid":
		//					AddGrid(xr);
		//					break;
		//				case "procedure":
		//					{
		//						UpdateItemDepth(xr.Depth + 1, int.Parse(xr.GetAttribute("itemid")));
		//						pbImportProcedure.PerformStep();
		//						lblImportProcedure.Text = string.Format("{0} of {1} Procedures", pbImportProcedure.Value.ToString(), pbImportProcedure.Maximum.ToString());
		//						pCount++;
		//						pbImportSection.Maximum = MyCounts[pCount].Count;
		//						pbImportSection.Value = 0;
		//						sCount = 0;
		//						Application.DoEvents();
		//						break;
		//					}
		//				case "section":
		//					{
		//						UpdateItemDepth(xr.Depth + 1, int.Parse(xr.GetAttribute("itemid")));
		//						pbImportSection.PerformStep();
		//						lblImportSection.Text = string.Format("{0} of {1} Sections", pbImportSection.Value.ToString(), pbImportSection.Maximum.ToString());
		//						sCount++;
		//						pbImportStep.Maximum = MyCounts[pCount][sCount];
		//						pbImportStep.Value = 0;
		//						Application.DoEvents();
		//						break;
		//					}
		//				case "step":
		//					{
		//						UpdateItemDepth(xr.Depth + 1, int.Parse(xr.GetAttribute("itemid")));
		//						if (xr.Depth == 8)
		//						{
		//							pbImportStep.PerformStep();
		//							lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
		//							Application.DoEvents();
		//						}
		//						break;
		//					}
		//				case "caution":
		//				case "note":
		//				case "rno":
		//				case "table":
		//					UpdateItemDepth(xr.Depth + 1, int.Parse(xr.GetAttribute("itemid")));
		//					break;
		//				case "cautions":
		//				case "notes":
		//				case "rnos":
		//				case "sections":
		//				case "steps":
		//				case "tables":
		//					{
		//						UpdateItemDepth(xr.Depth, int.Parse(xr.GetAttribute("fromtype")));
		//						UpdatePreviousItem(xr.Depth + 2, null);
		//						UpdateParentItem(xr.Depth + 2, dicParentItem[xr.Depth - 1]);
		//						break;
		//					}
		//				case "rodb":
		//					{
		//						MyRODb = AddRODb(xr);
		//						rofst = AddROFst(dicRofst);
		//						docversion.DocVersionAssociations.Add(rofst);
		//						docversion.Save();
		//						break;
		//					}
		//				case "rofst":
		//					dicRofst = GetROFstData(xr);
		//					break;
		//				case "rousage":
		//					AddROUsage(xr);
		//					break;
		//				//case "transition":
		//				//  break;
		//				default:
		//					break;
		//			}
		//			Console.WriteLine("{0} - {1}", xr.Name, xr.Depth.ToString());
		//		}
		//	}
		//	pbImportProcedure.PerformStep();
		//	Application.DoEvents();
		//	fs.Close();
		//	FixImportDataTransitions();
		//	StoreItemContentIDs();
		//	ResolveExternalTransitions(folder);
		//}

		// This is called only when we are importing an entire folder.
		// if there is a .impx file (a zip file generated from the last folder export file and based on location -folder name- of the export file you are importing), then it updates it with new values, 
		// else it will create a .impx file, and saves the id information listed below.
		// This will create and save the ItemIDs (old and new), ContentIDs (old andnew), library document IDs (old and new), and pending transitions each in their own xml file
		// the xml files are then added (or replaced) in the .impx file.
		private void SaveTransitionAndItemContentIDs()
		{
			XmlDocument xd = new XmlDocument();
			XmlElement xe = xd.CreateElement("items");
			xd.AppendChild(xe);
			string fn = PEIPath + @"\items.xml";
			foreach (int key in Old2NewItem.Keys)
			{
				xe = xd.CreateElement("item");
				xe.Attributes.SetNamedItem(AddAttribute(xd, "old", key.ToString()));
				xe.Attributes.SetNamedItem(AddAttribute(xd, "new", Old2NewItem[key].ToString()));
				xd.DocumentElement.AppendChild(xe);
			}
			xd.Save(fn);
			ZipEntry ze = MyImpxZipFile["items.xml"];
			MyImpxZipFile.RemoveEntry(ze);
			MyImpxZipFile.Save();
			MyImpxZipFile.AddFile(fn, "");
			MyImpxZipFile.Save();
			File.Delete(fn);
			xd = new XmlDocument();
			xe = xd.CreateElement("contents");
			xd.AppendChild(xe);
			fn = PEIPath + @"\contents.xml";
			foreach (int key in Old2NewContent.Keys)
			{
				xe = xd.CreateElement("content");
				xe.Attributes.SetNamedItem(AddAttribute(xd, "old", key.ToString()));
				xe.Attributes.SetNamedItem(AddAttribute(xd, "new", Old2NewContent[key].ToString()));
				xd.DocumentElement.AppendChild(xe);
			}
			xd.Save(fn);
			ze = MyImpxZipFile["contents.xml"];
			MyImpxZipFile.RemoveEntry(ze);
			MyImpxZipFile.Save();
			MyImpxZipFile.AddFile(fn, "");
			MyImpxZipFile.Save();
			File.Delete(fn);
			xd = new XmlDocument();
			xe = xd.CreateElement("transitions");
			xd.AppendChild(xe);
			fn = PEIPath + @"\transitions.xml";
			if (PendingTransitions != null && PendingTransitions.DocumentElement.HasChildNodes)
			{
				foreach (XmlNode nd in PendingTransitions.DocumentElement.ChildNodes)
				{
					if (nd.InnerText == "")
						xd.DocumentElement.AppendChild(xd.ImportNode(nd, true));
				}
			}
			xd.Save(fn);
			ze = MyImpxZipFile["transitions.xml"];
			MyImpxZipFile.RemoveEntry(ze);
			MyImpxZipFile.Save();
			MyImpxZipFile.AddFile(fn, "");
			MyImpxZipFile.Save();
			File.Delete(fn);
		}
		// appears to not be used - jsj 4-28-2016
		//private void StoreItemContentIDs()
		//{
		//	XmlDocument xd = new XmlDocument();
		//	string fn = PEIPath + @"\ExternalTransitions.xml";
		//	xd.Load(fn);
		//	XmlElement xe = (XmlElement)xd.SelectSingleNode("externaltransitions/oldtonewitem");
		//	foreach (int key in Old2NewItem.Keys)
		//	{
		//		XmlElement xee = xd.CreateElement("item");
		//		XmlAttribute xa = AddAttribute(xd, "old", key.ToString());
		//		xee.Attributes.SetNamedItem(xa);
		//		xa = AddAttribute(xd, "new", Old2NewItem[key].ToString());
		//		xee.Attributes.SetNamedItem(xa);
		//		xe.AppendChild(xee);
		//	}
		//	xd.Save(fn);
		//	xe = (XmlElement)xd.SelectSingleNode("externaltransitions/oldtonewcontent");
		//	foreach (int key in Old2NewContent.Keys)
		//	{
		//		XmlElement xee = xd.CreateElement("content");
		//		XmlAttribute xa = AddAttribute(xd, "old", key.ToString());
		//		xee.Attributes.SetNamedItem(xa);
		//		xa = AddAttribute(xd, "new", Old2NewContent[key].ToString());
		//		xee.Attributes.SetNamedItem(xa);
		//		xe.AppendChild(xee);
		//	}
		//	xd.Save(fn);
		//}
		//private void ResolveExternalTransitions(Folder folder)
		//{
		//	XmlDocument xd = new XmlDocument();
		//	string fn = PEIPath + @"\ExternalTransitions.xml";
		//	xd.Load(fn);
		//	AddStoredItemContentIDs(xd);
		//	XmlNodeList nl = xd.SelectNodes("//transition[@folder!='']");
		//	foreach (XmlNode nd in nl)
		//	{
		//		int transitionid = int.Parse(nd.Attributes.GetNamedItem("transitionid").InnerText);
		//		int fromid = int.Parse(nd.Attributes.GetNamedItem("fromid").InnerText);
		//		int toid = int.Parse(nd.Attributes.GetNamedItem("toid").InnerText);
		//		int rangeid = int.Parse(nd.Attributes.GetNamedItem("rangeid").InnerText);
		//		if (Old2NewContent.ContainsKey(fromid) && Old2NewItem.ContainsKey(toid) && Old2NewItem.ContainsKey(rangeid))
		//		{
		//			int isrange = int.Parse(nd.Attributes.GetNamedItem("isrange").InnerText);
		//			int trantype = int.Parse(nd.Attributes.GetNamedItem("trantype").InnerText);
		//			string config = nd.Attributes.GetNamedItem("config").InnerText;
		//			string userid = nd.Attributes.GetNamedItem("userid").InnerText;
		//			DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
		//			string lookfor;
		//			if (isrange == 0)
		//				lookfor = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
		//			else
		//				lookfor = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
		//			fromid = Old2NewContent[fromid];
		//			toid = Old2NewItem[toid];
		//			rangeid = Old2NewItem[rangeid];
		//			Content cc = Content.Get(fromid);
		//			Transition tt = Transition.MakeTransition(cc, Item.Get(toid), Item.Get(rangeid), isrange, trantype, config, dts, userid);
		//			transitionid = tt.TransitionID;
		//			string replacewith;
		//			if (isrange == 0)
		//				replacewith = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
		//			else
		//				replacewith = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
		//			cc.Text = cc.Text.Replace(lookfor, replacewith);
		//			cc.Save();
		//			nd.Attributes.GetNamedItem("folder").InnerText = "";
		//		}
		//	}
		//	xd.Save(fn);
		//}

		// This is called only when we are importing an entire folder and there is a .impx file (a zip file)
		// the name of the .impx file is based on the folder name containing the export file being imported
		// This will read in the saved ItemIDs (old and new), ContentIDs (old andnew), library document IDs (old and new), and pending transitions
		private void ReadTransitionAndItemContentIDs()
		{
			ZipEntry ze = MyImpxZipFile["items.xml"];
			ze.Extract(PEIPath, ExtractExistingFileAction.OverwriteSilently);
			string fn = PEIPath + @"\items.xml";
			XmlDocument xd = new XmlDocument();
			xd.Load(fn);
			// B2016-176, B2016-197  Transitions were no always properly resolved - don't load in the old item ids
			//XmlNodeList nl = xd.SelectNodes("//item");
			//foreach (XmlNode nd in nl)
			//{
			//	int oldid = int.Parse(nd.Attributes.GetNamedItem("old").InnerText);
			//	int newid = int.Parse(nd.Attributes.GetNamedItem("new").InnerText);
			//	//if (!Old2NewItem.ContainsKey(oldid))
			//		Old2NewItem.Add(oldid, newid);
			//}
			File.Delete(fn);
			ze = MyImpxZipFile["contents.xml"];
			ze.Extract(PEIPath, ExtractExistingFileAction.OverwriteSilently);
			fn = PEIPath + @"\contents.xml";
			xd = new XmlDocument();
			xd.Load(fn);
			// B2016-176, B2016-197  Transitions were no always properly resolved - don't load in the old content ids
			//nl = xd.SelectNodes("//content");
			//foreach (XmlNode nd in nl)
			//{
			//	int oldid = int.Parse(nd.Attributes.GetNamedItem("old").InnerText);
			//	int newid = int.Parse(nd.Attributes.GetNamedItem("new").InnerText);
			//	//if (!Old2NewContent.ContainsKey(oldid))
			//		Old2NewContent.Add(oldid, newid);
			//}
			File.Delete(fn);
			ze = MyImpxZipFile["libdocs.xml"];
			ze.Extract(PEIPath, ExtractExistingFileAction.OverwriteSilently);
			fn = PEIPath + @"\libdocs.xml";
			xd = new XmlDocument();
			xd.Load(fn);
			XmlNodeList nl = xd.SelectNodes("//libdoc");
			//nl = xd.SelectNodes("//libdoc");
			foreach (XmlNode nd in nl)
			{
				int oldid = int.Parse(nd.Attributes.GetNamedItem("old").InnerText);
				int newid = int.Parse(nd.Attributes.GetNamedItem("new").InnerText);
				//if (!Old2NewContent.ContainsKey(oldid))
				Old2NewLibDoc.Add(oldid, newid);
			}
			File.Delete(fn);
			ze = MyImpxZipFile["transitions.xml"];
			ze.Extract(PEIPath, ExtractExistingFileAction.OverwriteSilently);
			fn = PEIPath + @"\transitions.xml";
			PendingTransitions.Load(fn);
			File.Delete(fn);
		}
		// appears not to be used - jsj  4-28-2016
		//private void AddStoredItemContentIDs(XmlDocument xd)
		//{
		//	XmlNodeList nl = xd.SelectNodes("//item");
		//	foreach (XmlNode nd in nl)
		//	{
		//		int oldid = int.Parse(nd.Attributes.GetNamedItem("old").InnerText);
		//		int newid = int.Parse(nd.Attributes.GetNamedItem("new").InnerText);
		//		if (!Old2NewItem.ContainsKey(oldid))
		//			Old2NewItem.Add(oldid, newid);
		//	}
		//	nl = xd.SelectNodes("//content");
		//	foreach (XmlNode nd in nl)
		//	{
		//		int oldid = int.Parse(nd.Attributes.GetNamedItem("old").InnerText);
		//		int newid = int.Parse(nd.Attributes.GetNamedItem("new").InnerText);
		//		if (!Old2NewContent.ContainsKey(oldid))
		//			Old2NewContent.Add(oldid, newid);
		//	}
		//}

		// appears not to be used - jsj  4-28-2016
		//private void FixImportDataTransitions()
		//{
		//	XmlDocument xd = new XmlDocument();
		//	string fn = PEIPath + @"\ExternalTransitions.xml";
		//	if (!File.Exists(fn))
		//	{
		//		XmlElement xe = xd.CreateElement("externaltransitions");
		//		XmlElement xee = xd.CreateElement("oldtonewitem");
		//		xe.AppendChild(xee);
		//		xee = xd.CreateElement("oldtonewcontent");
		//		xe.AppendChild(xee);
		//		xee = xd.CreateElement("transitions");
		//		xe.AppendChild(xee);
		//		xd.AppendChild(xe);
		//		xd.Save(fn);
		//	}
		//	else
		//	{
		//		xd.Load(fn);
		//	}
		//	FileStream fs = File.OpenRead(txtImport.Text);
		//	XmlReaderSettings rs = new XmlReaderSettings();
		//	rs.CheckCharacters = false;
		//	XmlReader xr = XmlReader.Create(fs, rs);
		//	while (xr.Read())
		//	{
		//		if (xr.IsStartElement())
		//		{
		//			switch (xr.Name)
		//			{
		//				case "transition":
		//					AddTransitions(xr);
		//					break;
		//				case "externaltransition":
		//					{
		//						AddExternalTransition(xr, xd);
		//						break;
		//					}
		//				default:
		//					break;
		//			}
		//		}
		//	}
		//	fs.Close();
		//	xd.Save(fn);
		//}

		// jsj 4-29-2016 appears to not be used
		//private Dictionary<int, Dictionary<int, int>> MyCounts = null;
		//private Dictionary<int, int> MySubCounts = null;
		//private void GetImportDataCounts()
		//{
		//	int pCount = 0;
		//	int sCount = 0;
		//	int tCount = 0;
		//	MyCounts = new Dictionary<int, Dictionary<int, int>>();
		//	MySubCounts = new Dictionary<int, int>();
		//	FileStream fs = File.OpenRead(txtImport.Text);
		//	XmlReaderSettings rs = new XmlReaderSettings();
		//	rs.CheckCharacters = false;
		//	XmlReader xr = XmlReader.Create(fs, rs);
		//	while (xr.Read())
		//	{
		//		if (xr.IsStartElement())
		//		{
		//			switch (xr.Name)
		//			{
		//				case "procedure":
		//					{
		//						if (pCount > 0)
		//						{
		//							MySubCounts.Add(sCount, tCount);
		//							MyCounts.Add(pCount, MySubCounts);
		//							sCount = 0;
		//							tCount = 0;
		//							MySubCounts = new Dictionary<int, int>();
		//						}
		//						pCount++;
		//						break;
		//					}
		//				case "section":
		//					{
		//						if (sCount > 0)
		//						{
		//							MySubCounts.Add(sCount, tCount);
		//							tCount = 0;
		//						}
		//						sCount++;
		//						break;
		//					}
		//				case "step":
		//					{
		//						if (xr.Depth == 8)
		//							tCount++;
		//						break;
		//					}
		//				default:
		//					break;
		//			}
		//		}
		//	}
		//	MySubCounts.Add(sCount, tCount);
		//	MyCounts.Add(pCount, MySubCounts);
		//	fs.Close();
		//}

		private void btnImport_Click(object sender, EventArgs e)
		{
			if (_MyMode.ToUpper().Contains("FORMAT"))
			{
				ofd.Filter = "PROMS Procedure Export Files|*.pxml";
				if (ofd.ShowDialog(this) == DialogResult.OK)
					txtImport.Text = ofd.FileName;
				return;
			}
			if (MyFolder != null)
			{
				if (ofd.ShowDialog(this) == DialogResult.OK)
				{
					if (ofd.FileName != string.Empty)
					{
						Old2NewItem = new Dictionary<int, int>();
						Old2NewContent = new Dictionary<int, int>();
						Old2NewLibDoc = new Dictionary<int, int>();
						GetExistingLibDocsList(); // B2019-035 better memory management
						PendingTransitions = new XmlDocument();
						FileInfo fi = new FileInfo(ofd.FileName);
						string dn;
						if (fi.Name.IndexOf("-") > 0)
							dn = fi.Name.Substring(0, fi.Name.IndexOf("-"));
						else
							dn = fi.Name.Substring(0, fi.Name.IndexOf("."));
						txtImport.Text = ofd.FileName;
						ReadOptions ro = new ReadOptions();
						ro.Encoding = Encoding.UTF8;
						MyExpxZipFile = ZipFile.Read(txtImport.Text, ro);
						string fn = string.Format(@"{0}\{1}.impx", PEIPath, dn);
						if (File.Exists(fn))
						{
							MyImpxZipFile = ZipFile.Read(fn, ro);
							ReadTransitionAndItemContentIDs();
						}
						else
						{
							MyImpxZipFile = new ZipFile(fn, Encoding.UTF8);
							//transitions
							XmlElement xe = PendingTransitions.CreateElement("transitions");
							PendingTransitions.AppendChild(xe);
							fn = PEIPath + @"\transitions.xml";
							PendingTransitions.Save(fn);
							MyImpxZipFile.AddFile(fn, "");
							MyImpxZipFile.Save();
							File.Delete(fn);
							//itemids
							XmlDocument xd = new XmlDocument();
							xe = xd.CreateElement("items");
							xd.AppendChild(xe);
							fn = PEIPath + @"\items.xml";
							xd.Save(fn);
							MyImpxZipFile.AddFile(fn, "");
							MyImpxZipFile.Save();
							File.Delete(fn);
							//contentids
							xd = new XmlDocument();
							xe = xd.CreateElement("contents");
							xd.AppendChild(xe);
							fn = PEIPath + @"\contents.xml";
							xd.Save(fn);
							MyImpxZipFile.AddFile(fn, "");
							MyImpxZipFile.Save();
							File.Delete(fn);
							//libdocids
							xd = new XmlDocument();
							xe = xd.CreateElement("libdocs");
							xd.AppendChild(xe);
							fn = PEIPath + @"\libdocs.xml";
							xd.Save(fn);
							MyImpxZipFile.AddFile(fn, "");
							MyImpxZipFile.Save();
							File.Delete(fn);
						}
					}
				}
			}
			if (MyDocVersion != null)
			{
				ofd.Filter = "PROMS Procedure Export Files|*.pxml";
				if (ofd.ShowDialog(this) == DialogResult.OK)
					txtImport.Text = ofd.FileName;
			}
		}
		private void txtImport_TextChanged(object sender, EventArgs e)
		{
			btnDoImport.Enabled = txtImport.TextLength > 0;
			if (btnDoImport.Enabled)
				lblImportStatus.Text = "Ready To Perform Import";
			else
				lblImportStatus.Text = "Awaiting Import File Name:";
		}
		#region Export for Merge
		private string FromFolderName = string.Empty;
		private void ExportFolder(XmlDocument xd, FolderInfo fi, string nodename)
		{
			/*
			FolderID
			ParentID
			DBID
			Name
			Title
			ShortName
			FormatID
			ManualOrder
			Config
			DTS
			UsrID
			*/
			lblExportStatus.Text = "Exporting Folder...";
			Application.DoEvents();
			string formatFileName = (fi.MyFormat != null) ? fi.MyFormat.Name : "";
			FromFolderName = fi.Name;
			XmlElement xe = xd.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xd, "folderid", fi.FolderID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xd, "parentid", fi.ParentID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xd, "dbid", fi.DBID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xd, "name", fi.Name));
			xe.Attributes.SetNamedItem(AddAttribute(xd, "title", fi.Title));
			xe.Attributes.SetNamedItem(AddAttribute(xd, "shortname", fi.ShortName));
			xe.Attributes.SetNamedItem(AddAttribute(xd, "formatid", fi.FormatID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xd, "manualorder", fi.ManualOrder.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xd, "config", fi.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xd, "dts", fi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xd, "usrid", fi.UsrID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xd, "formatfilename", formatFileName));
			xd.AppendChild(xe);
			ExportAnnotationTypes(xe, "annotationtypes");
			ExportFormats(FormatInfoList.GetFormatInfoListUsed(), xe, "formats", true);
			if (fi.FolderDocVersionCount > 0)
				foreach (DocVersionInfo dvi in fi.FolderDocVersions)
					ExportDocVersion(xe, dvi, "docversion");
		}
		private void ExportFormats(FormatInfoList fil, XmlElement xn, string nodename, bool doElement)
		{
			XmlElement xe = null;
			if (doElement) xe = xn.OwnerDocument.CreateElement(nodename);
			else xe = xn;
			foreach (FormatInfo fi in fil)
				ExportFormat(xe, fi, "format");
			if (doElement) xn.AppendChild(xe);
		}
		private void ExportFormat(XmlElement xn, FormatInfo fi, string nodename)
		{
			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "formatid", fi.FormatID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "name", fi.Name));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "pname", fi.MyParent == null ? "null" : fi.MyParent.Name));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "description", fi.Description));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", fi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", fi.UserID));

			if (fi.Config != null && fi.Config != "")
			{
				FormatConfig MyFormatConfig = FormatConfig.Get(fi.Config);
				string scf = MyFormatConfig.ConvertToString();
				scf = Regex.Replace(scf, " *<[a-zA-Z ]+/>\r\n", "");
				xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", scf));
			}
			xn.AppendChild(xe);
		}
		private void ExportAnnotationTypes(XmlElement xn, string nodename)
		{
			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			AnnotationTypeInfoList atl = AnnotationTypeInfoList.Get();
			foreach (AnnotationTypeInfo ati in atl)
				ExportAnnotationType(xe, ati, "annotationtype");
			xn.AppendChild(xe);
		}
		private void ExportAnnotationType(XmlElement xn, AnnotationTypeInfo ati, string nodename)
		{
			/*
			TypeID
			Name
			Config
			DTS
			UserID
			*/
			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "typeid", ati.TypeID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "name", ati.Name));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ati.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ati.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ati.UserID.ToString()));
			xn.AppendChild(xe);
		}

		// jsj 4-29-2016  appears to not be used
		//private void ExportFolder(FolderInfo fi, string nodename)
		//{
		//	/*
		//	FolderID
		//	ParentID
		//	DBID
		//	Name
		//	Title
		//	ShortName
		//	FormatID
		//	ManualOrder
		//	Config
		//	DTS
		//	UsrID
		//	*/
		//	string formatFileName = (fi.MyFormat != null) ? fi.MyFormat.Name : "";
		//	FromFolderName = fi.Name;
		//	MyWriter.WriteStartDocument();
		//	MyWriter.WriteStartElement(nodename);
		//	MyWriter.WriteAttributeString("folderid", fi.FolderID.ToString());
		//	MyWriter.WriteAttributeString("parentid", fi.ParentID.ToString());
		//	MyWriter.WriteAttributeString("dbid", fi.DBID.ToString());
		//	MyWriter.WriteAttributeString("name", fi.Name);
		//	MyWriter.WriteAttributeString("title", fi.Title);
		//	MyWriter.WriteAttributeString("shortname", fi.ShortName);
		//	MyWriter.WriteAttributeString("formatid", fi.FormatID.ToString());
		//	MyWriter.WriteAttributeString("manualorder", fi.ManualOrder.ToString());
		//	MyWriter.WriteAttributeString("config", fi.Config);
		//	MyWriter.WriteAttributeString("dts", fi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
		//	MyWriter.WriteAttributeString("usrid", fi.UsrID.ToString());
		//	MyWriter.WriteAttributeString("formatfilename", formatFileName);

		//	if (fi.FolderDocVersionCount > 0)
		//		foreach (DocVersionInfo dvi in fi.FolderDocVersions)
		//			ExportDocVersion(dvi, "docversion");
		//	MyWriter.WriteEndElement();
		//	MyWriter.WriteEndDocument();
		//}

		// bug fix:  B2017-082 don't export if no RO Path - display an message to the user to assign a RO Path
		private bool ValidDocVersionAssociation(DocVersionInfo dvi)
		{
			if (dvi.DocVersionAssociationCount <= 0)
			{
				MessageBox.Show("Assign a Referenced Object path to the Working Draft tree node before exporting.", "RO Path not assigned");
				successfullExport = false;
				return false;
			}
			return true;
		}
		private void ExportDocVersion(XmlElement xn, DocVersionInfo dvi, string nodename)
		{
			/*
			VersionID
			FolderID
			VersionType
			Name
			Title
			ItemID
			FormatID
			Config
			DTS
			UserID
			*/
			lblExportStatus.Text = "Exporting DocVersion...";
			Application.DoEvents();
			string formatFileName = (dvi.MyFormat != null) ? dvi.MyFormat.Name : "";
			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "versionid", dvi.VersionID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "folderid", dvi.FolderID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "versiontype", dvi.VersionType.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "name", dvi.Name));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "title", dvi.Title));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "itemid", dvi.ItemID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "formatid", dvi.FormatID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", dvi.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", dvi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", dvi.UserID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "formatfilename", formatFileName));
			xn.AppendChild(xe);
			if (!ValidDocVersionAssociation(dvi)) return;  // bug fix:  B2017-082 don't export if no RO Path
			if (dvi.DocVersionAssociationCount > 0)
				foreach (AssociationInfo ai in dvi.DocVersionAssociations)
					ExportAssociation(xe, ai, "association");
			string fn = PEIPath + @"\folder.xml";
			xn.OwnerDocument.Save(fn);
			MyExpxZipFile.AddFile(fn, "folder");
			MyExpxZipFile.Save();
			File.Delete(fn);
			//here
			lblExportStatus.Text = "Exporting Procedures...";
			Application.DoEvents();
			if (dvi.Procedures.Count > 0)
			{
				pbExportProcedure.Value = 0;
				pbExportProcedure.Maximum = dvi.Procedures.Count;
				lblExportProcedure.Text = pbExportProcedure.Maximum.ToString() + " Procedures";
				foreach (ItemInfo ii in dvi.Procedures)
				{
					XmlDocument xd = new XmlDocument();
					ExportItem(xd, ii, "procedure");
					fn = string.Format(@"{0}\proc{1}.xml", PEIPath, pbExportProcedure.Value.ToString().PadLeft(4, '0'));
					xd.Save(fn);
					MyExpxZipFile.AddFile(fn, "procedures");
					MyExpxZipFile.Save();
					File.Delete(fn);
					xd = null;
				}
			}
		}
		private void ExportDocVersion(DocVersionInfo dvi, string nodename)
		{
			/*
			VersionID
			FolderID
			VersionType
			Name
			Title
			ItemID
			FormatID
			Config
			DTS
			UserID
			*/
			string formatFileName = (dvi.MyFormat != null) ? dvi.MyFormat.Name : "";
			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("versionid", dvi.VersionID.ToString());
			MyWriter.WriteAttributeString("folderid", dvi.FolderID.ToString());
			MyWriter.WriteAttributeString("versiontype", dvi.VersionType.ToString());
			MyWriter.WriteAttributeString("name", dvi.Name);
			MyWriter.WriteAttributeString("title", dvi.Title);
			MyWriter.WriteAttributeString("itemid", dvi.ItemID.ToString());
			MyWriter.WriteAttributeString("formatid", dvi.FormatID.ToString());
			MyWriter.WriteAttributeString("config", dvi.Config);
			MyWriter.WriteAttributeString("dts", dvi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", dvi.UserID.ToString());
			MyWriter.WriteAttributeString("formatfilename", formatFileName);
			if (dvi.DocVersionAssociationCount > 0)
				foreach (AssociationInfo ai in dvi.DocVersionAssociations)
					ExportAssociation(ai, "association");
			if (dvi.Procedures.Count > 0)
			{
				pbExportProcedure.Value = 0;
				pbExportProcedure.Maximum = dvi.Procedures.Count;
				lblExportProcedure.Text = pbExportProcedure.Maximum.ToString() + " Procedures";
				foreach (ItemInfo ii in dvi.Procedures)
				{
					ExportItem(ii, "procedure");
				}
			}
			MyWriter.WriteEndElement();
		}
		private void ExportAssociation(XmlElement xn, AssociationInfo ai, string nodename)
		{
			/*
			AssociationID
			VersionID
			ROFstID
			Config
			DTS
			UserID
			*/
			lblExportStatus.Text = "Exporting Association...";
			Application.DoEvents();
			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "associationid", ai.AssociationID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "versionid", ai.VersionID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rofstid", ai.ROFstID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ai.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ai.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ai.UserID.ToString()));
			xn.AppendChild(xe);
			ExportROFst(xe, ai.MyROFst, "rofst");
		}
		private void ExportAssociation(AssociationInfo ai, string nodename)
		{
			/*
			AssociationID
			VersionID
			ROFstID
			Config
			DTS
			UserID
			*/
			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("associationid", ai.AssociationID.ToString());
			MyWriter.WriteAttributeString("versionid", ai.VersionID.ToString());
			MyWriter.WriteAttributeString("rofstid", ai.ROFstID.ToString());
			MyWriter.WriteAttributeString("config", ai.Config);
			MyWriter.WriteAttributeString("dts", ai.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", ai.UserID.ToString());
			ExportROFst(ai.MyROFst, "rofst");
			MyWriter.WriteEndElement();
		}

		private void ExportROFst(XmlElement xn, ROFstInfo fst, string nodename)
		{
			/*
			ROFstID
			RODbID
			ROLookup
			Config
			DTS
			UserID
			*/
			lblExportStatus.Text = "Exporting ROFst...";
			Application.DoEvents();

			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rofstid", fst.ROFstID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rodbid", fst.RODbID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rolookup", Convert.ToBase64String(ROFSTLookup.GetRofstLookupBytes(fst.ROFstID)))); // B2022-026 RO Memory reduction - new calls
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", fst.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", fst.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", fst.UserID.ToString()));
			xn.AppendChild(xe);

			ExportFigures(xe, fst);
			ExportRODb(xe, fst.MyRODb, "rodb");
		}

		private void ExportROFst(ROFstInfo fst, string nodename)
		{
			/*
			ROFstID
			RODbID
			ROLookup
			Config
			DTS
			UserID
			*/
			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("rofstid", fst.ROFstID.ToString());
			MyWriter.WriteAttributeString("rodbid", fst.RODbID.ToString());
			MyWriter.WriteAttributeString("rolookup", Convert.ToBase64String(ROFSTLookup.GetRofstLookupBytes(fst.ROFstID))); // B2022-026 RO Memory reduction - new calls
			MyWriter.WriteAttributeString("config", fst.Config);
			MyWriter.WriteAttributeString("dts", fst.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", fst.UserID.ToString());

			ExportRODb(fst.MyRODb, "rodb");
			MyWriter.WriteEndElement();
		}

		private void ExportFigures(XmlElement xn, ROFstInfo fst)
		{
			if (fst.ROFstFigureCount > 0)
			{
				XmlElement xe = xn.OwnerDocument.CreateElement("figures");
				xn.AppendChild(xe);

				foreach (FigureInfo figure in fst.ROFstFigures)
				{
					XmlElement xee = xn.OwnerDocument.CreateElement("figure");

					xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "figureid", figure.FigureID.ToString()));
					xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "rofstid", figure.ROFstID.ToString()));
					xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "imageid", figure.ImageID.ToString()));
					xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "config", figure.Config));
					xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", figure.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
					xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", figure.UserID));
					xe.AppendChild(xee);

					// B2018-031 Output figure names as they are exported to provide more constant feedback
					lblExportStatus.Text = string.Format("Exporting Figure...{0}", figure.MyROImage.FileName);
					Application.DoEvents();

					ExportROImage(xee, figure.MyROImage);
				}
			}
		}

		private void ExportROImage(XmlElement xn, ROImageInfo image)
		{
			XmlElement xe = xn.OwnerDocument.CreateElement("image");
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "imageid", image.ImageID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rodbid", image.RODbID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "filename", image.FileName));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "content", Convert.ToBase64String(image.Content)));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", image.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", image.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", image.UserID));
			xn.AppendChild(xe);
		}

		private void ExportRODb(XmlElement xn, RODbInfo db, string nodename)
		{
			/*
			RODbID
			ROName
			FolderPath
			DBConnectionString
			Config
			DTS
			UserID
			*/
			lblExportStatus.Text = "Exporting RODb...";
			Application.DoEvents();

			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rodbid", db.RODbID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "roname", db.ROName));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "folderpath", db.FolderPath));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dbconnectionstring", db.DBConnectionString));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", db.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", db.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", db.UserID.ToString()));
			xn.AppendChild(xe);
		}

		private void ExportRODb(RODbInfo db, string nodename)
		{
			/*
			RODbID
			ROName
			FolderPath
			DBConnectionString
			Config
			DTS
			UserID
			*/
			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("rodbid", db.RODbID.ToString());
			MyWriter.WriteAttributeString("roname", db.ROName);
			MyWriter.WriteAttributeString("folderpath", db.FolderPath);
			MyWriter.WriteAttributeString("dbconnectionstring", db.DBConnectionString);
			MyWriter.WriteAttributeString("config", db.Config);
			MyWriter.WriteAttributeString("dts", db.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", db.UserID.ToString());
			MyWriter.WriteEndElement();
		}

		public void ExportItem(XmlDocument xd, ItemInfo ii, string nodename)
		{
			XmlElement xe = xd.CreateElement(nodename);
			if (ii.IsProcedure)
			{
				xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rodbid", ii.MyDocVersion.DocVersionAssociations[0].MyROFst.MyRODb.RODbID.ToString()));
				xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rofolderpath", ii.MyDocVersion.DocVersionAssociations[0].MyROFst.MyRODb.FolderPath));
				xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rofstid", ii.MyDocVersion.DocVersionAssociations[0].MyROFst.ROFstID.ToString()));
				xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rofstdts", ii.MyDocVersion.DocVersionAssociations[0].MyROFst.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			}
			xd.AppendChild(xe);
			ExportItem(xe, ii, nodename);
		}

		private void ExportItem(XmlElement xn, ItemInfo ii, string nodename)
		{
			/*
			ItemID
			PreviousID
			ContentID
			DTS
			*/
			XmlElement xe = null;
			if (xn.Name == "procedure")
				xe = xn;
			else
			{
				xe = xn.OwnerDocument.CreateElement(nodename);
				xn.AppendChild(xe);
			}

			if (ii.IsProcedure)
			{
				pbExportProcedure.PerformStep();
				lblExportProcedure.Text = string.Format("{0} of {1} Procedures", pbExportProcedure.Value.ToString(), pbExportProcedure.Maximum.ToString());
				TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
				lblExportTime.Text = "Elapsed Time: " + elapsed.ToString();
				Application.DoEvents();

				pbExportSection.Value = 0;
				pbExportSection.Maximum = pbExportSection.Value;
				pbExportStep.Value = 0;
				pbExportStep.Maximum = pbExportStep.Value;

				if (ii.Sections != null)
					pbExportSection.Maximum = ii.Sections.Count;
				else
				{
					pbExportSection.Maximum = 1;
					pbExportSection.PerformStep();
					pbExportStep.Maximum = 1;
					pbExportStep.PerformStep();
					lblExportSection.Text = "Sections";
					lblExportStep.Text = "Steps";
					Application.DoEvents();
				}
			}

			if (ii.IsSection && ii.ActiveParent.IsProcedure)
			{
				pbExportSection.PerformStep();
				lblExportSection.Text = string.Format("{0} of {1} Sections", pbExportSection.Value.ToString(), pbExportSection.Maximum.ToString());
				Application.DoEvents();
				pbExportStep.Value = 0;
				pbExportStep.Maximum = pbExportStep.Value;

				if (ii.Steps != null)
					pbExportStep.Maximum = ii.Steps.Count;
				else
				{
					pbExportStep.Maximum = 1;
					pbExportStep.PerformStep();
					lblExportStep.Text = "Word Section Data";
					Application.DoEvents();
				}
			}

			if (ii.IsStep && ii.ActiveParent.IsSection && ii.ActiveParent.ActiveParent.IsProcedure)
			{
				pbExportStep.PerformStep();
				lblExportStep.Text = string.Format("{0} of {1} Steps", pbExportStep.Value.ToString(), pbExportStep.Maximum.ToString());
				Application.DoEvents();
			}

			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "itemid", ii.ItemID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "previousid", ii.PreviousID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", ii.ContentID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ii.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			
			//item audits
			ExportItemAudits(xe, ii);
			ExportContent(xe, ii.MyContent, "content");

			if (ii.ItemAnnotationCount > 0)
				foreach (AnnotationInfo ai in ii.ItemAnnotations)
					ExportAnnotation(xe, ai, "annotation");
		}

		private void ExportItemAudits(XmlElement xn, ItemInfo ii)
		{
			if (cbxExportAudits.Checked)
			{
				ItemAuditInfoList audits = ItemAuditInfoList.Get(ii.ItemID);

				if (audits.Count > 0)
				{
					XmlElement xe = xn.OwnerDocument.CreateElement("audits");

					foreach (ItemAuditInfo audit in audits)
					{
						if (audit.DeleteStatus == 0)
						{
							XmlElement xee = xn.OwnerDocument.CreateElement("audit");

							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentid", audit.ContentID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "itemid", audit.ItemID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "previousid", audit.PreviousID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));

							xe.AppendChild(xee);
						}
					}

					xn.AppendChild(xe);
				}
			}
		}

		// used to save word sections with resolved ROs (export generated from Approve)
		private Dictionary<int, byte[]> _DocReplace;
		public Dictionary<int, byte[]> DocReplace
		{
			get { return _DocReplace; }
			set
			{
				_DocReplace = value;
				_ConvertROsAndTransitionsToText = (value != null);
			}
		}

		private void ExportItem(ItemInfo ii, string nodename)
		{
			/*
			ItemID
			PreviousID
			ContentID
			DTS
			*/
			if (ii.IsProcedure)
			{
				pbExportProcedure.PerformStep();
				lblExportProcedure.Text = string.Format("{0} of {1} Procedures", pbExportProcedure.Value.ToString(), pbExportProcedure.Maximum.ToString());
				Application.DoEvents();

				pbExportSection.Value = 0;
				pbExportStep.Value = 0;
				pbExportSection.Maximum = ii.Sections.Count;

				if (ii.Sections != null)
					pbExportSection.Maximum = ii.Sections.Count;
				else
				{
					pbExportSection.Maximum = 1;
					pbExportSection.PerformStep();
					pbExportStep.Maximum = 1;
					pbExportStep.PerformStep();
					lblExportSection.Text = "Sections";
					lblExportStep.Text = "Steps";
					Application.DoEvents();
				}
			}

			if (ii.IsSection)
			{
				pbExportSection.PerformStep();
				lblExportSection.Text = string.Format("{0} of {1} Sections", pbExportSection.Value.ToString(), pbExportSection.Maximum.ToString());
				Application.DoEvents();
				pbExportStep.Value = 0;
				if (ii.Steps != null)
					pbExportStep.Maximum = ii.Steps.Count;
				else
				{
					pbExportStep.Maximum = 1;
					pbExportStep.PerformStep();
					lblExportStep.Text = "Word Section Data";
					Application.DoEvents();
				}
			}

			if (ii.IsStep)
			{
				pbExportStep.PerformStep();
				lblExportStep.Text = string.Format("{0} of {1} Steps", pbExportStep.Value.ToString(), pbExportStep.Maximum.ToString());
				Application.DoEvents();
			}

			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("itemid", ii.ItemID.ToString());
			MyWriter.WriteAttributeString("previousid", ii.PreviousID.ToString());
			MyWriter.WriteAttributeString("contentid", ii.ContentID.ToString());
			MyWriter.WriteAttributeString("dts", ii.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));

			ExportContent(ii.MyContent, "content");
			if (ii.ItemAnnotationCount > 0)
				foreach (AnnotationInfo ai in ii.ItemAnnotations)
					ExportAnnotation(ai, "annotation");

			MyWriter.WriteEndElement();
		}

		private void ExportContent(XmlElement xn, ContentInfo ci, string nodename)
		{
			/*
			ContentID
			Number
			Text
			Type
			FormatID
			Config
			DTS
			UserID
			*/
			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			// strip the link information if we are convertingthe RO and Transitions to text
			string ciText = (_ConvertROsAndTransitionsToText) ? ItemInfo.StripLinks(ci.Text) : ci.Text;
			string formatFileName = (ci.MyFormat != null) ? ci.MyFormat.Name : "";

			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", ci.ContentID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "number", ci.Number));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "text", ciText));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "type", ci.Type.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "formatid", ci.FormatID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ci.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ci.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ci.UserID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "formatfilename", formatFileName));

			//content audits
			ExportContentAudits(xe, ci);
			xn.AppendChild(xe);

			if (ci.ContentTransitionCount > 0)
				foreach (TransitionInfo ti in ci.ContentTransitions)
					ExportTransition(xe, ti, "transition");

			if (ci.ContentRoUsageCount > 0)
				foreach (RoUsageInfo ri in ci.ContentRoUsages)
					ExportROUsage(xe, ri, "rousage");

			if (ci.ContentEntryCount > 0)
				ExportEntry(xe, ci.MyEntry, "entry");

			if (ci.ContentGridCount > 0)
				ExportGrid(xe, ci.MyGrid, "grid");

			if (ci.ContentImageCount > 0)
				ExportImage(xe, ci.MyImage, "image");

			if (ci.ContentPartCount > 0)
				foreach (PartInfo pi in ci.ContentParts)
					ExportPart(xe, pi, ((E_FromTypes)pi.FromType).ToString().ToLower());
		}

		private void ExportContentAudits(XmlElement xn, ContentInfo ci)
		{
			if (cbxExportAudits.Checked)
			{
				ContentAuditInfoList audits = ContentAuditInfoList.Get(ci.ContentID);

				if (audits.Count > 0)
				{
					XmlElement xe = xn.OwnerDocument.CreateElement("audits");

					foreach (ContentAuditInfo audit in audits)
					{
						if (audit.DeleteStatus == 0)
						{
							XmlElement xee = xn.OwnerDocument.CreateElement("audit");
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentid", audit.ContentID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "number", audit.Number));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "text", audit.Text));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "type", audit.Type.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "formatid", audit.FormatID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "config", audit.Config));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "actiondts", audit.ActionWhen.ToString("MM/dd/yyyy HH:mm:ss.fff")));
							xe.AppendChild(xee);
						}
					}
				}
			}
		}

		private void ExportContent(ContentInfo ci, string nodename)
		{
			/*
			ContentID
			Number
			Text
			Type
			FormatID
			Config
			DTS
			UserID
			*/
			// strip the link information if we are convertinga the ROs and Transitions to text
			string ciText = (_ConvertROsAndTransitionsToText) ? ItemInfo.StripLinks(ci.Text) : ci.Text;
			string formatFileName = (ci.MyFormat != null) ? ci.MyFormat.Name : "";

			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("contentid", ci.ContentID.ToString());
			MyWriter.WriteAttributeString("number", ci.Number);
			MyWriter.WriteAttributeString("text", ciText);
			MyWriter.WriteAttributeString("type", ci.Type.ToString());
			MyWriter.WriteAttributeString("formatid", ci.FormatID.ToString());
			MyWriter.WriteAttributeString("config", ci.Config);
			MyWriter.WriteAttributeString("dts", ci.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", ci.UserID.ToString());
			MyWriter.WriteAttributeString("formatfilename", formatFileName);

			if (ci.ContentTransitionCount > 0)
				foreach (TransitionInfo ti in ci.ContentTransitions)
					ExportTransition(ti, "transition");

			if (ci.ContentRoUsageCount > 0)
				foreach (RoUsageInfo ri in ci.ContentRoUsages)
					ExportROUsage(ri, "rousage");

			if (ci.ContentEntryCount > 0)
				ExportEntry(ci.MyEntry, "entry");

			if (ci.ContentGridCount > 0)
				ExportGrid(ci.MyGrid, "grid");

			if (ci.ContentImageCount > 0)
				ExportImage(ci.MyImage, "image");

			if (ci.ContentPartCount > 0)
				foreach (PartInfo pi in ci.ContentParts)
					ExportPart(pi, ((E_FromTypes)pi.FromType).ToString().ToLower());

			MyWriter.WriteEndElement();
		}

		private void ExportGrid(XmlElement xn, GridInfo gi, string nodename)
		{
			/*
			ContentID
			Data
			Config
			DTS
			UserID
			*/
			string giData = gi.Data;
			if (_ConvertROsAndTransitionsToText)
			{
				giData = giData.Replace("<IsRoTable>True", "<IsRoTable>False"); // converts a RO table to a unlinked regular table
				giData = ItemInfo.StripLinks(giData); // this converts ROs and transitions to text
			}

			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", gi.ContentID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "data", giData));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", gi.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", gi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", gi.UserID.ToString()));
			
			//grid audits
			ExportGridAudits(xe, gi);
			xn.AppendChild(xe);
		}

		private void ExportGridAudits(XmlElement xn, GridInfo gi)
		{
			if (cbxExportAudits.Checked)
			{
				GridAuditInfoList audits = GridAuditInfoList.Get(gi.ContentID);

				if (audits.Count > 0)
				{
					XmlElement xe = xn.OwnerDocument.CreateElement("audits");

					foreach (GridAuditInfo audit in audits)
					{
						if (audit.DeleteStatus == 0)
						{
							XmlElement xee = xn.OwnerDocument.CreateElement("audit");
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentid", audit.ContentID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "data", audit.Data));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "config", audit.Config));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentauditid", audit.ContentAuditID.ToString()));
							xe.AppendChild(xee);

						}
					}
				}
			}
		}

		private void ExportGrid(GridInfo gi, string nodename)
		{
			/*
			ContentID
			Data
			Config
			DTS
			UserID
			*/
			string giData = gi.Data;
			if (_ConvertROsAndTransitionsToText)
			{
				giData = giData.Replace("IsRoTable&gtTrue", "IsRoTable&gt;False"); // converts a RO table to regular table
				giData = ItemInfo.StripLinks(giData); // converts ROs and Transitions to text
			}

			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("contentid", gi.ContentID.ToString());
			MyWriter.WriteAttributeString("data", giData);
			MyWriter.WriteAttributeString("config", gi.Config);
			MyWriter.WriteAttributeString("dts", gi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", gi.UserID.ToString());
			MyWriter.WriteEndElement();
		}

		private void ExportEntry(XmlElement xn, EntryInfo ei, string nodename)
		{
			/*
			ContentID
			DocID
			DTS
			UserID
			*/
			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", ei.ContentID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "docid", ei.DocID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ei.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ei.UserID.ToString()));
			
			//entry audits
			ExportEntryAudits(xe, ei);
			xn.AppendChild(xe);
			ExportDocument(xe, ei.MyDocument, "document");
		}

		private void ExportEntryAudits(XmlElement xn, EntryInfo ei)
		{
			if (cbxExportAudits.Checked)
			{
				EntryAuditInfoList audits = EntryAuditInfoList.Get(ei.ContentID);

				if (audits.Count > 0)
				{
					XmlElement xe = xn.OwnerDocument.CreateElement("audits");

					foreach (EntryAuditInfo audit in audits)
					{
						if (audit.DeleteStatus == 0)
						{
							XmlElement xee = xn.OwnerDocument.CreateElement("audit");
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentid", audit.ContentID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "docid", audit.DocID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
							xe.AppendChild(xee);
						}
					}
				}
			}
		}

		private void ExportEntry(EntryInfo ei, string nodename)
		{
			/*
			ContentID
			DocID
			DTS
			UserID
			*/
			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("contentid", ei.ContentID.ToString());
			MyWriter.WriteAttributeString("docid", ei.DocID.ToString());
			MyWriter.WriteAttributeString("dts", ei.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", ei.UserID.ToString());
			ExportDocument(ei.MyDocument, "document");
			MyWriter.WriteEndElement();
		}

		private void ExportImage(XmlElement xn, ImageInfo ii, string nodename)
		{
			/*
			ContentID
			ImageType
			FileName
			Data
			Config
			DTS
			UserID
			*/
			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", ii.ContentID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "imagetype", ii.ImageType.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "filename", ii.FileName));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "data", Convert.ToBase64String(ii.Data)));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ii.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ii.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ii.UserID.ToString()));
			//image audits
			ExportImageAudits(xe, ii);
			xn.AppendChild(xe);
		}

		private void ExportImageAudits(XmlElement xn, ImageInfo ii)
		{
			if (cbxExportAudits.Checked)
			{
				ImageAuditInfoList audits = ImageAuditInfoList.Get(ii.ContentID);

				if (audits.Count > 0)
				{
					XmlElement xe = xn.OwnerDocument.CreateElement("audits");

					foreach (ImageAuditInfo audit in audits)
					{
						if (audit.DeleteStatus == 0)
						{
							XmlElement xee = xn.OwnerDocument.CreateElement("audit");
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentid", audit.ContentID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "imagetype", audit.ImageType.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "filename", audit.FileName));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "data", Convert.ToBase64String(audit.Data)));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "config", audit.Config));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
							xe.AppendChild(xee);
						}
					}
				}
			}
		}

		private void ExportImage(ImageInfo ii, string nodename)
		{
			/*
			ContentID
			ImageType
			FileName
			Data
			Config
			DTS
			UserID
			*/
			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("contentid", ii.ContentID.ToString());
			MyWriter.WriteAttributeString("imagetype", ii.ImageType.ToString());
			MyWriter.WriteAttributeString("filename", ii.FileName);
			MyWriter.WriteAttributeString("data", Convert.ToBase64String(ii.Data));
			MyWriter.WriteAttributeString("config", ii.Config);
			MyWriter.WriteAttributeString("dts", ii.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", ii.UserID.ToString());
			MyWriter.WriteEndElement();
		}

		private void ExportDocument(XmlElement xn, DocumentInfo di, string nodename)
		{
			/*
			DocID
			LibTitle
			DocContent
			DocAscii
			Config
			DTS
			UserID
			FileExtension
			*/
			byte[] buf = di.DocContent;
			string libDocTitle = di.LibTitle;
			if (DocReplace != null && DocReplace.ContainsKey(di.DocID) && _ConvertROsAndTransitionsToText)
			{
				buf = DocReplace[di.DocID];
				libDocTitle = null;  // unlink the word section from the library document
			}

			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "docid", di.DocID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "libtitle", libDocTitle)); // di.LibTitle));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "doccontent", Convert.ToBase64String(buf)));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "docascii", di.DocAscii));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", di.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", di.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", di.UserID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "fileextension", di.FileExtension));
			
			//document audits
			ExportDocumentAudits(xe, di);
			xn.AppendChild(xe);
		}

		private void ExportDocumentAudits(XmlElement xn, DocumentInfo di)
		{
			if (cbxExportAudits.Checked)
			{
				DocumentAuditInfoList audits = DocumentAuditInfoList.Get(di.DocID);

				if (audits.Count > 0)
				{
					XmlElement xe = xn.OwnerDocument.CreateElement("audits");

					foreach (DocumentAuditInfo audit in audits)
					{
						if (audit.DeleteStatus == 0)
						{
							XmlElement xee = xn.OwnerDocument.CreateElement("audit");
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "docid", audit.DocID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "libtitle", audit.LibTitle));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "doccontent", Convert.ToBase64String(audit.DocContent)));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "docascii", audit.DocAscii));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "config", audit.Config));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "fileextension", audit.FileExtension));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
							xe.AppendChild(xee);
						}
					}
				}
			}
		}
		private void ExportDocument(DocumentInfo di, string nodename)
		{
			/*
			DocID
			LibTitle
			DocContent
			DocAscii
			Config
			DTS
			UserID
			FileExtension
			*/
			byte[] buf = di.DocContent;
			string libDocTitle = di.LibTitle;
			if (DocReplace != null && DocReplace.ContainsKey(di.DocID) && _ConvertROsAndTransitionsToText)
			{
				buf = DocReplace[di.DocID];
				libDocTitle = null; // unlink the word section from the library document
			}

			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("docid", di.DocID.ToString());
			MyWriter.WriteAttributeString("libtitle", libDocTitle);// di.LibTitle);
			MyWriter.WriteAttributeString("doccontent", Convert.ToBase64String(buf));
			MyWriter.WriteAttributeString("docascii", di.DocAscii);
			MyWriter.WriteAttributeString("config", di.Config);
			MyWriter.WriteAttributeString("dts", di.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", di.UserID.ToString());
			MyWriter.WriteAttributeString("fileextension", di.FileExtension);
			MyWriter.WriteEndElement();
		}

		private void ExportROUsage(XmlElement xn, RoUsageInfo ri, string nodename)
		{
			/*
			ROUsageID
			ContentID
			ROID
			Config
			DTS
			UserID
			RODbID
			*/
			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rousageid", ri.ROUsageID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", ri.ContentID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "roid", ri.ROID));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ri.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ri.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ri.UserID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rodbid", ri.RODbID.ToString()));
			
			//rousage audits
			ExportROUsageAudits(xe, ri);
			xn.AppendChild(xe);
		}

		private void ExportROUsageAudits(XmlElement xe, RoUsageInfo ri)
		{
			if (cbxExportAudits.Checked) { };
		}

		private void ExportROUsage(RoUsageInfo ri, string nodename)
		{
			/*
			ROUsageID
			ContentID
			ROID
			Config
			DTS
			UserID
			RODbID
			*/
			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("rousageid", ri.ROUsageID.ToString());
			MyWriter.WriteAttributeString("contentid", ri.ContentID.ToString());
			MyWriter.WriteAttributeString("roid", ri.ROID);
			MyWriter.WriteAttributeString("config", ri.Config);
			MyWriter.WriteAttributeString("dts", ri.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", ri.UserID.ToString());
			MyWriter.WriteAttributeString("rodbid", ri.RODbID.ToString());
			MyWriter.WriteEndElement();
		}

		private void ExportPart(XmlElement xn, PartInfo pi, string nodename)
		{
			/*
			ContentID
			FromType
			ItemID
			DTS
			UserID
			*/
			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "contentid", pi.ContentID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "fromtype", pi.FromType.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "itemid", pi.ItemID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", pi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", pi.UserID.ToString()));
			
			//part audits
			ExportPartAudits(xe, pi);
			xn.AppendChild(xe);
			foreach (ItemInfo ii in pi.MyItems)
				ExportItem(xe, ii, pi.PartType.ToString().ToLower());
		}

		private void ExportPartAudits(XmlElement xn, PartInfo pi)
		{
			if (cbxExportAudits.Checked)
			{
				PartAuditInfoList audits = PartAuditInfoList.Get(pi.ContentID);

				if (audits.Count > 0)
				{
					XmlElement xe = xn.OwnerDocument.CreateElement("audits");

					foreach (PartAuditInfo audit in audits)
					{
						if (audit.DeleteStatus == 0)
						{
							XmlElement xee = xn.OwnerDocument.CreateElement("audit");
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "contentid", audit.ContentID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "fromtype", audit.FromType.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "itemid", audit.ItemID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
							xe.AppendChild(xee);
						}
					}
				}
			}
		}

		private void ExportPart(PartInfo pi, string nodename)
		{
			/*
			ContentID
			FromType
			ItemID
			DTS
			UserID
			*/
			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("contentid", pi.ContentID.ToString());
			MyWriter.WriteAttributeString("fromtype", pi.FromType.ToString());
			MyWriter.WriteAttributeString("itemid", pi.ItemID.ToString());
			MyWriter.WriteAttributeString("dts", pi.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", pi.UserID.ToString());
			foreach (ItemInfo ii in pi.MyItems)
				ExportItem(ii, pi.PartType.ToString().ToLower());
			MyWriter.WriteEndElement();
		}

		private void ExportTransition(XmlElement xn, TransitionInfo ti, string nodename)
		{
			/*
			TransitionID
			FromID
			ToID
			RangeID
			IsRange
			TranType
			Config
			DTS
			UserID
			*/
			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "transitionid", ti.TransitionID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "fromid", ti.FromID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "toid", ti.ToID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rangeid", ti.RangeID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "isrange", ti.IsRange.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "trantype", ti.TranType.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ti.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ti.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ti.UserID.ToString()));
			
			//transition audits
			ExportTransitionAudits(xe, ti);
			xn.AppendChild(xe);
		}

		private void ExportTransitionAudits(XmlElement xe, TransitionInfo ti)
		{
			if (cbxExportAudits.Checked) { };
		}

		private void ExportTransition(TransitionInfo ti, string nodename)
		{
			/*
			TransitionID
			FromID
			ToID
			RangeID
			IsRange
			TranType
			Config
			DTS
			UserID
			*/
			string folder = string.Empty;
			if (ti.MyItemToID.MyDocVersion != null && ti.MyItemToID.MyDocVersion.MyFolder.Name != MyFolder.Name)
			{
				nodename = "external" + nodename;
				folder = ti.MyItemToID.MyDocVersion.MyFolder.Name;
			}
			else
			{
				nodename = "external" + nodename;
				folder = "UNKNOWN";
			}

			MyWriter.WriteStartElement(nodename);

			if (folder != string.Empty)
				MyWriter.WriteAttributeString("folder", folder);

			MyWriter.WriteAttributeString("transitionid", ti.TransitionID.ToString());
			MyWriter.WriteAttributeString("fromid", ti.FromID.ToString());
			MyWriter.WriteAttributeString("toid", ti.ToID.ToString());
			MyWriter.WriteAttributeString("rangeid", ti.RangeID.ToString());
			MyWriter.WriteAttributeString("isrange", ti.IsRange.ToString());
			MyWriter.WriteAttributeString("trantype", ti.TranType.ToString());
			MyWriter.WriteAttributeString("config", ti.Config);
			MyWriter.WriteAttributeString("dts", ti.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", ti.UserID.ToString());
			MyWriter.WriteEndElement();
		}

		private void ExportAnnotation(XmlElement xn, AnnotationInfo ai, string nodename)
		{
			/*
			AnnotationID
			ItemID
			TypeID
			RtfText
			SearchText
			Config
			DTS
			UserID
			*/
			XmlElement xe = xn.OwnerDocument.CreateElement(nodename);
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "annotationid", ai.AnnotationID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "itemid", ai.ItemID.ToString()));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "typeid", ai.TypeID.ToString()));
			//if(ai.TypeID > 6)
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "typename", ai.MyAnnotationType.Name));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "rtftext", ai.RtfText));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "searchtext", ai.SearchText));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "config", ai.Config));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "dts", ai.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
			xe.Attributes.SetNamedItem(AddAttribute(xe.OwnerDocument, "userid", ai.UserID.ToString()));
			//annotation audits
			ExportAnnotationAudits(xe, ai);
			xn.AppendChild(xe);
		}

		private void ExportAnnotationAudits(XmlElement xn, AnnotationInfo ai)
		{
			if (cbxExportAudits.Checked)
			{
				AnnotationAuditInfoList audits = AnnotationAuditInfoList.GetByAnnotationID(ai.AnnotationID);

				if (audits.Count > 0)
				{
					XmlElement xe = xn.OwnerDocument.CreateElement("audits");

					foreach (AnnotationAuditInfo audit in audits)
					{
						if (audit.DeleteStatus == 0)
						{
							XmlElement xee = xn.OwnerDocument.CreateElement("audit");
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "auditid", audit.AuditID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "annotationid", audit.AnnotationID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "itemid", audit.ItemID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "typeid", audit.TypeID.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "rtftext", audit.RtfText));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "searchtext", audit.SearchText));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "config", audit.Config));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "deletestatus", audit.DeleteStatus.ToString()));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "dts", audit.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff")));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "userid", audit.UserID));
							xee.Attributes.SetNamedItem(AddAttribute(xee.OwnerDocument, "actiondts", audit.ActionWhen.ToString("MM/dd/yyyy HH:mm:ss.fff")));
							xe.AppendChild(xee);
						}
					}
					xn.AppendChild(xe);
				}
			}
		}

		private void ExportAnnotation(AnnotationInfo ai, string nodename)
		{
			/*
			AnnotationID
			ItemID
			TypeID
			RtfText
			SearchText
			Config
			DTS
			UserID
			*/
			MyWriter.WriteStartElement(nodename);
			MyWriter.WriteAttributeString("annotationid", ai.AnnotationID.ToString());
			MyWriter.WriteAttributeString("itemid", ai.ItemID.ToString());
			MyWriter.WriteAttributeString("typeid", ai.TypeID.ToString());
			MyWriter.WriteAttributeString("rtftext", ai.RtfText);
			MyWriter.WriteAttributeString("searchtext", ai.SearchText);
			MyWriter.WriteAttributeString("config", ai.Config);
			MyWriter.WriteAttributeString("dts", ai.DTS.ToString("MM/dd/yyyy HH:mm:ss.fff"));
			MyWriter.WriteAttributeString("userid", ai.UserID.ToString());
			MyWriter.WriteEndElement();
		}

		#endregion

		#region Import for Merge

		// jsj 4-29-2016  appears to not be used
		//private void AddExternalTransition(XmlReader xr, XmlDocument xd)
		//{
		//	XmlElement xe = xd.CreateElement("transition");
		//	XmlAttribute xa = AddAttribute(xd, "folder", xr.GetAttribute("folder"));
		//	xe.Attributes.SetNamedItem(xa);
		//	xa = AddAttribute(xd, "transitionid", xr.GetAttribute("transitionid"));
		//	xe.Attributes.SetNamedItem(xa);
		//	xa = AddAttribute(xd, "fromid", xr.GetAttribute("fromid"));
		//	xe.Attributes.SetNamedItem(xa);
		//	xa = AddAttribute(xd, "toid", xr.GetAttribute("toid"));
		//	xe.Attributes.SetNamedItem(xa);
		//	xa = AddAttribute(xd, "rangeid", xr.GetAttribute("rangeid"));
		//	xe.Attributes.SetNamedItem(xa);
		//	xa = AddAttribute(xd, "isrange", xr.GetAttribute("isrange"));
		//	xe.Attributes.SetNamedItem(xa);
		//	xa = AddAttribute(xd, "trantype", xr.GetAttribute("trantype"));
		//	xe.Attributes.SetNamedItem(xa);
		//	xa = AddAttribute(xd, "config", xr.GetAttribute("config"));
		//	xe.Attributes.SetNamedItem(xa);
		//	xa = AddAttribute(xd, "userid", xr.GetAttribute("userid"));
		//	xe.Attributes.SetNamedItem(xa);
		//	xa = AddAttribute(xd, "dts", xr.GetAttribute("dts"));
		//	xe.Attributes.SetNamedItem(xa);
		//	xd.SelectSingleNode("externaltransitions/transitions").AppendChild(xe);
		//}

		// jsj 4-29-2016  appears to not be used
		//private void AddTransitions(XmlReader xr)
		//{
		//	int transitionid = int.Parse(xr.GetAttribute("transitionid"));
		//	int fromid = int.Parse(xr.GetAttribute("fromid"));
		//	int toid = int.Parse(xr.GetAttribute("toid"));
		//	int rangeid = int.Parse(xr.GetAttribute("rangeid"));
		//	int isrange = int.Parse(xr.GetAttribute("isrange"));
		//	int trantype = int.Parse(xr.GetAttribute("trantype"));
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	string lookfor;
		//	if (isrange == 0)
		//		lookfor = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
		//	else
		//		lookfor = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
		//	fromid = Old2NewContent[fromid];
		//	toid = Old2NewItem[toid];
		//	rangeid = Old2NewItem[rangeid];
		//	Content cc = Content.Get(fromid);
		//	Transition tt = Transition.MakeTransition(cc, Item.Get(toid), Item.Get(rangeid), isrange, trantype, config, dts, userid);
		//	transitionid = tt.TransitionID;
		//	string replacewith;
		//	if (isrange == 0)
		//		replacewith = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
		//	else
		//		replacewith = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
		//	cc.Text = cc.Text.Replace(lookfor, replacewith);
		//	cc.Save();
		//}

		private bool _DidProcessTransitions = false; // B2017-076 keep track whether we procrocessed Transitions

		private void AddTransitions(Content content, XmlNode xn)
		{
			/*
			Content
			Item
			Item
			int
			int
			string
			dts
			string
			<transition transitionid="1" fromid="186" toid="175" rangeid="177" isrange="1" trantype="2" config="" dts="4/11/1997 1:20:00 PM" userid="MH" />

			#Link:Transition:1 2 187
			type,id,toid

			#Link:TransitionRange:2 1 175 177
			type,id,toid,rangeid
			*/
			XmlNodeList nl = xn.SelectNodes("./transition");

			foreach (XmlNode nd in nl)
			{
				int toid = int.Parse(nd.Attributes.GetNamedItem("toid").InnerText);
				int rangeid = int.Parse(nd.Attributes.GetNamedItem("rangeid").InnerText);

				if (Old2NewItem.ContainsKey(toid) && Old2NewItem.ContainsKey(rangeid))
				{
					int transitionid = int.Parse(nd.Attributes.GetNamedItem("transitionid").InnerText);
					int isrange = int.Parse(nd.Attributes.GetNamedItem("isrange").InnerText);
					int trantype = int.Parse(nd.Attributes.GetNamedItem("trantype").InnerText);
					string config = nd.Attributes.GetNamedItem("config").InnerText;
					string userid = nd.Attributes.GetNamedItem("userid").InnerText;
					DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
					string lookfor;

					if (isrange == 0)
						lookfor = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
					else
						lookfor = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);

					//fromid = content.ContentID;
					toid = Old2NewItem[toid];
					rangeid = Old2NewItem[rangeid];
					Transition tt = Transition.MakeTransition(content, Item.Get(toid), Item.Get(rangeid), isrange, trantype, config, dts, userid);
					transitionid = tt.TransitionID;
					string replacewith;

					if (isrange == 0)
						replacewith = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
					else
						replacewith = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);

					content.Text = content.Text.Replace(lookfor, replacewith);

					if (content.MyGrid != null && content.MyGrid.Data != "")
					{
						content.MyGrid.Data = content.MyGrid.Data.Replace(lookfor, replacewith);
					}

					_DidProcessTransitions |= content.FixTransitionText(TransitionInfo.Get(tt.TransitionID)); // B2017-076 FixTransitionText will tell us if transitions were processed/changed
					// B2017=003 make sure any grid changes are saved.
					// done here because FixTransitionText() could update the transitions in the grid
					if (content.MyGrid != null && content.MyGrid.Data != "")
						content.MyGrid.Save();

					content.Save();
				}
				else
				{
					PendingTransitions.DocumentElement.AppendChild(PendingTransitions.ImportNode(nd, true));
					//save to holding pen
				}
			}
		}

		private void AddTransitions()
		{
			AddTransitions(PendingTransitions);
		}

		private void AddTransitions(XmlDocument xd)
		{
			/*
			Content
			Item
			Item
			int
			int
			string
			dts
			string
			<transition transitionid="1" fromid="186" toid="175" rangeid="177" isrange="1" trantype="2" config="" dts="4/11/1997 1:20:00 PM" userid="MH" />

			#Link:Transition:1 2 187
			type,id,toid

			#Link:TransitionRange:2 1 175 177
			type,id,toid,rangeid
			*/
			XmlNodeList nl = xd.SelectNodes("//transition");
			lblImportStatus.Text = string.Format("Updating {0} Tranistions", nl.Count.ToString());

			foreach (XmlNode nd in nl)
			{
				int fromid = int.Parse(nd.Attributes.GetNamedItem("fromid").InnerText);
				int toid = int.Parse(nd.Attributes.GetNamedItem("toid").InnerText);
				int rangeid = int.Parse(nd.Attributes.GetNamedItem("rangeid").InnerText);
				int trantype = int.Parse(nd.Attributes.GetNamedItem("trantype").InnerText);
				if (Old2NewContent.ContainsKey(fromid)) //transition from new contentid
				{
					if (Old2NewItem.ContainsKey(toid) && Old2NewItem.ContainsKey(rangeid))	//transition to new itemid (internal)
					{
						int transitionid = int.Parse(nd.Attributes.GetNamedItem("transitionid").InnerText);
						int isrange = int.Parse(nd.Attributes.GetNamedItem("isrange").InnerText);
						string config = nd.Attributes.GetNamedItem("config").InnerText;
						string userid = nd.Attributes.GetNamedItem("userid").InnerText;
						DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
						string lookfor;
						
						if (isrange == 0)
							lookfor = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
						else
							lookfor = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
						
						fromid = Old2NewContent[fromid];
						toid = Old2NewItem[toid];
						rangeid = Old2NewItem[rangeid];
						Content cc = Content.Get(fromid);
						Transition tt = Transition.MakeTransition(cc, Item.Get(toid), Item.Get(rangeid), isrange, trantype, config, dts, userid);
						transitionid = tt.TransitionID;
						string replacewith;
						
						if (isrange == 0)
							replacewith = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
						else
							replacewith = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
						
						cc.Text = cc.Text.Replace(lookfor, replacewith);

						if (cc.MyGrid != null && !string.IsNullOrEmpty(cc.MyGrid.Data))
						{
							cc.MyGrid.Data = cc.MyGrid.Data.Replace(lookfor, replacewith);
						}

						bool forceConvertToText = false;
						if (TransitionInfo.Get(tt.TransitionID).MyItemToID.ActiveSection != null)
						{
							SectionConfig sc = TransitionInfo.Get(tt.TransitionID).MyItemToID.ActiveSection.MyConfig as SectionConfig;
							// Bug fix B2016-081 also check if transition is to a step element
							// This was found when fixing B2018-002 but it actually applies to B2016-081
							forceConvertToText = (sc.SubSection_Edit == "N" && TransitionInfo.Get(tt.TransitionID).MyItemToID.IsStep);
						}

						_DidProcessTransitions |= cc.FixTransitionText(TransitionInfo.Get(tt.TransitionID), forceConvertToText); // B2017-076 FixTransitionText will tell us if transitions were processed/changed
						// B2017=003 make sure any grid changes are saved.
						// done here because FixTransitionText() could update the transitions in the grid
						if (cc.MyGrid != null && cc.MyGrid.Data != "")
							cc.MyGrid.Save();
						cc.Save();
						nd.InnerText = "done";
					}
					else  //transition to existing itemid (external)
					{
						bool forceConvertToText = false;
						int transitionid = int.Parse(nd.Attributes.GetNamedItem("transitionid").InnerText);
						int isrange = int.Parse(nd.Attributes.GetNamedItem("isrange").InnerText);
						string config = nd.Attributes.GetNamedItem("config").InnerText;
						string userid = nd.Attributes.GetNamedItem("userid").InnerText;
						DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
						string lookfor;
						
						if (isrange == 0)
							lookfor = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
						else
							lookfor = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
						
						fromid = Old2NewContent[fromid];
						Content cc = Content.Get(fromid);
						Transition tt = Transition.MakeTransition(cc, Item.Get(toid), Item.Get(rangeid), isrange, trantype, config, dts, userid);
						
						if (tt.TransitionID < 0)
						{
							forceConvertToText = true;
							_DidProcessTransitions |= cc.FixTransitionText(TransitionInfo.Get(tt.TransitionID), forceConvertToText); // B2017-076 FixTransitionText will tell us if transitions were processed/changed
							cc.Save();
							nd.InnerText = "done";
						}
						else
						{
							transitionid = tt.TransitionID;
							string replacewith;
							
							if (isrange == 0)
								replacewith = string.Format("#Link:Transition:{0} {1} {2}", trantype, transitionid, toid);
							else
								replacewith = string.Format("#Link:TransitionRange:{0} {1} {2} {3}", trantype, transitionid, toid, rangeid);
							
							cc.Text = cc.Text.Replace(lookfor, replacewith);

							if (cc.MyGrid != null && !string.IsNullOrEmpty(cc.MyGrid.Data))
							{
								cc.MyGrid.Data = cc.MyGrid.Data.Replace(lookfor, replacewith);
							}

							// B2016-176, B2016-197 - external transitions should be converted to text
							forceConvertToText = true;
							//if (TransitionInfo.Get(tt.TransitionID).MyItemToID.ActiveSection != null)
							//{
							//	SectionConfig sc = TransitionInfo.Get(tt.TransitionID).MyItemToID.ActiveSection.MyConfig as SectionConfig;
							//	forceConvertToText = (sc.SubSection_Edit == "N");
							//}
							//if (!forceConvertToText)	//check to see if external with internal format
							//{
							//	TransitionInfo tran = TransitionInfo.Get(transitionid);
							//	if (tran.MyContent.ContentItems[0].MyProcedure.ItemID != tran.MyItemToID.MyProcedure.ItemID)
							//		if (!tran.MyContent.ContentItems[0].ActiveFormat.PlantFormat.FormatData.TransData.TransTypeList[tran.TranType].TransMenu.Contains("Proc"))
							//			forceConvertToText = true;
							//}
							//if (!forceConvertToText)	//check to see if external to different doc version
							//{
							//	TransitionInfo tran = TransitionInfo.Get(transitionid);
							//	if (tran.MyContent.ContentItems[0].MyDocVersion.VersionID != tran.MyItemToID.MyDocVersion.VersionID)
							//		forceConvertToText = true;
							//}
							_DidProcessTransitions |= cc.FixTransitionText(TransitionInfo.Get(tt.TransitionID), forceConvertToText); // B2017-076 FixTransitionText will tell us if transitions were processed/changed
							// B2017=003 make sure any grid changes are saved.
							// done here because FixTransitionText() could update the transitions in the grid
							if (cc.MyGrid != null && cc.MyGrid.Data != "")
								cc.MyGrid.Save();
							cc.Save();
							nd.InnerText = "done";
							_DidConvertTransitionsToText |= (forceConvertToText && _DidProcessTransitions);  // B2016-225 - notify user when transitions are converted to text
						}
					}
				}
			}
		}

		private Dictionary<int, int> Old2NewItem;
		private Dictionary<int, int> Old2NewContent;
		private Dictionary<int, int> Old2NewLibDoc;
		private Dictionary<string, int> ExistingLibDocs; // B2019-035 better memory management
		private XmlDocument PendingTransitions;
		private RODb MyRODb = null;

		// jsj 4-29-2016  appears to not be used
		//private Folder AddFolder(Folder folder, XmlReader xr)
		//{
		//	Old2NewItem = new Dictionary<int, int>();
		//	Old2NewContent = new Dictionary<int, int>();
		//	Old2NewLibDoc = new Dictionary<int, int>();
		//	string title = xr.GetAttribute("title");
		//	string name = xr.GetAttribute("name");
		//	string shortname = xr.GetAttribute("shortname");
		//	string usrid = xr.GetAttribute("usrid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	string formatid = xr.GetAttribute("formatid");
		//	string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
		//	Format format = formatid == string.Empty ? null : OldToNewFormat(int.Parse(formatid),formatfilename);
		//	folder = Folder.MakeFolder(folder, folder.MyConnection, name, title, shortname, format, null, dts, usrid);
		//	//f.Save();
		//	return folder;
		//}

		private Folder AddFolder(Folder p, XmlDocument xd, string name)
		{
			lblImportStatus.Text = "Creating Folder...";
			Application.DoEvents();

			string title = xd.DocumentElement.Attributes.GetNamedItem("title").InnerText;
			//string name = xd.DocumentElement.Attributes.GetNamedItem("name").InnerText;
			string shortname = xd.DocumentElement.Attributes.GetNamedItem("shortname").InnerText;
			string usrid = xd.DocumentElement.Attributes.GetNamedItem("usrid").InnerText;
			DateTime dts = DateTime.Parse(xd.DocumentElement.Attributes.GetNamedItem("dts").InnerText);
			string formatid = xd.DocumentElement.Attributes.GetNamedItem("formatid").InnerText;
			XmlNode fnNode = xd.DocumentElement.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
			string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
			Format format = formatid == string.Empty ? null : OldToNewFormat(int.Parse(formatid), formatfilename);

			if (Folder.GetByParentID_Name(p.FolderID, name) != null)
				return null;

			// B2020-053: procedure set (folder) specific info was not imported:
			string config = xd.DocumentElement.Attributes.GetNamedItem("config").InnerText;
			Folder f = Folder.MakeFolder(p, p.MyConnection, name, title, shortname, format, config, dts, usrid);

			return f;
		}

		private Format OldToNewFormat(int formatID, string formatFileName)
		{
			try
			{
				string formatName = formatFileName; // B2016-103,  new export files include the format filename use that if it exists
				if (formatFileName == string.Empty)
				{
					if (formatID >= importedFormat.Count) return null; // formatID not found, use default file name
					formatName = importedFormat[formatID];  // for backwards compatibility with older export files
				}
				if (renamedUCFFormatName != null && renamedUCFFormatName.ContainsKey(formatFileName)) formatName = renamedUCFFormatName[formatName];
				formatID = existingFormat[formatName];
				return Format.Get(formatID);
			}
			catch
			{
				return null; // format not found return null to use default format
			}
		}

		private DocVersion AddDocVersion(Folder f, XmlReader xr)
		{
			int versiontype = int.Parse(xr.GetAttribute("versiontype"));
			string name = xr.GetAttribute("name");
			string config = xr.GetAttribute("config");
			string userid = xr.GetAttribute("userid");
			DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
			string formatid = xr.GetAttribute("formatid");
			string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
			Format format = formatid == string.Empty ? null : OldToNewFormat(int.Parse(formatid), formatfilename);
			
			DocVersion dv = DocVersion.MakeDocVersion(f, versiontype, name, null, null, format, config, dts, userid);
			
			return dv;
		}

		private void AddAnnotationTypes(XmlDocument xd)
		{
			XmlNodeList nl = xd.SelectNodes("folder/annotationtypes/annotationtype");
			foreach (XmlNode nd in nl)
			{
				AnnotationTypeInfo ati = AnnotationTypeInfo.GetByName(nd.Attributes.GetNamedItem("name").InnerText);
				if (ati == null)
					AnnotationType.MakeAnnotationType(nd.Attributes.GetNamedItem("name").InnerText, nd.Attributes.GetNamedItem("config").InnerText, DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText), nd.Attributes.GetNamedItem("userid").InnerText);
			}
		}

		private DocVersionInfo AddDocVersion(Folder f, XmlDocument xd)
		{
			lblImportStatus.Text = "Creating DocVersion...";
			Application.DoEvents();

			XmlElement xe = (XmlElement)xd.SelectSingleNode("folder/docversion");
			int versiontype = int.Parse(xe.Attributes.GetNamedItem("versiontype").InnerText);
			string name = xe.Attributes.GetNamedItem("name").InnerText;
			string config = xe.Attributes.GetNamedItem("config").InnerText;
			config = StripEnhanced(config);
			string userid = xe.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(xe.Attributes.GetNamedItem("dts").InnerText);
			string formatid = xe.Attributes.GetNamedItem("formatid").InnerText;
			XmlNode fnNode = xe.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
			string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
			Format format = formatid == string.Empty ? null : OldToNewFormat(int.Parse(formatid), formatfilename);

			DocVersion dv = DocVersion.MakeDocVersion(f, versiontype, name, null, null, format, config, dts, userid);
			XmlNode xassoc = xe.SelectSingleNode("association");

			if (xassoc != null)
			{
				XmlNode xrofst = xassoc.SelectSingleNode("rofst");
				XmlNode xrodb = xrofst.SelectSingleNode("rodb");
				MyRODb = AddRODb(xrodb);
				ROFst rofst = AddROFst(xrofst);

				DocVersionAssociation dva = dv.DocVersionAssociations.Add(rofst);

				dv.Save();
			}

			return DocVersionInfo.Get(dv.VersionID);
		}

		// jsj 4-29-2016  appears to not be used
		//private Dictionary<string, string> GetROFstData(XmlReader xr)
		//{
		//	Dictionary<string, string> rv = new Dictionary<string, string>();
		//	rv.Add("rolookup", xr.GetAttribute("rolookup"));
		//	rv.Add("config", xr.GetAttribute("config"));
		//	rv.Add("userid", xr.GetAttribute("userid"));
		//	rv.Add("dts", xr.GetAttribute("dts"));
		//	return rv;
		//}

		// jsj 4-29-2016  appears to not be used
		//private ROFst AddROFst(Dictionary<string,string> dic)
		//{
		//	byte[] rolookup = Convert.FromBase64String(dic["rolookup"]);
		//	string config = dic["config"];
		//	string userid = dic["userid"];
		//	DateTime dts = DateTime.Parse(dic["dts"]);
		//	ROFst rv = null;
		//	rv = ROFst.GetByRODbID_DTS(MyRODb.RODbID, dts);	//MyRODb.DTS);
		//	if (rv == null)
		//		rv = ROFst.MakeROFst(MyRODb, rolookup, config, dts, userid);
		//	return rv;
		//}

		private ROFst AddROFst(XmlNode xrofst)
		{
			lblImportStatus.Text = "Creating ROFst...";
			Application.DoEvents();

			byte[] rolookup = Convert.FromBase64String(xrofst.Attributes.GetNamedItem("rolookup").InnerText);
			string config = xrofst.Attributes.GetNamedItem("config").InnerText;
			string userid = xrofst.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(xrofst.Attributes.GetNamedItem("dts").InnerText);

			ROFst rv = ROFst.GetByRODbID_DTS(MyRODb.RODbID, dts);

			// if the RO database is not found in the current data (does not have the same RODBid nor date/time stamp
			// then spin through the list of RO databases and compare the FST information.
			// If the RO FST information is the same, then use that current RO database when importing
			if (rv == null)
			{
				RODbInfoList rodblst = RODbInfoList.Get();

				foreach (RODbInfo roinfo in rodblst)
				{
					rv = ROFst.GetByRODbID_DTS(roinfo.RODbID, dts);
					if (rv != null && Same(ROFSTLookup.GetRofstLookupBytes(rv.ROFstID), rolookup)) // B2022-026 RO Memory reduction - new calls
					{
						return rv;
					}
				}

				rv = ROFst.MakeROFst(MyRODb, rolookup, config, dts, userid);

				XmlNode xfigures = xrofst.SelectSingleNode("figures");
				if (xfigures != null)
					AddFigures(xfigures, rv);
			}

			return rv;
		}

		private bool Same(byte[] p, byte[] rolookup)
		{
			if (p.Length != rolookup.Length) return false;
			for (int i = 0; i < p.Length; i++)
				if (p[i] != rolookup[i]) return false;
			return true;
		}

		private void AddFigures(XmlNode xfigures, ROFst rofst)
		{
			foreach (XmlNode nd in xfigures.SelectNodes("figure"))
			{
				XmlNode image = nd.SelectSingleNode("image");
				int imageid = int.Parse(image.Attributes.GetNamedItem("imageid").InnerText);

				using (ROImage roimage = ROImage.GetJustROImage(imageid))//Dispose when done
				{
					string config;
					DateTime dts;
					string userid;

					if (roimage == null)
					{
						string filename = image.Attributes.GetNamedItem("filename").InnerText;
						byte[] content = Convert.FromBase64String(image.Attributes.GetNamedItem("content").InnerText);
						config = image.Attributes.GetNamedItem("config").InnerText;
						dts = DateTime.Parse(image.Attributes.GetNamedItem("dts").InnerText);
						userid = image.Attributes.GetNamedItem("userid").InnerText;

						// Dispose when done
						using (ROImage roimage1 = ROImage.MakeROImage(MyRODb, filename, content, config, dts, userid))
						{
							config = nd.Attributes.GetNamedItem("config").InnerText;
							dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
							userid = nd.Attributes.GetNamedItem("userid").InnerText;

							// Dispose when done
							using (Figure fig = Figure.MakeFigure(rofst, roimage, config, dts, userid)) { ;}
						}
					}
					else
					{
						config = nd.Attributes.GetNamedItem("config").InnerText;
						dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
						userid = nd.Attributes.GetNamedItem("userid").InnerText;
						// Dispose when done
						using (Figure fig = Figure.MakeFigure(rofst, roimage, config, dts, userid)) { ;}
					}

				}
			}
		}

		// jsj 4-29-2016  appears to not be used
		//private RODb AddRODb(XmlReader xr)
		//{
		//	oldRODbID = int.Parse(xr.GetAttribute("rodbid"));
		//	string roname = xr.GetAttribute("roname");
		//	string folderpath = xr.GetAttribute("folderpath");
		//	string dbconnectionstring = xr.GetAttribute("dbconnectionstring");
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	RODb rv = null;
		//	rv = RODb.GetByFolderPath(folderpath);
		//	if (rv == null)
		//		rv = RODb.MakeRODb(roname, folderpath, dbconnectionstring, config, dts, userid);
		//	newRODbID = rv.RODbID;
		//	return rv;
		//}

		private RODb AddRODb(XmlNode xrodb)
		{
			lblImportStatus.Text = "Creating RODb...";
			Application.DoEvents();

			oldRODbID = int.Parse(xrodb.Attributes.GetNamedItem("rodbid").InnerText);
			string roname = xrodb.Attributes.GetNamedItem("roname").InnerText;
			string folderpath = xrodb.Attributes.GetNamedItem("folderpath").InnerText;
			string dbconnectionstring = xrodb.Attributes.GetNamedItem("dbconnectionstring").InnerText;
			string config = xrodb.Attributes.GetNamedItem("config").InnerText;
			string userid = xrodb.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(xrodb.Attributes.GetNamedItem("dts").InnerText);

			RODb rv = RODb.GetByFolderPath(folderpath);

			if (rv == null)
			{
				// create a list of the RO databases currently in the database
				List<string> roDbNameList = new List<string>();
				RODbInfoList rolist = RODbInfoList.Get();

				foreach (RODbInfo rodbinfo in rolist)
				{
					if (!roDbNameList.Contains(rodbinfo.ROName))
						roDbNameList.Add(rodbinfo.ROName);
				}

				rolist.Dispose();
				int cnt = 0;
				string roNameNew = roname;

				// if the ROname we are importing is the same as one already in the database
				// and the ROpaths are different, then rename the one we are importing
				while (roDbNameList.Contains(roNameNew))
				{
					roNameNew = string.Format("{0}_{1}", roname, (++cnt).ToString());
				}

				rv = RODb.MakeRODb(roNameNew, folderpath, dbconnectionstring, config, dts, userid);
			}

			newRODbID = rv.RODbID;
			return rv;
		}

		// jsj 4-29-2016 appears to not be used
		//private int GetProcedureData(XmlReader xr)
		//{
		//	return int.Parse(xr.GetAttribute("itemid"));
		//}

		// jsj 4-29-2016 appears to not be used
		//private ItemInfo AddProcedure(XmlReader xr, DocVersion dv, ItemInfo procInfo, int oldid)
		//{
		//	DocVersionInfo dvInfo = DocVersionInfo.Get(dv.VersionID);
		//	string number = xr.GetAttribute("number");
		//	string text = xr.GetAttribute("text");
		//	int proctype = int.Parse(xr.GetAttribute("type"));
		//	string formatid = xr.GetAttribute("formatid");
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	Procedure p = Procedure.MakeProcedure(dvInfo, procInfo, number, text, proctype);
		//	p.DTS = dts;
		//	p.UserID = userid;
		//	string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
		//	if (formatid != string.Empty)
		//		p.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid),formatfilename);
		//	p.MyContent.Config = config;
		//	p.MyContent.DTS = dts;
		//	p.MyContent.UserID = userid;
		//	p.Save();
		//	Old2NewItem.Add(oldid, p.ItemID);
		//	Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), p.MyContent.ContentID);
		//	procInfo = ProcedureInfo.Get(p.ItemID);
		//	return procInfo;
		//}
		private ProcedureInfo AddProcedure(XmlNode xn, DocVersionInfo dvInfo, ProcedureInfo procInfo)
		{
			pbImportProcedure.PerformStep();
			lblImportProcedure.Text = string.Format("{0} of {1} Procedures", pbImportProcedure.Value.ToString(), pbImportProcedure.Maximum.ToString());
			TimeSpan elapsed = DateTime.Now.Subtract(MyStart);
			lblImportTime.Text = "Elapsed Time: " + elapsed.ToString();
			Application.DoEvents();

			XmlNode xc = xn.SelectSingleNode("content");
			string number = xc.Attributes.GetNamedItem("number").InnerText;
			string text = xc.Attributes.GetNamedItem("text").InnerText;
			int proctype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
			string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
			string config = xc.Attributes.GetNamedItem("config").InnerText;
			config = StripEnhanced(config);
			string userid = xc.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);

			using (Procedure p = Procedure.MakeProcedure(dvInfo, procInfo, number, text, proctype))
			{
				p.DTS = dts;
				p.UserID = userid;
				// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
				XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
				string formatfilename = (fnNode != null) ? fnNode.InnerText : "";

				if (formatid != string.Empty) p.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
				p.MyContent.Config = config;
				p.MyContent.DTS = dts;
				p.MyContent.UserID = userid;

				p.Save();

				if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
					Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), p.ItemID);
				else
					Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = p.ItemID; // B2016-176, B2016-197 refresh saved ItemId with current ItemID
				
				if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
					Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), p.MyContent.ContentID);
				else
					Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = p.MyContent.ContentID; // B2016-176, B2016-197 refresh saved ContentID with current ContentID
				
				if (xn.SelectNodes("annotation").Count > 0)
					AddAnnotations(p.ItemID, xn);

				if (xc.SelectNodes("rousage").Count > 0)
					AddROUsages(p.MyContent, xc);

				if (xc.SelectNodes("transition").Count > 0)
					AddTransitions(p.MyContent, xc);

				procInfo = ProcedureInfo.Get(p.ItemID);
			}

			if (xc.HasChildNodes)
			{
				AddParts(xc, procInfo);
			}

			FixSectionStart(procInfo);

			return procInfo;
		}

		// jsj 2016Feb16 - This appears to not be used
		//private void AddROUsage(XmlReader xr)
		//{
		//	int contentid = int.Parse(xr.GetAttribute("contentid"));
		//	contentid = Old2NewContent[contentid];
		//	Content content = Content.Get(contentid);
		//	string rousageid = xr.GetAttribute("rousageid");
		//	string roid = xr.GetAttribute("roid");
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	RoUsage rou = RoUsage.MakeRoUsage(content, roid, config, dts, userid, MyRODb);
		//	rou.Save();
		//	string lookFor = string.Format("#Link:ReferencedObject:{0} {1} {2}[END>", rousageid, roid, oldRODbID.ToString());
		//	string replaceWith = (cbxCvrtROsToText.Checked) ? "" : string.Format("#Link:ReferencedObject:{0} {1} {2}[END>", rou.ROUsageID.ToString(), roid, newRODbID.ToString());
		//	if (lookFor != replaceWith)
		//	{
		//		content.Text = content.Text.Replace(lookFor, replaceWith);
		//		content.Save();
		//	}
		//}
		private string GetMyPrefix(string text, int start, int lastIndex)
		{
			string defPrefix = text.Substring(start - 3, 3);
			if (defPrefix != @"\v ") throw new Exception(string.Format("rtf string {0} does not match expected format", defPrefix));
			string txt = text.Substring(lastIndex, start - lastIndex - 3);
			int lastSlash = txt.LastIndexOf(@"\");
			int lastSpace = txt.LastIndexOf(" ");
			int lastCR = txt.LastIndexOf("\r");
			if (lastSpace < lastCR)
				lastSpace = lastCR;
			if (lastSlash <= lastSpace) //this will return "\v "
				return defPrefix;
			txt = txt.Substring(lastSlash);
			if (txt.StartsWith(@"\'"))	//this is a hex
				return defPrefix;
			if (Regex.IsMatch(txt, @"\\u[0-9].*"))	//this is unicode
				return defPrefix;
			return @"\v";
		}
		private string GetMySuffix(string text, int start)
		{
			string txt = text.Substring(start);
			int firstSlashVeeZero = txt.IndexOf(@"\v0");
			if (firstSlashVeeZero == 0 && txt.Length > 3 && txt[3] == ' ')	//"\v0 "
				return text.Substring(start, 4);
			return text.Substring(start, firstSlashVeeZero + 3);	//everything upto \v0"
		}
		private void ConvertImportProcedureROsToText(Content content, XmlNode xn)
		{
			foreach (XmlNode nd in xn.SelectNodes("rousage"))
			{
				string rousageid = nd.Attributes.GetNamedItem("rousageid").InnerText;
				string roid = nd.Attributes.GetNamedItem("roid").InnerText;

				string findLink = @"<START\].*?\[END>";
				content.Text = content.Text.Replace("<START]<START]", "<START]").Replace(@"[END><START]", @"[END>\v0 \v <START]"); //B2020-057 bad RO link - remove extra START and insert comment off/on between <END]<START]
				content.Save();
				MatchCollection ms = Regex.Matches(content.Text, findLink);
				string lookFor = string.Format(@"^<START\](\\[^v \\]+)*\\v0(\\[^v '?{{}}~\\]+)*( |\\u[0-9]{{1,4}}?|\\'[0-9a-fA-F]{{2}}|\\[{{}}~])(.*?)(\\[^v'?{{}}~ \\]+)*\\v(\\[^v \\]+)* #Link:ReferencedObject:{0} .*?\[END>$", rousageid);
				int lastIndex = 0;
				string newText = content.Text;
				// B2018-046 This loop repeats code to convert duplicate ROs in text to text
				int originalCount = 0;
				while (ms.Count > 0 && (originalCount == 0 || ms.Count < originalCount))
				{
					originalCount = ms.Count;
					foreach (Match mm in ms)
					{
						int offset = mm.Index;
						Match m = Regex.Match(mm.Value, lookFor, RegexOptions.Singleline);
						if (m != null && m.Groups.Count > 1)
						{
							string prefix = GetMyPrefix(content.Text, mm.Index, lastIndex);
							string suffix = GetMySuffix(content.Text, mm.Index + mm.Length);
							int myIndex = m.Groups[4].Index + mm.Index;
							int myLength = m.Groups[4].Length;
							if (m.Groups[3].Value != " ")
							{
								myIndex = m.Groups[3].Index + mm.Index;
								myLength += m.Groups[3].Length;
							}
							string gg = newText.Substring(myIndex, myLength);
							gg = gg.Replace("{", @"\{").Replace("}", @"\}");
							string part1 = newText.Substring(0, mm.Index);
							string part2 = gg;
							string part3 = newText.Substring(mm.Index + mm.Length);
							//modify part1 based on prefix
							if (prefix == @"\v ")
								part1 = part1.Substring(0, part1.Length - 3);
							else
								part1 = part1.Substring(0, part1.Length - 3) + " ";
							//modify part3 based on suffix
							if (suffix == @"\v0 ")
								part3 = part3.Substring(4);
							else
								part3 = suffix.Replace(@"\v0", "") + part3.Substring(suffix.Length);
							content.Text = part1 + part2 + part3;
							ROToTextAnnotation(content, part2); // B2016-225 (follow through) add annotation when RO is converted to text
							_DidProcessROs = true; // B2017-076 flag that ROs where processed
							break;  // B2018-046 If it finds a match try again
						}
						lastIndex = mm.Index + mm.Length;
					}
					ms = Regex.Matches(content.Text, findLink); // B2018-046 Look for match again
				}
			}
			content.Save();
		}

		// B2016-225 (follow through) add annotation when RO is converted to text
		private void ROToTextAnnotation(Content content, string txtRO)
		{
			// replace unicode symbols to DOS code symbols
			txtRO = txtRO.Replace(@"\u8209?", "-"); // dash
			txtRO = txtRO.Replace(@"\u9586?", @"\\"); // backslash
			txtRO = txtRO.Replace(@"\'b0", "\xb0"); //degree
			txtRO = txtRO.Replace(@"\u160?", " "); //hard space
			txtRO = txtRO.Replace(@"\u916?", "\x7F"); // delta
			txtRO = txtRO.Replace(@"\u8805?", "\xF2"); //greater than or equal
			txtRO = txtRO.Replace(@"\u8804?", "\xF3");	// less than or equal
			txtRO = txtRO.Replace(@"\u931?", "\xE4");		// sigma
			txtRO = txtRO.Replace(@"\u947?", "\xE7");		// gamma
			txtRO = txtRO.Replace(@"\u9604?", "\xFE");	// accum 2584
			txtRO = txtRO.Replace(@"\u9679?", "\x7");		// bullet 25CF
			txtRO = txtRO.Replace(@"\u8776?", "\xF7");	// approx eq
			txtRO = txtRO.Replace(@"\u8773?", "\xF0");	// similar eq 2245
			txtRO = txtRO.Replace(@"\u8730?", "\xFB");	// square root
			txtRO = txtRO.Replace(@"\u961?", "\xE2");		// rho 3C1
			txtRO = txtRO.Replace(@"\u960?", "\xE3");		// pi
			txtRO = txtRO.Replace(@"\u956?", "\xE6");	// micro
			txtRO = txtRO.Replace(@"\u948?", "\xEB");	// lower case delta
			txtRO = txtRO.Replace(@"\u963?", "\xE5");	// lower case sigma
			txtRO = txtRO.Replace(@"\u274?", "\x90");		// energy, 112
			txtRO = txtRO.Replace(@"\u949?", "\xEE");	// epsilon	
			txtRO = txtRO.Replace(@"\u952?", "\xE9");	// theta, 3B8
			txtRO = txtRO.Replace(@"\u8857?", "\xEC");	// dot in oval, 2299
			txtRO = txtRO.Replace(@"\u964?", "\xA8");		// tau, 3C4
			txtRO = txtRO.Replace(@"\u9830?", "\xA9");	// diamond, 2666
			txtRO = txtRO.Replace(@"\u8593?", "\x18"); // Up Arrow - changes to \xff
			txtRO = txtRO.Replace(@"\u8595?", "\x19"); // Down Arrow - changes to \xd6

			Item myitem = content.ContentItems[0].MyItem; // The Using statement caused the content.text to disappear
			//using (Item myitem = content.ContentItems[0].MyItem) // so that myitem does not stay in cache
			//{
			Annotation.MakeAnnotation(myitem, AnnotationType.GetByNameOrCreate("Link Converted To Text"), "", string.Format("RO value ({0}) converted to text", txtRO), null);
			//}
			_DidConvertROsToText |= true;
		}

		private bool _DidProcessROs = false; // B2017-076 flag that ROs where processed
		private void AddROUsages(Content content, XmlNode xn)
		{
			AddROUsages(content, xn, false);
		}

		// part of bug fix B2017-060 added the isGrid parameter
		private void AddROUsages(Content content, XmlNode xn, bool isGrid)
		{
			if (_ImportingApprovedExportFile) return; //B2020-095 the links are already removed from the import file
			_DidProcessROs = false;

			if (_ConvertROsToTextDuringImport)
				ConvertImportProcedureROsToText(content, xn);
			else
			{
				foreach (XmlNode nd in xn.SelectNodes("rousage"))
				{
					string rousageid = nd.Attributes.GetNamedItem("rousageid").InnerText;
					string roid = nd.Attributes.GetNamedItem("roid").InnerText;
					string config = nd.Attributes.GetNamedItem("config").InnerText;
					string userid = nd.Attributes.GetNamedItem("userid").InnerText;
					DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);

					if (MyDocVersion.DocVersionAssociations == null)
						MyDocVersion.RefreshDocVersionAssociations();

					ROFSTLookup lookup = MyDocVersion.DocVersionAssociations[0].MyROFst.GetROFSTLookup(MyDocVersion);

					// B2023-104 use this to replace RO Link information in the imported text
					//            FormatRoidKey() was creating the roid with the new formatting introduce with B2022-088 & B2022-098
					//           We need to save the ROID from the imported text in order to update it with the new RO link information
					string contentROID = roid;

					// B2022-088: [JPR] Find Doc Ro button not working in Word Sections
					// B2022-098: [JPR] ROs not being resolved in Word Sections
					roid = ROFSTLookup.FormatRoidKey(roid, true);
					ROFSTLookup.rochild roc = lookup.GetRoChild(roid);
					string roval = roc.value;
					
					if (roval == "?")
					{
						RoUsageInfo roui = RoUsageInfo.Get(int.Parse(rousageid));
						content.FixContentText(roui, roval, 0, MyDocVersion.DocVersionAssociations[0].MyROFst, null, rousageid); // + " " + roid);
						_DidConvertROsToText |= true; // B2016-225 (follow through) add annotation when RO is converted to text
						_DidProcessROs = true; // B2017-076 flag that ROs where processed
					}
					else
					{
						RoUsage rou = RoUsage.MakeRoUsage(content, roid, config, dts, userid, MyRODb);
						rou.Save();

						RoUsageInfo roui = RoUsageInfo.Get(rou.ROUsageID);
						//B2023-104 use the ROID from the imported text (contentROID) to create the lookFor string
						string lookFor = string.Format("#Link:ReferencedObject:{0} {1} {2}[END>", rousageid, contentROID, oldRODbID.ToString());
						string replaceWith = string.Format("#Link:ReferencedObject:{0} {1} {2}[END>", rou.ROUsageID.ToString(), roid, newRODbID.ToString());
						_DidProcessROs = content.Text.Contains(lookFor); // B2017-076 RO link in the text so we will be processing it
						
						if (lookFor != replaceWith)
						{
							content.Text = content.Text.Replace(lookFor, replaceWith);
							content.FixContentText(roui, roval, 0, MyDocVersion.DocVersionAssociations[0].MyROFst);
						}

						if (isGrid) // B2017-060 when importing a grid, also update the grid's xml defination
						{
							string glookFor = string.Format("#Link:ReferencedObject:{0} {1} {2}[END&gt;", rousageid, roid, oldRODbID.ToString());
							string greplaceWith = string.Format("#Link:ReferencedObject:{0} {1} {2}[END&gt;", rou.ROUsageID.ToString(), roid, newRODbID.ToString());
							
							if (glookFor != greplaceWith)
							{
								content.MyGrid.Data = content.MyGrid.Data.Replace(glookFor, greplaceWith);
							}
						}
					}

				}

				content.Save();

				if (isGrid)
					GridInfo.Refresh(content.MyGrid); // force the updated grid (table) to refresh
			}
		}

		// jsj 4-29-2016 appears to not be used
		//private void AddAnnotation(XmlReader xr)
		//{
		//	int itemid = int.Parse(xr.GetAttribute("itemid"));
		//	itemid = Old2NewItem[itemid];
		//	Item itm = Item.Get(itemid);
		//	int typeid = int.Parse(xr.GetAttribute("typeid"));
		//	string rtftext = xr.GetAttribute("rtftext");
		//	string searchtext = xr.GetAttribute("searchtext");
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	Annotation ann = Annotation.MakeAnnotation(itm, AnnotationType.Get(typeid), rtftext, searchtext, config, dts, userid);
		//}
		private void AddImage(Content content, XmlNode xc)
		{
			XmlNode xn = xc.SelectSingleNode("image");
			int imagetype = int.Parse(xn.Attributes.GetNamedItem("imagetype").InnerText);
			string filename = xn.Attributes.GetNamedItem("filename").InnerText;
			byte[] data = Convert.FromBase64String(xn.Attributes.GetNamedItem("data").InnerText);
			string config = xn.Attributes.GetNamedItem("config").InnerText;
			string userid = xn.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(xn.Attributes.GetNamedItem("dts").InnerText);
			VEPROMS.CSLA.Library.Image img = VEPROMS.CSLA.Library.Image.MakeImage(content, imagetype, filename, data, config, dts, userid);
			img.Save();
		}
		private void AddAnnotations(int itemID, XmlNode xn)
		{
			using (Item itm = Item.Get(itemID)) //B2019-035 better memory management
			{
				foreach (XmlNode nd in xn.SelectNodes("annotation"))
				{
					int typeid = int.Parse(nd.Attributes.GetNamedItem("typeid").InnerText);
					string rtftext = nd.Attributes.GetNamedItem("rtftext").InnerText;
					string searchtext = nd.Attributes.GetNamedItem("searchtext").InnerText;
					string config = nd.Attributes.GetNamedItem("config").InnerText;
					string userid = nd.Attributes.GetNamedItem("userid").InnerText;
					DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
					AnnotationType annType = AnnotationType.GetByNameOrCreate(nd.Attributes.GetNamedItem("typename").InnerText);
					Annotation ann = Annotation.MakeAnnotation(itm, annType, rtftext, searchtext, config, dts, userid);
					ann.Save();
				}
			}
		}
		private void AddParts(XmlNode myNode, ItemInfo parentInfo)
		{
			foreach (XmlNode xn in myNode.ChildNodes)
			{
				// B2018-154 Code added to check for incorrect Part record.
				// Barakah Conversion Code incorrectly set the FromType to Step rather than Table.
				// This has been corrected in the conversion code.
				string xnName = xn.Name;
				if (xn.SelectSingleNode("step/content/grid") != null)
					xnName = "tables";
				switch (xnName)
				{
					case "sections":
						AddSections(xn, parentInfo);
						break;
					case "cautions":
						AddCautions(xn, parentInfo);
						break;
					case "notes":
						AddNotes(xn, parentInfo);
						break;
					case "rnos":
						AddRNOs(xn, parentInfo);
						break;
					case "steps":
						AddSteps(xn, parentInfo);
						break;
					case "supinfos":
						AddSupInfos(xn, parentInfo);
						break;
					case "tables":
						AddTables(xn, parentInfo);
						break;
					case "entry": // this is word section max out the status bar
						lblImportStep.Text = "Word Section Data";
						pbImportStep.Maximum = 1;
						pbImportStep.PerformStep();
						break;
					default:
						break;
				}
			}
		}

		private void AddTables(XmlNode xn, ItemInfo parentInfo)
		{
			if (parentInfo.IsProcedure)
			{
				pbImportSection.Value = 0;
				pbImportStep.Value = 0;
				pbImportSection.Maximum = xn.ChildNodes.Count;
			}
			if (parentInfo.IsSection)
			{
				pbImportStep.Value = 0;
				pbImportStep.Maximum = xn.ChildNodes.Count;
			}
			ItemInfo prevInfo = null;
			foreach (XmlNode nd in xn.ChildNodes)
				prevInfo = AddTable(nd, parentInfo, prevInfo);
		}

		// jsj 2016Feb16 - This appears to not be used
		//private ItemInfo AddTable(XmlReader xr, ItemInfo parentInfo, ItemInfo prevInfo, int oldid)
		//{
		//	string number = xr.GetAttribute("number");
		//	string text = xr.GetAttribute("text");
		//	int steptype = int.Parse(xr.GetAttribute("type"));
		//	string formatid = xr.GetAttribute("formatid");
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	Step step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Table);
		//	step.DTS = dts;
		//	step.UserID = userid;
		//	if (formatid != string.Empty)
		//		step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid));
		//	step.MyContent.Config = config;
		//	step.MyContent.DTS = dts;
		//	step.MyContent.UserID = userid;
		//	step.Save();
		//	Old2NewItem.Add(oldid, step.ItemID);
		//	Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), step.MyContent.ContentID);
		//	prevInfo = StepInfo.Get(step.ItemID);
		//	return prevInfo;
		//}
		private ItemInfo AddTable(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
		{
			pbImportStep.PerformStep();
			lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
			Application.DoEvents();

			XmlNode xc = xn.SelectSingleNode("content");
			Step step;
			string number = xc.Attributes.GetNamedItem("number").InnerText;
			string text = xc.Attributes.GetNamedItem("text").InnerText;
			int steptype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
			string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
			string config = xc.Attributes.GetNamedItem("config").InnerText;
			config = StripEnhanced(config);
			int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
			CheckForFloatingFoldout(contentid, config);
			string userid = xc.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);

			using (step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Table))
			{
				step.DTS = dts;
				step.UserID = userid;
				// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
				XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
				string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
				
				if (formatid != string.Empty)
					step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);

				step.MyContent.Config = config;
				step.MyContent.DTS = dts;
				step.MyContent.UserID = userid;

				step.Save();

				if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
					Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), step.ItemID);
				else
					Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = step.ItemID; // B2016-176, B2016-197 refresh saved ItemId with current ItemID
				
				if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
					Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), step.MyContent.ContentID);
				else
					Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = step.MyContent.ContentID;  // B2016-176, B2016-197 refresh saved ContentID with current ContentID
				
				if (xc.SelectNodes("grid").Count > 0)
					AddGrid(step.MyContent, xc);
				
				if (xc.SelectNodes("image").Count > 0)
					AddImage(step.MyContent, xc);
				
				if (xn.SelectNodes("annotation").Count > 0)
					AddAnnotations(step.ItemID, xn);
				
				if (xc.SelectNodes("rousage").Count > 0)
					AddROUsages(step.MyContent, xc, true); // part of bug fix:  B2017060 to properly convert invalid RO to text
				
				if (xc.SelectNodes("transition").Count > 0)
					AddTransitions(step.MyContent, xc);
				
				prevInfo = StepInfo.Get(step.ItemID);
				
				if (xc.HasChildNodes)
					AddParts(xc, prevInfo);
			}

			return prevInfo;
		}

		private void AddSteps(XmlNode xn, ItemInfo parentInfo)
		{
			if (parentInfo.IsProcedure)
			{
				pbImportSection.Value = 0;
				pbImportStep.Value = 0;
				pbImportSection.Maximum = xn.ChildNodes.Count;
			}
			if (parentInfo.IsSection)
			{
				pbImportStep.Value = 0;
				pbImportStep.Maximum = xn.ChildNodes.Count;
			}
			ItemInfo prevInfo = null;
			foreach (XmlNode nd in xn.ChildNodes)
				prevInfo = AddStep(nd, parentInfo, prevInfo);
		}

		// jsj 4-29-2016 appears to not be used
		//private ItemInfo AddStep(XmlReader xr, ItemInfo parentInfo, ItemInfo prevInfo, int oldid)
		//{
		//	string number = xr.GetAttribute("number");
		//	string text = xr.GetAttribute("text");
		//	int steptype = int.Parse(xr.GetAttribute("type"));
		//	string formatid = xr.GetAttribute("formatid");
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	Step step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Step);
		//	step.DTS = dts;
		//	step.UserID = userid;
		//	string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
		//	if (formatid != string.Empty)
		//		step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid),formatfilename);
		//	step.MyContent.Config = config;
		//	step.MyContent.DTS = dts;
		//	step.MyContent.UserID = userid;
		//	step.Save();
		//	Old2NewItem.Add(oldid, step.ItemID);
		//	Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), step.MyContent.ContentID);
		//	prevInfo = StepInfo.Get(step.ItemID);
		//	return prevInfo;
		//}
		private ItemInfo AddStep(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
		{
			pbImportStep.PerformStep();
			lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
			Application.DoEvents();

			XmlNode xc = xn.SelectSingleNode("content");
			Step step;
			string number = xc.Attributes.GetNamedItem("number").InnerText;
			string text = xc.Attributes.GetNamedItem("text").InnerText;
			int steptype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
			string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
			string config = xc.Attributes.GetNamedItem("config").InnerText;
			config = StripEnhanced(config);
			int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
			CheckForFloatingFoldout(contentid, config);
			string userid = xc.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);

			using (step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Step))
			{
				step.DTS = dts;
				step.UserID = userid;
				// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
				XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
				string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
				
				if (formatid != string.Empty)
					step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
				
				step.MyContent.Config = config;
				step.MyContent.DTS = dts;
				step.MyContent.UserID = userid;

				step.Save();

				if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
					Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), step.ItemID);
				else
					Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = step.ItemID;  // B2016-176, B2016-197 refresh saved ItemId with current ItemID
				
				if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
					Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), step.MyContent.ContentID);
				else
					Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = step.MyContent.ContentID;  // B2016-176, B2016-197 refresh saved ContentID with current ContentID
				
				if (xn.SelectNodes("annotation").Count > 0)
					AddAnnotations(step.ItemID, xn);
				
				if (xc.SelectNodes("rousage").Count > 0)
					AddROUsages(step.MyContent, xc);
				
				if (xc.SelectNodes("transition").Count > 0)
					AddTransitions(step.MyContent, xc);
				
				prevInfo = StepInfo.Get(step.ItemID);
				
				if (xc.HasChildNodes)
					AddParts(xc, prevInfo);
			}

			return prevInfo;
		}

		private void AddRNOs(XmlNode xn, ItemInfo parentInfo)
		{
			if (parentInfo.IsProcedure)
			{
				pbImportSection.Value = 0;
				pbImportStep.Value = 0;
				pbImportSection.Maximum = xn.ChildNodes.Count;
			}
			if (parentInfo.IsSection)
			{
				pbImportStep.Value = 0;
				pbImportStep.Maximum = xn.ChildNodes.Count;
			}
			ItemInfo prevInfo = null;
			foreach (XmlNode nd in xn.ChildNodes)
				prevInfo = AddRNO(nd, parentInfo, prevInfo);
		}

		private void AddSupInfos(XmlNode xn, ItemInfo parentInfo)
		{
			if (parentInfo.IsProcedure)
			{
				pbImportSection.Value = 0;
				pbImportStep.Value = 0;
				pbImportSection.Maximum = xn.ChildNodes.Count;
			}
			if (parentInfo.IsSection)
			{
				pbImportStep.Value = 0;
				pbImportStep.Maximum = xn.ChildNodes.Count;
			}
			ItemInfo prevInfo = null;
			foreach (XmlNode nd in xn.ChildNodes)
				prevInfo = AddSupInfo(nd, parentInfo, prevInfo);
		}

		// jsj 4-29-2016 appears to not be used
		//private ItemInfo AddRNO(XmlReader xr, ItemInfo parentInfo, ItemInfo prevInfo, int oldid)
		//{
		//	string number = xr.GetAttribute("number");
		//	string text = xr.GetAttribute("text");
		//	int steptype = int.Parse(xr.GetAttribute("type"));
		//	string formatid = xr.GetAttribute("formatid");
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	Step step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.RNO);
		//	step.DTS = dts;
		//	step.UserID = userid;
		//	string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
		//	if (formatid != string.Empty)
		//		step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
		//	step.MyContent.Config = config;
		//	step.MyContent.DTS = dts;
		//	step.MyContent.UserID = userid;
		//	step.Save();
		//	Old2NewItem.Add(oldid, step.ItemID);
		//	Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), step.MyContent.ContentID);
		//	prevInfo = StepInfo.Get(step.ItemID);
		//	return prevInfo;
		//}

		private ItemInfo AddRNO(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
		{
			pbImportStep.PerformStep();
			lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
			Application.DoEvents();
			XmlNode xc = xn.SelectSingleNode("content");
			Step step;
			string number = xc.Attributes.GetNamedItem("number").InnerText;
			string text = xc.Attributes.GetNamedItem("text").InnerText;
			int steptype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
			string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
			string config = xc.Attributes.GetNamedItem("config").InnerText;
			config = StripEnhanced(config);
			int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
			CheckForFloatingFoldout(contentid, config);
			string userid = xc.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
			using (step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.RNO))
			{
				step.DTS = dts;
				step.UserID = userid;
				// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
				XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
				string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
				if (formatid != string.Empty)
					step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
				step.MyContent.Config = config;
				step.MyContent.DTS = dts;
				step.MyContent.UserID = userid;
				step.Save();
				if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
					Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), step.ItemID);
				else
					Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = step.ItemID;  // B2016-176, B2016-197 refresh saved ItemId with current ItemID
				if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
					Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), step.MyContent.ContentID);
				else
					Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = step.MyContent.ContentID;  // B2016-176, B2016-197 refresh saved ContentID with current ContentID
				if (xn.SelectNodes("annotation").Count > 0)
					AddAnnotations(step.ItemID, xn);
				if (xc.SelectNodes("rousage").Count > 0)
					AddROUsages(step.MyContent, xc);
				if (xc.SelectNodes("transition").Count > 0)
					AddTransitions(step.MyContent, xc);
				prevInfo = StepInfo.Get(step.ItemID);
				if (xc.HasChildNodes)
					AddParts(xc, prevInfo);
			}
			return prevInfo;
		}
		private ItemInfo AddSupInfo(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
		{
			pbImportStep.PerformStep();
			lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
			Application.DoEvents();
			XmlNode xc = xn.SelectSingleNode("content");
			Step step;
			string number = xc.Attributes.GetNamedItem("number").InnerText;
			string text = xc.Attributes.GetNamedItem("text").InnerText;
			int steptype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
			string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
			string config = xc.Attributes.GetNamedItem("config").InnerText;
			config = StripEnhanced(config);
			int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
			CheckForFloatingFoldout(contentid, config);
			string userid = xc.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
			using (step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.SupInfo))
			{
				step.DTS = dts;
				step.UserID = userid;
				// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
				XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
				string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
				if (formatid != string.Empty)
					step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
				step.MyContent.Config = config;
				step.MyContent.DTS = dts;
				step.MyContent.UserID = userid;
				step.Save();
				if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
					Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), step.ItemID);
				if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
					Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), step.MyContent.ContentID);
				if (xn.SelectNodes("annotation").Count > 0)
					AddAnnotations(step.ItemID, xn);
				if (xc.SelectNodes("rousage").Count > 0)
					AddROUsages(step.MyContent, xc);
				if (xc.SelectNodes("transition").Count > 0)
					AddTransitions(step.MyContent, xc);
				prevInfo = StepInfo.Get(step.ItemID);
				if (xc.HasChildNodes)
					AddParts(xc, prevInfo);
			}
			return prevInfo;
		}
		private void AddNotes(XmlNode xn, ItemInfo parentInfo)
		{
			if (parentInfo.IsProcedure)
			{
				pbImportSection.Value = 0;
				pbImportStep.Value = 0;
				pbImportSection.Maximum = xn.ChildNodes.Count;
			}
			if (parentInfo.IsSection)
			{
				pbImportStep.Value = 0;
				pbImportStep.Maximum = xn.ChildNodes.Count;
			}
			ItemInfo prevInfo = null;
			foreach (XmlNode nd in xn.ChildNodes)
				prevInfo = AddNote(nd, parentInfo, prevInfo);
		}

		// jsj 4-29-2016 appears to not be used
		//private ItemInfo AddNote(XmlReader xr, ItemInfo parentInfo, ItemInfo prevInfo, int oldid)
		//{
		//	string number = xr.GetAttribute("number");
		//	string text = xr.GetAttribute("text");
		//	int steptype = int.Parse(xr.GetAttribute("type"));
		//	string formatid = xr.GetAttribute("formatid");
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	Step step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Note);
		//	step.DTS = dts;
		//	step.UserID = userid;
		//	string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
		//	if (formatid != string.Empty)
		//		step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
		//	step.MyContent.Config = config;
		//	step.MyContent.DTS = dts;
		//	step.MyContent.UserID = userid;
		//	step.Save();
		//	Old2NewItem.Add(oldid, step.ItemID);
		//	Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), step.MyContent.ContentID);
		//	prevInfo = StepInfo.Get(step.ItemID);
		//	return prevInfo;
		//}

		private ItemInfo AddNote(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
		{
			pbImportStep.PerformStep();
			lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
			Application.DoEvents();
			XmlNode xc = xn.SelectSingleNode("content");
			Step step;
			string number = xc.Attributes.GetNamedItem("number").InnerText;
			string text = xc.Attributes.GetNamedItem("text").InnerText;
			int steptype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
			string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
			string config = xc.Attributes.GetNamedItem("config").InnerText;
			config = StripEnhanced(config);
			int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
			CheckForFloatingFoldout(contentid, config);
			string userid = xc.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
			using (step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Note))
			{
				step.DTS = dts;
				step.UserID = userid;
				// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
				XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
				string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
				if (formatid != string.Empty)
					step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
				step.MyContent.Config = config;
				step.MyContent.DTS = dts;
				step.MyContent.UserID = userid;
				step.Save();
				if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
					Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), step.ItemID);
				else
					Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = step.ItemID;  // B2016-176, B2016-197 refresh saved ItemId with current ItemID
				if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
					Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), step.MyContent.ContentID);
				else
					Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = step.MyContent.ContentID;  // B2016-176, B2016-197 refresh saved ContentID with current ContentID
				if (xn.SelectNodes("annotation").Count > 0)
					AddAnnotations(step.ItemID, xn);
				if (xc.SelectNodes("rousage").Count > 0)
					AddROUsages(step.MyContent, xc);
				if (xc.SelectNodes("transition").Count > 0)
					AddTransitions(step.MyContent, xc);
				prevInfo = StepInfo.Get(step.ItemID);
				if (xc.HasChildNodes)
					AddParts(xc, prevInfo);
			}
			return prevInfo;
		}
		private void AddCautions(XmlNode xn, ItemInfo parentInfo)
		{
			if (parentInfo.IsProcedure)
			{
				pbImportSection.Value = 0;
				pbImportStep.Value = 0;
				pbImportSection.Maximum = xn.ChildNodes.Count;
			}
			if (parentInfo.IsSection)
			{
				pbImportStep.Value = 0;
				pbImportStep.Maximum = xn.ChildNodes.Count;
			}
			ItemInfo prevInfo = null;
			foreach (XmlNode nd in xn.ChildNodes)
				prevInfo = AddCaution(nd, parentInfo, prevInfo);
		}

		// jsj 4-29-2016 appears to not be used
		//private ItemInfo AddCaution(XmlReader xr, ItemInfo parentInfo, ItemInfo prevInfo, int oldid)
		//{
		//	string number = xr.GetAttribute("number");
		//	string text = xr.GetAttribute("text");
		//	int steptype = int.Parse(xr.GetAttribute("type"));
		//	string formatid = xr.GetAttribute("formatid");
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	Step step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Caution);
		//	step.DTS = dts;
		//	step.UserID = userid;
		//	string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
		//	if (formatid != string.Empty)
		//		step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
		//	step.MyContent.Config = config;
		//	step.MyContent.DTS = dts;
		//	step.MyContent.UserID = userid;
		//	step.Save();
		//	Old2NewItem.Add(oldid, step.ItemID);
		//	Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), step.MyContent.ContentID);
		//	prevInfo = StepInfo.Get(step.ItemID);
		//	return prevInfo;
		//}

		private ItemInfo AddCaution(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
		{
			pbImportStep.PerformStep();
			lblImportStep.Text = string.Format("{0} of {1} Steps", pbImportStep.Value.ToString(), pbImportStep.Maximum.ToString());
			Application.DoEvents();
			XmlNode xc = xn.SelectSingleNode("content");
			Step step;
			string number = xc.Attributes.GetNamedItem("number").InnerText;
			string text = xc.Attributes.GetNamedItem("text").InnerText;
			int steptype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
			string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
			string config = xc.Attributes.GetNamedItem("config").InnerText;
			config = StripEnhanced(config);
			int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
			CheckForFloatingFoldout(contentid, config);
			string userid = xc.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
			using (step = Step.MakeStep(parentInfo, prevInfo, number, text, steptype, E_FromType.Caution))
			{
				step.DTS = dts;
				step.UserID = userid;
				// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
				XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
				string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
				if (formatid != string.Empty)
					step.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
				step.MyContent.Config = config;
				step.MyContent.DTS = dts;
				step.MyContent.UserID = userid;
				step.Save();
				if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
					Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), step.ItemID);
				else
					Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = step.ItemID;  // B2016-176, B2016-197 refresh saved ItemId with current ItemID
				if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
					Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), step.MyContent.ContentID);
				else
					Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = step.MyContent.ContentID;  // B2016-176, B2016-197 refresh saved ContentID with current ContentID
				if (xn.SelectNodes("annotation").Count > 0)
					AddAnnotations(step.ItemID, xn);
				if (xc.SelectNodes("rousage").Count > 0)
					AddROUsages(step.MyContent, xc);
				if (xc.SelectNodes("transition").Count > 0)
					AddTransitions(step.MyContent, xc);
				prevInfo = StepInfo.Get(step.ItemID);
				if (xc.HasChildNodes)
					AddParts(xc, prevInfo);
			}
			return prevInfo;
		}
		private void AddSections(XmlNode xn, ItemInfo parentInfo)
		{
			if (parentInfo.IsProcedure)
			{
				pbImportSection.Value = 0;
				pbImportStep.Value = 0;
				pbImportSection.Maximum = xn.ChildNodes.Count;
			}
			if (parentInfo.IsSection)
			{
				pbImportStep.Value = 0;
				pbImportStep.Maximum = xn.ChildNodes.Count;
			}
			ItemInfo prevInfo = null;
			foreach (XmlNode nd in xn.ChildNodes)
				prevInfo = AddSection(nd, parentInfo, prevInfo);
		}

		private Dictionary<string, string> GetSectionData(XmlReader xr)
		{
			Dictionary<string, string> rv = new Dictionary<string, string>();
			rv.Add("itemid", xr.GetAttribute("itemid"));
			return rv;
		}

		// js j4-29-2016 appears to not be used
		//private ItemInfo AddSection(XmlReader xr, ItemInfo parentInfo, ItemInfo prevInfo, int oldid)
		//{
		//	string number = xr.GetAttribute("number");
		//	string text = xr.GetAttribute("text");
		//	int sectiontype = int.Parse(xr.GetAttribute("type"));
		//	string formatid = xr.GetAttribute("formatid");
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	Section sect = Section.MakeSection(parentInfo, prevInfo, number, text, sectiontype);
		//	sect.DTS = dts;
		//	sect.UserID = userid;
		//	string formatfilename = xr.GetAttribute("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
		//	if (formatid != string.Empty)
		//		sect.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
		//	sect.MyContent.Config = config;
		//	sect.MyContent.DTS = dts;
		//	sect.MyContent.UserID = userid;
		//	sect.Save();
		//	Old2NewItem.Add(oldid, sect.ItemID);
		//	Old2NewContent.Add(int.Parse(xr.GetAttribute("contentid")), sect.MyContent.ContentID);
		//	prevInfo = SectionInfo.Get(sect.ItemID);
		//	return prevInfo;
		//}

		private ItemInfo AddSection(XmlNode xn, ItemInfo parentInfo, ItemInfo prevInfo)
		{
			pbImportSection.PerformStep();
			lblImportSection.Text = string.Format("{0} of {1} Sections", pbImportSection.Value.ToString(), pbImportSection.Maximum.ToString());
			Application.DoEvents();
			XmlNode xc = xn.SelectSingleNode("content");
			string number = xc.Attributes.GetNamedItem("number").InnerText;
			string text = xc.Attributes.GetNamedItem("text").InnerText;
			int sectiontype = int.Parse(xc.Attributes.GetNamedItem("type").InnerText);
			string formatid = xc.Attributes.GetNamedItem("formatid").InnerText;
			string config = xc.Attributes.GetNamedItem("config").InnerText;
			config = StripEnhanced(config);
			int contentid = int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText);
			CheckForFloatingFoldout(contentid, config);
			string userid = xc.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(xc.Attributes.GetNamedItem("dts").InnerText);
			using (Section sect = Section.MakeSection(parentInfo, prevInfo, number, text, sectiontype)) // B2019-035 better memory management
			{
				sect.DTS = dts;
				sect.UserID = userid;
				// check for a null in case an older export file is being imported (the older files will not have the fromatfilename attribute)
				XmlNode fnNode = xc.Attributes.GetNamedItem("formatfilename"); //Bug fix B2016-103  the formatid in an Export file may not match the formatid where you are importing to
				string formatfilename = (fnNode != null) ? fnNode.InnerText : "";
				// If this formatfile is a copy in this database (was not in exported database), use the copy name (note that the 
				// Config data must match and this was checked in the code that loads the formats:
				if (formatid != string.Empty)
				{
					if (existingCopyFCName.ContainsKey(formatfilename)) formatfilename = existingCopyFCName[formatfilename];
					sect.MyContent.MyFormat = OldToNewFormat(int.Parse(formatid), formatfilename);
				}
				sect.MyContent.Config = config;
				sect.MyContent.DTS = dts;
				sect.MyContent.UserID = userid;
				sect.Save();
				if (!Old2NewContent.ContainsKey(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)))
					Old2NewContent.Add(int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText), sect.MyContent.ContentID);
				else
					Old2NewContent[int.Parse(xc.Attributes.GetNamedItem("contentid").InnerText)] = sect.MyContent.ContentID;  // B2016-176, B2016-197 refresh saved ContentID with current ContentID
				if (!Old2NewItem.ContainsKey(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)))
					Old2NewItem.Add(int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText), sect.ItemID);
				else
					Old2NewItem[int.Parse(xn.Attributes.GetNamedItem("itemid").InnerText)] = sect.ItemID;  // B2016-176, B2016-197 refresh saved ItemId with current ItemID
				if (xn.SelectNodes("annotation").Count > 0)
					AddAnnotations(sect.ItemID, xn);
				if (xc.SelectNodes("entry").Count > 0)
					AddEntry(sect.MyContent, xc);
				if (xc.SelectNodes("rousage").Count > 0)
					AddROUsages(sect.MyContent, xc);
				if (xc.SelectNodes("transition").Count > 0)
					AddTransitions(sect.MyContent, xc);
				prevInfo = SectionInfo.Get(sect.ItemID);
				if (xc.HasChildNodes)
					AddParts(xc, prevInfo);
			}
			return prevInfo;
		}

		private string StripEnhanced(string config)
		{
			if (config.Length > 0)
			{
				XmlDocument xd = new XmlDocument();
				xd.LoadXml(config);
				XmlNodeList nl = xd.DocumentElement.SelectNodes("//Enhanced");
				foreach (XmlNode nd in nl)
					nd.ParentNode.RemoveChild(nd);
				return xd.OuterXml;
			}
			return config;
		}

		private void CheckForFloatingFoldout(int contentid, string config)
		{
			if (config != string.Empty)
			{
				XmlDocument xd = new XmlDocument();
				xd.LoadXml(config);
				XmlNode xn = xd.SelectSingleNode("Config/Step/@FloatingFoldout");
				if (xn != null)
					floatFoldout.Add(contentid, int.Parse(xn.InnerText));
			}
		}

		// jsj 2016Feb16 - This appears to not be used
		//private void AddGrid(XmlReader xr)
		//{
		//	int contentid = int.Parse(xr.GetAttribute("contentid"));
		//	contentid = Old2NewContent[contentid];
		//	Content content = Content.Get(contentid);
		//	string data = xr.GetAttribute("data");
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	Grid gg = Grid.MakeGrid(content, data, config, dts, userid);
		//}

		private void AddGrid(Content content, XmlNode xc)
		{
			XmlNode nd = xc.SelectSingleNode("grid");
			string data = nd.Attributes.GetNamedItem("data").InnerText;
			XmlDocument xd = new XmlDocument();
			xd.LoadXml(data);
			XmlNode gn = xd.SelectSingleNode("C1FlexGrid/Control/IsRoTable");

			if (gn.InnerText.ToLower() == "true")
			{
				if (_ConvertROsToTextDuringImport)
				{
					gn.InnerText = "False";
					ROToTextAnnotation(content, "RO Table"); // B2016-225 (follow through) add annotation when RO is converted to text 
				}
				else
				{
					gn = xd.SelectSingleNode("C1FlexGrid/Control/RODbId");
					gn.InnerText = newRODbID.ToString();
				}
				data = xd.OuterXml;
			}
			else
			{
				XmlNodeList nl = xd.SelectNodes("C1FlexGrid/Cells/Cell/Data");
				bool modified = false;
				if (_ConvertROsToTextDuringImport)
				{
					string newvalue = "";
					// if it's an ro within a table, need to process into an flex grid to save the grid data:
					string findLinkXml = @"&lt;START\].*?\[END&gt;";
					//string lookForXml = string.Format(@"^&lt;START\](\\[^v \\]+)*\\v0(\\[^v '?{{}}\\]+)*( |\\u[0-9]{{1,4}}?|\\'[0-9a-fA-F]{{2}}|\\[{{}}~])(.*?)(\\[^v'?{{}} \\]+)*\\v(\\[^v \\]+)* #Link:ReferencedObject:{0} .*?\[END&gt;$", rousageid);
					string lookForXml = @"^&lt;START\](\\[^v \\]+)*\\v0(\\[^v '?{{}}\\]+)*( |\\u[0-9]{{1,4}}?|\\'[0-9a-fA-F]{{2}}|\\[{{}}~])(.*?)(\\[^v'?{{}} \\]+)*\\v(\\[^v \\]+)* #Link:ReferencedObject:.*?\[END&gt;$";
					MatchCollection msg = Regex.Matches(data, findLinkXml);
					int nmsg = msg.Count;
					for (int i = nmsg - 1; i >= 0; i--)
					{
						Match mmg = msg[i];
						Match mg = Regex.Match(mmg.Value, lookForXml);// Regex.Match(MyGrid.Data, lookForXml);
						if (mg != null && mg.Groups.Count > 1)
						{
							int myIndex = mg.Groups[4].Index + mmg.Index;
							int myLength = mg.Groups[4].Length;
							if (mg.Groups[3].Value != " ")
							{
								myIndex = mg.Groups[3].Index + mmg.Index;
								myLength += mg.Groups[3].Length;
							}
							string ss = data.Substring(myIndex, myLength);
							if (ss != newvalue)
							{
								data = Content.ConvertGridROsToText(data, mmg, mg, ss); // part of bug fix:  B2017060 to properly convert invalid RO to text
							}
						}
					}
				}
				else
				{
					string lookFor = string.Format(" {0}[END", oldRODbID.ToString());
					string replaceWith = string.Format(" {0}[END", newRODbID.ToString());
					foreach (XmlNode nn in nl)
					{
						if (nn.InnerText.Contains("#Link:ReferencedObject:"))
						{
							nn.InnerText = nn.InnerText.Replace(lookFor, replaceWith);
							modified = true;
						}
					}
					if (modified)
						data = xd.OuterXml;
				}
			}

			string config = nd.Attributes.GetNamedItem("config").InnerText;
			string userid = nd.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
			Grid gg = Grid.MakeGrid(content, data, config, dts, userid);

			gg.Save();

			content.MyGrid = gg;
		}


		// jsj 4-29-2016 appears to not be used
		//private Dictionary<string, string> AddEntry(XmlReader xr)
		//{
		//	Dictionary<string, string> dic = new Dictionary<string, string>();
		//	dic.Add("contentid", xr.GetAttribute("contentid"));
		//	dic.Add("dts", xr.GetAttribute("dts"));
		//	dic.Add("userid", xr.GetAttribute("userid"));
		//	return dic;
		//}

		private void AddEntry(Content content, XmlNode xc)
		{
			XmlNode nd = xc.SelectSingleNode("entry");
			string userid = nd.Attributes.GetNamedItem("userid").InnerText;
			DateTime dts = DateTime.Parse(nd.Attributes.GetNamedItem("dts").InnerText);
			using (Document dd = AddDocument(nd.SelectSingleNode("document"))) // B2019-035 better memory management
			{
				Entry ee = Entry.MakeEntry(content, dd, dts, userid);
				ee.Save();
			}
		}
		// jsj 2016Feb16 - This appears to not be used
		//private void AddDocument(XmlReader xr, Dictionary<string, string> dic)
		//{
		//	string libtitle = xr.GetAttribute("libtitle");
		//	byte[] doccontent = Convert.FromBase64String(xr.GetAttribute("doccontent"));
		//	string docascii = xr.GetAttribute("docascii");
		//	string config = xr.GetAttribute("config");
		//	string userid = xr.GetAttribute("userid");
		//	DateTime dts = DateTime.Parse(xr.GetAttribute("dts"));
		//	string fileextension = xr.GetAttribute("fileextension");
		//	Document dd = Document.MakeDocument(libtitle, doccontent, docascii, config, dts, userid, fileextension);
		//	int contentid = int.Parse(dic["contentid"]);
		//	contentid = Old2NewContent[contentid];
		//	Content content = Content.Get(contentid);
		//	dts = DateTime.Parse(dic["dts"]);
		//	userid = dic["userid"];
		//	Entry ee = Entry.MakeEntry(content, dd, dts, userid);
		//}
		
		// B2019-035 This is called only once to get the existing library document info.
		//           when it was in the AddDocument() logic, it would use up (and not free up) memory each time
		//           a Word section was added during the import
		private void GetExistingLibDocsList()
		{
			ExistingLibDocs = new Dictionary<string,int>();
			using (DocumentInfoList dil = DocumentInfoList.GetLibraries(true))
			{
				foreach (DocumentInfo di in dil)
				{
					string keystr = di.LibTitle; // B2019-085  don't add the date/time to the title of the existing list of lib docs - was causing multiple copies of the lib doc to be added
					if (!ExistingLibDocs.ContainsKey(keystr))
						ExistingLibDocs.Add(keystr, di.DocID);
					di.Dispose();
				}
			}
		}

		private Document AddDocument(XmlNode xn)
		{
			Document d=null;
			int docid = int.Parse(xn.Attributes.GetNamedItem("docid").InnerText);
			if (Old2NewLibDoc.ContainsKey(docid))
			{
				docid = Old2NewLibDoc[docid];
				d = Document.Get(docid);
			}
			else // see if it is in the existing database
			{
				string libtitle = xn.Attributes.GetNamedItem("libtitle").InnerText;
				DateTime dts = DateTime.Parse(xn.Attributes.GetNamedItem("dts").InnerText);
				if (libtitle != "")
				{
					// C2019-026 if the lib doc title exists in the current database, compare it with the contents of what we
					//           are importing.  If the same, use it, else enter a new lib doc appending the date/time
					byte[] doccontent = Convert.FromBase64String(xn.Attributes.GetNamedItem("doccontent").InnerText);
					
					if (ExistingLibDocs.ContainsKey(libtitle))
					{
						d = Document.Get(ExistingLibDocs[libtitle]);
						if (!ByteArrayCompare.DoCompare(d.DocContent,doccontent))
							d = null;
					}

					if (d == null)
					{
						// B2019-035 better memory management.  Prior logic would eat up memory (and not free it).
						string libkey = libtitle + "_" + dts.ToString();
						if (ExistingLibDocs.ContainsKey(libkey))
							d = Document.Get(ExistingLibDocs[libkey]); // found library document in existing database
					}
				}

				if (d == null) // not found in existing database, create it
				{
					byte[] doccontent = Convert.FromBase64String(xn.Attributes.GetNamedItem("doccontent").InnerText);
					string docascii = xn.Attributes.GetNamedItem("docascii").InnerText;
					string config = xn.Attributes.GetNamedItem("config").InnerText;
					string userid = xn.Attributes.GetNamedItem("userid").InnerText;
					string fileextension = xn.Attributes.GetNamedItem("fileextension").InnerText;
					if (libtitle != "") libtitle = libtitle + "_" + dts.ToString(); // if a lib document, append the date/time to the title incase there are duplicate titles
					d = Document.MakeDocument(libtitle, doccontent, docascii, config, dts, userid, fileextension);
					d.Save();
					Old2NewLibDoc.Add(docid, d.DocID);
				}

			}

			return d;
		}
		#endregion

		private void btnCloseExport_Click(object sender, EventArgs e)
		{
			this.Close();
		}

		private void btnCloseImport_Click(object sender, EventArgs e)
		{
			this.Close();
		}
	}
}