mschill
057915baaa
When searching for step elements (the Find Selected Step Elements option is selected) and multiple procedure sets are selected, but the procedure sets use different formats, PROMS puts a message in the Results area that says "folders selected contain multiple formats". Need to expand this messaging to provide more clear information regarding which formats are causing the issue, so that they can more easily decide which sets to de-select rather than doing so randomly. There is also a refresh issue where deselecting everything, it will not always refresh properly.
3550 lines
124 KiB
C#
3550 lines
124 KiB
C#
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 <20> change <20>AER<45> to <20>Left<66> 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)
|
||
{
|
||
// 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 (tabSearchTypes.SelectedTab != tabSearchTypes.Tabs[4]) lbSrchResults.DataSource = sortedResults;
|
||
else lbSrchResultsIncTrans.DataSource = sortedResults;
|
||
}
|
||
|
||
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;
|
||
SearchResults = ItemInfoList.GetListFromTextSearch(DVISearchList, TypeSearchList, string.Empty, cbxBooleanTxtSrch.Checked ? 2 : cbxCaseSensitive.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");
|
||
SearchResults = ItemInfoList.GetListFromTextSearch(DVISearchList, TypeSearchList, TextSearchString /*.Replace(@"\",@"\u9586?")*/, cbxBooleanTxtSrch.Checked ? 2 : cbxCaseSensitive.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)
|
||
{
|
||
SearchResults = ItemInfoList.GetListFromTextSearch(DVISearchList, TypeSearchList, ROSearchList, cbxBooleanTxtSrch.Checked ? 2 : cbxCaseSensitive.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);
|
||
}
|
||
}
|
||
|
||
//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);
|
||
}
|
||
}
|
||
|
||
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);
|
||
}
|