using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;
using VEPROMS.CSLA.Library;
using DevComponents.DotNetBar;
using DevComponents.AdvTree;
using Volian.Base.Library;
using System.Text.RegularExpressions;
using JR.Utils.GUI.Forms;
using System.Linq;

namespace Volian.Controls.Library
{
	public partial class DisplaySearch : UserControl
	{
		#region Public Events/Handlers

		public event DisplaySearchEvent PrintRequest;
		public event DisplaySearchEvent SearchComplete;

		private void OnPrintRequest(DisplaySearchEventArgs args)
		{
			if (PrintRequest != null)
				PrintRequest(this, args);
		}

		private void OnSearchComplete(DisplaySearchEventArgs args)
		{
			if (SearchComplete != null)
				SearchComplete(this, args);
		}

		#endregion

		#region Fields
		// B2022-026 RO Memeory reduction logic change - defined dummy node text variable to ensure consistancy
		private const string DummyNodeText = "VLN_DUMMY_NODE";

		// B2023-076: Adding option to select all procedure sets
		private const string SelectAllProcedureSetsText = "Select All Procedure Sets";

		// B2019-161 When tracking timing time this action
		private static VolianTimer _TimeActivity = new VolianTimer("DisplaySearch _TmrRefresh_Tick", 399);
		private Timer _TmrRefresh = null;

		public FormatVersionList myFormatVersionList;
		private ItemInfo _SearchIncTransII = null;
		private static UserInfo _MyUserInfo = null;
		private string _strSrchText = string.Empty;
		private List<DocVersionInfo> lstCheckedDocVersions = new List<DocVersionInfo>();
		private List<int> lstCheckedStepTypes = new List<int>();
		private List<string> lstCheckedStepTypesStr = new List<string>();
		private AnnotationDetails _AnnotationDetails = null;
		public ItemInfo _ItemInfo = null;
		private DisplayTabControl _TabControl;
		private DocVersionInfo _MyDocVersion;
		private Color saveXpSetToSearchColor;
		private Color saveXpStepTypeTitleColor;
		private Color saveGpSrchAnnoTextColor;
		private Color saveGpSrchTextColor;
		private Color saveGpFindROsColor;
		private Color saveGrpPanSearchResults;
		private ItemInfoList _SearchResults;

		private string _DisplayMember = "SearchPath_clean";
		private bool _OpenDocFromSearch;
		private ROFSTLookup _MyROFSTLookup;
		private bool _LoadingList = false;
		private int LastResultsMouseOverIndex = -1;
		private ProgressBarItem _ProgressBar;

		DevComponents.AdvTree.Node wordSectionTreeNode = null;      // C2020-010: Disable Word Section choice for Transition search

		private static int _lastRoFstId = -1;
		private Dictionary<DevComponents.AdvTree.Node, bool> dicSelectedFolderNodes = new Dictionary<DevComponents.AdvTree.Node, bool>();
		private Dictionary<DevComponents.AdvTree.Node, bool> dicExpandedFolderNodes = new Dictionary<DevComponents.AdvTree.Node, bool>();
		private int _TopFolderID = 1;
		private bool _ProcessingSelectedValueChanged = false;

		// Search Related Fields
		private bool _LastSearchWasAnnotations = false; // B2019-119 only refresh annotation search results if an annotation search was done

		// ProcSetSelection Related Fields
		private int _MyRODbID;
		private static bool checkingChildren = false;

		// A timer updated the step type tree but if it was loaded from xml the timer update overwrite what
		//	was loaded in from the xml file.  Added a flag that gets set on load and set to false on new Search
		private bool _fromLoad = false;
		private string _ReportTitle;
		private string _SearchString = null;
		private string _TypesSelected;

		private bool fromTranCvtBtn = false;

		#endregion

		#region Properties

		// C2020-033: SearchIncTransII represents the item that the transitions go to.  It can be either the item the user
		//	tried to delete or that the user selected to get Incoming Transitions from tree view or ribbon.
		public ItemInfo SearchIncTransII
		{
			get { return _SearchIncTransII; }
			set
			{
				_SearchIncTransII = value;

				if (_SearchIncTransII != null)
					lblSrchIncTran.Text = _SearchIncTransII.Path;
				else
					lblSrchIncTran.Text = string.Empty;
			}
		}

		public static UserInfo MyUserInfo
		{
			get { return _MyUserInfo; }
			set { _MyUserInfo = value; }
		}

		public ItemInfoList SearchResults
		{
			get { return _SearchResults; }
			set
			{
				if (DesignMode) return; // B2019-043 need to check if we are just saving changes to the user interface

				_SearchResults = value;

				if (value != null) // Don't select an item from the list when it is updated
					_SearchResults.ListChanged += new ListChangedEventHandler(_SearchResults_ListChanged);

				DisplayResults();

				// B2022-044: don't set selection to top of list (commented out/changed if). Remove event that does this
				//	after results are displayed.  Without this, the code in _SearchResults_ListChanged was run upon selections
				if (value != null)
					_SearchResults.ListChanged -= new ListChangedEventHandler(_SearchResults_ListChanged);
			}
		}

		public bool OpenDocFromSearch
		{
			get { return _OpenDocFromSearch; }
		}

		public DocVersionInfo Mydocversion
		{
			get { return _MyDocVersion; }
			set
			{
				if (DesignMode) return; // B2019-043 need to check if we are just saving changes to the user interface

				_MyDocVersion = value;

				if (_MyDocVersion != null)
				{
					if (_MyDocVersion.DocVersionAssociationCount > 0)
					{
						// if the count variable is not consistent with the actual list count,
						// do a refresh. There was a bug, B2012-040, that was not reproducible..
						// so this is an attempt to fix it.
						if (_MyDocVersion.DocVersionAssociations.Count == 0)
						{
							_MyDocVersion.RefreshDocVersionAssociations();
							if (_MyDocVersion.DocVersionAssociations.Count == 0) return;
						}
						MyROFSTLookup = _MyDocVersion.DocVersionAssociations[0].MyROFst.GetROFSTLookup(_MyDocVersion);
						_MyRODbID = _MyDocVersion.DocVersionAssociations[0].MyROFst.RODbID;
					}
				}
				else
				{
					MyROFSTLookup = null;
				}
			}
		}

		public ROFSTLookup MyROFSTLookup
		{
			get { return _MyROFSTLookup; }
			set
			{
				if (DesignMode) return; // B2019-043 need to check if we are just saving changes to the user interface

				bool beforeIsNotNull = _MyROFSTLookup != null;
				bool afterIsNotNull = value != null;
				//if (!Visible) return;		// don't reset anything if the form is invisible.
				_MyROFSTLookup = value;         // define the tree nodes based on this rofst

				if (beforeIsNotNull || afterIsNotNull)
				{
					LoadROComboTree();// B2017-215 Added logic so that database is not accessed during initialization.
				}
			}
		}

		public bool LoadingList
		{
			get { return _LoadingList; }
			set { _LoadingList = value; }
		}

		public ProgressBarItem ProgressBar
		{
			get { return _ProgressBar; }
			set { _ProgressBar = value; }
		}

		public Timer TmrRefresh
		{
			get
			{
				if (_TmrRefresh == null)
				{
					_TmrRefresh = new Timer();
					_TmrRefresh.Interval = 1000;
					_TmrRefresh.Tick += _TmrRefresh_Tick;
				}
				return _TmrRefresh;
			}
		}

		public int TopFolderID
		{
			get { return _TopFolderID; }
			set { _TopFolderID = value; }
		}

		public string ReportTitle
		{
			get { return _ReportTitle; }
			set { _ReportTitle = value; }
		}

		public string SearchString
		{
			get { return _SearchString; }
			set { _SearchString = value; }
		}

		public string TypesSelected
		{
			get { return _TypesSelected; }
			set { _TypesSelected = value; }
		}

		#region (Search)

		private string DVISearchList
		{
			get
			{
				// append list of document versions to search
				if (lstCheckedDocVersions.Count > 0)
				{
					string strRtnStr = string.Empty;
					// get list of doc versions to search
					foreach (DocVersionInfo dvi in lstCheckedDocVersions)
					{
						strRtnStr += string.Format(",{0}", dvi.VersionID.ToString());
					}
					return strRtnStr.Substring(1);
				}
				return string.Empty;
			}
		}

		private string TypeSearchList
		{
			get
			{
				// append list of step types to search
				if (lstCheckedStepTypes.Count > 0)
				{
					string strRtnStr = string.Empty;
					// get list of selected types
					foreach (int typ in lstCheckedStepTypes)
					{
						int tmp = typ;
						if (tmp == 0)
							tmp = 10000; // this is the accessory page type
						else
							tmp += 20000; // step/substep types
						strRtnStr += string.Format(",{0}", tmp);
					}
					return strRtnStr.Substring(1);
				}

				return string.Empty;
			}
		}

		private string TextSearchString
		{
			get
			{
				if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[0])
					return ConvertSpecialChars(cbxTextSearchText.Text);

				return string.Empty;
			}
		}

		private string AnnotationSearchType
		{
			get
			{
				if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[1])
					return ((AnnotationTypeSearch)cbxAnnoTypes.SelectedValue).ID;

				return string.Empty;
			}
		}

		private string ROSearchList
		{
			get
			{
				if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[2])
				{    // RO Search
					ROFSTLookup.rochild[] chld = null;
					ROFSTLookup.rochild ch;
					if (cmboTreeROs.SelectedNode != null)
					{
						if (cbxFndUnLnkROVals.Enabled && cbxFndUnLnkROVals.Checked)
						{
							ch = (ROFSTLookup.rochild)cmboTreeROs.SelectedNode.Tag;
							_strSrchText = string.Format("{0}", ch.value);
							return _strSrchText; // append RO Value text to search
						}
						else
						{
							if (cmboTreeROs.SelectedNode.Tag is ROFSTLookup.rodbi)
							{
								ROFSTLookup.rodbi db = (ROFSTLookup.rodbi)cmboTreeROs.SelectedNode.Tag;
								return _MyRODbID.ToString() + ":" + string.Format("{0}", db.dbiID.ToString("X4"));
							}
							else if (cmboTreeROs.SelectedNode.Tag is ROFSTLookup.rochild)
							{
								ch = (ROFSTLookup.rochild)cmboTreeROs.SelectedNode.Tag;
								chld = ch.children;
								// build a list of ROs to search
								// B2022-118: remove the ending comma otherwise query will fail
								string strRtnStr = _MyRODbID.ToString() + ":" + GetROsToSearch(chld);
								if (strRtnStr.EndsWith(","))
									strRtnStr = strRtnStr.Substring(0, strRtnStr.Length - 1);
								return strRtnStr;
							}
						}
					}
				}
				return string.Empty;
			}
		}

		public bool LastSearchWasAnnotations
		{
			get { return _LastSearchWasAnnotations; }
			set { _LastSearchWasAnnotations = value; }
		}

		#endregion

		#endregion

		#region Constructor

		public DisplaySearch()
		{
			InitializeComponent();
			LoadSearchTextListBox();
			saveXpSetToSearchColor = xpSetToSearch.TitleStyle.BackColor1.Color;
			saveXpStepTypeTitleColor = xpStepTypes.TitleStyle.BackColor1.Color;
			saveGpSrchAnnoTextColor = gpSrchAnnoText.Style.BackColor;
			saveGpSrchTextColor = gpSrchText.Style.BackColor;
			saveGpFindROsColor = gpFindROs.Style.BackColor;
			gpSrchText.Style.BackColor = Color.Yellow;
			saveGrpPanSearchResults = grpPanSearchResults.Style.BackColor;

			// start out with the procedure and type selection windows colasped
			xpSetToSearch.Expanded = false;
			xpStepTypes.Expanded = false;
			rbtnSrchTxt.Checked = true;
			gpSrchAnnoText.Enabled = true;
			cmbResultsStyle.Enabled = false;
			tabSearchTypes.SelectedTabChanged += new TabStrip.SelectedTabChangedEventHandler(tabSearchTypes_SelectedTabChanged);
			// Don't do this here.  If you do then the /DB parameter has not yet been set, which will cause the database menu to be displayed
			//SetupContextMenu(); // so that the symbol list is available without selecting a procedure set or procedure
		}

		#endregion

		#region Public Methods

		public void _SearchResults_ListChanged(object sender, ListChangedEventArgs e)
		{
			lbSrchResults.SelectedIndex = -1; // Don't select an item from the new list
			lbSrchResultsIncTrans.SelectedIndex = -1;
		}

		public void tabSearchTypes_SelectedTabChanged(object sender, TabStripTabChangedEventArgs e)
		{
			if (wordSectionTreeNode != null) //B2020-070 NULL reference check
				wordSectionTreeNode.Enabled = true;
			btnSearch.Enabled = true;
			xpSetToSearch.Enabled = true;
			xpStepTypes.Enabled = true;
			lbSrchResults.Visible = true;
			lbSrchResultsIncTrans.Visible = false;
			cbxRnoOnly.Visible = true;
			if (e.NewTab == tabIncTrans)        // C2020-033: Incoming transitions
			{
				xpSetToSearch.Enabled = false;
				xpStepTypes.Enabled = false;
				lbSrchResults.Visible = false;
				lbSrchResultsIncTrans.Visible = true;
				lbSrchResultsIncTrans.CheckBoxesVisible = true;
				lbSrchResultsIncTrans.AutoScroll = true;
				btnSearch.Enabled = false; // C2021 - 002: disable search button - no functionality for Incoming Transitions
				cbxRnoOnly.Visible = false;
			}
			else if (e.NewTab == tabROSearch)
			{
				LoadROComboTree();
			}
			else if (e.NewTab == tabTranSearch)
			{
				if (wordSectionTreeNode != null) //B2020-070 NULL reference check
				{
					wordSectionTreeNode.Enabled = false;        // C2020-010: Disable Word Section choice for Transition search
					wordSectionTreeNode.Checked = false;
				}
				btnSearch.Enabled = (cbxTranCategory.Items.Count > 0); // B2017-038 disable search button if no format selected
																	   //enable-disable doc version nodes based on version type if selected
				if (cbxTranVersion.SelectedIndex > -1)
				{
					if (dicExpandedFolderNodes.Count > 0)
					{
						foreach (DevComponents.AdvTree.Node n in dicExpandedFolderNodes.Keys)
						{
							DocVersionInfo dvi = (DocVersionInfo)n.Tag;
							if (cbxTranVersion.Tag.ToString().Contains(dvi.VersionID.ToString()))
								n.Enabled = true;
							else
								n.Enabled = false;
						}
					}
				}
				//setup transition format versions
				this.Cursor = Cursors.WaitCursor;
				if (myFormatVersionList == null)
				{
					this.Refresh();
					myFormatVersionList = FormatVersionList.GetFormatVersions();
					cbxTranVersion.DisplayMember = "Title";
					int lastLastFormatID = 0;
					foreach (FormatVersion fv in myFormatVersionList)
					{
						if (fv.FormatID != lastLastFormatID)
						{
							cbxTranVersion.Items.Add(fv);
							lastLastFormatID = fv.FormatID;
						}
					}
					cbxTranVersion.SelectedIndexChanged += new EventHandler(cbxTranVersion_SelectedIndexChanged);
					cbxTranFormat.SelectedIndexChanged += new EventHandler(cbxTranFormat_SelectedIndexChanged);
				}
				this.Cursor = Cursors.Default;
			}
			else
			{
				foreach (DevComponents.AdvTree.Node n in dicExpandedFolderNodes.Keys)
					n.Enabled = true;
				if (dicSelectedFolderNodes.Count > 0)
				{
					foreach (DevComponents.AdvTree.Node n in dicSelectedFolderNodes.Keys)
					{
						n.Enabled = true;
					}
					dicSelectedFolderNodes.Clear();
				}
			}
		}

		public void cbxTranFormat_SelectedIndexChanged(object sender, EventArgs e)
		{
			#region 1st cut
			//if (cbxTranFormat.SelectedItem.ToString() == "All")
			//{
			//  cbxTranCategory.Items.Clear();
			//  cbxTranCategory.Items.Add("All");
			//  cbxTranCategory.Items.Add("Internal");
			//  cbxTranCategory.Items.Add("External");
			//  cbxTranCategory.Items.Add("Outside");
			//  cbxTranCategory.SelectedIndex = 0;
			//}
			//else if (cbxTranFormat.SelectedItem.ToString().Contains("{Proc"))
			//{
			//  cbxTranCategory.Items.Clear();
			//  cbxTranCategory.Items.Add("All");
			//  cbxTranCategory.Items.Add("External");
			//  cbxTranCategory.Items.Add("Outside");
			//  cbxTranCategory.SelectedIndex = 0;
			//}
			//else
			//{
			//  cbxTranCategory.Items.Clear();
			//  cbxTranCategory.Items.Add("Internal");
			//  cbxTranCategory.SelectedIndex = 0;
			//}
			#endregion

			#region 2nd cut
			if (cbxTranFormat.SelectedItem.ToString().Contains("{Proc"))
			{
				cbxTranCategory.Items.Clear();
				cbxTranCategory.Items.Add("All");
				cbxTranCategory.Items.Add("External");
				cbxTranCategory.Items.Add("Outside");
				cbxTranCategory.SelectedIndex = 0;
			}
			else
			{
				cbxTranCategory.Items.Clear();
				cbxTranCategory.Items.Add("All");
				cbxTranCategory.Items.Add("Internal");
				cbxTranCategory.Items.Add("External");
				cbxTranCategory.Items.Add("Outside");
				cbxTranCategory.SelectedIndex = 0;
			}
			#endregion

			btnSearch.Enabled = true; // B2017-038 enable search button if when a format selected
		}

		public void cbxTranVersion_SelectedIndexChanged(object sender, EventArgs e)
		{
			this.Cursor = Cursors.WaitCursor;
			string versionList = string.Empty;
			string sep = string.Empty;
			FormatVersion sfv = cbxTranVersion.SelectedItem as FormatVersion;
			foreach (FormatVersion fv in myFormatVersionList)
			{
				if (fv.FormatID == sfv.FormatID)
				{
					versionList += sep + fv.VersionID;
					sep = ",";
				}
			}
			cbxTranVersion.Tag = versionList;
			cbxTranFormatFillIn(versionList);
			if (dicExpandedFolderNodes.Count > 0)
			{
				foreach (DevComponents.AdvTree.Node n in dicExpandedFolderNodes.Keys)
				{
					FolderInfo fi = (FolderInfo)n.Tag;
					// if this folder has a docversion, use its id:
					string svid = null;
					if (fi.FolderDocVersionCount > 0)
						svid = fi.FolderDocVersions[0].VersionID.ToString();
					if (cbxTranVersion.Tag.ToString().Contains(svid))
						n.Enabled = true;
					else
						n.Enabled = false;
				}
			}

			List<DevComponents.AdvTree.Node> uncheckNodes = new List<Node>();
			foreach (DevComponents.AdvTree.Node n in dicSelectedFolderNodes.Keys)
			{
				FolderInfo fi = (FolderInfo)n.Tag;          // this was crashing in old version of code
															// if this folder has a docversion, use its id:
				string svid = null;
				if (fi.FolderDocVersionCount > 0)
					svid = fi.FolderDocVersions[0].VersionID.ToString();
				if (svid != null && !versionList.Contains(svid))
					uncheckNodes.Add(n);
				else
					n.Enabled = true;
			}
			while (uncheckNodes.Count > 0)
			{
				uncheckNodes[0].Checked = false;
				uncheckNodes[0].Enabled = false;
				uncheckNodes.Remove(uncheckNodes[0]);
			}
			if (lstCheckedDocVersions.Count > 0)
			{
				if (FlexibleMessageBox.Show(this, "Do you want to expand to all relevant procedure sets for the selected format?", "Expand Procedure Sets", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
				{
					lstCheckedDocVersions.Clear();
					foreach (DevComponents.AdvTree.Node n in dicSelectedFolderNodes.Keys)
						uncheckNodes.Add(n);
					while (uncheckNodes.Count > 0)
					{
						uncheckNodes[0].Checked = false;
						uncheckNodes.Remove(uncheckNodes[0]);
					}
					dicSelectedFolderNodes.Clear();
				}
			}
			this.Cursor = Cursors.Default;
		}

		// C2020-033: Update the search panel for Incoming transitions.  This gets called from the tree view & the ribbon
		public void UpdateSearchIncTransResults()
		{
			//IncTransSelectedCount = 0;
			tabSearchTypes.SelectedTab = tabSearchTypes.Tabs[4];

			lbSrchResultsIncTrans.DataSource = null;
			lbSrchResultsIncTrans.Items.Clear();
			// Get item to do search for, either from tree or from editor
			if (SearchIncTransII != null)
			{
				// B2021-010: Use IncomingTranGetMergedTranList to get a complete list of incoming transitions (transitions to procedure
				//	were only included if there were NO transitions to items within procedure)
				SearchResults = IncomingTranGetMergedTranList();
				ReportTitle = string.Format("Search For Incoming Transitions to {0}: ", SearchIncTransII.Path);
			}
			if (SearchResults != null && SearchResults.Count > 0)
			{
				AddMessageForEmptyAnnotations();
				cmbResultsStyle.SelectedIndex = 1;  //display step locations in results
				DisplayResults();
				//If any transitions are listed after the Convert, Admin Tools/Links/Refresh Transitions can be used to fix incorrect links.  This will eliminate any in the list.
				// B2023-103 if any items are left in search list, there may be bad transition link data - put out a message box
				if (fromTranCvtBtn)
					FlexibleMessageBox.Show(this, "If items remain in the list after performing Convert All to Text, running Admin Tools/Links/Refresh Transitions will clear the list.", 
						"Convert Transitions to Text", MessageBoxButtons.OK);
			}
			else
			{
				btnPrnSrchRslts.Enabled = false;
				btnClearSearchResults.Enabled = false;
				btnCopySearchResults.Enabled = false;
				btnSaveSearchResults.Enabled = false;
				cmbResultsStyle.Enabled = false;
				if (!fromTranCvtBtn) FlexibleMessageBox.Show("No Matches Found.", "Search");  // B2021-009: Research after convert transitions to text
			}
			btnTranCvtAllToTxt.Enabled = IncTransCvtAllToTextPerm();
			btnTranCvtSelToTxt.Enabled = false;
			btnSearch.Enabled = false;  // C2021 - 002: disable search button - no functionality for Incoming Transitions
		}

		public bool IncTranCvtPerm()
		{
			FolderInfo topFolder = FolderInfo.Get(1);
			FolderConfig fc = topFolder.MyConfig as FolderConfig;
			return fc.General_IncTranCvtPerm;
		}

		#region (ROFST Combo Tree)

		public void StartAdvTreeStepTypesFillIn()// B2016-258 Hang after selecting a procedure if the Step Type panel is open on the search panel
		{
			TmrRefresh.Enabled = true;
		}

		public void AdvTreeStepTypesFillIn()
		{
			DevComponents.AdvTree.Node topnode = new DevComponents.AdvTree.Node();
			advTreeStepTypes.Nodes.Clear();
			lstCheckedStepTypes.Clear();
			lstCheckedStepTypesStr.Clear();
			topnode.Text = "Types";
			advTreeStepTypes.Nodes.Add(topnode);
			FormatData fmtdata = null;
			// B2017-181: selecting/deselecting, and no nodes are selected was causing null reference when trying
			//	to access the DocVersion (none are selected), use the format off of the top folder:
			if (_MyDocVersion == null)
			{
				FolderInfo fi = FolderInfo.Get(TopFolderID);
				fmtdata = fi.ActiveFormat.PlantFormat.FormatData;
			}
			else
			{
				fmtdata = _MyDocVersion.ActiveFormat.PlantFormat.FormatData;
			}
			List<StepDataRetval> lstSrchStpTypes = fmtdata.GetSearchableSteps(); // list of searchable step types
			if (lstSrchStpTypes != null && lstSrchStpTypes.Count > 0)
			{
				DevComponents.AdvTree.Node newnode;
				advTreeStepTypes.Nodes.Clear();
				// Add a dummy node for searching Word Sections (MS Word sections)
				//newnode = new DevComponents.AdvTree.Node();
				//newnode.Text = "Word Sections";
				//newnode.Selectable = true;
				//newnode.CheckBoxAlignment = DevComponents.AdvTree.eCellPartAlignment.NearCenter;
				//newnode.CheckBoxStyle = eCheckBoxStyle.CheckBox;
				//newnode.CheckBoxThreeState = false;
				//newnode.CheckBoxVisible = true;
				newnode = NewAdvTreeNode("WORD Sections", true, true);      // C2020-010: Change Accessory Sections to Word Sections
				wordSectionTreeNode = newnode;
				// C2021-028: RNO Only search, disable Word section tree node
				wordSectionTreeNode.Enabled = !(tabSearchTypes.SelectedTab == tabTranSearch || cbxRnoOnly.Checked);
				advTreeStepTypes.Nodes.Add(newnode);

				// C2023-010: Allow selecting all section types or none
				newnode = NewAdvTreeNode("All Types", true, true);
				newnode.NodeClick += new EventHandler(AllSectionTypes_clicked);
				advTreeStepTypes.Nodes.Add(newnode);

				foreach (StepDataRetval sdr in lstSrchStpTypes)
				{
					StepDataList sdl = fmtdata.StepDataList; ;
					StepData sd = sdl[sdr.Index]; // get the step type record
					string parentName = sd.ParentType; // this gets the parent of the this step/substep type

					//Console.WriteLine("{0} {1} - {2}", parentName,sd.Type,sdr.Name);
					//newnode = new DevComponents.AdvTree.Node();
					//newnode.Text = sdr.Name;
					//newnode.Name = sd.Type; // this needed for the FindNodeByName() function
					//newnode.Tag = sd;
					//newnode.Selectable = true;
					//newnode.CheckBoxAlignment = DevComponents.AdvTree.eCellPartAlignment.NearCenter;
					//newnode.CheckBoxStyle = eCheckBoxStyle.CheckBox;
					//newnode.CheckBoxThreeState = false;
					//newnode.CheckBoxVisible = true;
					if (parentName.Equals("Base"))
					{
						newnode = NewAdvTreeNode(sdr.Name, true, true);
						newnode.Tag = sd;
						newnode.Name = sd.Type;
						DevComponents.AdvTree.Node pnode = NewAdvTreeNode(sd.Type, true, true); //create parent node (non selectable)
						pnode.Name = sd.Type;
						if (!sd.Type.Equals("Title")) // only use Title as a tree grouping to put Title with Text Right/Below substep types
							pnode.Nodes.Add(newnode);
						pnode.Nodes.Sort();
						advTreeStepTypes.Nodes.Add(pnode);

						//C2030-010:
						pnode.NodeClick += new EventHandler(pnode_selected);
					}
					else if (sd.Type.Equals("RNOType")) // B2019-016 Allow for search of RNO step types (when selecting types to search)
					{
						newnode = NewAdvTreeNode(sdr.Name, true, true);
						newnode.Tag = sd;
						newnode.Name = sd.Type;
						advTreeStepTypes.Nodes.Add(newnode);
					}
					else if (sd.Type.Equals("RNOType")) // B2019-016 Allow for search of RNO step types (when selecting types to search)
					{
						newnode = NewAdvTreeNode(sdr.Name, true, true);
						newnode.Tag = sd;
						newnode.Name = sd.Type;
						advTreeStepTypes.Nodes.Add(newnode);
					}
					else
					{
						// B2016-236: for global search – change ‘AER’ to ‘Left’ in list of step types for figures
						string nameInTree = sdr.Name;
						if (sdr.Name.Contains("AER") && sdr.Name.ToUpper().Contains("FIGURE")) nameInTree = nameInTree.Replace("AER", "Left");
						newnode = NewAdvTreeNode(nameInTree, true, true);
						newnode.Name = sd.Type; // this needed for the FindNodeByName() function
						newnode.Tag = sd;

						// if the parent node exists in the tree, then add the new node to that parent
						// else, it is a parent node, so add it as a new parent

						DevComponents.AdvTree.Node parnode = advTreeStepTypes.FindNodeByName(parentName);
						// Group by High Level Steps, Substeps, Cautions, Notes, Figures, Tables and Equations
						while (!parentName.Equals("Base") && !parentName.Equals("Substep") && !parentName.Equals("High") &&
							!parentName.Equals("Caution") && !parentName.Equals("Note") && !parentName.Equals("Table") &&
							!parentName.Equals("Figure") && !parentName.Equals("Title") &&
							!parentName.Equals("And") && !parentName.Equals("Or") && !parentName.Equals("Paragraph") && !parentName.Equals("Equation"))
						{
							StepData tmpsd = (StepData)parnode.Tag;
							parentName = tmpsd.ParentType;
							parnode = advTreeStepTypes.FindNodeByName(parentName);
						}
						if (parnode != null)
						{
							parnode.Nodes.Add(newnode);
							parnode.Nodes.Sort(); // sort the second level of the tree
						}
						else
							advTreeStepTypes.Nodes.Add(newnode);
					}
				}
				advTreeStepTypes.Nodes.Sort(); // sort the first level of the tree
			}
			buildStepTypePannelTitle();
		}

		private void AllProcedureSets_clicked(object sender, EventArgs e)
		{
			Node pNode = sender as Node;
			foreach (Node node in advTreeProcSets.Nodes)
			{
				node.Checked = pNode.Checked;
				CheckTreeNodeChildren(node.Nodes);
			}
			// B2023-112: Clear the docversion list - this flags 'All' when the 'All Proc Sets' tree node is checked and 'None' when it isn't.  Then
			//	Use buildSetToSearchPanelTitle to set the text for how many sets are in search.
			lstCheckedDocVersions.Clear();
			buildSetToSearchPanelTitle();
		}

		private void AllSectionTypes_clicked(object sender, EventArgs e)
		{
			Node pNode = sender as Node;
			foreach (Node node in advTreeStepTypes.Nodes)
			{
				node.Checked = pNode.Checked;
				CheckTreeNodeChildren(node.Nodes);
			}
		}

		//C2023-010: Select all child nodes when a subtype is selected
		private void pnode_selected(object sender, EventArgs e)
		{
			DevComponents.AdvTree.Node pnode = sender as DevComponents.AdvTree.Node;
			if (pnode != null && pnode.HasChildNodes)
			{
				CheckTreeNodeChildren(pnode.Nodes);
			}
		}

		public void advTreeProcSetsFillIn(bool blSeachTabClicked)
		{
			DevComponents.AdvTree.Node topnode = null;
			int cntnd = 0;
			VETreeNode vtn = VETreeNode.GetFolder(TopFolderID);
			FolderInfo fi = vtn.VEObject as FolderInfo;
			int fiCount = fi.ChildFolderCount;
			advTreeProcSets.Nodes.Clear();
			lstCheckedDocVersions.Clear();
			topnode = new DevComponents.AdvTree.Node();
			topnode.Text = "Available Procedure Sets";
			topnode.Tag = fi;
			topnode.DataKey = fi.FolderID;
			advTreeProcSets.Nodes.Add(topnode);
			//advTreeProcSets.AfterNodeInsert += new TreeNodeCollectionEventHandler(advTreeProcSets_AfterNodeInsert);

			//B2023-076: Adding option to select all procedure sets
			DevComponents.AdvTree.Node selectAllNode = new Node();
			selectAllNode.Text = SelectAllProcedureSetsText;
			selectAllNode.Tag = SelectAllProcedureSetsText;
			selectAllNode.CheckBoxVisible = true;
			selectAllNode.NodeClick += new EventHandler(AllProcedureSets_clicked);
			topnode.Nodes.Add(selectAllNode);

			if (fi.SortedChildFolders != null)
			{
				foreach (FolderInfo fic in fi.SortedChildFolders)
				{
					DevComponents.AdvTree.Node newnode = new DevComponents.AdvTree.Node();
					newnode.Text = fic.ToString();
					newnode.Tag = fic;
					newnode.DataKey = fi.FolderID;
					AddCheckBox(true, newnode);//C2016-045 Allow Folders to be selected.
					cntnd++;
					if (fic.ChildFolderCount > 0 || fic.FolderDocVersionCount > 0)      // allow for '+' for tree expansion
					{
						if (fic.ChildFolderCount > 0)           // B2017-176: Do not display the Working Draft node (don't create dummy for expander)
						{
							DevComponents.AdvTree.Node tnt = new DevComponents.AdvTree.Node();
							tnt.Text = DummyNodeText;
							newnode.Nodes.Add(tnt);
						}
						topnode.Nodes.Add(newnode);
					}
				}
			}
			else
			{
				DevComponents.AdvTree.Node newnode = new DevComponents.AdvTree.Node();
				newnode.Text = fi.ToString();
				newnode.Tag = fi;
				newnode.DataKey = fi.FolderID;
				AddCheckBox(true, newnode);//C2016-045 Allow Folders to be selected.
				topnode.Nodes.Add(newnode);
				lstCheckedDocVersions.Add(Mydocversion);
				buildSetToSearchPanelTitle();
			}
			// if nothing was added to the tree, just put in the node above the docversions...
			if (advTreeProcSets.Nodes.Count == 0)
			{
				cntnd++;
				fi = Mydocversion.MyFolder;
				topnode = new DevComponents.AdvTree.Node();
				topnode.Text = fi.ToString();
				advTreeProcSets.Nodes.Add(topnode);
				topnode.Tag = fi;
				topnode.DataKey = fi.FolderID;
			}

			advTreeProcSets.BeforeExpand += new DevComponents.AdvTree.AdvTreeNodeCancelEventHandler(advTreeProcSets_BeforeExpand);

			// position to the procedure set in the tree if we have a procedure open
			if (Mydocversion != null)
				advTreeProcSetsPreSelect();
			else
				advTreeProcSets.Nodes[0].SelectedCell = advTreeProcSets.Nodes[0].Cells[0]; // select the first node - fixes cosmetic problem

			if (blSeachTabClicked)
				cbxTextSearchText.Focus(); // set initial focus to enter search text
		}

		public void advTreeProcSets_BeforeExpand(object sender, DevComponents.AdvTree.AdvTreeNodeCancelEventArgs e)
		{
			DevComponents.AdvTree.Node par = e.Node;
			// get first child's text, if it has one & if the text is "VLN_DUMMY_NODE", load children
			DevComponents.AdvTree.Node tn = null;
			if (par.Nodes.Count > 0) tn = par.Nodes[0];
			if (tn.Text == DummyNodeText)       // expand this
			{
				par.Nodes.Clear();
				Object obj = par.Tag;
				if (!(obj is FolderInfo)) return;   // should always be folderinfo on expand
				FolderInfo fi = (FolderInfo)obj;
				if (fi.ChildFolderCount > 0)
				{
					foreach (FolderInfo fic in fi.SortedChildFolders)
					{
						DevComponents.AdvTree.Node newnode = new DevComponents.AdvTree.Node();
						newnode.Text = fic.ToString();
						newnode.Tag = fic;
						newnode.DataKey = fic.FolderID;
						par.Nodes.Add(newnode);
						AddCheckBox(true, newnode);//C2016-045 Allow Folders to be selected.
						newnode.Enabled = true;
						if (fic.ChildFolderCount > 0)       // B2017-176: Only expand if folder has folders (not working draft nodes)
						{
							DevComponents.AdvTree.Node tnt = new DevComponents.AdvTree.Node();
							tnt.Text = DummyNodeText;
							newnode.Nodes.Add(tnt);
							// B2017-176: Only expand if folder has folders (not working draft nodes): the following was moved from the code
							//  that would check if this should be enabled if seraching for transition types.  The transition controls
							//  had a list of associated docversions, so needed to get the docversion in the folder:
							if (tabSearchTypes.SelectedTab == tabTranSearch)
							{
								if (!dicSelectedFolderNodes.ContainsKey(newnode)) dicSelectedFolderNodes.Add(newnode, false);
								// get the docversion for this folder, if it has one and determine whether it is enabled for transitions:
								string svid = null;
								if (fic.FolderDocVersionCount > 0)
									svid = fic.FolderDocVersions[0].VersionID.ToString();
								newnode.Enabled = svid != null && cbxTranVersion.Tag != null ? cbxTranVersion.Tag.ToString().Contains(svid) : false;
							}
						}
					}
				}
			}
		}

		public void AdvTree_AfterExpandorCollapse(object sender, AdvTreeNodeEventArgs e)
		{
			Node bottomNode = BottomTreeNode(cmboTreeROs.AdvTree.Nodes);
			Node lastNode = cmboTreeROs.AdvTree.Nodes[cmboTreeROs.AdvTree.Nodes.Count - 1];

			int top = cmboTreeROs.AdvTree.Nodes[0].Bounds.Top;
			int bottom = bottomNode.Bounds.Bottom + 5;
			int hScrollBarHeight = cmboTreeROs.AdvTree.HScrollBar != null ? cmboTreeROs.AdvTree.HScrollBar.Height : 0;
			bottom = bottomNode.Bounds.Bottom + 5;
			cmboTreeROs.AdvTree.Size = new Size(cmboTreeROs.AdvTree.Size.Width, Math.Min(525, bottom - top + hScrollBarHeight));

			if (cmboTreeROs.AdvTree.VScrollBar != null && bottom < cmboTreeROs.AdvTree.Size.Height)
			{
				int yLookFor = (bottom - cmboTreeROs.AdvTree.Size.Height) + 2 * hScrollBarHeight;
				Node topNode = FindTreeNodeAt(cmboTreeROs.AdvTree.Nodes, yLookFor);
				if (topNode != null)
				{
					topNode.EnsureVisible();
				}
			}
		}

		#endregion

		#region (Annotation Search)

		public void SetupAnnotationSearch(AnnotationDetails annotationDetails, DisplayTabControl tc)
		{
			_AnnotationDetails = annotationDetails;
			List<AnnotationTypeSearch> annoTypes = new List<AnnotationTypeSearch>();
			annoTypes.Add(new AnnotationTypeSearch("All Annotations", string.Empty));
			AnnotationTypeInfoList annoList = AnnotationTypeInfoList.Get();
			foreach (AnnotationTypeInfo ati in annoList)
				annoTypes.Add(new AnnotationTypeSearch(ati.Name, ati.TypeID.ToString()));
			cbxAnnoTypes.DisplayMember = "Name";
			cbxAnnoTypes.DataSource = annoTypes;
			lbSrchResults.MouseMove += new MouseEventHandler(lbSrchResults_MouseMove);
			_TabControl = tc;
		}

		#endregion

		#region (Search Results)

		public void UpdateAnnotationSearchResults()
		{
			if (!LastSearchWasAnnotations) return; // B2019-119 only refresh annotation search results if an annotation search was done
												   // B2019-004: update search results list when an annotation is removed. (before bug fix, code method & code below was commented out)
			string unitPrefix = string.Empty;

			if (Mydocversion != null)
				unitPrefix = Mydocversion.DocVersionConfig.Unit_ProcedureNumber;

			if (unitPrefix.EndsWith("#"))
				unitPrefix = unitPrefix.Replace("#", string.Empty);

			// C2023-005: Lose list position after delete. Save selected index to restore after & don't open the
			//		section after reset of index (UpdateAnnotationList setting below)
			int curindx = lbSrchResults.SelectedIndex;

			SearchResults = ItemInfoList.GetListFromAnnotationSearch(DVISearchList, TypeSearchList, AnnotationSearchType, cbxTextSearchAnnotation.Text, cbxCaseSensitiveAnnoText.Checked, unitPrefix);

			DisplayResults();
			UpdatedAnnotationList = true;
			// C2023-007: C2023-005 reset position after delete but positioned to item before deleted item, modified the
			//	list reset to position after deleted item
			lbSrchResults.SelectedIndex = curindx < 0 ? -1 : curindx == lbSrchResults.Items.Count ? curindx - 1 : curindx;
			UpdatedAnnotationList = false;
		}
		private bool UpdatedAnnotationList = false;
		#endregion

		#region (ContextMenu)

		// Changed to a public so that it could be called after the /DB parameter has been processed
		public void SetupContextMenu()
		{
			galSymbols.SubItems.Clear();
			// Bug fix B2014-057
			// if we are searching for a symbol character in all procedure sets MyDocVersion is null
			// when MyDocVersion is null, get the symbol list directly from the PROMS base format (BaseAll.xml)
			// this will populate the context menu of the Search text entry field so that a symbol can be selected without first selecting a procedure set
			FormatData fmtdata = (_MyDocVersion != null) ? _MyDocVersion.ActiveFormat.PlantFormat.FormatData : FormatInfo.PROMSBaseFormat.FormatData;

			if (fmtdata != null && fmtdata.SymbolList != null)
			{
				SymbolList sl = fmtdata.SymbolList;

				if (sl == null || sl.Count <= 0)
				{
					FlexibleMessageBox.Show("No symbols are available, check with administrator");
					return;
				}

				foreach (Symbol sym in sl)
				{
					DevComponents.DotNetBar.ButtonItem btnCM = new DevComponents.DotNetBar.ButtonItem();

					btnCM.Text = string.Format("{0}", (char)sym.Unicode);
					// to name button use unicode rather than desc, desc may have spaces or odd chars
					btnCM.Name = "btnCM" + sym.Unicode.ToString();
					btnCM.Tooltip = sym.Desc;
					btnCM.Tag = string.Format(@"{0}", sym.Unicode);
					btnCM.FontBold = true;
					btnCM.Click += new System.EventHandler(btnSym_Click);
					galSymbols.SubItems.Add(btnCM);
				}
			}
		}

		#endregion

		#region (Refresh Timer)

		public void _TmrRefresh_Tick(object sender, EventArgs e)
		{
			// B2016-258 Hang after selecting a procedure if the Step Type panel is open on the search panel
			_TimeActivity.Open();

			TmrRefresh.Enabled = false;
			if (!_fromLoad) AdvTreeStepTypesFillIn();       // Don't reload if coming from Load - this overwrites the load settings

			_TimeActivity.Close();
		}

		#endregion

		#endregion

		#region Private Methods

		private void LoadSearchTextListBox()
		{
			// Setup SearchText Combo
			cbxTextSearchText.Items.Clear();
			if (Properties.Settings.Default["SearchList"] != null && Properties.Settings.Default.SearchList.Count > 0)
			{
				foreach (string str in Properties.Settings.Default.SearchList)
					cbxTextSearchText.Items.Add(str);
			}
			// Setup SearchAnnotation Combo
			cbxTextSearchAnnotation.Items.Clear();
			if (Properties.Settings.Default["SearchAList"] != null && Properties.Settings.Default.SearchAList.Count > 0)
			{
				foreach (string str in Properties.Settings.Default.SearchAList)
					cbxTextSearchAnnotation.Items.Add(str);
			}
		}

		private DevComponents.AdvTree.Node NewAdvTreeNode(string nodetext, bool selectable, bool chxbxvisable)
		{
			DevComponents.AdvTree.Node newnode;
			newnode = new DevComponents.AdvTree.Node();
			newnode.Text = nodetext;
			newnode.Selectable = selectable;
			AddCheckBox(chxbxvisable, newnode);//C2016-045 Allow Folders to be selected.
			return newnode;
		}

		private void AddCheckBox(bool chxbxvisable, DevComponents.AdvTree.Node newnode)
		{
			//C2016-045 Allow Folders to be selected.
			newnode.CheckBoxAlignment = DevComponents.AdvTree.eCellPartAlignment.NearCenter;
			newnode.CheckBoxStyle = eCheckBoxStyle.CheckBox;
			newnode.CheckBoxThreeState = false;
			newnode.CheckBoxVisible = chxbxvisable;

			// Set newnode.Checked = parent.Checked
			if (newnode.Parent != null)
				newnode.Checked = newnode.Parent.Checked;
		}

		private Node LookInTree(NodeCollection monkeys, string bananna)
		{
			Node foundit = null;
			foreach (Node chimp in monkeys)
			{
				if (chimp.Text.Equals(bananna))
				{
					foundit = chimp;
					// need to select the node (cell) for it to be checked
					chimp.SelectedCell = chimp.Cells[0];
					if (chimp.Nodes.Count > 0)
						chimp.Expand();
					break;
				}
				chimp.Collapse();
			}
			return foundit;
		}

		// C2020-033: Before allowing conversion of Incoming Transitions to text, get list of results that the user has permission edit.
		private List<int> TranCvtCheckPermission(bool all)
		{
			// B2023-102 Don't crash on converting incoming transitions to text if there are none (can happen if 2nd pass occurs)
			if (_SearchResults == null) return null;

			// check if a non-reader can convert transitions to text even if a reader - this is set by an administrator on the top
			// folder properties dialog
			bool allowNonAdmin = IncTranCvtPerm();
			List<int> itmsEditable = new List<int>();   // return this list
			int listCount = 0;
			if (all)  // Check all in list
			{
				listCount = _SearchResults.Count;
				foreach (ItemInfo ii in _SearchResults)
				{
					if (allowNonAdmin || UserInfo.CanEdit(MyUserInfo, ii.MyDocVersion)) itmsEditable.Add(ii.ContentID);
				}
			}
			else  // check only the items selected
			{
				listCount = lbSrchResultsIncTrans.CheckedItems.Count;
				List<ListBoxItem> lbis = lbSrchResultsIncTrans.CheckedItems;
				foreach (ListBoxItem lbi in lbis)
				{
					ItemBindingData tmpii = lbi.Tag as ItemBindingData;
					ItemInfo ii = tmpii.DataItem as ItemInfo;
					if (allowNonAdmin || UserInfo.CanEdit(MyUserInfo, ii.MyDocVersion)) itmsEditable.Add(ii.ContentID);
				}
			}
			// Prompt user if convert to text should continue.  If some items cannot be edited, also state that
			// not all can be converted to text. If count of itmsEditable & lbis are different some cannot be edited.
			if (itmsEditable.Count == 0)
			{
				FlexibleMessageBox.Show("You do not have permission to edit any of the procedures, sections, and/or steps" + (all ? "." : " that are selected."),
						"Convert Transition to Text", MessageBoxButtons.OK, MessageBoxIcon.Information);
				return null;
			}
			else if (itmsEditable.Count != listCount)
			{
				DialogResult ans = FlexibleMessageBox.Show("You only have permission to edit some of the procedures, sections, and/or steps that are selected.procedures, sections, and/or steps" + (all ? "." : " that are selected.") +
					"\r\n\r\n Should the conversion of the transitions to text continue?",
							"Convert Transition to Text", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
				if (ans == DialogResult.No) return null;
			}
			else
			{
				// B2023-103 add spinner (WaitCursor) and also, change FlexibleMessageBox to regular MessageBox since restore of cursor to
				//		wait cursor did not work after FlexibleMessageBox
				Cursor savcursor = Cursor;
				DialogResult ans = MessageBox.Show(this, "Are you sure you want to convert the transitions to text?", "Convert Transitions to Text", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
				this.Cursor = savcursor;
				if (ans == DialogResult.No) return null;
			}

			return itmsEditable;
		}

		// C2020-033: convert selected transitions to text
		private void btnTranCvtSelToTxt_Click(object sender, EventArgs e)
		{
			// First see if all selected can be converted, i.e. user has permission to edit 
			List<ListBoxItem> lbis = lbSrchResultsIncTrans.CheckedItems;
			List<int> itmsEditable = TranCvtCheckPermission(false);
			if (itmsEditable == null || itmsEditable.Count == 0) return;
			TranCvtToTxt(itmsEditable);
			fromTranCvtBtn = true;
			UpdateSearchIncTransResults();  // B2021-009: Research after convert transitions to text
			fromTranCvtBtn = false;
		}

		// B2021-010: IncomingTranGetMergedTranList gets a complete list of incoming transitions (before fix transitions to procedure
		//	were only included if there were NO transitions to items within procedure, the GetExternalTransitionsToChildren query
		//	did not get transitions 'incoming to' the item itself)
		private ItemInfoList IncomingTranGetMergedTranList()
		{
			ItemInfoList iil = null;
			bool first = true;

			using (TransitionInfoList exTrans = TransitionInfoList.GetExternalTransitionsToChildren(SearchIncTransII.ItemID))
			{
				foreach (TransitionInfo ti in exTrans)
				{
					if (first)
					{
						ContentInfo ci = ContentInfo.Get(ti.FromID);
						ItemInfo tmp = ci.ContentItems[0];
						iil = new ItemInfoList(tmp);
						first = false;
					}
					else
					{
						ContentInfo ci = ContentInfo.Get(ti.FromID);
						ItemInfo tmp = ci.ContentItems[0];
						iil.AddItem(tmp);
					}
				}
			}
			using (TransitionInfoList exTrans = TransitionInfoList.GetExternalTransitions(SearchIncTransII.ItemID))
			{
				foreach (TransitionInfo ti in exTrans)
				{
					if (first)
					{
						ContentInfo ci = ContentInfo.Get(ti.FromID);
						ItemInfo tmp = ci.ContentItems[0];
						iil = new ItemInfoList(tmp);
						first = false;
					}
					else
					{
						ContentInfo ci = ContentInfo.Get(ti.FromID);
						ItemInfo tmp = ci.ContentItems[0];

						// B2021-014:  if in list, don't add another
						if (!iil.Contains(tmp)) iil.AddItem(tmp);
					}
				}
			}

			return iil;
		}

		// C2020-033: For items in list, do the actual conversion of the Incoming Transition to text
		private void TranCvtToTxt(List<int> itmsEditable)
		{
			// B2023-103 Add wait cursor (and remove at end)
			this.Cursor = Cursors.WaitCursor;
			ItemInfo trII = SearchIncTransII;

			if (trII != null)
			{
				using (TransitionInfoList exTrans = TransitionInfoList.GetExternalTransitionsToChildren(trII.ItemID))
				{
					foreach (TransitionInfo ti in exTrans)
					{
						// See if the 'item to' id is to be converted and if so do it.  To figure this out, 
						//  see if it is in the list itmsEditable.
						if (itmsEditable.Contains(ti.FromID))
						{
							ContentInfo ci = ContentInfo.Get(ti.FromID);
							ItemInfo tmp = ci.ContentItems[0];

							using (Content content = Content.Get(tmp.ContentID))
							{
								content.FixTransitionText(ti, true);
								content.Save();
							}
						}
					}

				}

				// B2021-010: Convert the text of transitions pointing (incoming) to the item itself
				using (TransitionInfoList exTrans = TransitionInfoList.GetExternalTransitions(trII.ItemID))
				{
					foreach (TransitionInfo ti in exTrans)
					{
						// See if the 'item to' id is to be converted and if so do it.  To figure this out, 
						//  see if it is in the list itmsEditable.
						if (itmsEditable.Contains(ti.FromID))
						{
							ContentInfo ci = ContentInfo.Get(ti.FromID);
							ItemInfo tmp = ci.ContentItems[0];

							using (Content content = Content.Get(tmp.ContentID))
							{
								content.FixTransitionText(ti, true);
								content.Save();
							}
						}
					}

				}
			}
			this.Cursor = Cursors.Default;
		}

		#region (ProgressBar)

		private void ProgressBar_Initialize(int max, string desc)
		{
			if (_ProgressBar != null)
			{
				_ProgressBar.Maximum = max;
				_ProgressBar.Text = desc;
				_ProgressBar.TextVisible = true;
			}
		}

		private void ProgressBar_SetValue(int curval)
		{
			if (_ProgressBar != null)
				_ProgressBar.Value = curval;
		}

		private void ProgressBar_Clear()
		{
			if (_ProgressBar != null)
			{
				_ProgressBar.Text = string.Empty;
				_ProgressBar.Maximum = 0;
				_ProgressBar.Value = 0;
			}
		}

		#endregion

		#region (ROFST Combo Tree)

		private void LoadROComboTree()
		{
			lblSrchRoMsg.Visible = false;           // C2019-041: start out with no message about rofsts and folder(s) compatibility
													// if only one docversion selected, this RoFst can be used.  If more than one or none (none is all docversions), then check if they 
													// use the same RO fst.  If not, put a message as the first tree node and return, otherwise, load the tree.
			List<DocVersionInfo> dvilTmp = new List<DocVersionInfo>();

			if (lstCheckedDocVersions == null || lstCheckedDocVersions.Count == 0)
			{
				DocVersionInfoList dvil = DocVersionInfoList.Get();
				foreach (DocVersionInfo dvi in dvil) dvilTmp.Add(dvi);
			}
			else
			{
				dvilTmp = lstCheckedDocVersions;
			}

			bool same = true;
			// get the first rofstId for comparing to the rest:
			int rofstId = (dvilTmp.Count > 0) ? (dvilTmp[0].DocVersionAssociations != null && dvilTmp[0].DocVersionAssociations.Count > 0) ? dvilTmp[0].DocVersionAssociations[0].ROFstID : -1 : -1;

			// for remaining folder/docversions in the list, check if they have an associated rofst & if so, if it is the same as the first in list.
			for (int i = 1; i < dvilTmp.Count; i++)
			{
				if (dvilTmp[i].DocVersionAssociations != null && dvilTmp[i].DocVersionAssociations.Count > 0)
				{
					if (rofstId != dvilTmp[i].DocVersionAssociations[0].ROFstID)
					{
						same = false;
						break;
					}
				}
			}

			// rofsts for selected folder/docversions are not the same, cannot do an ro search:
			if (!same)
			{
				DevComponents.AdvTree.Node tn = new DevComponents.AdvTree.Node();
				// C2019-041: if selected folders do not have the same ro.fst then clear the ro list and let user know.
				cmboTreeROs.Nodes.Clear();

				if (lstCheckedDocVersions == null || lstCheckedDocVersions.Count == 0)
					lblSrchRoMsg.Text = "RO values are incompatible between the folders. This may be due to the RO values needing to be updated.";
				else
					lblSrchRoMsg.Text = "This folder(s) RO values are incompatible with the currently selected folder(s).  This may be due to the RO values needing to be updated.";

				lblSrchRoMsg.Visible = true;
				_lastRoFstId = -1;
				return;
			}

			// C2019-041: if requested rofst is same as last one, just return;
			if (_lastRoFstId == rofstId) return;

			lblSrchRoMsg.Refresh();
			cmboTreeROs.Nodes.Clear();
			this.cmboTreeROs.AdvTree.BeforeExpand += new DevComponents.AdvTree.AdvTreeNodeCancelEventHandler(this.cmboTreeROs_BeforeExpand);
			cmboTreeROs.AdvTree.AfterExpand += new AdvTreeNodeEventHandler(AdvTree_AfterExpandorCollapse);
			cmboTreeROs.AdvTree.AfterCollapse += new AdvTreeNodeEventHandler(AdvTree_AfterExpandorCollapse);

			// populate the tree - only 1 folder/docversion is selected or all selected use the same rofst:
			// B2022-071 use the dvilTmp instead of lstCheckedDocVersions because if none are check then it's count will be zero
			if (dvilTmp != null && dvilTmp.Count > 0)
			{
				// C2019-041:  Save this rofstid in case a new one is processed.
				// B2022-071: We were setting _lastRoFstId before checking if we were going to load the RO tree,
				//            So now set set it only if we actually load the RO tree
				//            Also, set _MydocVersion to dvilTmp[0]
				_lastRoFstId = rofstId;
				// B2022-143:  Only reset _MyDocVersion if it is null, it a procedure is in editor, _MyDocVersion is the set for
				//	the procedure active in the editor:
				if (_MyDocVersion == null) _MyDocVersion = dvilTmp[0];

				if (_MyDocVersion.DocVersionAssociations != null && _MyDocVersion.DocVersionAssociations.Count > 0)
				{
					_MyROFSTLookup = _MyDocVersion.DocVersionAssociations[0].MyROFst.GetROFSTLookup(_MyDocVersion);

					ROFSTLookup.rodbi[] dbs = _MyROFSTLookup.GetRODatabaseList(true);

					if (dbs != null && dbs.Length > 0)
					{
						for (int i = 0; i < dbs.Length; i++)
						{
							ROFSTLookup.rodbi db = dbs[i];

							DevComponents.AdvTree.Node tn = new DevComponents.AdvTree.Node(db.dbiTitle);
							tn.Tag = db;
							cmboTreeROs.Nodes.Add(tn);

							AddDummyGroup(db, tn);
						}
					}
				}
			}
		}

		private Node FindTreeNodeAt(NodeCollection nodes, int y)
		{
			foreach (Node node in nodes)
			{
				if (node.Bounds.Top <= y && node.Bounds.Bottom >= y)
					return node;
				if (node.Bounds.Top > y)
				{
					if (node.PrevNode != null && node.PrevNode.Expanded)
						return FindTreeNodeAt(node.PrevNode.Nodes, y);
					return node;
				}
			}
			return null;
		}

		private Node BottomTreeNode(NodeCollection nodes)
		{
			Node bottomNode = nodes[nodes.Count - 1]; // Return bottom node in collection
			if (bottomNode.Expanded) // If expanded return bottom child
				return BottomTreeNode(bottomNode.Nodes);
			return bottomNode;
		}

		private void AddDummyGroup(ROFSTLookup.rodbi rodbi, DevComponents.AdvTree.Node tn)
		{
			if (MyROFSTLookup.HasChildren(ref rodbi))
			{
				DevComponents.AdvTree.Node tmp = new DevComponents.AdvTree.Node(DummyNodeText);
				tn.Nodes.Add(tmp);
			}
		}

		private void cmboTreeROs_BeforeExpand(object sender, DevComponents.AdvTree.AdvTreeNodeCancelEventArgs e)
		{
			LoadChildren(e.Node);
		}

		private void LoadChildren(DevComponents.AdvTree.Node tn)
		{
			if (tn.HasChildNodes && tn.Nodes[0].Text != DummyNodeText) return;  // already loaded.
			if (tn.HasChildNodes && tn.Nodes[0].Text == DummyNodeText) tn.Nodes[0].Remove();

			ROFSTLookup.rochild[] chld = null;

			if (tn.Tag is ROFSTLookup.rodbi)
			{
				ROFSTLookup.rodbi db = (ROFSTLookup.rodbi)tn.Tag;
				MyROFSTLookup.LoadChildren(ref db);
				chld = db.children;
			}
			else if (tn.Tag is ROFSTLookup.rochild)
			{
				ROFSTLookup.rochild ch = (ROFSTLookup.rochild)tn.Tag;
				MyROFSTLookup.LoadChildren(ref ch);
				chld = ch.children;
			}
			else
			{
				Console.WriteLine("error - no type");
				return;
			}

			// if children, add dummy node
			// B2022-026 RO Memory Reduction code - need to check length
			if (chld != null && chld.Length > 0)
			{
				ProgressBar_Initialize(chld.Length, tn.Text);

				for (int i = 0; i < chld.Length; i++)
				{
					ProgressBar_SetValue(i);
					DevComponents.AdvTree.Node tmp = null;

					ROFSTLookup.rochild roc = chld[i];

					// if this is a group, i.e. type 0, add a dummy node
					// B2022-026 RO Memory Reduction code - check children length
					if (roc.type == 0 && !MyROFSTLookup.HasChildren(ref roc))
					{
						continue; // Ignore: Junk Scenario
					}
					else if (!string.IsNullOrEmpty(roc.appid))
					{
						MyROFSTLookup.LoadChildren(ref roc);

						if (roc.children.Length == 1 && roc.children.First().roid.Length == 16)
						{
							roc.appid = roc.children.First().appid;
							roc.roid = roc.children.First().roid;
							roc.value = roc.children.First().value;

							roc.children = new List<ROFSTLookup.rochild>().ToArray();
						}
					}


					if (roc.value == null)
					{
						tmp = new DevComponents.AdvTree.Node(roc.title);
						tmp.Tag = roc;

						int index = FindIndex(tn.Nodes, tmp.Text);
						tn.Nodes.Insert(index, tmp);

						DevComponents.AdvTree.Node sub = new DevComponents.AdvTree.Node(DummyNodeText);
						tmp.Nodes.Add(sub);
					}
					else
					{
						tmp = new DevComponents.AdvTree.Node(roc.title);
						tmp.Tag = roc;

						if (roc.roid.Length == 16)
						{
							tn.Nodes.Add(tmp);
						}
						else
						{
							int index = FindIndex(tn.Nodes, tmp.Text);
							tn.Nodes.Insert(index, tmp);
						}
					}
				}
			}

			ProgressBar_Clear();
		}

		private int FindIndex(NodeCollection nodes, string value)
		{
			int index = 0;
			foreach (Node node in nodes)
			{
				if (GreaterValue(node.Text, value)) return index;
				index++;
			}
			return index;
		}

		private bool GreaterValue(string value1, string value2)
		{
			return DisplayRO.GreaterValue(value1, value2);
		}

		private void cmboTreeROs_SelectedIndexChanged(object sender, EventArgs e)
		{
			if (cmboTreeROs.SelectedIndex == -1 || cmboTreeROs.SelectedNode.Tag is ROFSTLookup.rodbi)
			{
				cbxFndUnLnkROVals.Enabled = false;
			}
			else if (cmboTreeROs.SelectedNode.Tag is ROFSTLookup.rochild)
			{
				ROFSTLookup.rochild ro = (ROFSTLookup.rochild)cmboTreeROs.SelectedNode.Tag;
				// B2022-026 RO Memory Reduction code - check children length
				cbxFndUnLnkROVals.Enabled = (ro.children == null || ro.children.Length <= 0);
			}

			if (!cbxFndUnLnkROVals.Enabled)
				cbxFndUnLnkROVals.Checked = false;
		}

		private void gpFindROs_EnabledChanged(object sender, EventArgs e)
		{
			if (gpFindROs.Enabled)
				gpFindROs.Style.BackColor = Color.Yellow;
			else
				gpFindROs.Style.BackColor = saveGpFindROsColor;
		}

		private void advTreeProcSetsPreSelect()
		{
			bool keeplooking = true;
			//build a stack (bread crumb trail) of where is procedure set came from within the tree.
			Stack<string> crumbs = new Stack<string>();
			//crumbs.Push(Mydocversion.Name); // ex: "working draft"
			//crumbs.Push(Mydocversion.MyFolder.Name); // ex: "Emergency Procedures"
			//crumbs.Push(Mydocversion.MyFolder.MyParent.Name); // ex: "STPNOC-South Texas"
			//crumbs.Push(advTreeProcSets.Nodes[0].Text); //top node of my tree

			//crumbs.Push(Mydocversion.Name); // ex: "working draft"
			crumbs.Push(Mydocversion.MyFolder.Name); // ex: "Emergency Procedures"
			FolderInfo fi = Mydocversion.MyFolder.MyParent;
			while (fi != null)
			{
				if (fi.MyParent != null)
					crumbs.Push(fi.Name);
				fi = fi.MyParent;
			}
			crumbs.Push(advTreeProcSets.Nodes[0].Text); //top node of my tree

			// now walk the tree, looking for the node names we saved in the stack.
			NodeCollection monkeys = advTreeProcSets.Nodes;
			while (keeplooking)
			{
				Node climber = LookInTree(monkeys, crumbs.Pop());
				keeplooking = (climber != null && crumbs.Count > 0);
				if (keeplooking)
					monkeys = climber.Nodes;
				if (!keeplooking && climber != null)
				{
					climber.Checked = true;
				}
			}
		}

		#endregion

		#region (Annotation Search)

		private void cbxTextSearchAnnotation_Leave(object sender, EventArgs e)
		{
			InsertAnnotationSearchCriteria();

		}

		private void InsertAnnotationSearchCriteria()
		{
			if (!cbxTextSearchAnnotation.Text.Equals(string.Empty))
			{
				string tstr = cbxTextSearchAnnotation.Text;
				if (!cbxTextSearchAnnotation.Items.Contains(tstr))
					cbxTextSearchAnnotation.Items.Insert(0, tstr);
			}
		}

		private void gpSrchAnnoText_EnabledChanged(object sender, EventArgs e)
		{
			if (gpSrchAnnoText.Enabled)
			{
				gpSrchAnnoText.Style.BackColor = Color.Yellow;
				cbxTextSearchAnnotation.Focus();
			}
			else
				gpSrchAnnoText.Style.BackColor = saveGpSrchAnnoTextColor;
		}

		#endregion

		#region (Search Results)

		private void DisplayResults()
		{
			_LoadingList = true;
			// C2020-033: Incoming Transition tab.  Note that this tab uses a different control for the search
			//	results, it uses the dotnetbar list that has check boxes.  Because of this, various places throughout
			//	the code will check for what tab is displayed and will work eith the associated list box, either
			//	lbSrchResults or lbSrchResultsIncTrans
			if (tabSearchTypes.SelectedTab != tabSearchTypes.Tabs[4]) lbSrchResults.DisplayMember = _DisplayMember;
			else lbSrchResultsIncTrans.DisplayMember = _DisplayMember;
			if (_SearchResults != null)
			{
				// record count flag
				bool reccnt = true;
				// B2021-076: Proms search results are not presented in order when printed to PDF
				// B2023-041 - backed out previous change as it was not needed and was preventing the sorting of search results text
				if (cbSorted.Checked)
				{
					Csla.SortedBindingList<ItemInfo> sortedResults = new Csla.SortedBindingList<ItemInfo>(_SearchResults);
					sortedResults.ApplySort(_DisplayMember, ListSortDirection.Ascending);
					if (tabSearchTypes.SelectedTab != tabSearchTypes.Tabs[4]) lbSrchResults.DataSource = sortedResults;
					else lbSrchResultsIncTrans.DataSource = sortedResults;
				}
				else
				{
					// B2021-076: Proms search results are not presented in order when printed to PDF
					var sortedResults = _SearchResults.OrderBy(x => x.SearchDefaultSort).ToList();

					// if searching for just a "?" remove all the special code matches and leaving only the true matches.
					if (SearchString == "\\?")
					{
						string pat = @"\?";
						Regex r = new Regex(pat, RegexOptions.IgnoreCase);
						for (int i = 0; i < sortedResults.Count; i++)
						{

							Match m = r.Match(sortedResults[i].DisplayText);
							if (m.Success)
							{
								continue;
							}
							else
							{
								sortedResults.Remove(sortedResults[i]);

								i--;
							}
						}
						grpPanSearchResults.Text = string.Format("Search Results Found: {0}", sortedResults.Count);
						reccnt = false;
					}

					if (tabSearchTypes.SelectedTab != tabSearchTypes.Tabs[4]) lbSrchResults.DataSource = sortedResults;
					else lbSrchResultsIncTrans.DataSource = sortedResults;
				}
				if (reccnt)
				{
					grpPanSearchResults.Text = string.Format("Search Results Found: {0}", _SearchResults.Count);
				}
				grpPanSearchResults.Style.BackColor = Color.LightGreen;// Color.YellowGreen;  Color.DarkSeaGreen;
			}
			else
			{
				grpPanSearchResults.Text = "Search Results";
				grpPanSearchResults.Style.BackColor = saveGrpPanSearchResults;
			}

			// Turn Print and Results display style on/off based on whether there are search results
			if (_SearchResults != null && _SearchResults.Count > 0)
			{
				btnPrnSrchRslts.Enabled = true;
				btnClearSearchResults.Enabled = true;
				btnCopySearchResults.Enabled = true;
				btnSaveSearchResults.Enabled = true;
				cmbResultsStyle.Enabled = true;
			}
			else
			{
				btnPrnSrchRslts.Enabled = false;
				btnClearSearchResults.Enabled = false;
				btnCopySearchResults.Enabled = false;
				btnSaveSearchResults.Enabled = false;
				cmbResultsStyle.Enabled = false;
			}

			// B2021-076: Proms search results are not presented in order when printed to PDF
			if (_DisplayMember == "SearchPath_clean" || _DisplayMember == "ShortSearchPath_clean")
			{
				cbSorted.Checked = false;
				cbSorted.Enabled = false;
			}
			else
			{
				cbSorted.Enabled = true;
			}

			lbSrchResults.SelectedIndex = -1;
			lbSrchResultsIncTrans.SelectedIndex = -1;
			LastResultsMouseOverIndex = -1;
			_LoadingList = false;

		}

		private void lbSrchResults_MouseMove(object sender, MouseEventArgs e)
		{
			int ResultsMouseOverIndex = lbSrchResults.IndexFromPoint(e.Location);
			if (ResultsMouseOverIndex != -1 && ResultsMouseOverIndex != LastResultsMouseOverIndex)
			{
				ItemInfo ii = lbSrchResults.Items[ResultsMouseOverIndex] as ItemInfo;
				if (cmbResultsStyle.Text == "Step Path" && !ii.IsRtfRaw)
					toolTip1.SetToolTip(lbSrchResults, ii.DisplayText); // display the text in a tooltip
				else
					toolTip1.SetToolTip(lbSrchResults, ii.Path); // display location of corresponding procedure text in a tooltip
				LastResultsMouseOverIndex = ResultsMouseOverIndex;
			}
		}

		// B2021-018: Removed code that was tracking the number of items checked in the incoming transition
		//	listbox.  Found that could just look at the CheckedItems.Count value. (Previous fixes
		//	that were removed are B2021-003 & part of C2020-033 (part was for permissions, which was not removed)
		// C2020-033: lbSrchResultsIncTrans_ItemClicked is used to check permissions of a selection before allowing an
		//	item to be clicked and to turn on/off the btnTranCvtSelToTxt button for converting selected to test.
		private void lbSrchResultsIncTrans_ItemClicked(object sender, EventArgs e)
		{
			ListBoxItem lbi = sender as ListBoxItem;
			if (lbi != null)
			{
				ItemBindingData ibd = lbi.Tag as ItemBindingData;
				ItemInfo ii = ibd.DataItem as ItemInfo;
				bool allowNonAdmin = IncTranCvtPerm();
				if (lbi.CheckState == CheckState.Checked && ii != null)
				{
					if (!allowNonAdmin && !UserInfo.CanEdit(MyUserInfo, ii.MyDocVersion))
					{
						FlexibleMessageBox.Show("You do not have permission to edit the procedure, section, or step.",
							"Convert Transition to Text", MessageBoxButtons.OK, MessageBoxIcon.Information);
						lbi.CheckState = CheckState.Unchecked;
					}
				}
				// B2021-018: use the CheckedItems.Count on the list box for the search results for
				//	incoming transitions to determine whether to enable the convert selected to text:
				btnTranCvtSelToTxt.Enabled = (lbSrchResultsIncTrans.CheckedItems.Count > 0);
			}
		}

		private void GrpPanSearchResults_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
		{
			// B2021-004: If a multiple selection occurred in the results list for Incoming Transitions, tell user that
			//	processing is occurring
			if (!lbSrchResultsIncTrans.Enabled) FlexibleMessageBox.Show("Processing a request to open a procedure. Try again when complete.",
				"Try Again", MessageBoxButtons.OK, MessageBoxIcon.Information);
		}

		private void lbSrchResults_SelectedValueChanged(object sender, EventArgs e)
		{
			if (_LoadingList) return;
			if (_ProcessingSelectedValueChanged) return;
			if (UpdatedAnnotationList) return;
			_ProcessingSelectedValueChanged = true;
			// B2021-004: Prevent multiple selections on the Incoming Transitions listbox  (disable selections
			//	for the listbox until all processing is done, listbox is enabled at end of method)
			if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[4])
			{
				lbSrchResultsIncTrans.Enabled = false;
				lbSrchResultsIncTrans.UseWaitCursor = true;
			}
			ListBox mylb = sender as ListBox;

			// If the list is being refreshed, then set the selection index to -1 (no selection)
			// B2022-044: don't set selection to top of list (commented out/changed if)
			//if (mylb != null && _SearchResults.RefreshingList && mylb.SelectedIndex != -1)
			//	//mylb.SelectedIndex = -1;
			//else
			if (mylb != null && !_SearchResults.RefreshingList)
			{
				_ItemInfo = (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[4]) ? lbSrchResultsIncTrans.SelectedValue as ItemInfo : lbSrchResults.SelectedValue as ItemInfo;
				if ((tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[1]) && (_ItemInfo != null))
				{
					// B2020-019: Don't set the CurrentAnnotation to an annotation in a procedure that cannot be opened.
					AnnotationInfo tmpca = AnnotationInfo.Get(_ItemInfo.SearchAnnotationID);
					DisplayTabItem dti = null;
					if (tmpca != null) dti = _TabControl.OpenItem(tmpca.MyItem); // open the corresponding procedure text
					if (dti != null)
					{
						_AnnotationDetails.CurrentAnnotation = tmpca;
						_AnnotationDetails.FindCurrentAnnotation(); // position to corresponding row in annotation grid
					}
				}
				else
				{
					if (_ItemInfo != null)
					{
						_OpenDocFromSearch = true;
						// B2023-089: selecting a deleted item from search results shows deleted step in the editor when the StepTabItem for 
						//	the deleted item was displayed but is not the active StepTabItem.  Use its procedure if it was deleted
						ItemInfo openItem = _ItemInfo.IsDeleted ? ItemInfo.Get(_ItemInfo.MyProcedure == null ? _ItemInfo.ItemID : _ItemInfo.MyProcedure.ItemID) : _ItemInfo;
						DisplayTabItem dti = _TabControl.OpenItem(openItem); // open the corresponding procedure text
						if (dti != null)
						{
							if (dti.MyDSOTabPanel != null)
								dti.MyDSOTabPanel.SearchString = _strSrchText == null || _strSrchText == string.Empty ? this.cbxTextSearchText.Text : _strSrchText;
							if (dti.MyStepTabPanel != null)
								dti.MyStepTabPanel.SearchString = _strSrchText == null || _strSrchText == string.Empty ? this.cbxTextSearchText.Text : _strSrchText;
							_OpenDocFromSearch = false;
						}
					}
				}
			}
			_ProcessingSelectedValueChanged = false;
			if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[4])
			{
				lbSrchResultsIncTrans.Enabled = true;
				lbSrchResultsIncTrans.UseWaitCursor = false;
			}
		}

		private void cmbResultsStyle_SelectedValueChanged(object sender, EventArgs e)
		{
			switch (cmbResultsStyle.Text)
			{
				case "Document Path":
					_DisplayMember = "SearchDVPath_clean";
					break;
				case "Step Path":
					_DisplayMember = "ShortSearchPath_clean";
					break;
				case "Annotation Text":
					_DisplayMember = "SearchAnnotationText";
					break;
				case "Document Text":
					_DisplayMember = "DisplayText";
					break;
				default:
					_DisplayMember = "SearchPath_clean";
					break;
			}
			DisplayResults();
		}

		private void cbSorted_CheckedChanged(object sender, EventArgs e)
		{
			Cursor savcursor = Cursor;
			Application.DoEvents();
			Cursor = Cursors.WaitCursor;
			//Console.WriteLine(string.Format("Checked = {0}", cbSorted.Checked));
			DisplayResults();
			Cursor = savcursor;
		}

		#endregion

		#region (Search)

		private string ConvertSpecialChars(string str)
		{
			string rtnVal = str;
			rtnVal = rtnVal.Replace("\u00A0", @"\u160?"); //convert \u00A0 to a hard space (\u00A0 shows as a blank in the search text field)
			rtnVal = rtnVal.Replace("\n", @"\line "); //B2018-020 SQL content record has "\line " for the hard return
													  // Bug fix B2014-057
													  // if we are searching for a symbol character in all procedure sets MyDocVersion is null
													  // when MyDocVersion is null, get the symbol list directly from the PROMS base format (BaseAll.xml)
			FormatData fmtdata = (_MyDocVersion != null) ? _MyDocVersion.ActiveFormat.PlantFormat.FormatData : FormatInfo.PROMSBaseFormat.FormatData;
			if (fmtdata != null && fmtdata.SymbolList != null)
			{
				SymbolList sl = fmtdata.SymbolList;
				if (sl != null)
				{
					foreach (Symbol sym in sl)
					{
						string rplace = string.Format(sym.Unicode < 256 ? @"\'{0:X2}" : @"\u{0}?", sym.Unicode);  // bug fix B2014-057 we were not including the ? in the replace
						rtnVal = rtnVal.Replace(((char)sym.Unicode).ToString(), rplace);
					}
				}
			}
			return rtnVal;
		}

		// Same funtion as GetROChildren in DisplayReport.cs
		private string GetROsToSearch(ROFSTLookup.rochild[] chld)
		{
			string rtnstr = string.Empty;
			// B2022-118: If the ro has child nodes in tree view but they aren't loaded, load them
			if ((chld == null || chld.Length <= 0) && (cmboTreeROs.SelectedNode.Nodes != null || cmboTreeROs.SelectedNode.Nodes.Count >= 1))
			{
				ROFSTLookup.rochild ro = (ROFSTLookup.rochild)cmboTreeROs.SelectedNode.Tag;
				MyROFSTLookup.LoadChildren(ref ro);
				chld = ro.children;
			}

			// B2022-026 RO Memory Reduction code - check children length
			if (chld == null || chld.Length <= 0) // get a single ROID
			{
				ROFSTLookup.rochild ro = (ROFSTLookup.rochild)cmboTreeROs.SelectedNode.Tag;
				// B2022-107: Display Progress Bar Messages/Statuses when a new ROFST binary file is loaded into the database
				rtnstr += ROFSTLookup.FormatRoidKey(ro.roid, false);
			}
			else
			{ // spin through the child list and get the ROIDs.
			  // if the child has children, then call this function recursively 
				foreach (ROFSTLookup.rochild roc in chld)
				{
					// B2022-026 RO Memory Reduction code - check children length
					if (roc.children != null && roc.children.Length > 0)
						rtnstr += GetROsToSearch(roc.children);
					else
					{
						// B2022-118: If the ro has child nodes in tree view but they aren't loaded, load them
						ROFSTLookup.rochild rot = roc;
						MyROFSTLookup.LoadChildren(ref rot);
						chld = rot.children;

						if (rot.children != null && rot.children.Length > 0)
							rtnstr += GetROsToSearch(rot.children);
						else
							rtnstr += string.Format("{0},", ROFSTLookup.FormatRoidKey(roc.roid, false));
					}
				}
			}

			return rtnstr;
		}

		private void btnSearch_Click(object sender, EventArgs e)
		{
			_fromLoad = false;
			DateTime start = DateTime.Now;
			Cursor savcursor = Cursor;
			// keeps track of index into combo box for results style.  This combo box may have 3 or 4
			// items depending on whether annotations exist.
			int cmbResultsStyleIndex = -1;
			try
			{
				LastSearchWasAnnotations = false; // B2019-119 only refresh annotation search results if an annotation search was done
				ClearResults();
				Cursor = Cursors.WaitCursor;
				SearchResults = null;
				bool includeRTFformat = false;
				bool includeSpecialChars = (TextSearchString != @"\?"); // true;
																		// Build list of selected types that were searched
				string typstr = null;
				foreach (string s in lstCheckedStepTypesStr) typstr = typstr == null ? s : typstr + ", " + s;
				TypesSelected = "Filtered By:  " + ((typstr != null) ? typstr : "All Step Types");
				//TypesSelected = "Step Types Searched: " + ((typstr != null) ? typstr : "all step types");
				//TypesSelected = "Searched Step Types: " + ((typstr != null) ? typstr : "all step types");
				//TypesSelected = (typstr != null) ? "Searched Step Types: " + typstr : "Searched All Step Types";
				string unitPrefix = string.Empty;
				if (Mydocversion != null)
					unitPrefix = Mydocversion.DocVersionConfig.Unit_ProcedureNumber;
				if (unitPrefix.EndsWith("#"))
					unitPrefix = unitPrefix.Replace("#", string.Empty);

				if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[0]) // Text Search
				{
					if (cbxSrchTypeUsage.Checked) // find just the usage of the selected types
					{
						if (lstCheckedStepTypes.Count == 0)
						{
							FlexibleMessageBox.Show("Please select one or more types then press the Search button", "No Types Selected");
							xpStepTypes.Expanded = true;
							advTreeStepTypes.Focus();
							xpStepTypes.TitleStyle.BackColor1.Color = Color.Crimson;
						}
						else
						{
							//string typstr = null;
							//foreach (string s in lstCheckedStepTypesStr) typstr = typstr==null?s:typstr + ", " + s;
							//ReportTitle = "Search for Selected Types"; //"Proms - Search by Type: " + typstr;
							ReportTitle = "Step Element Report"; //"Proms - Search by Type: " + typstr;
							TypesSelected = "Filtered By:  " + typstr;
							SearchString = null;
								// B2022-031 - added a cbxProcSectSrch to filter out procedure and section titles from global search results.
							SearchResults = ItemInfoList.GetListFromTextSearch(DVISearchList, TypeSearchList, string.Empty, cbxBooleanTxtSrch.Checked ? 2 : cbxCaseSensitive.Checked ? 1 : 0, cbxProcSectSrch.Checked ? 1 : 0, ItemSearchIncludeLinks.Value, includeRTFformat, includeSpecialChars, unitPrefix, string.Empty, string.Empty);
							cmbResultsStyleIndex = 1;  //display step locations in results
						}
					}
					else
					{
						//if (textSearchString.Equals(string.Empty))
						//{
						//  MessageBox.Show("Please enter some search text, then click the Search button", "No Search Text");
						//  cbxTextSearchText.Focus();
						//}
						//else
						//{
						//ReportTitle = string.Format("Proms - {0} Search for '{1}'", cbxBooleanTxtSrch.Checked ? "Boolean" : "Text", TextSearchString);
						ReportTitle = string.Format("Search for '{0}'", TextSearchString);

						// C2020-009: Search - Allow search 'By Word'. 
						string byWordPrefix = string.Empty;
						string byWordSuffix = string.Empty;
						if (cbxByWord.Checked)
						{
							// Generate a prefix & suffix to be used in the sql query around the search string.
							// If the search string starts (prefix)/ends(suffix) with a number, then use an expression that 
							// does not allow the preceding/following text to have a number, '.', letter or other rtf 
							// commands.  If the search string starts/ends with a letter, then use an expression that does not
							// find the preceding/following text that is text, i.e. a letter.
							if (Regex.IsMatch(TextSearchString, @"^[\d\.]"))        // starts with a number or '.' decimal pt
							{
								byWordPrefix = @"[^0-9a-zA-Z.vbpi:\\-]";
							}
							else if (Regex.IsMatch(TextSearchString, @"^[a-zA-Z]")) // starts with a letter
							{
								byWordPrefix = @"[^a-zA-Z]";
							}
							if (Regex.IsMatch(TextSearchString, @"[\d\.]$"))        // ends with a number or decimal
							{
								byWordSuffix = @"[^0-9a-zA-Z.vbpi:\\-]";
							}
							else if (Regex.IsMatch(TextSearchString, @"[a-zA-Z]$")) // ends with a letter
							{
								byWordSuffix = @"[^a-zA-Z]";
							}
						}
						SearchString = TextSearchString;
						//TypesSelected = (typstr != null) ? "Searched Step Types: " + typstr : "Searched All Step Types";
						//TypesSelected = "Searched Step Types: " + ((typstr != null) ? typstr : "All Step Types");
							// B2022-031 - added a cbxProcSectSrch to filter out procedure and section titles from global search results.
						SearchResults = ItemInfoList.GetListFromTextSearch(DVISearchList, TypeSearchList, TextSearchString /*.Replace(@"\",@"\u9586?")*/, cbxBooleanTxtSrch.Checked ? 2 : cbxCaseSensitive.Checked ? 1 : 0, cbxProcSectSrch.Checked ? 1 : 0, cbxIncROTextSrch.Checked ? ItemSearchIncludeLinks.Value : ItemSearchIncludeLinks.Nothing, includeRTFformat, includeSpecialChars, unitPrefix, byWordPrefix, byWordSuffix);

						cmbResultsStyleIndex = 3;  // display step text in results
												   //}
					}
					// C2019-001: Search in RNO steps only
					if (cbxRnoOnly.Checked) GetInRNOResults();
				}
				else if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[1]) // Annotation Search
				{
					LastSearchWasAnnotations = true; // B2019-119 only refresh annotation search results if an annotation search was done
					SearchString = null;
					//ReportTitle = string.Format("Proms - Annotation Search for '{0}'", cbxTextSearchAnnotation.Text);
					if (cbxTextSearchAnnotation.Text == null || cbxTextSearchAnnotation.Text == string.Empty)
					{
						ReportTitle = string.Format("Find {0}{1}", cbxAnnoTypes.Text, (cbxAnnoTypes.SelectedIndex > 0) ? " Annotations" : string.Empty);
					}
					else
					{
						ReportTitle = string.Format("Search {0}{1} For '{2}'", cbxAnnoTypes.Text, (cbxAnnoTypes.SelectedIndex > 0) ? " Annotations" : string.Empty, cbxTextSearchAnnotation.Text);
					}
					//ReportTitle = string.Format("Search Annotations for '{0}'", cbxTextSearchAnnotation.Text);
					//string srchStr = ConvertSpecialChars(cbxTextSearchAnnotation.Text);//cbxTextSearchAnnotation.Text;
					//TypesSelected = "Searched Step Types: " + ((typstr != null) ? typstr : "All Step Types");

					//SearchResults = ItemInfoList.GetListFromAnnotationSearch(dviSearchList, typeSearchList, textSearchString, srchStr, cbxCaseSensitiveAnnoText.Checked);

					SearchResults = ItemInfoList.GetListFromAnnotationSearch(DVISearchList, TypeSearchList, AnnotationSearchType, cbxTextSearchAnnotation.Text, cbxCaseSensitiveAnnoText.Checked, unitPrefix);
					//UpdateAnnotationSearchResults();
					cmbResultsStyleIndex = 2;  // display annotation text in results
											   // C2019-001: Search in RNO steps only
					if (cbxRnoOnlyAnnot.Checked) GetInRNOResults();
				}
				else if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[2]) // RO Search
				{
					SearchString = null;
					//ReportTitle = "Proms - Referenced Object Search";
					ReportTitle = string.Format("Search For Referenced Object:\n{0}", cmboTreeROs.Text);
					//TypesSelected = "Searched Step Types: " + ((typstr != null) ? typstr : "All Step Types");

					if (cbxFndUnLnkROVals.Enabled && cbxFndUnLnkROVals.Checked)
					{
						// B2022-031 - added a cbxProcSectSrch to filter out procedure and section titles from global search results.
						SearchResults = ItemInfoList.GetListFromTextSearch(DVISearchList, TypeSearchList, ROSearchList, cbxBooleanTxtSrch.Checked ? 2 : cbxCaseSensitive.Checked ? 1 : 0, cbxProcSectSrch.Checked ? 1 : 0, ItemSearchIncludeLinks.Nothing, includeRTFformat, includeSpecialChars, unitPrefix, string.Empty, string.Empty);
						cmbResultsStyleIndex = 3;  // display step text in results
					}
					else
					{
						SearchResults = ItemInfoList.GetListFromROSearch(DVISearchList, TypeSearchList, ROSearchList, unitPrefix);
						cmbResultsStyleIndex = 3;  // display step text in results
					}
					// C2019-001: Search in RNO steps only
					if (cbxRnoOnlyRO.Checked) GetInRNOResults();
				}
				else if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[3])  //Transition Search
				{
					ReportTitle = string.Format("Search For Transitions: Transition Type: {0}, Transition Category: {1}", cbxTranFormat.SelectedItem, cbxTranCategory.SelectedItem);
					string docVersionList = string.Empty;
					if (lstCheckedDocVersions.Count == 0)
						docVersionList = cbxTranVersion.Tag.ToString();
					else
					{
						string sep = string.Empty;
						foreach (DocVersionInfo dvi in lstCheckedDocVersions)
						{
							docVersionList += sep + dvi.VersionID.ToString();
							sep = ",";
						}
					}
					// B2018-134 to search specifically for Outside Transitions, set docVeronList to empty string so that all procedure sets are considered
					if (cbxTranCategory.SelectedItem.ToString() == "Outside")
						docVersionList = string.Empty;
					// added TypeSearchList for bug fix B2015-055
					SearchResults = ItemInfoList.GetListFromTransitionSearch(docVersionList, cbxTranFormat.SelectedIndex - 1, cbxTranCategory.SelectedItem.ToString() == "All" ? string.Empty : cbxTranCategory.SelectedItem.ToString(), TypeSearchList);
					cmbResultsStyleIndex = 3;  // display step text in results
											   // C2019-001: Search in RNO steps only
					if (cbxRnoOnlyTrans.Checked) GetInRNOResults();
				}
				else if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[4])
				{
					// C2020-033: Incoming Transitions: Make an iteminfolist from the list returned from
					//	GetExternalTransitionsToChildren (also gets transitions to the item itself)
					// B2021-010: Use IncomingTranGetMergedTranList to get a complete list of incoming transitions (transitions to procedure
					//	were only included if there were NO transitions to items within procedure)
					ReportTitle = string.Format("Search For Incoming Transitions to {0}: ", SearchIncTransII.Path);
					SearchResults = IncomingTranGetMergedTranList();
					cmbResultsStyleIndex = 1;  //display step locations in results
					if (SearchResults == null || SearchResults.Count == 0)
					{
						FlexibleMessageBox.Show("No Matches Found.", "Search");
					}
				}
				if (SearchResults != null)
				{
					AddMessageForEmptyAnnotations();
					if (cmbResultsStyleIndex == 3 && cmbResultsStyle.Items.Count == 3) cmbResultsStyleIndex--;
					cmbResultsStyle.SelectedIndex = cmbResultsStyleIndex;
					DisplayResults();
					if (SearchResults != null && SearchResults.Count == 0)
					{
						FlexibleMessageBox.Show("No Matches Found.", "Search");
					}
				}
				btnTranCvtAllToTxt.Enabled = IncTransCvtAllToTextPerm();    // C2020-033: does user have access to at least one item
			}
			catch (Exception ex)
			{
				while (ex.InnerException != null)
					ex = ex.InnerException;
				string tmpmsg = (cbxBooleanTxtSrch.Checked && ex.Message.Contains("Syntax error") && ex.Message.Contains("full-text search")) ?
					"Place \"\" around words that you are searching for, so that parser can better understand what you are trying to find" :
					ex.Message;
				FlexibleMessageBox.Show(tmpmsg, "Search Error: " + ex.GetType().Name);
			}
			finally
			{
				Cursor = savcursor;
			}
			//Console.WriteLine("{0} Milliseconds", TimeSpan.FromTicks(DateTime.Now.Ticks - start.Ticks).TotalMilliseconds);
			OnSearchComplete(new DisplaySearchEventArgs(TimeSpan.FromTicks(DateTime.Now.Ticks - start.Ticks)));
			//if (VlnSettings.DebugMode)
			//    MessageBox.Show(string.Format("{0} Milliseconds", TimeSpan.FromTicks(DateTime.Now.Ticks - start.Ticks).TotalMilliseconds));
		}

		private void ClearResults()     // B2021-103 if no results when RNO only, clear results list.  (moved from btnSearch_Click)
		{
			if (tabSearchTypes.SelectedTab != tabSearchTypes.Tabs[4])
			{
				lbSrchResults.DataSource = null;
				lbSrchResults.Items.Clear();
				toolTip1.SetToolTip(lbSrchResults, null);
			}
			else        // C2020-033: Incoming Transiiotns
			{
				lbSrchResultsIncTrans.DataSource = null;
				lbSrchResultsIncTrans.Items.Clear();
				toolTip1.SetToolTip(lbSrchResultsIncTrans, null);
			}
		}

		// C2019-001: Search in RNO steps only
		private void GetInRNOResults()
		{
			bool first = true;
			ItemInfoList iil = null;

			foreach (ItemInfo ii in SearchResults)
			{
				if (ii.SearchPath.Contains(".RNO."))
				{
					if (first)
					{
						iil = new ItemInfoList(ii);
						first = false;
					}
					else
					{
						iil.AddItem(ii);
					}
				}
			}
			SearchResults = iil;
			// B2021-075 - put up none found message for RNO only
			if (SearchResults == null || SearchResults.Count == 0)
			{
				FlexibleMessageBox.Show("No Matches Found.", "Search");
				ClearResults();     // B2021-103 Clear results list if none found.
			}
		}

		private void AddMessageForEmptyAnnotations()
		{
			bool hasAnnot = false;

			foreach (ItemInfo ii in SearchResults)
			{
				if (ii.ItemAnnotations != null && ii.ItemAnnotationCount > 0)
				{
					// RHM - can an iteminfo have an itemannotationcount>0 and not have searchannotationtext.
					if (ii.SearchAnnotationText == null) ii.SearchAnnotationText = AnnotationInfo.Get(ii.ItemAnnotations[0].AnnotationID).SearchText;
				}

				if (ii.SearchAnnotationText == null) ii.SearchAnnotationText = "None - [" + ii.DisplayText + "]";
				else
				{
					hasAnnot = true;
				}
			}
			cmbResultsStyle.Items.Clear();
			cmbResultsStyle.Items.Add(comboItem1);
			cmbResultsStyle.Items.Add(comboItem2);
			if (hasAnnot) cmbResultsStyle.Items.Add(comboItem3);
			cmbResultsStyle.Items.Add(comboItem4);
		}

		private void cbxTextSearchText_Leave(object sender, EventArgs e)
		{
			InsertSearchCriteria();
		}

		private void InsertSearchCriteria()
		{
			if (!cbxTextSearchText.Text.Equals(string.Empty))
			{
				string tstr = cbxTextSearchText.Text;
				// if its already exists in the list - remove it
				if (cbxTextSearchText.Items.Contains(tstr))
					cbxTextSearchText.Items.Remove(tstr);
				// Add the new criteria to the top of the list
				cbxTextSearchText.Items.Insert(0, tstr);
				// set the text to the new criteria
				cbxTextSearchText.Text = tstr;
				// If there are more than 10 remove the last one
				if (cbxTextSearchText.Items.Count > 10)
					cbxTextSearchText.Items.RemoveAt(10);
			}
		}

		private void cbxSrchTypeUsage_CheckedChanged(object sender, EventArgs e)
		{
			gpSrchText.Enabled = !cbxSrchTypeUsage.Checked;
			if (!cbxSrchTypeUsage.Checked)
				xpStepTypes.TitleStyle.BackColor1.Color = saveXpStepTypeTitleColor;
			else
			{
				xpStepTypes.Expanded = true;
				if (lstCheckedStepTypes.Count == 0)
					xpStepTypes.TitleStyle.BackColor1.Color = Color.Crimson;
				advTreeStepTypes.Focus();

			}
		}

		private void rbtnSrchTxt_CheckedChanged(object sender, EventArgs e)
		{
			if (rbtnSrchTxt.Checked)
				cbxTextSearchText.Focus();
		}

		private void gpSrchText_EnabledChanged(object sender, EventArgs e)
		{
			if (gpSrchText.Enabled)
				gpSrchText.Style.BackColor = cbxBooleanTxtSrch.Checked ? Color.Orange : Color.Yellow;
			else
				gpSrchText.Style.BackColor = saveGpSrchTextColor;
		}

		private void tabStepTypeSearch_Click(object sender, EventArgs e)
		{
			if (rbtnSrchTxt.Checked)
			{
				cbxTextSearchText.Focus();
				cbxBooleanTxtSrch_CheckedChanged(sender, e);
			}
		}

		private void ProcessEnterKey(object sender, KeyPressEventArgs e)
		{
			if (e.KeyChar == '\r') // enter key pressed
			{
				e.Handled = true;
				btnSearch_Click(sender, e);
				if (sender == cbxTextSearchText)
					InsertSearchCriteria();
				else
					InsertAnnotationSearchCriteria();
			}
		}

		#endregion

		#region (ProcSetSelection)

		private void advTreeProcSets_AfterCheck(object sender, DevComponents.AdvTree.AdvTreeCellEventArgs e)
		{
			// this method gets called if child nodes get checked by the code, return if doing this process.
			if (checkingChildren)
				return;

			DevComponents.AdvTree.Node n = advTreeProcSets.SelectedNode;
			dicSelectedFolderNodes[n] = n.Checked;

			// if this tree node is checked, and there are children, check the children too.
			if (n.Checked)
			{
				checkingChildren = true;
				if (n.Nodes != null && n.Nodes.Count > 0 && n.Nodes[0].Text != DummyNodeText) CheckTreeNodeChildren(n.Nodes);
				checkingChildren = false;
			}
			else
            {
				//C2025-005 Find Step Elements
				//uncheck the parents if there are any
				DevComponents.AdvTree.Node tmp_n = n;
				while (tmp_n.Parent != null)
				{
					tmp_n = tmp_n.Parent;
					tmp_n.Checked = false;
				}
			}

			// if the selected folder has a docversion, handle it:
			if (n.Tag != SelectAllProcedureSetsText)
			{
				FolderInfo fi = (FolderInfo)n.Tag;
				RefreshLstCheckedDocVersions();
				RefreshStepTypes();// Refresh Step Types after Working Draft is checked.

				if (lstCheckedDocVersions.Count == 1 && fi.FolderDocVersions != null && fi.FolderDocVersions.Count > 0)
				{
					Mydocversion = fi.FolderDocVersions[0];
					StartAdvTreeStepTypesFillIn();// B2016-258 Hang after selecting a procedure if the Step Type panel is open on the search panel
				}
			}

			SetupContextMenu();
			buildSetToSearchPanelTitle();

			//C2025-005 Find Step Elements
			//Need to refresh the Doc List and Available Step Types
			//if All Procedure Sets was selected
			if (n.Tag == SelectAllProcedureSetsText)
			{
				if (n.Checked)
				{
					checkingChildren = true;
					foreach (Node node in advTreeProcSets.Nodes[0].Nodes)
					{
						node.Checked = true;
						CheckTreeNodeChildren(node.Nodes);
					}
					checkingChildren = false;
				}
				RefreshLstCheckedDocVersions();
				RefreshStepTypes();
			}

		}

		// check all folder nodes below this
		private void CheckTreeNodeChildren(NodeCollection nodeCollection)
		{
			foreach (Node tn in nodeCollection)
			{
				tn.Checked = tn.Parent.Checked;

				if (tn.Nodes != null && tn.Nodes.Count > 0 && tn.Nodes[0].Text != DummyNodeText)
					CheckTreeNodeChildren(tn.Nodes);
			}
		}

		// The 'lstCheckedDocVersions' maintains a list of the docversions that are associated with folders that are checked
		// on the search tree of folders, i.e. procedure sets that should be included in the search.
		private void RefreshLstCheckedDocVersions()
		{
			lstCheckedDocVersions.Clear();
			AddFromTreeNodes(advTreeProcSets.Nodes);        // add docversions to the list
			LoadROComboTree();                                                  // reset the ro tree based on docversion selections.
		}

		private void AddFromTreeNodes(NodeCollection nodeCollection)
		{
			foreach (Node tn in nodeCollection)
			{
				AddFromTreeNode(tn);
			}
		}

		private void AddFromTreeNode(Node tn)
		{
			if (tn.Checked)
			{
				//tn.Style = DevComponents.AdvTree.NodeStyles.Apple;      // sets green background on selected folder(s)
				//B2023-112:  Don't crash if on top 'All' node (did not have associated folder)
				FolderInfo fi = tn.Tag as FolderInfo;
				// if this folder has a docversion, use its id:
				if (tn.Nodes != null && tn.Nodes.Count > 0 && tn.Nodes[0].Text != DummyNodeText)        // Folder has been expanded, so add its docversion list
				{
					if (fi != null && fi.FolderDocVersionCount > 0) lstCheckedDocVersions.Add(fi.FolderDocVersions[0]);
				}
				else    // it has not been expanded process all below.
				{
					//B2023-076: Do not process the "Select All" node
					if (tn.Text != SelectAllProcedureSetsText && fi != null)
						AddAllChildVersions(fi);
				}
			}
			else  // not checked, set style so no background color
			{
				tn.Style = null;
			}

			if (tn.Nodes != null)
				AddFromTreeNodes(tn.Nodes);
		}

		private void RemoveAllVersions(FolderInfo child)
		{
			RemoveAllChildVersions(child);
			RefreshStepTypes(); // Refresh the Step Type TreeView
		}

		/// <summary>
		/// RessetStepTypes - Clear Step Type Treeview
		/// </summary>
		private void ResetStepTypes()
		{
			ResetStepTypes("....select a procedure set for types to appear...");
		}

		//C2025-005 Find Step Elements
		//improve messaging when multiple formats
		private void ResetStepTypes(params string[] strs)
		{
			advTreeStepTypes.Nodes.Clear();
			lstCheckedStepTypes.Clear();
			lstCheckedStepTypesStr.Clear();
			foreach (string str in strs)
			{
				Node newnode = new DevComponents.AdvTree.Node();
				newnode.Text = str;
				advTreeStepTypes.Nodes.Add(newnode);
			}
			buildStepTypePannelTitle();
		}

		private void AddAllVersions(FolderInfo child)
		{
			AddAllChildVersions(child);
			RefreshStepTypes();
		}

		/// <summary>
		/// RefreshStepTypes - Updates the StepType TreeView to allow step types to be specified.
		/// </summary>
		private void RefreshStepTypes()
		{
			if (lstCheckedDocVersions.Count == 0)
			{
				ResetStepTypes();
				return;
			}

			string formatName = lstCheckedDocVersions[0].ActiveFormat.Name;

			foreach (DocVersionInfo dvi in lstCheckedDocVersions)
			{
				if (formatName != dvi.ActiveFormat.Name)
				{
					//C2025-005 Find Step Elements
					//improve messaging when multiple formats
					string frmt1 = $"    Format is {formatName} before {dvi.MyFolder.Name}";
					string frmt2 = $"    which begins format: {dvi.ActiveFormat.Name}";
					ResetStepTypes("...folders selected include multiple formats.", frmt1, frmt2);
					return;
				}
			}

			_MyDocVersion = lstCheckedDocVersions[0];

			// B2016-258 Hang after selecting a procedure if the Step Type panel is open on the search panel
			StartAdvTreeStepTypesFillIn();
		}

		// remove all docversion children
		private void RemoveAllChildVersions(FolderInfo myFolderInfo)
		{
			if (myFolderInfo.FolderDocVersionCount > 0)
			{
				foreach (DocVersionInfo dvi in myFolderInfo.FolderDocVersions)
				{
					if (lstCheckedDocVersions.Contains(dvi))
						lstCheckedDocVersions.Remove(dvi);
				}
			}

			if (myFolderInfo.ChildFolders != null)
			{
				foreach (FolderInfo folderChild in myFolderInfo.ChildFolders)
				{
					RemoveAllChildVersions(folderChild);
				}
			}
		}

		// add all docversion children
		private void AddAllChildVersions(FolderInfo myFolderInfo)
		{
			if (myFolderInfo.FolderDocVersionCount > 0)
			{
				foreach (DocVersionInfo dvi in myFolderInfo.FolderDocVersions)
				{
					if (!lstCheckedDocVersions.Contains(dvi))
						lstCheckedDocVersions.Add(dvi);
				}
			}

			if (myFolderInfo.ChildFolders != null)
			{
				foreach (FolderInfo folderChild in myFolderInfo.ChildFolders)
				{
					AddAllChildVersions(folderChild);
				}
			}
		}

		private void cbxTranFormatFillIn(string vid)
		{
			vid = vid.IndexOf(",") < 0 ? vid : vid.Substring(0, cbxTranVersion.Tag.ToString().IndexOf(","));

			DocVersionInfo dvi = DocVersionInfo.Get(int.Parse(vid));
			TransTypeList ttl = dvi.ActiveFormat.PlantFormat.FormatData.TransData.TransTypeList;

			cbxTranFormat.Items.Clear();
			cbxTranFormat.Items.Add("All");

			for (int i = 0; i < ttl.MaxIndex; i++)
			{
				cbxTranFormat.Items.Add(new TransItem(ttl[i].TransMenu.Replace("?.", string.Empty), ttl[i].TransFormat.Replace("?.", string.Empty)));
			}

			cbxTranFormat.SelectedIndex = 0;
			cbxTranCategory.Items.Clear();
			cbxTranCategory.Items.Add("All");
			cbxTranCategory.Items.Add("Internal");
			cbxTranCategory.Items.Add("External");
			cbxTranCategory.Items.Add("Outside");
			cbxTranCategory.SelectedIndex = 0;
		}

		private void xpSetToSearch_ExpandedChanged(object sender, ExpandedChangeEventArgs e)
		{
			buildSetToSearchPanelTitle();
		}

		private void buildSetToSearchPanelTitle()
		{
			// B2023-112: lstCheckedDocVersions has list of sets, if 'all' it is empty.  However, in order to get proc set tree to handle appropriate selections
			//	and work with this list, check both the list count and the whether the 'all' is checked.
			if (lstCheckedDocVersions.Count == 0 && advTreeProcSets.Nodes != null && (advTreeProcSets.Nodes.Count <=1 || (advTreeProcSets.Nodes.Count > 1 && advTreeProcSets.Nodes[0].Nodes != null)) && (advTreeProcSets.Nodes[0].Nodes.Count == 0 || (advTreeProcSets.Nodes[0].Nodes.Count > 0 && !advTreeProcSets.Nodes[0].Nodes[0].Checked)))
			{
				xpSetToSearch.TitleText = string.Format("No Procedure Sets Selected");
				xpSetToSearch.TitleStyle.BackColor1.Color = Color.PapayaWhip;
				btnSearch.Enabled = false;
				tabSearchTypes.Enabled = false; // disable all the search tabs
			}
			else if (lstCheckedDocVersions.Count == 0)
			{
				xpSetToSearch.TitleText = string.Format("All Procedure Sets Selected");
				xpSetToSearch.TitleStyle.BackColor1.Color = Color.PapayaWhip;
				btnSearch.Enabled = true;
				tabSearchTypes.Enabled = true; // enable all the search tabs
			}
			else
			{
				// display the number of selected procedure sets whether panel is expanded or not
				xpSetToSearch.TitleText = string.Format("{0} Procedure Sets Selected", lstCheckedDocVersions.Count);
				xpSetToSearch.TitleStyle.BackColor1.Color = Color.PapayaWhip;
				btnSearch.Enabled = true;
				tabSearchTypes.Enabled = true; // enable all the search tabs
			}
		}

		private void advTreeProcSets_AfterNodeSelect(object sender, AdvTreeNodeEventArgs e)
		{
			DevComponents.AdvTree.Node n = advTreeProcSets.SelectedNode;

			if (advTreeStepTypes.Nodes.Count == 1 && n.Checked)
			{
				if (n.Tag is DocVersionInfo) // Only set MyDocVersion if it is a DocVersion
				{
					Mydocversion = (DocVersionInfo)n.Tag;
					StartAdvTreeStepTypesFillIn();// B2016-258 Hang after selecting a procedure if the Step Type panel is open on the search panel
				}
			}
			// B2023-112:  If unchecking a procedure set, uncheck the 'All' node also
			if (n.Checked)
				advTreeProcSets.Nodes[0].Nodes[0].Checked = false;
		}

		#endregion

		#region (StepTypeSelection)

		private void advTreeStepTypes_AfterCheck(object sender, DevComponents.AdvTree.AdvTreeCellEventArgs e)
		{
			xpStepTypes.TitleStyle.BackColor1.Color = saveXpStepTypeTitleColor;
			DevComponents.AdvTree.Node n = advTreeStepTypes.SelectedNode;

			if (n == null)
				return;

			StepData sd = (StepData)n.Tag;

			if (n.Checked)
			{
				//n.Style = DevComponents.AdvTree.NodeStyles.Apple;		// B2023-112: coloring of proc set tree nodes was not working correctly

				if (sd == null)
				{
					//C2023-010: Since the tag is null for Word Sections and HLS types, we need to determine which one has been selected.  Word sections we need
					//to process, but we need to ignore adding HLS types.
					if (n.Text == "WORD Sections")
					{
						if (!lstCheckedStepTypesStr.Contains("WORD Sections"))
						{
							lstCheckedStepTypes.Add(0); //use zero to identify attachment search
							lstCheckedStepTypesStr.Add("WORD Sections");
						}
					}
				}
				else
				{
					if (!lstCheckedStepTypesStr.Contains(advTreeStepTypes.SelectedNode.Text))
					{
						lstCheckedStepTypes.Add((int)sd.Index);
						lstCheckedStepTypesStr.Add(advTreeStepTypes.SelectedNode.Text);
					}
				}
			}
			else
			{
				n.Style = null;

				if (sd == null)
				{
					//C2023-010: Since the tag is null for Word Sections and HLS types, we need to determine which one has been selected.  Word sections we need
					//to process, but we need to ignore removing HLS types since they were not added in the previous process.
					if (n.Text == "WORD Sections")
					{
						lstCheckedStepTypesStr.Remove("WORD Sections");
						lstCheckedStepTypes.Remove(0);
					}
				}
				else
				{
					lstCheckedStepTypes.Remove((int)sd.Index);
					lstCheckedStepTypesStr.Remove(advTreeStepTypes.SelectedNode.Text);
				}

				//B2025-012 Find Step Elements
				//uncheck the parents if there are any
				DevComponents.AdvTree.Node tmp_n = n;
				while (tmp_n.Parent != null)
				{
					tmp_n = tmp_n.Parent;
					tmp_n.Checked = false;
				}
				//uncheck All Types
				advTreeStepTypes.Nodes[0].Checked = false;
			}

			//C2023-010: Check if the node has children and if we need to process those children as well
			if (n.HasChildNodes)
			{
				foreach (Node child in n.Nodes)
				{
					child.Checked = n.Checked;
					advTreeStepTypes.SelectedNode = child;
					advTreeStepTypes_AfterCheck(sender, null);
				}
			}
			else if (n.Text == "All Types")
			{
				//B2025-012 Find Step Elements
				//if checking / un-checking All Types
				//Add Types to type list appropriately
				if (n.Checked)
				{
					foreach (Node child in advTreeStepTypes.Nodes)
					{
						if (child.Text != "All Types")
                        {
							child.Checked = true;
							advTreeStepTypes.SelectedNode = child;
							advTreeStepTypes_AfterCheck(sender, null);
						}
					}
				}
				else
                {
					foreach (Node child in advTreeStepTypes.Nodes)
					{
						if (child.Text != "All Types")
						{
							child.Checked = false;
							advTreeStepTypes.SelectedNode = child;
							advTreeStepTypes_AfterCheck(sender, null);
						}
					}
				}

			}

			buildStepTypePannelTitle();

			// B2021-100: Enable/disable the RNO Only checkbox & WORD Sections tree node in Step Elements to Search.
			//	The only time the RNO Only checkbox is disabled is if the only selection in Step Elements to Search is WORD Sections.
			cbxRnoOnly.Enabled = true;

			if (OnlyWordSectTypeSel())
				cbxRnoOnly.Checked = cbxRnoOnly.Enabled = false;
		}

		private void xpStepTypes_ExpandedChanged(object sender, ExpandedChangeEventArgs e)
		{
			buildStepTypePannelTitle();
		}

		private void buildStepTypePannelTitle()
		{
			if (lstCheckedStepTypes.Count == 0)
			{
				if (xpStepTypes.Expanded)
				{
					xpStepTypes.TitleText = "Select Step Elements To Search"; //"Select Types To Search";
					advTreeStepTypes.Focus();
					advTreeStepTypes.Nodes[0].SelectedCell = advTreeStepTypes.Nodes[0].Cells[0];
				}
				else
				{
					xpStepTypes.TitleText = "Click Here To Search By Step Element"; //"Click Here To Search By Types";
				}

				xpStepTypes.TitleStyle.BackColor1.Color = saveXpStepTypeTitleColor;
			}
			else //lstCheckedStepTypes.Count > 0
			{
				// show how many selected whether panel is expanded or not
				xpStepTypes.TitleText = string.Format("{0} Step Element{1} Selected", lstCheckedStepTypes.Count, (lstCheckedStepTypes.Count > 1) ? "s" : string.Empty); // B2018-132 changed second {0} to {1}
				xpStepTypes.TitleStyle.BackColor1.Color = Color.PapayaWhip;
			}
		}

		#endregion

		#region (ContextMenu)

		private void btnSym_Click(object sender, EventArgs e)
		{
			DevComponents.DotNetBar.ButtonItem b = (DevComponents.DotNetBar.ButtonItem)sender;

			if (cbxTextSearchAnnotation.Focused)
			{
				cbxTextSearchAnnotation.SelectedText = (string)b.Text;
			}
			else if (cbxTextSearchText.Focused)
			{
				cbxTextSearchText.SelectedText = (string)b.Text;
			}
		}

		private void cmFndTxtInsHardSp_Click(object sender, EventArgs e)
		{
			// We use \u00A0 to represent a hard space because it show in the search text field as a blank
			// It will get translated to a real hard space character prior to searching
			if (cbxTextSearchAnnotation.Focused)
			{
				cbxTextSearchAnnotation.SelectedText = "\u00A0";
			}
			else if (cbxTextSearchText.Focused)
			{
				cbxTextSearchText.SelectedText = "\u00A0";
			}
		}

		private void cmFndTxtCut_Click(object sender, EventArgs e)
		{
			Clipboard.Clear();
			DataObject myDO = new DataObject(DataFormats.Text, cbxTextSearchAnnotation.Focused ? cbxTextSearchAnnotation.SelectedText : cbxTextSearchText.SelectedText);
			Clipboard.SetDataObject(myDO);

			// Need to check which combo box activated the context menu so that we know where to take/put selected text
			if (cbxTextSearchAnnotation.Focused)
			{
				cbxTextSearchAnnotation.SelectedText = string.Empty;
			}
			else if (cbxTextSearchText.Focused)
			{
				cbxTextSearchText.SelectedText = string.Empty;
			}
		}

		private void cmFndTxtCopy_Click(object sender, EventArgs e)
		{
			// Need to check which combo box activated the context menu so that we know where to take/put selected text
			DataObject myDO = new DataObject(DataFormats.Text, cbxTextSearchAnnotation.Focused ? cbxTextSearchAnnotation.SelectedText : cbxTextSearchText.SelectedText);

			if (cbxTextSearchText.Focused || cbxTextSearchAnnotation.Focused)
			{
				Clipboard.Clear();
				Clipboard.SetDataObject(myDO);
			}
		}

		private bool OnlyWordSectTypeSel()
		{
			// B2021-100: Enable/disable the RNO Only checkbox & WORD Sections tree node in Step Elements to Search.
			//	lstCheckedStepTypes[x] = 0 for Word sections:
			if (lstCheckedStepTypes != null && lstCheckedStepTypes.Count == 1 && lstCheckedStepTypes[0] == 0)
				return true;

			return false;
		}

		private void CbxRnoOnly_Click(object sender, System.EventArgs e)
		{
			// C2021-028: RNO Only search, disable Word section tree node: 
			// B2021 - 100: Enable / disable the RNO Only checkbox &WORD Sections tree node in Step Elements to Search.
			if (tabSearchTypes.SelectedTab == tabTranSearch) return;

			// B2021-122: null reference crash if clicking RNOOnly before anything else, i.e. tree set up with types.
			if (wordSectionTreeNode == null) return;

			wordSectionTreeNode.Enabled = true;
			if (!cbxRnoOnly.Checked)    // checked turning on
			{
				// Set enabling on WORD Sections tree node in Step Elements to Search. If either no items are selected in tree or
				//	just WORD Section is selected, then disable the WORD Section tree node.  Otherwise, i.e. other step types are selected
				//	in tree, thus they must be searched using RNO Only so need to disable anything.
				wordSectionTreeNode.Enabled = !(OnlyWordSectTypeSel() || (lstCheckedStepTypes != null && lstCheckedStepTypes.Count == 0));
				if (!wordSectionTreeNode.Enabled) wordSectionTreeNode.Checked = false;
			}
			else  // turning off - WORD Sections tree node is enabled.
			{
				wordSectionTreeNode.Enabled = true;
			}
		}

		private void cmFndTxtPaste_Click(object sender, EventArgs e)
		{
			// Need to check which combo box activated the context menu so that we know where to take/put selected text
			IDataObject myDO = Clipboard.GetDataObject();

			if (myDO.GetDataPresent(DataFormats.Text))
			{
				if (cbxTextSearchAnnotation.Focused)
				{
					cbxTextSearchAnnotation.SelectedText = Clipboard.GetText();
				}
				else if (cbxTextSearchText.Focused)
				{
					cbxTextSearchText.SelectedText = Clipboard.GetText();
				}
			}
		}

		private void btnCMIFindText_PopupOpen(object sender, PopupOpenEventArgs e)
		{
			// the context menu is available with just a mouse hover, even if the combo box does not have focus
			// ... set the focus to which ever combo box initiated the context menu
			if (tabAnnotationSearch.IsSelected)
			{
				if (!cbxTextSearchAnnotation.Focused)
					cbxTextSearchAnnotation.Focus();
			}
			else if (tabStepTypeSearch.IsSelected)
			{
				if (!cbxTextSearchText.Focused)
					cbxTextSearchText.Focus();
			}
		}

		#endregion

		#region (Button/UI Event Handlers)

		private void buttonItem2_Click(object sender, EventArgs e)
		{
			if (cbxTextSearchAnnotation.Focused)
				cbxTextSearchAnnotation.SelectedText = "*";
			else if (cbxTextSearchText.Focused)
				cbxTextSearchText.SelectedText = "*";
		}

		private void buttonItem3_Click(object sender, EventArgs e)
		{
			if (cbxTextSearchAnnotation.Focused)
				cbxTextSearchAnnotation.SelectedText = "?";
			else if (cbxTextSearchText.Focused)
				cbxTextSearchText.SelectedText = "?";

		}

		private void buttonItem4_Click(object sender, EventArgs e)
		{
			if (cbxTextSearchAnnotation.Focused)
				cbxTextSearchAnnotation.SelectedText = "?*";
			else if (cbxTextSearchText.Focused)
				cbxTextSearchText.SelectedText = "?*";
		}

		private void cbxBooleanTxtSrch_CheckedChanged(object sender, EventArgs e)
		{
			// If the Boolean search is not working - run the following two commands in SQL:
			//  use veproms
			//  ALTER FULLTEXT INDEX ON Contents START FULL POPULATION
			//  ALTER FULLTEXT INDEX ON Documents START FULL POPULATION
			//  use master
			//Boolean search uses a list of noise, or STOP, words. This list can be found
			// in file: C:\Program Files\Microsoft SQL Server\MSSQL.1\MSSQL\FTData\noiseenu.txt.
			// Another file exists in that directory, tsenu.xml, this is a thesaurus. RHM tried
			// to use around 2010, but couldn't get it to work for words like 'dg' versus 'diesel generator',
			// and 'sg' versus 'steam generator'.

			if (cbxBooleanTxtSrch.Checked)
			{
				gpSrchText.Style.BackColor = Color.Orange;
				btnCMIFindText.SubItems[1].SubItems[2].Visible = false;
				btnCMIFindText.SubItems[1].SubItems[3].Visible = true;
				cbxCaseSensitive.Enabled = false;
				cbxIncROTextSrch.Enabled = false;
			}
			else
			{
				gpSrchText.Style.BackColor = Color.Yellow;
				btnCMIFindText.SubItems[1].SubItems[2].Visible = true;
				btnCMIFindText.SubItems[1].SubItems[3].Visible = false;
				cbxCaseSensitive.Enabled = true;
				cbxIncROTextSrch.Enabled = true;
			}
		}

		private void cbxBooleanAnoTxtSrch_CheckedChanged(object sender, EventArgs e)
		{
			if (cbxBooleanAnoTxtSrch.Checked)
			{
				gpSrchAnnoText.Style.BackColor = Color.Orange;
				btnCMIFindText.SubItems[1].SubItems[2].Visible = false;
				btnCMIFindText.SubItems[1].SubItems[3].Visible = true;
			}
			else
			{
				gpSrchAnnoText.Style.BackColor = Color.Yellow;
				btnCMIFindText.SubItems[1].SubItems[2].Visible = true;
				btnCMIFindText.SubItems[1].SubItems[3].Visible = false;
			}
		}

		private void btnAND_Click(object sender, EventArgs e)
		{
			if (cbxTextSearchAnnotation.Focused)
				cbxTextSearchAnnotation.SelectedText = " AND ";
			else if (cbxTextSearchText.Focused)
				cbxTextSearchText.SelectedText = " AND ";
		}

		private void btnOR_Click(object sender, EventArgs e)
		{
			if (cbxTextSearchAnnotation.Focused)
				cbxTextSearchAnnotation.SelectedText = " OR ";
			else if (cbxTextSearchText.Focused)
				cbxTextSearchText.SelectedText = " OR ";
		}

		private void btnNOT_Click(object sender, EventArgs e)
		{
			if (cbxTextSearchAnnotation.Focused)
				cbxTextSearchAnnotation.SelectedText = " NOT ";
			else if (cbxTextSearchText.Focused)
				cbxTextSearchText.SelectedText = " NOT ";
		}

		private void tabAnnotationSearch_Click(object sender, EventArgs e)
		{
			cbxAnnoTypes.Focus();
			cbxBooleanAnoTxtSrch_CheckedChanged(sender, e);
		}

		private void btnClearSearchResults_Click(object sender, EventArgs e)
		{
			if (tabSearchTypes.SelectedTab == tabIncTrans)  // C2020-033: Clear the Incoming Transitions list box
			{
				lbSrchResultsIncTrans.DataSource = null;
				lbSrchResultsIncTrans.Items.Clear();
			}
			else
			{
				lbSrchResults.DataSource = null;
			}

			_SearchResults = null;
			DisplayResults();
			btnTranCvtAllToTxt.Enabled = false;
		}

		private void btnLoadSearchResults_Click(object sender, System.EventArgs e)
		{
			_fromLoad = true;
			_LoadingList = true;
			ofdSearchResults.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + @"\VEPROMS";

			if (ofdSearchResults.ShowDialog(this) == DialogResult.OK)
			{
				lbSrchResults.DataSource = null;
				lbSrchResults.Items.Clear();
				toolTip1.SetToolTip(lbSrchResults, null);
				string unitPrefix = string.Empty;
				if (Mydocversion != null)
					unitPrefix = Mydocversion.DocVersionConfig.Unit_ProcedureNumber;
				if (unitPrefix.EndsWith("#"))
					unitPrefix = unitPrefix.Replace("#", string.Empty);
				Cursor = Cursors.WaitCursor;

				try   // B2021-045: don't crash if xml file cannot be loaded.
				{
					SearchResults = ItemInfoList.GetByContentID(0);
					// C2021-006: removed all file type options except xml
					System.Xml.XmlDocument xd = new System.Xml.XmlDocument();
					xd.Load(ofdSearchResults.FileName);
					// B2020-107: Add missing attributes/nodes for loading of search results, include procsets & steptypes:
					System.Xml.XmlNodeList nlp = xd.SelectNodes("search/procsets/set");
					if (nlp != null)
					{
						DocVersionInfo tmpdvi = Mydocversion;
						DocVersionInfo fromLoadFiledvi = null;
						foreach (System.Xml.XmlNode nd in nlp)
						{
							int folderID = int.Parse(nd.Attributes.GetNamedItem("fid").InnerText);
							FolderInfo fi = FolderInfo.Get(folderID);
							_MyDocVersion = fi.FolderDocVersions[0];
							if (fromLoadFiledvi == null) fromLoadFiledvi = _MyDocVersion;
							advTreeProcSetsPreSelect();
						}
						foreach (System.Xml.XmlNode nd in nlp)
						{
							int folderID = int.Parse(nd.Attributes.GetNamedItem("fid").InnerText);
							FolderInfo fi = FolderInfo.Get(folderID);
							Node tnode = advTreeProcSets.FindNodeByDataKey(folderID);
							if (tnode != null) tnode.Checked = true;
						}
						Mydocversion = tmpdvi == null ? fromLoadFiledvi : tmpdvi;
					}

					AdvTreeStepTypesFillIn();
					System.Xml.XmlNodeList nl1 = xd.SelectNodes("search/StepType/type");

					if (nl1 != null)
					{
						foreach (System.Xml.XmlNode nd in nl1)
						{
							string stptype = nd.Attributes.GetNamedItem("str").InnerText;
							Node tnode = advTreeStepTypes.FindNodeByText(stptype);
							if (tnode != null)
							{
								tnode.Checked = true;
								xpStepTypes.TitleStyle.BackColor1.Color = saveXpStepTypeTitleColor;
								lstCheckedStepTypesStr.Add(stptype);
								StepData sd = (StepData)tnode.Tag;
								lstCheckedStepTypes.Add((int)sd.Index);
							}
						}

						string typstr = null;
						foreach (string s in lstCheckedStepTypesStr) typstr = typstr == null ? s : typstr + ", " + s;
						TypesSelected = "Filtered By:  " + ((typstr != null) ? typstr : "All Step Types");
						ReportTitle = "Step Element Report"; //"Proms - Search by Type: " + typstr;
						TypesSelected = "Filtered By:  " + typstr;
						advTreeStepTypes.RefreshItems();
						buildStepTypePannelTitle();
					}

					cmbResultsStyle.Text = xd.SelectSingleNode("search/results/@style").InnerText;
					int sti = int.Parse(xd.SelectSingleNode("search/criteria/@index").InnerText);
					switch (sti)
					{
						case 0: //text or steptypes
							{
								System.Xml.XmlNode xn = xd.SelectSingleNode("search/criteria/@text");
								tabSearchTypes.SelectedTab = tabStepTypeSearch;

								if (xn != null) // text search
								{
									cbxTextSearchText.Text = xn.InnerText;
									cbxCaseSensitive.Checked = bool.Parse(xd.SelectSingleNode("search/criteria/@case").InnerText);
									cbxIncROTextSrch.Checked = bool.Parse(xd.SelectSingleNode("search/criteria/@ro").InnerText);
									cbxByWord.Checked = bool.Parse(xd.SelectSingleNode("search/criteria/@byword").InnerText);
								}
								else   // B2020-107: Add in step type search
								{
									cbxSrchTypeUsage.Checked = true;
								}

								System.Xml.XmlNodeList nl = xd.SelectNodes("search/results/item");
								foreach (System.Xml.XmlNode nd in nl)
								{
									int itemID = int.Parse(nd.Attributes.GetNamedItem("id").InnerText);
									ItemInfo ii = ItemInfo.Get(itemID);
									if (ii.SearchAnnotationText == null && ii.ItemAnnotations != null) ii.SearchAnnotationText = AnnotationInfo.Get(ii.ItemAnnotations[0].AnnotationID).SearchText;
									SearchResults.AddItemInfo(ii);
								}
								lbSrchResults.DataSource = SearchResults;
								DisplayResults();
								break;
							}

						case 1: //annotation
							{
								cbxAnnoTypes.Text = xd.SelectSingleNode("search/criteria/@type").InnerText;
								cbxTextSearchAnnotation.Text = xd.SelectSingleNode("search/criteria/@text").InnerText;
								cbxCaseSensitiveAnnoText.Checked = bool.Parse(xd.SelectSingleNode("search/criteria/@case").InnerText);
								tabSearchTypes.SelectedTab = tabAnnotationSearch;
								cmbResultsStyle.Text = xd.SelectSingleNode("search/results/@style").InnerText;
								System.Xml.XmlNodeList nl = xd.SelectNodes("search/results/item");

								foreach (System.Xml.XmlNode nd in nl)
								{
									int itemID = int.Parse(nd.Attributes.GetNamedItem("id").InnerText);
									ItemInfo ii = ItemInfo.Get(itemID);
									// B2020-107: The following was needed to set the Step Path result type for annotations
									if (ii.SearchAnnotationText == null && ii.ItemAnnotations != null)
									{
										ii.SearchAnnotationText = AnnotationInfo.Get(ii.ItemAnnotations[0].AnnotationID).SearchText;
										ii.SearchAnnotationID = ii.ItemAnnotations[0].AnnotationID;
									}
									SearchResults.AddItemInfo(ii);
								}

								lbSrchResults.DataSource = SearchResults;
								DisplayResults();
								break;
							}

						case 2: //referenced object
						case 3: // transitions
							{
								FlexibleMessageBox.Show(this, "Loading Referenced Objects and Transitions searches is under construction.", "Under Construction", MessageBoxButtons.OK);
								break;
							}

						case 4: // Incoming transitions
							{
								tabSearchTypes.SelectedTab = tabIncTrans;
								cmbResultsStyle.Text = xd.SelectSingleNode("search/results/@style").InnerText;
								string tmpi = xd.SelectSingleNode("search/results/@toid").InnerText;
								SearchIncTransII = ItemInfo.Get(Convert.ToInt32(tmpi));
								System.Xml.XmlNodeList nl = xd.SelectNodes("search/results/item");
								foreach (System.Xml.XmlNode nd in nl)
								{
									int itemID = int.Parse(nd.Attributes.GetNamedItem("id").InnerText);
									ItemInfo ii = ItemInfo.Get(itemID);
									if (ii.SearchAnnotationText == null && ii.ItemAnnotations != null) ii.SearchAnnotationText = AnnotationInfo.Get(ii.ItemAnnotations[0].AnnotationID).SearchText;
									SearchResults.AddItemInfo(ii);
								}
								lbSrchResultsIncTrans.DataSource = SearchResults;
								DisplayResults();
								break;
							}
					}
				}
				catch (Exception ex)
				{
					FlexibleMessageBox.Show("An error occurred while reading the xml file.\r\n\r\nThis can happen when the file selected for the Load is not saved\r\n" +
						"from a PROMS Search or if some of the steps no longer exist.", "Search Load Failed", MessageBoxButtons.OK);
				}

				Cursor = Cursors.Default;
			}

			btnTranCvtAllToTxt.Enabled = IncTransCvtAllToTextPerm();  // C2020-033: does user have access to at least one item
			_LoadingList = false;
		}

		private void btnSaveSearchResults_Click(object sender, System.EventArgs e)
		{
			ICollection<ItemInfo> myList = lbSrchResults.DataSource as ICollection<ItemInfo>;

			if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[4])
			{
				myList = lbSrchResultsIncTrans.DataSource as ICollection<ItemInfo>;   // C2020-033: use Incoming transition list
			}

			if (tabSearchTypes.SelectedTabIndex == 2 || tabSearchTypes.SelectedTabIndex == 3)   // ROs & Transitions are not coded yet
			{
				FlexibleMessageBox.Show(this, "Saving Referenced Objects and Transitions searches is under construction.", "Under Construction", MessageBoxButtons.OK);
				return;
			}

			sfdSearchResults.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + @"\VEPROMS";

			if (sfdSearchResults.ShowDialog(this) == DialogResult.OK)
			{
				// C2021-006: removed all file type options except xml
				System.Xml.XmlDocument xd = new System.Xml.XmlDocument();
				System.Xml.XmlElement xe = xd.CreateElement("search");
				xd.AppendChild(xe);
				xe = xd.CreateElement("criteria");
				xd.DocumentElement.AppendChild(xe);
				System.Xml.XmlAttribute xa = xd.CreateAttribute("index");
				int sti = tabSearchTypes.SelectedTabIndex;
				xa.InnerText = sti.ToString();
				xe.Attributes.SetNamedItem(xa);
				// B2020-107: save procedures sets & step types
				// do procsets selected
				System.Xml.XmlElement xp = null;
				System.Xml.XmlElement xst = null;

				if (sti != 4)  // C2020-033: no procsets or step types for Incoming transitions
				{
					if (lstCheckedDocVersions != null && lstCheckedDocVersions.Count > 0)
					{
						xp = xd.CreateElement("procsets");

						foreach (DocVersionInfo dvi in lstCheckedDocVersions)
						{
							System.Xml.XmlElement xee = xd.CreateElement("set");
							xa = xd.CreateAttribute("fid");
							xa.InnerText = dvi.MyFolder.FolderID.ToString();
							xee.Attributes.SetNamedItem(xa);
							xp.AppendChild(xee);
						}
					}

					if (lstCheckedStepTypesStr != null && lstCheckedStepTypesStr.Count > 0)
					{
						xst = xd.CreateElement("StepType");

						foreach (string str in lstCheckedStepTypesStr)      // Limited by step types
						{
							System.Xml.XmlElement xee = xd.CreateElement("type");
							xa = xd.CreateAttribute("str");
							xa.InnerText = str;
							xee.Attributes.SetNamedItem(xa);
							xst.AppendChild(xee);
						}
					}
				}

				switch (sti)
				{
					case 0: //text
						if (!cbxSrchTypeUsage.Checked)  // text search
						{
							xa = xd.CreateAttribute("text");
							xa.InnerText = cbxTextSearchText.Text;
							xe.Attributes.SetNamedItem(xa);
							xa = xd.CreateAttribute("case");
							xa.InnerText = cbxCaseSensitive.Checked.ToString();
							xe.Attributes.SetNamedItem(xa);
							xa = xd.CreateAttribute("ro");
							xa.InnerText = cbxIncROTextSrch.Checked.ToString();
							xe.Attributes.SetNamedItem(xa);
							xa = xd.CreateAttribute("byword");
							xa.InnerText = cbxByWord.Checked.ToString();
							xe.Attributes.SetNamedItem(xa);
							xd.DocumentElement.AppendChild(xe);
						}

						if (xp != null) xd.DocumentElement.AppendChild(xp);     // want criteria as first xml node
						if (xst != null) xd.DocumentElement.AppendChild(xst);   //   do procsets & steptypes after
																				// do results
						xe = xd.CreateElement("results");
						xa = xd.CreateAttribute("style");
						xa.InnerText = cmbResultsStyle.Text;
						xe.Attributes.SetNamedItem(xa);

						foreach (ItemInfo ii in myList)
						{
							System.Xml.XmlElement xee = xd.CreateElement("item");
							xa = xd.CreateAttribute("id");
							xa.InnerText = ii.ItemID.ToString();
							xee.Attributes.SetNamedItem(xa);
							xe.AppendChild(xee);
						}

						xd.DocumentElement.AppendChild(xe);
						xd.Save(sfdSearchResults.FileName);
						break;

					case 1: //annotation
						xa = xd.CreateAttribute("type");
						xa.InnerText = cbxAnnoTypes.Text;
						xe.Attributes.SetNamedItem(xa);
						xa = xd.CreateAttribute("text");
						xa.InnerText = cbxTextSearchAnnotation.Text;
						xe.Attributes.SetNamedItem(xa);
						xa = xd.CreateAttribute("case");
						xa.InnerText = cbxCaseSensitiveAnnoText.Checked.ToString();
						xe.Attributes.SetNamedItem(xa);
						xd.DocumentElement.AppendChild(xe);
						if (xp != null) xd.DocumentElement.AppendChild(xp);     // want criteria as first xml node
						if (xst != null) xd.DocumentElement.AppendChild(xst);   //   do procsets & steptypes after
						xe = xd.CreateElement("results");
						xa = xd.CreateAttribute("style");
						xa.InnerText = cmbResultsStyle.Text;
						xe.Attributes.SetNamedItem(xa);

						foreach (ItemInfo ii in myList)
						{
							System.Xml.XmlElement xee = xd.CreateElement("item");
							xa = xd.CreateAttribute("id");
							xa.InnerText = ii.ItemID.ToString();
							xee.Attributes.SetNamedItem(xa);
							xe.AppendChild(xee);
						}

						xd.DocumentElement.AppendChild(xe);
						xd.Save(sfdSearchResults.FileName);
						break;

					case 2: // ro
					case 3: // transitions
						FlexibleMessageBox.Show(this, "Saving Search Results for this search type is under construction.", "Under Construction", MessageBoxButtons.OK);
						break;

					case 4: // C2020-033: Incoming Transitions
						xe = xd.CreateElement("results");
						xa = xd.CreateAttribute("style");
						xa.InnerText = cmbResultsStyle.Text;
						xe.Attributes.SetNamedItem(xa);
						xa = xd.CreateAttribute("toid");
						xa.InnerText = SearchIncTransII.ItemID.ToString();
						xe.Attributes.SetNamedItem(xa);

						foreach (ItemInfo ii in myList)
						{
							System.Xml.XmlElement xee = xd.CreateElement("item");
							xa = xd.CreateAttribute("id");
							xa.InnerText = ii.ItemID.ToString();
							xee.Attributes.SetNamedItem(xa);
							xe.AppendChild(xee);
						}

						xd.DocumentElement.AppendChild(xe);
						xd.Save(sfdSearchResults.FileName);
						break;
				}
			}
		}

		private void btnCopySearchResults_Click(object sender, EventArgs e)
		{
			ICollection<ItemInfo> myList = lbSrchResults.DataSource as ICollection<ItemInfo>;
			if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[4]) myList = lbSrchResultsIncTrans.DataSource as ICollection<ItemInfo>;
			StringBuilder sb = new StringBuilder();
			sb.Append("\"Location\"\t\"Type\"\t\"Text\"\t\"High-Level\"\t\"Annotations\"");
			List<int> ItemsProcessed = new List<int>();

			foreach (ItemInfo myItem in myList)
			{
				if (!ItemsProcessed.Contains(myItem.ItemID))
				{
					ItemsProcessed.Add(myItem.ItemID);
					sb.Append(string.Format("\r\n\"{0}\"\t\"{1}\"\t\"{2}\"\t\"{3}\"", myItem.ShortPath, myItem.ToolTip,
						myItem.DisplayText, !myItem.IsSection && !myItem.IsHigh ? (myItem.MyHLS == null ? string.Empty : myItem.MyHLS.DisplayText) : string.Empty));
					if (myItem.ItemAnnotationCount > 0)
						foreach (AnnotationInfo myAnnotation in myItem.ItemAnnotations)
							sb.Append(string.Format("\t\"{0}\"", myAnnotation.SearchText));
				}
			}

			Clipboard.Clear();
			Clipboard.SetText(sb.ToString());
			FlexibleMessageBox.Show("Results Copied to Clipboard", "Copy Results", MessageBoxButtons.OK, MessageBoxIcon.Information);
		}

		private void btnPrnSrchRslts_Click(object sender, EventArgs e)
		{
			string sortedBy = string.Empty;
			if (cbSorted.Checked)
				sortedBy = string.Format("Sorted By: {0}", cmbResultsStyle.Text); //C2019-013 pass in sorted by information
			ICollection<ItemInfo> srchres = lbSrchResults.DataSource as ICollection<ItemInfo>;
			// C2020-033: If on the Incoming Transitions tab, use that list.
			if (tabSearchTypes.SelectedTab == tabSearchTypes.Tabs[4]) srchres = lbSrchResultsIncTrans.DataSource as ICollection<ItemInfo>;
			OnPrintRequest(new DisplaySearchEventArgs(ReportTitle, TypesSelected, SearchString, srchres, sortedBy));
		}

		private void panSearchButtons_Resize(object sender, EventArgs e)
		{
			cmbResultsStyle.Left = labelX1.Right + 3;
			cmbResultsStyle.Width = btnClearSearchResults.Left - cmbResultsStyle.Left - 3;
		}

		// C2020-033: Convert All (that have permissions) Incoming Transitions to text
		private void btnTranCvtAllToTxt_Click(object sender, EventArgs e)
		{
			Cursor = Cursors.WaitCursor;
			List<int> itmsEditable = TranCvtCheckPermission(true);      // Get list based on permissions
			if (itmsEditable == null || itmsEditable.Count == 0)
			{
				Cursor = Cursors.Default;
				return;
			}
			TranCvtToTxt(itmsEditable);
			Cursor = Cursors.Default;
			fromTranCvtBtn = true;
			UpdateSearchIncTransResults();  // B2021-009: Research after convert transitions to text
			fromTranCvtBtn = false;
		}

		// C22020-033: Use IncTransCvtAllToTextPerm to see if user has at least edit permissions to 1 in list.  This
		//	is used to see if Convert All button is enabled.
		private bool IncTransCvtAllToTextPerm()
		{
			if (_SearchResults == null) return false;
			int cnt = 0;
			bool allowNonAdmin = IncTranCvtPerm();
			foreach (ItemInfo ii in _SearchResults)
			{
				if (allowNonAdmin || UserInfo.CanEdit(MyUserInfo, ii.MyDocVersion)) return true;
			}
			return false;
		}

		#endregion

		#endregion
	}

	#region AnnotationTypeSearch Class

	// this class is used to generate the list of annotations to search.
	// this also allow us to add a dummy type which is used to search for all annotations
	public class AnnotationTypeSearch
	{
		private string _Name;
		public string Name
		{
			get { return _Name; }
			set { _Name = value; }
		}
		private string _ID;
		public string ID
		{
			get { return _ID; }
			set { _ID = value; }
		}
		public AnnotationTypeSearch(string name, string id)
		{
			_Name = name;
			_ID = id;
		}

	}

	#endregion

	#region DisplaySearchEventArgs Class

	public class DisplaySearchEventArgs
	{
		private string _ReportTitle;
		public string ReportTitle
		{
			get { return _ReportTitle; }
			set { _ReportTitle = value; }
		}

		private string _SearchString = null;
		public string SearchString
		{
			get { return _SearchString; }
			set { _SearchString = value; }
		}

		private string _TypesSelected;
		public string TypesSelected
		{
			get { return _TypesSelected; }
			set { _TypesSelected = value; }
		}

		private string _SortedBy = null;
		public string SortedBy // C2019-013 pass in sorted by information to print report 
		{
			get { return _SortedBy; }
			set { _SortedBy = value; }
		}

		private ICollection<ItemInfo> _MyItemInfoList;
		public ICollection<ItemInfo> MyItemInfoList
		{
			get { return _MyItemInfoList; }
			set { _MyItemInfoList = value; }
		}

		private TimeSpan _HowLong = TimeSpan.FromTicks(0);
		public TimeSpan HowLong
		{
			get { return _HowLong; }
			set { _HowLong = value; }
		}

		private string _PaperSize;
		public string PaperSize // C2020-002 paper size is now set in the format files
		{
			get { return _PaperSize; }
			set { _PaperSize = value; }
		}

		public DisplaySearchEventArgs(TimeSpan howLong)
		{
			HowLong = howLong;
		}

		public DisplaySearchEventArgs(string reportTitle, string typesSelected, string searchString, ICollection<ItemInfo> myItemInfoList, string sortedBy)
		{
			_ReportTitle = reportTitle;
			_TypesSelected = typesSelected;
			_MyItemInfoList = myItemInfoList;
			_SearchString = searchString;
			_SortedBy = sortedBy; // C2019-013 pass in sorted by information

			foreach (ItemInfo tmpII in myItemInfoList)
				if (tmpII != null && tmpII.ActiveFormat != null)
				{
					_PaperSize = tmpII.ActiveFormat.PlantFormat.FormatData.PDFPageSize.PaperSize; // C2020-002 paper size is now set in the format files
					break;
				}
		}
	}

	#endregion

	public delegate void DisplaySearchEvent(object sender, DisplaySearchEventArgs args);
}