5640 lines
193 KiB
C#
5640 lines
193 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Drawing;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.IO;
|
|
using System.Configuration;
|
|
using System.Reflection;
|
|
using VEPROMS.CSLA.Library;
|
|
//using Csla;
|
|
using DevComponents;
|
|
using DevComponents.DotNetBar;
|
|
using DevComponents.DotNetBar.Rendering;
|
|
using VEPROMS.Properties;
|
|
using Volian.Controls.Library;
|
|
using DescriptiveEnum;
|
|
using Volian.Base.Library;
|
|
using Volian.Print.Library;
|
|
using JR.Utils.GUI.Forms;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using System.Collections.Concurrent;
|
|
using System.Threading.Tasks;
|
|
|
|
[assembly: log4net.Config.XmlConfigurator(Watch = true)]
|
|
|
|
namespace VEPROMS
|
|
{
|
|
enum PropPgStyle { Button = 1, Tab = 2, Grid = 3 };
|
|
|
|
public partial class frmVEPROMS : DevComponents.DotNetBar.Office2007RibbonForm
|
|
{
|
|
#region Log4Net
|
|
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
#endregion
|
|
|
|
#region PropertiesVariables
|
|
|
|
private int securityRole;
|
|
private bool _panelExpandedChanging = false;
|
|
Color _CommentTitleBckColor;
|
|
DocVersionInfo _SelectedDVI = null;
|
|
StepTabPanel _SelectedStepTabPanel = null;
|
|
public FindReplace dlgFindReplace = null;
|
|
public VlnSpellCheck SpellChecker = null;
|
|
private Int64 _LastContentChange;
|
|
|
|
public Int64 LastContentChange
|
|
{
|
|
get { return _LastContentChange; }
|
|
set { _LastContentChange = value; }
|
|
}
|
|
|
|
public void RefreshLastChange()
|
|
{
|
|
lblLastChange.Text = string.Format("Last Change: {0}", MySessionInfo.LastContentChange - this.LastContentChange);
|
|
}
|
|
|
|
public StepTabPanel SelectedStepTabPanel
|
|
{
|
|
get
|
|
{
|
|
return _SelectedStepTabPanel;
|
|
}
|
|
set
|
|
{
|
|
_SelectedStepTabPanel = value;
|
|
if (value == null) // DSO Tab Panel
|
|
{
|
|
dlgFindReplace.Visible = false; // Find/Replace dialog should not be visible for DSO tab panels
|
|
if (tc.SelectedDisplayTabItem != null && tc.SelectedDisplayTabItem.MyItemInfo != null) // 2nd part is for unassociated libdocs
|
|
SelectedDVI = tc.SelectedDisplayTabItem.MyItemInfo.MyDocVersion;
|
|
else
|
|
SelectedDVI = null;
|
|
}
|
|
else // Step Tab Panel
|
|
{
|
|
// The following line was broken into separate lines because a NullReferenceError was occurring.
|
|
// Now we should be able to tell what is wrong by which line causes the Null Reference Error
|
|
// RHM 20101217
|
|
//SelectedDVI = value.MyStepPanel.MyProcedureItemInfo.MyProcedure.ActiveParent as DocVersionInfo;
|
|
StepPanel stepPanel = value.MyStepPanel;
|
|
ItemInfo itemInfo = stepPanel.MyProcedureItemInfo;
|
|
ProcedureInfo procedureInfo = itemInfo.MyProcedure;
|
|
SelectedDVI = procedureInfo.MyDocVersion;
|
|
// Remove it first, if it wasn't set, this doesn't do anything, but if it was set, you don't want
|
|
// multiple events because the print dialog will be displayed for each time the event was added.
|
|
_SelectedStepTabPanel.MyStepTabRibbon.PrintRequest -= new StepTabRibbonEvent(MyStepTabRibbon_PrintRequest);
|
|
_SelectedStepTabPanel.MyStepTabRibbon.PrintRequest += new StepTabRibbonEvent(MyStepTabRibbon_PrintRequest);
|
|
_SelectedStepTabPanel.MyStepTabRibbon.QPrintRequest -= new StepTabRibbonEvent(MyStepTabRibbon_QPrintRequest);
|
|
_SelectedStepTabPanel.MyStepTabRibbon.QPrintRequest += new StepTabRibbonEvent(MyStepTabRibbon_QPrintRequest);
|
|
_SelectedStepTabPanel.MyStepTabRibbon.ProgressBar = bottomProgBar;
|
|
_SelectedStepTabPanel.MyStepTabRibbon.ContActionSummaryRequest -= MyStepTabRibbon_ContActionSummaryRequest;
|
|
_SelectedStepTabPanel.MyStepTabRibbon.ContActionSummaryRequest += MyStepTabRibbon_ContActionSummaryRequest;
|
|
_SelectedStepTabPanel.MyStepTabRibbon.AddProcToDVInTree -= new StepTabRibbonEvent(MyStepTabRibbon_AddProcToDocVersionInTree);
|
|
_SelectedStepTabPanel.MyStepTabRibbon.AddProcToDVInTree += new StepTabRibbonEvent(MyStepTabRibbon_AddProcToDocVersionInTree);
|
|
_SelectedStepTabPanel.MyStepTabRibbon.EnableDisableStepProperties -= EnableDisableStepProperties;
|
|
_SelectedStepTabPanel.MyStepTabRibbon.EnableDisableStepProperties += new StepTabRibbonEvent(EnableDisableStepProperties);
|
|
// F2022-024 Time Critical Action Summary
|
|
_SelectedStepTabPanel.MyStepTabRibbon.TimeCriticalActionSummaryRequest -= MyStepTabRibbon_TimeCriticalActionSummaryRequest;
|
|
_SelectedStepTabPanel.MyStepTabRibbon.TimeCriticalActionSummaryRequest += MyStepTabRibbon_TimeCriticalActionSummaryRequest;
|
|
}
|
|
}
|
|
}
|
|
|
|
void MyStepTabRibbon_ContActionSummaryRequest(object sender, StepTabRibbonEventArgs args)
|
|
{
|
|
DialogResult dr = System.Windows.Forms.DialogResult.Yes;
|
|
|
|
ProcedureInfo piThis = null;
|
|
if (_CurrentItem != null) piThis = _CurrentItem.MyProcedure;
|
|
|
|
ProcedureInfo pi = args.Proc as ProcedureInfo;
|
|
if (piThis != null && pi.ItemID != piThis.ItemID) pi = piThis;
|
|
|
|
if (pi == null) return;
|
|
|
|
//added by jcb 20130718 to support create pdf button when multi-unit and user selects a unit
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = pi.ProcedureConfig.SelectedSlave;
|
|
|
|
DlgPrintProcedure prnDlg = new DlgPrintProcedure(pi);
|
|
|
|
//added by jcb 20130718 to support create pdf button when multi-unit and user selects a unit
|
|
prnDlg.SelectedSlave = (pi.ProcedureConfig.SelectedSlave == 0) ? -1 : pi.ProcedureConfig.SelectedSlave;
|
|
prnDlg.MySessionInfo = MySessionInfo;
|
|
prnDlg.Automatic = true;
|
|
prnDlg.CreateContinuousActionSummary = true;
|
|
prnDlg.OpenAfterCreate = (dr == System.Windows.Forms.DialogResult.Yes);
|
|
prnDlg.Prefix = "CASTMP_"; // A temporary procedure PDF is created to grab page numbers
|
|
|
|
prnDlg.SetupForProcedure();
|
|
prnDlg.CreatePDF();
|
|
|
|
//added by jcb 20130718 to support create pdf button when multi-unit and user selects a unit
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
// F2022-024 Time Critical Action Summary
|
|
void MyStepTabRibbon_TimeCriticalActionSummaryRequest(object sender, StepTabRibbonEventArgs args)
|
|
{
|
|
DialogResult dr = System.Windows.Forms.DialogResult.Yes;
|
|
|
|
ProcedureInfo piThis = null;
|
|
if (_CurrentItem != null) piThis = _CurrentItem.MyProcedure;
|
|
|
|
ProcedureInfo pi = args.Proc as ProcedureInfo;
|
|
if (piThis != null && pi.ItemID != piThis.ItemID) pi = piThis;
|
|
|
|
if (pi == null) return;
|
|
|
|
//added by jcb 20130718 to support create pdf button when multi-unit and user selects a unit
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = pi.ProcedureConfig.SelectedSlave;
|
|
|
|
DlgPrintProcedure prnDlg = new DlgPrintProcedure(pi);
|
|
|
|
//added by jcb 20130718 to support create pdf button when multi-unit and user selects a unit
|
|
prnDlg.SelectedSlave = (pi.ProcedureConfig.SelectedSlave == 0) ? -1 : pi.ProcedureConfig.SelectedSlave;
|
|
prnDlg.MySessionInfo = MySessionInfo;
|
|
prnDlg.Automatic = true;
|
|
prnDlg.CreateTimeCriticalActionSummary = true;
|
|
prnDlg.OpenAfterCreate = (dr == System.Windows.Forms.DialogResult.Yes);
|
|
prnDlg.Prefix = "TCASTMP_"; // A temporary procedure PDF is created to grab page numbers
|
|
|
|
prnDlg.SetupForProcedure();
|
|
prnDlg.CreatePDF();
|
|
|
|
//added by jcb 20130718 to support create pdf button when multi-unit and user selects a unit
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
|
|
public DocVersionInfo SelectedDVI
|
|
{
|
|
get { return _SelectedDVI; }
|
|
set
|
|
{
|
|
if (_SelectedDVI != value)
|
|
{
|
|
_SelectedDVI = value;
|
|
_SelectedROFst = null;
|
|
}
|
|
InitiateSearch(false);
|
|
InitiateDisplayReports(false);
|
|
}
|
|
}
|
|
|
|
private ROFstInfo _SelectedROFst;
|
|
public ROFstInfo SelectedROFst
|
|
{
|
|
get
|
|
{
|
|
if (_SelectedROFst == null && SelectedDVI != null)
|
|
{
|
|
if (SelectedDVI.DocVersionAssociationCount <= 0)
|
|
{
|
|
MessageBox.Show("There is no Referenced Object (RO) data for this procedure set. Use the Properties for the set to define the RO data.");
|
|
return null;
|
|
}
|
|
_SelectedROFst = SelectedDVI.DocVersionAssociations[0].MyROFst;
|
|
}
|
|
return _SelectedROFst;
|
|
}
|
|
set { _SelectedROFst = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
private frmVEPROMS _MyParent;
|
|
public frmVEPROMS MyParent
|
|
{
|
|
get { return _MyParent; }
|
|
set { _MyParent = value; }
|
|
}
|
|
|
|
private DocVersionInfo _MyDocVersion = null;
|
|
public DocVersionInfo MyDocVersion
|
|
{
|
|
get { return _MyDocVersion; }
|
|
set { _MyDocVersion = value; }
|
|
}
|
|
|
|
// C2015-022 setup the child PROMS window
|
|
public frmVEPROMS(frmVEPROMS myParent, DocVersionInfo myDocVersion)
|
|
{
|
|
MyParent = myParent;
|
|
MyDocVersion = myDocVersion;
|
|
InitializeComponent();
|
|
|
|
// B2019-082 set the date format on the VEPROMS.exe thread to U.S. for i/o of a date string
|
|
// this is to correct an issue for a UAE customer who could not open some procedures due to the desktop date setting using the "DD/MM/YYYY" instead of the "MM/DD/YYYY" format
|
|
// NOTE: not doing the "Using System.Threading;" statement at beginning of file because it conflicts with the declaration of the "Timer" variable
|
|
System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
|
|
displayRO.TabControl = tc; // B2019-043 this was being passed in as a parameter for DisplayRO which caused issues with the Visual Studio designer
|
|
|
|
SetupFolder(MyDocVersion.FolderID);
|
|
tc.MySessionInfo = MyParent.MySessionInfo;
|
|
displaySearch1.TopFolderID = myDocVersion.FolderID;
|
|
SelectedDVI = myDocVersion;
|
|
tc.VersionID = myDocVersion.VersionID;
|
|
|
|
tc.SeparateWindows = true; // need to set this in child window for goto Outside Transitions
|
|
displayBookMarks.MyBookMarks = MyParent.displayBookMarks.MyBookMarks;
|
|
displayBookMarks.SetupBookMarks(); // setup bookmarks in the child window
|
|
|
|
tc.MyCopyStep = myParent.tc.MyCopyStep; // copy the copystep info to the child window
|
|
|
|
(tv.Nodes[0] as VETreeNode).InChildWindow = true; // tells us this folder's tree nodes are in the child window
|
|
}
|
|
|
|
public void OpenItem(ItemInfo myItemInfo)
|
|
{
|
|
tc.OpenItem(myItemInfo);
|
|
}
|
|
|
|
public void RefreshItem(ItemInfo myItemInfo)
|
|
{
|
|
tc.RefreshItem(myItemInfo);
|
|
}
|
|
|
|
public void tv_FolderDelete(int folderId)
|
|
{
|
|
// Create an instance of the event args if needed
|
|
var args = new vlnTreeFolderDeleteEventArgs(folderId);
|
|
|
|
// Trigger the deletion using the event arguments
|
|
tv.RemoveFolder(args.FolderId);
|
|
|
|
}
|
|
private bool Tv_DeleteFolder(object sender, vlnTreeFolderDeleteEventArgs args)
|
|
{
|
|
tv.RemoveFolder(args.FolderId);
|
|
return true;
|
|
}
|
|
|
|
public frmVEPROMS()
|
|
{
|
|
// The following Try/Catch was added to protect against a problem seen by Kathy and Michelle
|
|
// on January 1, 2013. Michelle's user.config file was empty and PROMS would not run.
|
|
// This logic will delete a "Bad" config file to attempt to eliminate the problem, and
|
|
// instructs the user to try again.
|
|
try
|
|
{
|
|
if (Properties.Settings.Default.UpdateSettings)
|
|
{
|
|
Properties.Settings.Default.Upgrade();
|
|
Properties.Settings.Default.UpdateSettings = false;
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_MyLog.Error(ex.GetType().Name + " - " + ex.InnerException, ex);
|
|
|
|
if (ex.Message.StartsWith("Configuration system failed to initialize"))
|
|
{
|
|
string filename = ex.InnerException.Message;
|
|
filename = filename.Substring(filename.IndexOf("(") + 1);
|
|
filename = filename.Substring(0, filename.IndexOf("user.config") + 11);
|
|
|
|
FileInfo myfile = new FileInfo(filename);
|
|
myfile.Delete();
|
|
|
|
MessageBox.Show("Config file was corrupt, it has been deleted.\r\nTry Again", "Corrupt config file", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
System.Diagnostics.Process.GetCurrentProcess().Kill();
|
|
}
|
|
}
|
|
|
|
// If first time close any remaining WinWords. These will sometimes get hung in memory and cause problems.
|
|
if (System.Diagnostics.Process.GetProcessesByName(System.Diagnostics.Process.GetCurrentProcess().ProcessName).Length == 1)
|
|
{
|
|
Volian.MSWord.WordDoc.KillWordApps();
|
|
}
|
|
|
|
// cleanup from previous run:
|
|
Volian.Base.Library.TmpFile.RemoveAllTmps();
|
|
|
|
if (VlnSettings.DebugMode)
|
|
{
|
|
//use local data (for development/debug mode)
|
|
if (Environment.MachineName == "RMARK-PC")
|
|
VEPROMS.CSLA.Library.Database.ConnectionName = "VEPROMS_RMARK_DEBUG";
|
|
else if (Environment.MachineName == "WINDOWS7-RHM")
|
|
VEPROMS.CSLA.Library.Database.ConnectionName = "VEPROMS_RMARK_DEBUG";
|
|
else if (Environment.UserName.ToUpper() == "BODINE")
|
|
VEPROMS.CSLA.Library.Database.ConnectionName = "VEPROMS_BODINE_DEBUG";
|
|
else
|
|
VEPROMS.CSLA.Library.Database.ConnectionName = "VEPROMS_LOCAL";
|
|
}
|
|
else
|
|
{
|
|
// use server data (default)
|
|
// - except for the volian laptop and Rich's Demo version where we need to use local data
|
|
if (Environment.MachineName == "RMARK-PC")
|
|
VEPROMS.CSLA.Library.Database.ConnectionName = "VEPROMS_RMARK_DEMO";
|
|
else if (Environment.MachineName == "WINDOWS7-RHM")
|
|
VEPROMS.CSLA.Library.Database.ConnectionName = "VEPROMS_RMARK_DEMO";
|
|
else if (Environment.UserName.ToUpper() == "BODINE")
|
|
VEPROMS.CSLA.Library.Database.ConnectionName = "VEPROMS_BODINE_DEMO";
|
|
else
|
|
VEPROMS.CSLA.Library.Database.ConnectionName = "VEPROMS_LOCAL";
|
|
}
|
|
|
|
InitializeComponent();
|
|
|
|
// B2019-082 set the date format on the VEPROMS.exe thread to U.S. for i/o of a date string
|
|
// this is to correct an issue for a UAE customer who could not open some procedures due to the desktop date setting using the "DD/MM/YYYY" instead of the "MM/DD/YYYY" format
|
|
// NOTE: not doing the "Using System.Threading;" statement at beginning of file because it conflicts with the declaration of the "Timer" variable
|
|
System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
|
|
|
|
displayRO.TabControl = tc; // B2019-043 this was being passed in as a parameter for DisplayRO which caused issues with the Visual Studio designer
|
|
bottomProgBar.ValueChanged += new EventHandler(bottomProgBar_ValueChanged);
|
|
|
|
// When creating an XY Plot, a System.Drawing.Graphics is needed and it requires a form. Use the main form.
|
|
if (VlnSettings.DebugMode)
|
|
{
|
|
MSWordToPDF.DebugStatus = 1;
|
|
MSWordToPDF.OverrideColor = Color.Red;
|
|
}
|
|
else
|
|
{
|
|
MSWordToPDF.DebugStatus = 0;
|
|
MSWordToPDF.OverrideColor = Color.Transparent;
|
|
}
|
|
|
|
MSWordToPDF.FormForPlotGraphics = this;
|
|
|
|
// set the color of the ribbon
|
|
RibbonPredefinedColorSchemes.ChangeOffice2007ColorTable((eOffice2007ColorScheme)Settings.Default.SystemColor);
|
|
cmbFont.DataSource = FontFamily.Families;
|
|
cmbFont.DisplayMember = "Name";
|
|
cmbFont.SelectedIndex = -1;
|
|
string[] parameters = System.Environment.CommandLine.Split(" ".ToCharArray());
|
|
string db = Volian.Base.Library.VlnSettings.GetDB();
|
|
|
|
if (db != null)
|
|
Database.SelectedDatabase = db;
|
|
|
|
//B2018-129 Most Recently Used list was being cleared. Needed to remove a (string) type case in the IF statement
|
|
if (!string.IsNullOrEmpty((string)Properties.Settings.Default["DefaultDB"]))
|
|
Database.LastDatabase = Properties.Settings.Default.DefaultDB;
|
|
|
|
// Setup the Context menu for DisplaySearch including the symbols
|
|
displaySearch1.SetupContextMenu();
|
|
displaySearch1.SearchComplete += displaySearch1_SearchComplete;
|
|
|
|
if (!FormatInfo.HasLatestChanges())
|
|
throw new Exception("Inconsistent Formats");
|
|
|
|
if (!ItemAuditInfo.IsChangeManagerVersion())
|
|
throw new Exception("Inconsistent Data");
|
|
|
|
// set a static variable to the PROMS Base format (BASEall.xml)
|
|
// this is used to resolve Global Search bug B2014-057 so that we can get to the symbol list when no DocVersion is selected
|
|
if (FormatInfo.PROMSBaseFormat == null)
|
|
throw new Exception("Could not set PROMSBaseFormat");
|
|
|
|
if ((Database.LastDatabase ?? "") != (Database.SelectedDatabase ?? ""))
|
|
{
|
|
if (Properties.Settings.Default.VersionWindows != null)
|
|
Properties.Settings.Default.VersionWindows.Clear();
|
|
|
|
Properties.Settings.Default.MRIList = null;
|
|
Properties.Settings.Default.DefaultDB = Database.SelectedDatabase;
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
|
|
displayBookMarks.SetupBookMarks();
|
|
DateTime dtSunday = DateTime.Now.AddDays(-((int)DateTime.Now.DayOfWeek));
|
|
string c = Database.DBServer;
|
|
|
|
// D2017-260 - Use a prefix of the server name combined with the database name for temporary MSWord sections
|
|
DSOFile.TempFilePrefix = System.Text.RegularExpressions.Regex.Replace(System.Text.RegularExpressions.Regex.Replace(c, @"([^[\]]*) \[.*\]", "$1"), @"[\#\~\%\@\[\]\(\)\{\}\-. \\*<>:;""/?|]+", "_");
|
|
ChangeLogFileName("LogFileAppender", Database.ActiveDatabase + " " + dtSunday.ToString("yyyyMMdd") + " ErrorLog.txt");
|
|
|
|
// B2019-107 Error Log message for inconsistent PromsFixes
|
|
_MyLog.InfoFormat("\r\nSession Beginning\r\n<===={0}[SQL:{1:yyMM.ddHH}]====== User: {2}/{3} Started {4} ===============>{5}"
|
|
, Application.ProductVersion, Database.RevDate, Environment.UserDomainName, Environment.UserName, DateTime.Now.ToString("dddd MMMM d, yyyy h:mm:ss tt"), FormatInfo.Failed ?? "");
|
|
|
|
// C2022-030 Notify the user if the stored procedure in the database are not update to date
|
|
// with those in the PROMSFixes.sql delivered with the PROMS executable
|
|
string pfVersion = ExeInfo.GetAssocicatedPROMSFixesVersion();
|
|
string dbpfVersion = string.Format("{0:yyMM.ddHH}", Database.RevDate);
|
|
// if pfVersion is null, that means there was a problem finding or reading the PROMSFixes.SQL file in the executable folder
|
|
if (pfVersion != null && !pfVersion.Equals(dbpfVersion))
|
|
{
|
|
_MyLog.WarnFormat("PROMSFixes Version - in Data Version is {0} PROMS is Expecting Version {1}", dbpfVersion, pfVersion);
|
|
StringBuilder sbMsg = new StringBuilder();
|
|
//sbMsg.Append("The SQL Stored Procedures in the Database are a different version than what PROMS is expecting.");
|
|
sbMsg.Append("The SQL Stored Procedures version in the database is different than what PROMS is expecting.");
|
|
sbMsg.Append("\nPROMS may not run properly until the lastest SQL Stored Procedures are installed.");
|
|
sbMsg.AppendFormat("\n\n The database has SQL Stored Procedures version: {0}", dbpfVersion);
|
|
sbMsg.AppendFormat("\n PROMS is expecting SQL Stored Procedures version: {0}", pfVersion);
|
|
sbMsg.Append("\n\nPlease have your DBA update the database with the PROMSFixes.sql script file that was\ndelivered with this PROMS executable.");
|
|
sbMsg.Append("\n\nThe PROMSFixes.sql file is included with the PROMS installation download.");
|
|
sbMsg.Append("\n\nIt can also be found in your PROMS executable folder:");
|
|
sbMsg.AppendFormat("\n\t{0}",ExeInfo.PROMSExecutableFolderPath());
|
|
FlexibleMessageBox.Show(sbMsg.ToString(),"SQL Stored Procedures Version Difference");
|
|
}
|
|
|
|
foreach (string parameter in parameters)
|
|
{
|
|
if (parameter.ToUpper().StartsWith("/UF="))
|
|
UpdateFormats(parameter.Substring(4));
|
|
|
|
else if (parameter.ToUpper().StartsWith("/UF"))
|
|
UpdateFormats(null);
|
|
}
|
|
|
|
SetupFolder(1);
|
|
|
|
tc.VersionID = 0;
|
|
tc.SeparateWindows = Properties.Settings.Default.SeparateWindows;
|
|
tv.PauseRefresh += tv_PauseRefresh;
|
|
tv.UnPauseRefresh += tv_UnPauseRefresh;
|
|
}
|
|
|
|
void displaySearch1_SearchComplete(object sender, DisplaySearchEventArgs args)
|
|
{
|
|
ProgBarText = string.Format("{0} Seconds", args.HowLong.TotalSeconds);
|
|
}
|
|
|
|
private bool _PauseRefresh = false;
|
|
public bool PauseRefresh
|
|
{
|
|
get { return _PauseRefresh; }
|
|
set { _PauseRefresh = value; }
|
|
}
|
|
|
|
void tv_UnPauseRefresh(object sender, vlnTreeSectionInfoEventArgs args)
|
|
{
|
|
PauseRefresh = false;
|
|
}
|
|
|
|
void tv_PauseRefresh(object sender, vlnTreeSectionInfoEventArgs args)
|
|
{
|
|
//_MyLog.WarnFormat("Pause");
|
|
//PauseRefresh = true;
|
|
}
|
|
|
|
private void SetupFolder(int folderID)
|
|
{
|
|
VETreeNode tn = VETreeNode.GetFolder(folderID);
|
|
|
|
tv.Nodes.Add(tn);
|
|
tv.NodePSI += new vlnTreeViewPSIEvent(tv_NodePSI);
|
|
tv.NodeSI += new vlnTreeViewSIEvent(tv_NodeSI);
|
|
tv.NodeOpenProperty += new vlnTreeViewPropertyEvent(tv_NodeOpenProperty);
|
|
tv.NodeSelect += new Volian.Controls.Library.vlnTreeViewEvent(tv_NodeSelect);
|
|
tv.NodeNew += new vlnTreeViewEvent(tv_NodeNew);
|
|
tv.OpenItem += new vlnTreeViewItemInfoEvent(tv_OpenItem);
|
|
tv.TabDisplay += new StepPanelTabDisplayEvent(tc_PanelTabDisplay);
|
|
tv.DeleteFolder += new vlnTreeViewItemInfoDeleteFolderEvent(Tv_DeleteFolder);
|
|
tv.DeleteItemInfo += new vlnTreeViewItemInfoDeleteEvent(tv_DeleteItemInfo);
|
|
tv.InsertItemInfo += new vlnTreeViewItemInfoInsertEvent(tv_InsertItemInfo);
|
|
tv.NodeInsert += new vlnTreeViewEvent(tv_NodeInsert);
|
|
tv.PasteItemInfo += new vlnTreeViewItemInfoPasteEvent(tv_PasteItemInfo);
|
|
tv.SearchIncTrans += new vlnTreeViewSearchIncTransEvent(tv_SearchIncTrans);
|
|
tc.SearchIncTrans += new DisplayTabControlEditorSearchIncTransEvent(tc_SearchIncTrans);
|
|
tv.GetChangeId += new vlnTreeViewGetChangeIdEvent(tv_GetChangeId);
|
|
tv.NodeCopy += new vlnTreeViewEvent(tv_NodeCopy);
|
|
tv.ClipboardStatus += new vlnTreeViewClipboardStatusEvent(tv_ClipboardStatus);
|
|
|
|
tv.ProgressBar = bottomProgBar;
|
|
tc.ItemPaste += new StepPanelItemPastedEvent(tc_ItemPasted);
|
|
|
|
displayHistory.HistorySelectionChanged += new DisplayHistoryEvent(displayHistory_HistorySelectionChanged);
|
|
_CommentTitleBckColor = epAnnotations.TitleStyle.BackColor1.Color;
|
|
if (!btnAnnoDetailsPushPin.Checked)
|
|
epAnnotations.Expanded = false;
|
|
|
|
infoPanel.Expanded = false;
|
|
toolsPanel.Expanded = false;
|
|
displayTags.Visible = false;
|
|
ribbonControl1.ExpandedChanged += new EventHandler(ribbonControl1_ExpandedChanged);
|
|
dlgFindReplace = new FindReplace();
|
|
SpellChecker = new VlnSpellCheck();
|
|
|
|
displaySearch1.PrintRequest += new DisplaySearchEvent(displaySearch1_PrintRequest);
|
|
displayHistory.ChronologyPrintRequest += new DisplayHistoryReportEvent(displayHistory_ChronologyPrintRequest);
|
|
displayHistory.SummaryPrintRequest += new DisplayHistoryReportEvent(displayHistory_SummaryPrintRequest);
|
|
displayHistory.AnnotationRestored += new AnnotationRestoredHandler(displayHistory_AnnotationRestored);
|
|
displayReports.PrintRequest += new DisplayReportsEvent(displayReports_PrintRequest);
|
|
|
|
this.Activated += new EventHandler(frmVEPROMS_Activated);
|
|
|
|
VlnSettings.StepTypeToolTip = Settings.Default.StepTypeToolTip;
|
|
VlnSettings.cbShwRplWrdsColor = Settings.Default.cbShwRplWrdsColor;
|
|
displayLibDocs.PrintRequest += new DisplayLibDocEvent(displayLibDocs_PrintRequest);
|
|
ContentInfo.InfoChanged += new ContentInfoEvent(RefreshDisplayHistory);
|
|
AnnotationInfo.InfoChanged += new AnnotationInfoEvent(RefreshDisplayHistory);
|
|
ItemInfo.InfoRestored += new ItemInfoEvent(RefreshDisplayHistory);
|
|
ItemInfo.ItemDeleted += new ItemInfoEvent(RefreshDisplayHistory);
|
|
|
|
tv.PrintProcedure += new vlnTreeViewEvent(tv_PrintProcedure);
|
|
tv.PrintSection += new vlnTreeViewEvent(tv_PrintSection);
|
|
tv.QPrintSection += new vlnTreeViewEvent(tv_QPrintSection);
|
|
tv.QPrintProcedure += new vlnTreeViewEvent(tv_QPrintProcedure);
|
|
tv.PrintAllProcedures += new vlnTreeViewEvent(tv_PrintAllProcedures);
|
|
tv.PrintAllApprovedProcedures += new vlnTreeViewEvent(tv_PrintAllApprovedProcedures);
|
|
tv.ApproveProcedure += new vlnTreeViewEvent(tv_ApproveProcedure);
|
|
tv.ApproveAllProcedures += new vlnTreeViewEvent(tv_ApproveAllProcedures);
|
|
tv.ApproveSomeProcedures += new vlnTreeViewEvent(tv_ApproveSomeProcedures);
|
|
tv.ReportAllProceduresInconsistencies += new vlnTreeViewEvent(tv_ReportAllProceduresInconsistencies);
|
|
tv.RefreshCheckedOutProcedures += new vlnTreeViewEvent(tv_RefreshCheckedOutProcedures);
|
|
tv.ProcedureCheckedOutTo += new vlnTreeViewEvent(tv_ProcedureCheckedOutTo);
|
|
tv.ViewPDF += new vlnTreeViewPdfEvent(tv_ViewPDF);
|
|
displayApplicability.ApplicabilityViewModeChanged += new DisplayApplicability.DisplayApplicabilityEvent(displayApplicability_ApplicabilityViewModeChanged);
|
|
|
|
tv.ExportImportProcedureSets += new vlnTreeViewEvent(tv_ExportImportProcedureSets);
|
|
tv.PrintTransitionReport += new vlnTreeViewEvent(tv_PrintTransitionReport);
|
|
tv.ProcessingComplete += tv_ProcessingComplete;
|
|
tv.Processing += tv_Processing;
|
|
tv.CreateContinuousActionSummary += new vlnTreeViewEvent(tv_CreateContinuousActionSummary);
|
|
tv.SelectDateToStartChangeBars += tv_SelectDateToStartChangeBars;
|
|
tv.CreateTimeCriticalActionSummary += new vlnTreeViewEvent(tv_CreateTimeCriticalActionSummary);
|
|
tv.RefreshFormats += new vlnTreeViewStatusEvent(RefreshFormats);
|
|
|
|
displayBookMarks.ResetBookMarksInPROMSWindows += displayBookMarks_ResetBookMarksInPROMSWindows;
|
|
}
|
|
|
|
//C2021-035 Add Refresh Tree Option at highest level
|
|
void RefreshFormats(object sender, vlnTreeStatusEventArgs args)
|
|
{
|
|
Format.ClearFormatCache();
|
|
FormatInfo.ClearFormatInfoCache();
|
|
FormatInfo.Reset();
|
|
FormatInfoList.Reset();
|
|
Format.Reset();
|
|
FormatList.Reset();
|
|
displaySearch1.SetupContextMenu();
|
|
}
|
|
|
|
// Part of Separate Windows upgrade C2015-022
|
|
// Extend Changes to BookMark information to all of the child windows
|
|
void displayBookMarks_ResetBookMarksInPROMSWindows(object sender, EventArgs args)
|
|
{
|
|
foreach (int k in PROMSWindowForms.Keys)
|
|
{
|
|
frmVEPROMS tmp = PROMSWindowForms[k];
|
|
|
|
if (tmp.MyDocVersion.VersionID != this.SelectedDVI.VersionID)
|
|
tmp.displayBookMarks.ResetBookMarkList();
|
|
|
|
else if (tmp.MyParent != null)
|
|
tmp.MyParent.displayBookMarks.ResetBookMarkList();
|
|
}
|
|
}
|
|
|
|
//B2019-140 Change bars do not get refreshed when approval is run.
|
|
// Get the displaytab containing the procedure
|
|
// if none exists, return null
|
|
public DisplayTabItem GetTabContainingProcedure(int procid) => tc?.MyBar?.Items?.OfType<DisplayTabItem>().FirstOrDefault(x => x.MyItemInfo?.ItemID == procid);
|
|
// Refresh Node in Tree
|
|
// Used for when Change Bar Updates as part of approval.
|
|
public void RefreshProcedureNode(ProcedureInfo itm)
|
|
{
|
|
VETreeNode tn = tv.FindNode(itm, tv.Nodes);
|
|
var tmp = (ProcedureInfo)tn?.VEObject;
|
|
if (tmp != null)
|
|
{
|
|
tmp.ChangeBarDate = itm.ChangeBarDate;
|
|
tmp.MyConfig = itm.MyConfig;
|
|
}
|
|
|
|
tn?.RefreshNode();
|
|
}
|
|
|
|
void tv_SelectDateToStartChangeBars(object sender, vlnTreeEventArgs args)
|
|
{
|
|
ProcedureInfo pi = (args.Node as VETreeNode).VEObject as ProcedureInfo;
|
|
if (pi == null) return;
|
|
tc.SaveCurrentEditItem(pi);
|
|
|
|
ProcedureConfig pc = pi.MyConfig as ProcedureConfig;
|
|
if (pc == null) return;
|
|
|
|
dlgSetChangeBarStartDate cbdDlg = new dlgSetChangeBarStartDate(pc, pi);
|
|
if (cbdDlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
using (Item itm = Item.Get(pi.ItemID))
|
|
{
|
|
itm.MyContent.Config = pc.ToString();
|
|
itm.UserID = Volian.Base.Library.VlnSettings.UserID;
|
|
itm.Save();
|
|
|
|
//B2019-140 Change bars do not get refreshed when approval is run.
|
|
// Reset a Procedure and sub items in the cache
|
|
ProcedureInfo newproc = ItemInfo.ResetProcedure(pi.ItemID);
|
|
|
|
//// Refresh the StepPanel for the current Procedure
|
|
//// so change bars update
|
|
//// on any open StepPanel
|
|
|
|
//B2026-019 Attempt to prevent an Access Error by utilizing a different Refresh if a Procedure is Open
|
|
DisplayTabItem dti = GetTabContainingProcedure(pi.ItemID);
|
|
if (dti != null)
|
|
{
|
|
|
|
if (!dti.MyStepTabPanel.MyStepPanel.ContainsFocus)
|
|
dti.MyStepTabPanel.MyStepPanel.Focus();
|
|
|
|
foreach (EditItem eitm in dti.MyStepTabPanel.MyStepPanel.Controls.OfType<EditItem>())
|
|
{
|
|
eitm.ChangeBar = eitm.MyItemInfo.HasChangeBar;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _SkipRefresh = false;
|
|
public bool SkipRefresh
|
|
{
|
|
get { return _SkipRefresh; }
|
|
set { _SkipRefresh = value; }
|
|
}
|
|
|
|
void tv_Processing(object sender, vlnTreeStatusEventArgs args)
|
|
{
|
|
SkipRefresh = args.MyStatus;
|
|
|
|
if (args.MyStatus)
|
|
bottomProgBar.ColorTable = eProgressBarItemColor.Paused;
|
|
else
|
|
bottomProgBar.ColorTable = eProgressBarItemColor.Normal;
|
|
|
|
bottomProgBar.Text = args.MyMessage;
|
|
bottomProgBar.TextVisible = true;
|
|
|
|
Application.DoEvents();
|
|
}
|
|
|
|
void tv_ProcessingComplete(object sender, vlnTreeTimeEventArgs args)
|
|
{
|
|
bottomProgBar.Text = string.Format("{0} seconds - {1}", args.MyTimeSpan.TotalSeconds, args.MyMessage);
|
|
Application.DoEvents();
|
|
}
|
|
|
|
void bottomProgBar_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
if (bottomProgBar.Value < 10 && bottomProgBar.ColorTable != eProgressBarItemColor.Normal)
|
|
bottomProgBar.ColorTable = eProgressBarItemColor.Normal;
|
|
}
|
|
|
|
string tv_GetChangeId(object sender, vlnTreeItemInfoEventArgs args)
|
|
{
|
|
tc.HandleChangeId(args.MyItemInfo, null);
|
|
return tc.ChgId;
|
|
}
|
|
|
|
ItemInfo tv_ClipboardStatus(object sender, vlnTreeEventArgs args)
|
|
{
|
|
return tc.MyCopyStep;
|
|
}
|
|
|
|
void tv_NodeCopy(object sender, vlnTreeEventArgs args)
|
|
{
|
|
VETreeNode tn = args.Node as VETreeNode;
|
|
ItemInfo ii = tn.VEObject as ItemInfo;
|
|
tc.MyCopyStep = ii;
|
|
tc_CopyStepSelected(sender, null); // C2015-022 set copy step info in the child windows
|
|
}
|
|
|
|
void tv_PrintTransitionReport(object sender, vlnTreeEventArgs args)
|
|
{
|
|
FolderInfo fi = null;
|
|
ProcedureInfo pi = null;
|
|
|
|
if ((args.Node as VETreeNode).VEObject is FolderInfo)
|
|
fi = (args.Node as VETreeNode).VEObject as FolderInfo;
|
|
|
|
if ((args.Node as VETreeNode).VEObject is ProcedureInfo)
|
|
pi = (args.Node as VETreeNode).VEObject as ProcedureInfo;
|
|
|
|
if (fi != null) //working with folder
|
|
{
|
|
dlgTransitionReport dlg = new dlgTransitionReport(fi);
|
|
dlg.ShowDialog(this);
|
|
}
|
|
|
|
if (pi != null) //working with procedure
|
|
{
|
|
this.Cursor = Cursors.WaitCursor;
|
|
Application.DoEvents();
|
|
dlgTransitionReport dlg = new dlgTransitionReport(pi);
|
|
dlg.ShowDialog(this);
|
|
this.Cursor = Cursors.Default;
|
|
}
|
|
}
|
|
|
|
void tv_ExportImportProcedureSets(object sender, vlnTreeEventArgs args)
|
|
{
|
|
FolderInfo fi = null;
|
|
DocVersionInfo dvi = null;
|
|
ProcedureInfo pi = null;
|
|
|
|
if ((args.Node as VETreeNode).VEObject is FolderInfo)
|
|
fi = (args.Node as VETreeNode).VEObject as FolderInfo;
|
|
|
|
if ((args.Node as VETreeNode).VEObject is DocVersionInfo)
|
|
dvi = (args.Node as VETreeNode).VEObject as DocVersionInfo;
|
|
|
|
if ((args.Node as VETreeNode).VEObject is ProcedureInfo)
|
|
pi = (args.Node as VETreeNode).VEObject as ProcedureInfo;
|
|
|
|
if (fi != null)
|
|
{
|
|
string msg = string.Empty;
|
|
|
|
// B2018-023: If exporting a procedure set, and someone else is in the database (but not this folder)
|
|
// don't stop the export (CheckOutType.Session was changed to CheckOutType.Folder).
|
|
bool ok = MySessionInfo.CanCheckOutItem(fi.FolderID, CheckOutType.Folder, ref msg);
|
|
|
|
//bool ok = MySessionInfo.CanCheckOutItem(fi.FolderID, (args.Index == 0)? CheckOutType.Folder : CheckOutType.Session, ref msg);
|
|
if (!ok)
|
|
{
|
|
if (args.Index == 0)
|
|
MessageBox.Show(this, msg, "Export Procedure Set Unavailable");
|
|
else
|
|
MessageBox.Show(this, msg, "Import Procedure Set Unavailable");
|
|
}
|
|
else
|
|
{
|
|
int ownerid = MySessionInfo.CheckOutItem(fi.FolderID, CheckOutType.Session);
|
|
|
|
//C2025-024 Electronic Procedures - Phase 2 (PROMS XML output)
|
|
//form for exporting Electronic Procedures from FolderInfo
|
|
if (args.AnnotationTypeId > 0)
|
|
{
|
|
dlgExportImportEP dlg = new dlgExportImportEP(args.Index == 0 ? "Export" : "Import", fi, this, args.AnnotationTypeId, args.UnitIndex);
|
|
dlg.ShowDialog(this);
|
|
|
|
MySessionInfo.CheckInItem(ownerid);
|
|
|
|
if (args.Index == 1 && dlg.MyNewFolder != null)
|
|
{
|
|
tv.AddNewNode(dlg.MyNewFolder);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dlgExportImport dlg = new dlgExportImport(args.Index == 0 ? "Export" : "Import", fi, this);//Added frmVEPROMS Parameter
|
|
dlg.ShowDialog(this);
|
|
|
|
MySessionInfo.CheckInItem(ownerid);
|
|
|
|
if (args.Index == 1 && dlg.MyNewFolder != null)
|
|
{
|
|
tv.AddNewNode(dlg.MyNewFolder);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dvi != null)
|
|
{
|
|
string msg = string.Empty;
|
|
bool ok = MySessionInfo.CanCheckOutItem(dvi.VersionID, CheckOutType.DocVersion, ref msg);
|
|
|
|
if (!ok)
|
|
{
|
|
MessageBox.Show(this, msg, "Import Procedure Unavailable");
|
|
}
|
|
else
|
|
{
|
|
dvi.RefreshDocVersionAssociations(); // Refresh Associations Count
|
|
//Only allow Import if the Referenced Object Database is set
|
|
if (dvi.DocVersionAssociationCount == 0)
|
|
{
|
|
MessageBox.Show("Prior to Importing Procedures you must set the Referenced Object Database", "No RO Database set", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
|
|
return;
|
|
}
|
|
|
|
int ownerid = MySessionInfo.CheckOutItem(dvi.VersionID, CheckOutType.DocVersion);
|
|
|
|
//C2025-024 Electronic Procedures - Phase 2 (PROMS XML output)
|
|
//form for exporting Electronic Procedures from DocVersionInfo
|
|
if (args.AnnotationTypeId > 0)
|
|
{
|
|
dlgExportImportEP dlg = new dlgExportImportEP(args.Index == 0 ? "Export" : "Import", dvi, this, args.AnnotationTypeId, args.UnitIndex);
|
|
dlg.MyNewProcedure = null;
|
|
dlg.ExternalTransitionItem = null;
|
|
dlg.ShowDialog(this);
|
|
|
|
MySessionInfo.CheckInItem(ownerid);
|
|
|
|
if (dlg.MyNewProcedure != null)
|
|
tv.AddNewNode(dlg.MyNewProcedure);
|
|
|
|
if (dlg.ExternalTransitionItem != null)
|
|
tc.OpenItem(dlg.ExternalTransitionItem);
|
|
}
|
|
else
|
|
{
|
|
|
|
dlgExportImport dlg = new dlgExportImport("Import", dvi, this);//Added frmVEPROMS Parameter
|
|
dlg.MyNewProcedure = null;
|
|
dlg.ExternalTransitionItem = null;
|
|
dlg.ShowDialog(this);
|
|
|
|
MySessionInfo.CheckInItem(ownerid);
|
|
|
|
if (dlg.MyNewProcedure != null)
|
|
tv.AddNewNode(dlg.MyNewProcedure);
|
|
|
|
if (dlg.ExternalTransitionItem != null)
|
|
tc.OpenItem(dlg.ExternalTransitionItem);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if (pi != null)
|
|
{
|
|
string msg = string.Empty;
|
|
bool ok = MySessionInfo.CanCheckOutItem(pi.ItemID, CheckOutType.Procedure, ref msg);
|
|
|
|
if (!ok)
|
|
{
|
|
MessageBox.Show(this, msg, "Export Procedure Unavailable");
|
|
}
|
|
else
|
|
{
|
|
int ownerid = MySessionInfo.CheckOutItem(pi.ItemID, CheckOutType.Procedure);
|
|
|
|
//C2025-024 Electronic Procedures - Phase 2 (PROMS XML output)
|
|
//form for exporting Electronic Procedures from ProcedureInfo
|
|
if (args.AnnotationTypeId > 0)
|
|
{
|
|
dlgExportImportEP dlg = new dlgExportImportEP("Export", pi, this, args.AnnotationTypeId, args.UnitIndex);
|
|
dlg.ShowDialog(this);
|
|
|
|
MySessionInfo.CheckInItem(ownerid);
|
|
}
|
|
else
|
|
{
|
|
|
|
dlgExportImport dlg = new dlgExportImport("Export", pi, this);//Added frmVEPROMS Parameter
|
|
dlg.ShowDialog(this);
|
|
|
|
MySessionInfo.CheckInItem(ownerid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MakeDatabaseChanges()
|
|
{
|
|
// September 2012: Decided to store roimages as zipped. Any previous data may not have them zipped.
|
|
// Check the top folders config to see, and if needed, zip them:
|
|
ROImageInfo.CompressAllExistingImages += new ROImageInfoCompressionEvent(ROImageInfo_CompressAllExistingImages);
|
|
ROImageInfo.ZipImages();
|
|
ROImageInfo.CompressAllExistingImages -= new ROImageInfoCompressionEvent(ROImageInfo_CompressAllExistingImages);
|
|
|
|
}
|
|
|
|
void ROImageInfo_CompressAllExistingImages(object sender, ROImageInfoCompressionEventArgs args)
|
|
{
|
|
switch (args.Type)
|
|
{
|
|
case ROImageCompressionEventType.Complete:
|
|
ProgBarText = "Compressing Complete";
|
|
break;
|
|
|
|
case ROImageCompressionEventType.Initialize:
|
|
ProgBarMax = args.Total;
|
|
ProgBarText = "Compressing RO Images";
|
|
break;
|
|
|
|
case ROImageCompressionEventType.Update:
|
|
ProgBarValue = args.Current;
|
|
ProgBarText = args.FileName;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static string _ErrorLogFileName;
|
|
|
|
public static string ErrorLogFileName
|
|
{
|
|
get { return frmVEPROMS._ErrorLogFileName; }
|
|
set { frmVEPROMS._ErrorLogFileName = value; }
|
|
}
|
|
|
|
public static bool colorReplaceWords()
|
|
{
|
|
return Properties.Settings.Default.cbShwRplWrdsColor;
|
|
}
|
|
|
|
static bool ChangeLogFileName(string AppenderName, string NewFilename)
|
|
{
|
|
log4net.Repository.ILoggerRepository RootRep;
|
|
RootRep = log4net.LogManager.GetRepository();
|
|
|
|
foreach (log4net.Appender.IAppender iApp in RootRep.GetAppenders())
|
|
{
|
|
if ((iApp.Name.CompareTo(AppenderName) == 0) && (iApp is log4net.Appender.FileAppender))
|
|
{
|
|
log4net.Appender.FileAppender fApp = (log4net.Appender.FileAppender)iApp;
|
|
string folderPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
|
|
fApp.File = folderPath + @"\VEPROMS\" + (Volian.Base.Library.VlnSettings.GetCommand("prefix", "") + "_").TrimStart("_".ToCharArray()) + NewFilename;
|
|
ErrorLogFileName = fApp.File;
|
|
fApp.ActivateOptions();
|
|
|
|
return true; // Appender found and name changed to NewFilename
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void displayApplicability_ApplicabilityViewModeChanged(object sender, EventArgs args)
|
|
{
|
|
if (tc.SelectedDisplayTabItem == null) return;
|
|
StepPanel pnl = tc.SelectedDisplayTabItem.MyStepTabPanel.MyStepPanel;
|
|
|
|
if (pnl != null)
|
|
{
|
|
pnl.ApplDisplayMode = displayApplicability.ViewMode;
|
|
displayHistory.ApplDisplayMode = pnl.ApplDisplayMode;
|
|
}
|
|
}
|
|
|
|
void tv_ViewPDF(object sender, vlnTreeViewPdfArgs args)
|
|
{
|
|
byte[] buffer;
|
|
|
|
if (args.MyWatermark != string.Empty)
|
|
buffer = PromsPrinter.WatermarkPDF(args.MyBuffer, args.MyWatermark);
|
|
else
|
|
buffer = args.MyBuffer;
|
|
|
|
string fileName = Volian.Base.Library.VlnSettings.TemporaryFolder + "\\" + args.MyFilename;
|
|
|
|
try
|
|
{
|
|
FileStream fs = new FileStream(fileName, FileMode.Create);
|
|
fs.Write(buffer, 0, buffer.Length);
|
|
fs.Close();
|
|
System.Diagnostics.Process.Start(fileName);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.AppendLine("Could not create");
|
|
sb.AppendLine();
|
|
sb.AppendLine(fileName + ".");
|
|
sb.AppendLine();
|
|
sb.AppendLine("If it is open, close and retry.");
|
|
|
|
MessageBox.Show(sb.ToString(), "Error on CreatePdf", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
}
|
|
}
|
|
|
|
void displayHistory_AnnotationRestored(AnnotationInfo restoredAnnotationInfo, ItemInfo currentItem)
|
|
{
|
|
ctrlAnnotationDetails.UpdateAnnotationGrid(currentItem);
|
|
}
|
|
|
|
void tv_ReportAllProceduresInconsistencies(object sender, vlnTreeEventArgs args)
|
|
{
|
|
DocVersionInfo dvi = (args.Node as VETreeNode).VEObject as DocVersionInfo;
|
|
if (dvi == null) return;
|
|
|
|
this.Cursor = Cursors.WaitCursor;
|
|
|
|
ItemInfoList iil = ItemInfoList.GetAllInconsistencies(dvi.VersionID);
|
|
Volian.Print.Library.PDFConsistencyCheckReport rpt = new Volian.Print.Library.PDFConsistencyCheckReport(Volian.Base.Library.VlnSettings.TemporaryFolder + @"\AllInconsistencies.pdf", iil, dvi); //B2020-020 needed to pass in DocVersion to get paper size from format
|
|
rpt.BuildAllReport(dvi);
|
|
|
|
this.Cursor = Cursors.Default;
|
|
}
|
|
|
|
//C2020-036 returns a string of duplicate procedure numbers separated by newlines for use in FlexibleMessageBox
|
|
private string dupProcList
|
|
{
|
|
get
|
|
{
|
|
string rtn = "";
|
|
if (dpl.Count > 0)
|
|
{
|
|
foreach (string pn in dpl)
|
|
rtn += pn + "\n";
|
|
rtn = rtn.TrimEnd('\n');
|
|
}
|
|
return rtn;
|
|
}
|
|
}
|
|
|
|
private List<string> dpl = new List<string>(); //C2020-036 used to create list duplicate procedure numbers
|
|
|
|
// B2017-242 added check for duplicate procedure numbers in a procedure set
|
|
// This is called before doing any of the approval
|
|
// C2020-036 return a string containing a list of duplicate procedure numbers
|
|
// this will be used in a FlexibleMessageBox when trying to run Approval
|
|
private bool DuplicateProcedureNumbers(DocVersionInfo dvi, ProcedureInfo pinfo)
|
|
{
|
|
dpl.Clear();
|
|
dvi.ResetProcedures(); // B2021-035: Approve All � Pasted, modified number and deleted procedures not refreshed so missing from list
|
|
List<string> pnList = new List<string>();
|
|
|
|
foreach (ProcedureInfo pi in dvi.Procedures)
|
|
{
|
|
if (!pnList.Contains(pi.DisplayNumber))
|
|
{
|
|
pnList.Add(pi.DisplayNumber);
|
|
}
|
|
else if (pinfo != null)
|
|
{
|
|
if (pinfo.DisplayNumber == pi.DisplayNumber)
|
|
{
|
|
// In this case, we selected to approve a specific procedure from the tree view.
|
|
// Clear the list of found duplicate proc numbers thus far and add just this one - for use in messagebox
|
|
dpl.Clear();
|
|
dpl.Add(pi.DisplayNumber);
|
|
break; // C2020-036 break out of loop and return just the specific duplicate procedure number
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// C2020-036 Append to the list of duplicate procedure numbers
|
|
// In this case we are approving All or Some procedures from tree view
|
|
if (!dpl.Contains(pi.DisplayNumber)) dpl.Add(pi.DisplayNumber);
|
|
}
|
|
}
|
|
|
|
return (dpl.Count > 0);
|
|
}
|
|
|
|
void tv_ApproveSomeProcedures(object sender, vlnTreeEventArgs args)
|
|
{
|
|
DocVersionInfo dvi = (args.Node as VETreeNode).VEObject as DocVersionInfo;
|
|
if (dvi == null) return;
|
|
|
|
// B2017-242 added check for duplicate procedure numbers in a procedure set
|
|
if (DuplicateProcedureNumbers(dvi, null))
|
|
{
|
|
// C2020-036 display list of duplicate procedure numbers
|
|
FlexibleMessageBox.Show("This procedure set has two or more procedures with the same procedure number.\n\n" +
|
|
"Please make each procedure number unique before approving.\n\n" +
|
|
"Below is a list of the duplicate procedure numbers:\n\n" + dupProcList, "Approve Some Procedures", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return;
|
|
}
|
|
|
|
tc.SaveCurrentEditItem();
|
|
|
|
string message = string.Empty;
|
|
|
|
if (!MySessionInfo.CanCheckOutItem(dvi.VersionID, CheckOutType.DocVersion, ref message))
|
|
{
|
|
MessageBox.Show(this, message, "Working Draft Has Items Already Checked Out", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return;
|
|
}
|
|
|
|
int ownerid = MySessionInfo.CheckOutItem(dvi.VersionID, CheckOutType.DocVersion);
|
|
dvi.DocVersionConfig.SelectedSlave = args.UnitIndex;
|
|
|
|
dlgApproveProcedure dlg = new dlgApproveProcedure(dvi, true, this);
|
|
dlg.MySessionInfo = MySessionInfo;
|
|
dlg.ShowDialog(this);
|
|
|
|
displayHistory.RefreshList();
|
|
MySessionInfo.CheckInItem(ownerid);
|
|
|
|
dvi.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
|
|
void tv_ApproveAllProcedures(object sender, vlnTreeEventArgs args)
|
|
{
|
|
DocVersionInfo dvi = (args.Node as VETreeNode).VEObject as DocVersionInfo;
|
|
if (dvi == null) return;
|
|
|
|
// B2017-242 added check for duplicate procedure numbers in a procedure set
|
|
if (DuplicateProcedureNumbers(dvi, null))
|
|
{
|
|
// C2020-036 display list of duplicate procedure numbers
|
|
FlexibleMessageBox.Show("This procedure set has two or more procedures with the same procedure number.\n\n" +
|
|
"Please make each procedure number unique before approving.\n\n" +
|
|
"Below is a list of the duplicate procedure numbers:\n\n" + dupProcList, "Approve All Procedures", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return;
|
|
}
|
|
|
|
tc.SaveCurrentEditItem();
|
|
|
|
string message = string.Empty;
|
|
|
|
if (!MySessionInfo.CanCheckOutItem(dvi.VersionID, CheckOutType.DocVersion, ref message))
|
|
{
|
|
MessageBox.Show(this, message, "Working Draft Has Items Already Checked Out", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return;
|
|
}
|
|
|
|
int ownerid = MySessionInfo.CheckOutItem(dvi.VersionID, CheckOutType.DocVersion);
|
|
dvi.DocVersionConfig.SelectedSlave = args.UnitIndex;
|
|
|
|
dlgApproveProcedure dlg = new dlgApproveProcedure(dvi, this);//Added frmVEPROMS Parameter
|
|
dlg.MySessionInfo = MySessionInfo;
|
|
dlg.ShowDialog(this);
|
|
|
|
displayHistory.RefreshList();
|
|
MySessionInfo.CheckInItem(ownerid);
|
|
|
|
dvi.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
|
|
void tv_RefreshCheckedOutProcedures(object sender, vlnTreeEventArgs args)
|
|
{
|
|
OwnerInfoList.Reset();
|
|
OwnerInfoList oil = OwnerInfoList.Get();
|
|
Dictionary<int, int> dicProcCheckedOut = new Dictionary<int, int>();
|
|
Dictionary<int, int> dicDocCheckedOut = new Dictionary<int, int>();
|
|
|
|
foreach (OwnerInfo oi in oil)
|
|
{
|
|
if (oi.SessionID != MySessionInfo.SessionID && oi.OwnerType == (byte)CheckOutType.Procedure)
|
|
dicProcCheckedOut.Add(oi.OwnerItemID, oi.OwnerID);
|
|
else if (oi.SessionID != MySessionInfo.SessionID && oi.OwnerType == (byte)CheckOutType.Document)
|
|
dicDocCheckedOut.Add(oi.OwnerItemID, oi.OwnerID);
|
|
}
|
|
|
|
if (args.Node.IsExpanded)
|
|
{
|
|
foreach (TreeNode tn in args.Node.Nodes)
|
|
{
|
|
// B2021-036 Added a check if node is section when processing this first foreach loop.
|
|
// The set the tree node to red text if the procedure or the section in the respected dictionary
|
|
ProcedureInfo pi = (tn as VETreeNode).VEObject as ProcedureInfo;
|
|
SectionInfo si = (tn as VETreeNode).VEObject as SectionInfo;
|
|
|
|
if ((pi != null && dicProcCheckedOut.ContainsKey(pi.ItemID)) || (si != null && !si.IsStepSection && dicDocCheckedOut.ContainsKey(si.MyContent.MyEntry.DocID)))
|
|
tn.ForeColor = Color.Red;
|
|
else
|
|
tn.ForeColor = Color.Black;
|
|
|
|
bool expanded = tn.IsExpanded;
|
|
|
|
if (!expanded)
|
|
tn.Expand();
|
|
|
|
foreach (TreeNode tnn in tn.Nodes)
|
|
{
|
|
si = (tnn as VETreeNode).VEObject as SectionInfo;
|
|
|
|
if (si != null && si.MyContent.MyEntry != null)
|
|
{
|
|
if (dicDocCheckedOut.ContainsKey(si.MyContent.MyEntry.DocID))
|
|
tnn.ForeColor = Color.Red;
|
|
else
|
|
tnn.ForeColor = Color.Black;
|
|
}
|
|
}
|
|
|
|
if (!expanded)
|
|
tn.Collapse();
|
|
}
|
|
}
|
|
}
|
|
|
|
void tv_ProcedureCheckedOutTo(object sender, vlnTreeEventArgs args)
|
|
{
|
|
ProcedureInfo pi = null;
|
|
SectionInfo si = null;
|
|
|
|
pi = (args.Node as VETreeNode).VEObject as ProcedureInfo;
|
|
if (pi == null) si = (args.Node as VETreeNode).VEObject as SectionInfo;
|
|
|
|
UserInfo ui = UserInfo.GetByUserID(MySessionInfo.UserID);
|
|
|
|
dlgCheckedOutProcedure cop = new dlgCheckedOutProcedure(pi, si, ui);
|
|
cop.ShowDialog(this);
|
|
|
|
tv_RefreshCheckedOutProcedures(sender, new vlnTreeEventArgs(args.Node.Parent, null, 0));
|
|
}
|
|
|
|
void tv_ApproveProcedure(object sender, vlnTreeEventArgs args)
|
|
{
|
|
ProcedureInfo pi = (args.Node as VETreeNode).VEObject as ProcedureInfo;
|
|
if (pi == null) return;
|
|
|
|
// B2017-242 added check for duplicate procedure numbers in a procedure set?
|
|
if (DuplicateProcedureNumbers(pi.MyDocVersion, pi))
|
|
{
|
|
// C2020-036 display list of duplicate procedure numbers
|
|
FlexibleMessageBox.Show("Procedure number " + dupProcList + " is used by two or more procedures within this procedure set.\n\n" +
|
|
"Please make each procedure number unique before approving.", "Approve Procedure", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return;
|
|
}
|
|
|
|
tc.SaveCurrentEditItem(pi);
|
|
|
|
string message = string.Empty;
|
|
|
|
if (!MySessionInfo.CanCheckOutItem(pi.ItemID, CheckOutType.Procedure, ref message))
|
|
{
|
|
message = message.Replace("\r\nWould You like to open the procedure in View Only Mode?", "");
|
|
MessageBox.Show(this, message, "Procedure Already Checked Out", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return;
|
|
}
|
|
|
|
int ownerid = MySessionInfo.CheckOutItem(pi.ItemID, 0);
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = args.UnitIndex;
|
|
|
|
dlgApproveProcedure dlg = new dlgApproveProcedure(pi, this);//Added frmVEPROMS Parameter
|
|
dlg.MySessionInfo = MySessionInfo;
|
|
dlg.ShowDialog(this);
|
|
|
|
displayHistory.RefreshList();
|
|
MySessionInfo.CheckInItem(ownerid);
|
|
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
|
|
void tv_PrintAllProcedures(object sender, vlnTreeEventArgs args)
|
|
{
|
|
DocVersionInfo dvi = (args.Node as VETreeNode).VEObject as DocVersionInfo;
|
|
if (dvi == null) return;
|
|
|
|
tc.SaveCurrentEditItem();
|
|
|
|
dvi.DocVersionConfig.SelectedSlave = args.UnitIndex;
|
|
|
|
DlgPrintProcedure prnDlg = new DlgPrintProcedure(dvi);
|
|
prnDlg.SelectedSlave = args.UnitIndex;
|
|
prnDlg.MySessionInfo = MySessionInfo;
|
|
prnDlg.ShowDialog(this); // RHM 20120925 - Center dialog over PROMS window
|
|
|
|
dvi.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
|
|
// C2025-017 print all approved procedure to a specified folder
|
|
void tv_PrintAllApprovedProcedures(object sender, vlnTreeEventArgs args)
|
|
{
|
|
using (DocVersionInfo dvi = (args.Node as VETreeNode).VEObject as DocVersionInfo)
|
|
{
|
|
if (dvi == null) return;
|
|
|
|
tc.SaveCurrentEditItem(); // save the current edit item if user happens to be editing a procedure
|
|
|
|
// add a diaglog to prompt for the path inwhich to put the approved pdfs
|
|
int currentChildSetting = dvi.DocVersionConfig.SelectedSlave;
|
|
dvi.DocVersionConfig.SelectedSlave = args.UnitIndex; // set to selected child - will be -1 for non Parent/Child
|
|
|
|
dlgPrintAllApprovedProcedures dlgPrnAllAprv = new dlgPrintAllApprovedProcedures(dvi);
|
|
dlgPrnAllAprv.ShowDialog(this);
|
|
|
|
dvi.DocVersionConfig.SelectedSlave = currentChildSetting; // set back to what it was
|
|
}
|
|
}
|
|
|
|
void tv_PrintProcedure(object sender, vlnTreeEventArgs args)
|
|
{
|
|
ProcedureInfo pi = (args.Node as VETreeNode).VEObject as ProcedureInfo;
|
|
if (pi == null) return;
|
|
|
|
tc.SaveCurrentEditItem(pi);
|
|
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = args.UnitIndex;
|
|
|
|
DlgPrintProcedure prnDlg = new DlgPrintProcedure(pi);
|
|
prnDlg.SelectedSlave = args.UnitIndex;
|
|
prnDlg.MySessionInfo = MySessionInfo;
|
|
prnDlg.ShowDialog(this); // RHM 20120925 - Center dialog over PROMS window
|
|
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
|
|
void tv_QPrintProcedure(object sender, vlnTreeEventArgs args) // Quick Print right click menu on Procedure name.
|
|
{
|
|
try
|
|
{
|
|
ProcedureInfo pi = (args.Node as VETreeNode).VEObject as ProcedureInfo;
|
|
if (pi == null) return;
|
|
|
|
tc.SaveCurrentEditItem(pi);
|
|
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = args.UnitIndex;
|
|
|
|
using (DlgPrintProcedure prnDlg = new DlgPrintProcedure(pi))
|
|
{
|
|
prnDlg.OverwritePDF = false; // turn off overwriting of PDFs B2025-041
|
|
prnDlg.SelectedSlave = args.UnitIndex;
|
|
prnDlg.MySessionInfo = MySessionInfo;
|
|
prnDlg.SetupForProcedure(); // Setup filename
|
|
prnDlg.QPCreatePDF(); // Create Print report
|
|
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.AppendLine("Could not create PDF Print");
|
|
sb.AppendLine();
|
|
MessageBox.Show(sb.ToString(), "Error when creating PDF Print", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
|
|
_MyLog.Warn("Failed to create PDF print", ex);
|
|
}
|
|
|
|
}
|
|
|
|
//Print Section
|
|
//C2025-028 Add a Quick Print Section option
|
|
|
|
void tv_PrintSection(object sender, vlnTreeEventArgs args)
|
|
{
|
|
PrintSection(sender, args, false);
|
|
}
|
|
void tv_QPrintSection(object sender, vlnTreeEventArgs args)
|
|
{
|
|
PrintSection(sender, args, true);
|
|
}
|
|
|
|
void PrintSection(object sender, vlnTreeEventArgs args, bool quickprint)
|
|
{
|
|
try
|
|
{
|
|
//args.Node.Parent.
|
|
SectionInfo si2 = (args.Node as VETreeNode).VEObject as SectionInfo;
|
|
int _prtSectID = si2.ItemID;
|
|
|
|
if (si2 == null) return;
|
|
|
|
tc.SaveCurrentEditItem(si2.MyProcedure);
|
|
|
|
//B2025-032 Fix Section not Printing Applicability Properly
|
|
si2.MyDocVersion.DocVersionConfig.SelectedSlave = args.UnitIndex;
|
|
si2.MyProcedure.MyDocVersion.DocVersionConfig.SelectedSlave = args.UnitIndex;
|
|
|
|
using (DlgPrintProcedure prnDlg = new DlgPrintProcedure(si2.MyProcedure))
|
|
{
|
|
prnDlg.PrtSectID = _prtSectID;
|
|
prnDlg.SelectedSlave = args.UnitIndex;
|
|
prnDlg.MySessionInfo = MySessionInfo;
|
|
prnDlg.SetupForProcedure(); // Setup filename
|
|
|
|
if (quickprint)
|
|
{
|
|
prnDlg.OverwritePDF = false; // turn off overwriting of PDFs B2025-051
|
|
prnDlg.QPCreatePDF(); // Create Print report
|
|
}
|
|
else
|
|
{
|
|
prnDlg.ShowDialog(this); // Create Print report
|
|
}
|
|
|
|
//B2025-032 Fix Section not Printing Applicability Properly
|
|
si2.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
|
|
si2.MyProcedure.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.AppendLine("Could not create PDF Print");
|
|
sb.AppendLine();
|
|
MessageBox.Show(sb.ToString(), "Error when creating PDF Print", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
|
|
_MyLog.Warn("Failed to create PDF print", ex);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void tv_CreateContinuousActionSummary(object sender, vlnTreeEventArgs args)
|
|
{
|
|
DialogResult dr = System.Windows.Forms.DialogResult.Yes;
|
|
|
|
ProcedureInfo pi = (args.Node as VETreeNode).VEObject as ProcedureInfo;
|
|
if (pi == null) return;
|
|
|
|
tc.SaveCurrentEditItem(pi);
|
|
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = args.UnitIndex;
|
|
|
|
DlgPrintProcedure prnDlg = new DlgPrintProcedure(pi, true);
|
|
prnDlg.MySessionInfo = MySessionInfo;
|
|
prnDlg.SelectedSlave = args.UnitIndex;
|
|
prnDlg.Automatic = true;
|
|
prnDlg.CreateContinuousActionSummary = true;
|
|
prnDlg.OpenAfterCreate = (dr == System.Windows.Forms.DialogResult.Yes);
|
|
prnDlg.Prefix = "CASTMP_"; // prefix the temporary procedure PDF file that is generated (to grab page numbers)
|
|
prnDlg.SetupForProcedure();
|
|
prnDlg.CreatePDF();
|
|
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
public static void tv_SelectAnnotations()
|
|
{
|
|
dlgAnnotationsSelect sannoDlg = new dlgAnnotationsSelect(VlnSettings.UserID);
|
|
sannoDlg.ShowDialog(); // RHM 20120925 - Center dialog over PROMS window
|
|
}
|
|
void tv_CreateTimeCriticalActionSummary(object sender, vlnTreeEventArgs args)
|
|
{
|
|
DialogResult dr = System.Windows.Forms.DialogResult.Yes;
|
|
|
|
ProcedureInfo pi = (args.Node as VETreeNode).VEObject as ProcedureInfo;
|
|
if (pi == null) return;
|
|
|
|
tc.SaveCurrentEditItem(pi);
|
|
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = args.UnitIndex;
|
|
|
|
DlgPrintProcedure prnDlg = new DlgPrintProcedure(pi, true);
|
|
prnDlg.MySessionInfo = MySessionInfo;
|
|
prnDlg.SelectedSlave = args.UnitIndex;
|
|
prnDlg.Automatic = true;
|
|
prnDlg.CreateTimeCriticalActionSummary = true;
|
|
prnDlg.OpenAfterCreate = (dr == System.Windows.Forms.DialogResult.Yes);
|
|
prnDlg.Prefix = "TCASTMP_"; // prefix the temporary procedure PDF file that is generated (to grab page numbers)
|
|
prnDlg.SetupForProcedure();
|
|
prnDlg.CreatePDF();
|
|
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
|
|
void RefreshDisplayHistory(object sender)
|
|
{
|
|
displayHistory.RefreshChangeList();
|
|
}
|
|
|
|
void displayHistory_HistorySelectionChanged(object sender, DisplayHistoryEventArgs args)
|
|
{
|
|
tc.OpenItem(ItemInfo.Get(args.ItemID));
|
|
}
|
|
|
|
void displayHistory_SummaryPrintRequest(object sender, DisplayHistoryReportEventArgs args)
|
|
{
|
|
Volian.Print.Library.PDFChronologyReport myChronoRpt = new Volian.Print.Library.PDFChronologyReport(args.ReportTitle, args.ProcedureInfo, args.AuditList, args.AnnotationList);
|
|
myChronoRpt.BuildSummary();
|
|
}
|
|
|
|
void displayHistory_ChronologyPrintRequest(object sender, DisplayHistoryReportEventArgs args)
|
|
{
|
|
Volian.Print.Library.PDFChronologyReport myChronoRpt = new Volian.Print.Library.PDFChronologyReport(args.ReportTitle, args.ProcedureInfo, args.AuditList, args.AnnotationList);
|
|
myChronoRpt.BuildChronology();
|
|
}
|
|
|
|
DialogResult tv_NodePSI(object sender, vlnTreeEventArgs args)
|
|
{
|
|
VETreeNode vNode = (VETreeNode)args.Node;
|
|
IVEDrillDownReadOnly veObj = vNode.VEObject;
|
|
ProcedureInfo myProc = veObj as ProcedureInfo;
|
|
string message = string.Empty;
|
|
|
|
if (!MySessionInfo.CanCheckOutItem(myProc.ItemID, CheckOutType.Procedure, ref message))
|
|
{
|
|
MessageBox.Show(this, message, "Item Already Checked Out", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return DialogResult.None;
|
|
}
|
|
|
|
int ownerID = MySessionInfo.CheckOutItem(myProc.ItemID, 0);
|
|
frmPSI fpsi = new frmPSI(myProc);
|
|
DialogResult dr = fpsi.ShowDialog(this);
|
|
MySessionInfo.CheckInItem(ownerID);
|
|
|
|
return dr;
|
|
}
|
|
|
|
DialogResult tv_NodeSI(object sender, vlnTreeEventArgs args)
|
|
{
|
|
VETreeNode vNode = (VETreeNode)args.Node;
|
|
IVEDrillDownReadOnly veObj = vNode.VEObject;
|
|
|
|
// see if working draft or folder & get associated 'SI' info from its config. For now, do folder.
|
|
bool doFolder = true;
|
|
FolderInfo myFolder = veObj as FolderInfo;
|
|
DocVersionInfo myDV = veObj as DocVersionInfo;
|
|
|
|
if (myFolder == null) doFolder = false;
|
|
string message = string.Empty;
|
|
|
|
if (!MySessionInfo.CanCheckOutItem(doFolder ? myFolder.FolderID : myDV.VersionID, doFolder ? CheckOutType.Folder : CheckOutType.DocVersion, ref message))
|
|
{
|
|
MessageBox.Show(this, message, "Item Already Checked Out", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return DialogResult.None;
|
|
}
|
|
|
|
string strConfig = (doFolder) ? myFolder.Config : myDV.Config;
|
|
FormatInfo fi = (doFolder) ? myFolder.ActiveFormat : myDV.ActiveFormat;
|
|
|
|
if (fi == null)
|
|
{
|
|
MessageBox.Show("You must define a format at this level before access of Specific Information");
|
|
return DialogResult.Cancel;
|
|
}
|
|
|
|
int ownerID = MySessionInfo.CheckOutItem(doFolder ? myFolder.FolderID : myDV.VersionID, doFolder ? CheckOutType.Folder : CheckOutType.DocVersion);
|
|
frmSI fsi = new frmSI(fi.PlantFormat.FormatData.SI, strConfig, doFolder, myFolder, myDV);
|
|
DialogResult dr = fsi.ShowDialog(this);
|
|
MySessionInfo.CheckInItem(ownerID);
|
|
|
|
return dr;
|
|
}
|
|
|
|
|
|
void tv_NodeInsert(object sender, vlnTreeEventArgs args)
|
|
{
|
|
// Activate tmrTreeView so that the newly created Step receives focus
|
|
tmrTreeView.Enabled = true;
|
|
}
|
|
|
|
private int _LastROFSTID = 0;
|
|
|
|
void frmVEPROMS_Activated(object sender, EventArgs e)
|
|
{
|
|
//Volian.Base.Library.vlnStackTrace.ShowStack();
|
|
|
|
if (ActiveControl == tc) tc.HideCaret();
|
|
// refresh anything that pertains to external files or programs:
|
|
|
|
// if ro.fst was 'updated' from the roeditor, enable the update ro.fst values on the stepRibbon
|
|
if (tc.ShuttingDown) return;
|
|
|
|
// B2017-202 update the RO tree in the step properties panel
|
|
// B2017-205 - displayRO.MyROFST will be null if first thing opened is a Word section so added null check
|
|
if (tc.MyBar.SelectedDockTab > -1 && displayRO.MyROFST != null)
|
|
{
|
|
DisplayTabItem myDTI = tc.MyBar.Items[tc.MyBar.SelectedDockTab] as DisplayTabItem;
|
|
|
|
if (myDTI.MyDSOTabPanel != null)
|
|
{
|
|
DSOTabPanel myDTP = myDTI.MyDSOTabPanel;
|
|
// B2023-026 needed to check for a null itemInfo
|
|
if (myDTP.MyDisplayTabItem.MyItemInfo != null)
|
|
{
|
|
if (myDTP.MyDisplayTabItem.MyItemInfo.MyDocVersion.DocVersionAssociations == null)
|
|
{
|
|
SelectedROFst = null; // B2020-071 ROs are not associated with this procedure set. Set value to null so that PROMS does not try to generate the RO tree in Step Properties.
|
|
}
|
|
else
|
|
{
|
|
SelectedROFst = myDTP.MyDisplayTabItem.MyItemInfo.MyDocVersion.DocVersionAssociations[0].MyROFst;
|
|
}
|
|
}
|
|
}
|
|
else if (tc.MyEditItem != null && displayRO.MyROFST != null && tc.MyEditItem.MyItemInfo.MyDocVersion.DocVersionAssociations[0].ROFstID != displayRO.MyROFST.ROFstID)
|
|
{
|
|
SelectedROFst = tc.MyEditItem.MyItemInfo.MyDocVersion.DocVersionAssociations[0].MyROFst;
|
|
}
|
|
|
|
// need this to update RO Tree after UpdateRofst (B2015-226)
|
|
// B2022-026 RO Memory reduction coding (Jakes Merge)
|
|
if (displayRO.MyROFST != SelectedROFst)
|
|
{
|
|
displayRO.MyROFST = SelectedROFst;
|
|
// B2023-021: force Load of Step Prop/RO panel RO tree by passing in
|
|
// true to LoadTree
|
|
displayRO.LoadTree(true);
|
|
}
|
|
}
|
|
|
|
if (SelectedStepTabPanel != null && SelectedStepTabPanel.MyStepTabRibbon != null)
|
|
SelectedStepTabPanel.MyStepTabRibbon.SetUpdRoValBtn(SelectedStepTabPanel.MyStepTabRibbon.NewerRoFst());
|
|
|
|
// C2015-022 needed when creating a separate window from a tree selection
|
|
if (selectedChildWindow != null)
|
|
{
|
|
selectedChildWindow.Focus();
|
|
selectedChildWindow = null;
|
|
}
|
|
}
|
|
|
|
// Add a tree node for a procedure if this is the first procedure in the docversion, added from
|
|
// step editor (used for creating enhanced procedure in empty docversion)
|
|
void MyStepTabRibbon_AddProcToDocVersionInTree(object sender, StepTabRibbonEventArgs args)
|
|
{
|
|
tv.AdjustTree(args.Proc as ProcedureInfo);
|
|
}
|
|
|
|
void MyStepTabRibbon_PrintRequest(object sender, StepTabRibbonEventArgs args)
|
|
{
|
|
// Fix for B2013-173:
|
|
// if the user did the print by using the shortcut keys 'Ctrl-P' the arguments sent in
|
|
// is the first opened procedure rather than the active procedure. So check for this
|
|
// and if they are not the same, use the CurrentItem from the main frmVEPROMS.
|
|
ProcedureInfo piThis = null;
|
|
if (_CurrentItem != null) piThis = _CurrentItem.MyProcedure;
|
|
ProcedureInfo pi = args.Proc as ProcedureInfo;
|
|
if (args.OringFlg == 1) // B2025-036 split screen print issue. if oringFlg == 1 the ctrl-p keys was pressed.
|
|
{
|
|
if (piThis != null && pi.ItemID != piThis.ItemID) pi = piThis;
|
|
}
|
|
|
|
// Check if Procedure Info is null
|
|
if (pi == null) return;
|
|
|
|
|
|
//added by jcb 20130718 to support create pdf button when multi-unit and user selects a unit
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = pi.ProcedureConfig.SelectedSlave;
|
|
try
|
|
{
|
|
using (DlgPrintProcedure prnDlg = new DlgPrintProcedure(pi))
|
|
{
|
|
prnDlg.SelectedSlave = pi.ProcedureConfig.SelectedSlave == 0 ? -1 : pi.ProcedureConfig.SelectedSlave; //added by jcb 20130718 to support create pdf button when multi-unit and user selects a unit
|
|
prnDlg.MySessionInfo = MySessionInfo;
|
|
prnDlg.ShowDialog(this); // RHM 20120925 - Center dialog over PROMS window
|
|
|
|
//added by jcb 20130718 to support create pdf button when multi-unit and user selects a unit
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.AppendLine("Could not create PDF Print");
|
|
sb.AppendLine();
|
|
MessageBox.Show(sb.ToString(), "Error when creating PDF Print", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
|
|
_MyLog.Warn("Failed to create PDF print", ex);
|
|
}
|
|
}
|
|
|
|
void MyStepTabRibbon_QPrintRequest(object sender, StepTabRibbonEventArgs args)
|
|
{
|
|
// Fix for B2013-173:
|
|
// if the user did the print by using the shortcut keys 'Ctrl-P' the arguments sent in
|
|
// is the first opened procedure rather than the active procedure. So check for this
|
|
// and if they are not the same, use the CurrentItem from the main frmVEPROMS.
|
|
ProcedureInfo piThis = null;
|
|
if (_CurrentItem != null) piThis = _CurrentItem.MyProcedure;
|
|
|
|
ProcedureInfo pi = args.Proc as ProcedureInfo;
|
|
|
|
if (args.OringFlg == 1) // B2025-036 split screen print issue. if oringFlg == 1 the ctrl-p keys was pressed.
|
|
{
|
|
if (piThis != null && pi.ItemID != piThis.ItemID) pi = piThis;
|
|
}
|
|
// Check if Procedure Info is null
|
|
if (pi == null) return;
|
|
|
|
|
|
//added by jcb 20130718 to support create pdf button when multi-unit and user selects a unit
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = pi.ProcedureConfig.SelectedSlave;
|
|
|
|
|
|
try
|
|
{
|
|
using (DlgPrintProcedure prnDlg = new DlgPrintProcedure(pi))
|
|
{
|
|
prnDlg.OverwritePDF = false; // turn off overwriting of PDFs C2025-048.
|
|
prnDlg.SelectedSlave = pi.ProcedureConfig.SelectedSlave == 0 ? -1 : pi.ProcedureConfig.SelectedSlave; //added by jcb 20130718 to support create pdf button when multi-unit and user selects a unit
|
|
prnDlg.MySessionInfo = MySessionInfo;
|
|
prnDlg.SetupForProcedure(); // Setup filename
|
|
//prnDlg.ShowDialog(this); // RHM 20120925 - Center dialog over PROMS window
|
|
prnDlg.QPCreatePDF(); // Create Print report
|
|
|
|
//added by jcb 20130718 to support create pdf button when multi-unit and user selects a unit
|
|
pi.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.AppendLine("Could not create PDF Print");
|
|
sb.AppendLine();
|
|
MessageBox.Show(sb.ToString(), "Error when creating PDF Print", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
|
|
_MyLog.Warn("Failed to create PDF print", ex);
|
|
}
|
|
|
|
}
|
|
|
|
void displaySearch1_PrintRequest(object sender, DisplaySearchEventArgs args)
|
|
{
|
|
// C2020-002 paper size is now set in the format files - default is Letter, pass this PDFReport
|
|
//C2019-013 pass in sorted by information
|
|
Volian.Print.Library.PDFReport myReport = new Volian.Print.Library.PDFReport(args.ReportTitle, args.TypesSelected, args.MyItemInfoList,
|
|
Volian.Base.Library.VlnSettings.TemporaryFolder + @"\searchresults.pdf", args.PaperSize, args.SortedBy);
|
|
|
|
if (args.SearchString != null)
|
|
myReport.SearchString = args.SearchString;
|
|
|
|
if (!args.ReportTitle.Contains("Annotation"))
|
|
{
|
|
int annotationCount = 0;
|
|
|
|
foreach (ItemInfo itm in args.MyItemInfoList)
|
|
annotationCount += itm.ItemAnnotationCount;
|
|
|
|
if (annotationCount > 0)
|
|
myReport.ShowAnnotations = (MessageBox.Show("Show Annotations", "Include Annotations", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == System.Windows.Forms.DialogResult.Yes);
|
|
}
|
|
|
|
myReport.Build();
|
|
}
|
|
|
|
void displayLibDocs_PrintRequest(object sender, DisplayLibDocEventArgs args)
|
|
{
|
|
Volian.Print.Library.PDFReport myReport = new Volian.Print.Library.PDFReport(args.ReportTitle, args.LibDocList, Volian.Base.Library.VlnSettings.TemporaryFolder + @"\LibDocUsage.pdf", args.PaperSize);
|
|
myReport.Build();
|
|
}
|
|
|
|
void displayReports_PrintRequest(object sender, DisplayReportsEventArgs args)
|
|
{
|
|
// C2020-002 paper size is now set in the format files - default is Letter, pass this PDFReport
|
|
if (args.TypesSelected == "RO Usage")
|
|
{
|
|
Volian.Print.Library.PDFReport myReport = new Volian.Print.Library.PDFReport(args.ReportTitle, args.MyItemInfoList, Volian.Base.Library.VlnSettings.TemporaryFolder + @"\ROUsageReport.pdf", args.SortUsageByProcedure, args.IncludeMissingROs, args.PaperSize);
|
|
myReport.Build();
|
|
}
|
|
else if (args.TypesSelected == "Complete RO Report")
|
|
{
|
|
Volian.Print.Library.PDFReport myReport = new Volian.Print.Library.PDFReport(args.ReportTitle, args.RODataFile, Volian.Base.Library.VlnSettings.TemporaryFolder + @"\CompleteROReport.pdf", args.RofstLookup, args.CompleteROReport, args.ConvertCaretToDelta, args.IncludeEmptyROFields, args.PaperSize);
|
|
myReport.Build();
|
|
}
|
|
else if (args.TypesSelected == "RO Summary Report")
|
|
{
|
|
Volian.Print.Library.PDFReport myReport = new Volian.Print.Library.PDFReport(args.ReportTitle, Volian.Base.Library.VlnSettings.TemporaryFolder + @"\ROSummaryReport.pdf", args.RofstLookup, args.ROListForReport, args.PaperSize);
|
|
myReport.Build();
|
|
}
|
|
}
|
|
|
|
bool tv_InsertItemInfo(object sender, vlnTreeItemInfoInsertEventArgs args)
|
|
{
|
|
// Don't select the newly created Step. This will be handled by tmrTreeView
|
|
return tc.InsertRTBItem(args.MyItemInfo, args.StepText, args.InsertType, args.FromType, args.Type, false);
|
|
}
|
|
|
|
private bool tv_DeleteItemInfo(object sender, vlnTreeItemInfoEventArgs args)
|
|
{
|
|
if (displayHistory.MyEditItem != null && displayHistory.MyItemInfo.MyProcedure.ItemID == args.MyItemInfo.ItemID)
|
|
displayHistory.MyEditItem = null;
|
|
|
|
// bug fix B2016-005 - set MyCopyStep to null. This will take the paste options off of the tree node context menus. jsj 4-19-2016
|
|
// B2016-105 - added null reference check -jsj
|
|
if (tc.MyCopyStep != null && args.MyItemInfo.ItemID == tc.MyCopyStep.ItemID)
|
|
{
|
|
tc.MyCopyStep = null;
|
|
tc_CopyStepSelected(sender, null); // C2015-022 update copystep info in the child windows
|
|
}
|
|
|
|
bool rtval = tc.DeleteRTBItem(args.MyItemInfo);
|
|
|
|
// Also disable the paste options on the ribbon if it is open. jsj 4-19-2016
|
|
if (tc.SelectedDisplayTabItem != null && tc.SelectedDisplayTabItem.MyStepTabPanel != null) // MyStepTabPanel will be null if the active tab is a Word Attachment
|
|
{
|
|
StepPanel pnl = tc.SelectedDisplayTabItem.MyStepTabPanel.MyStepPanel;
|
|
// B2022-109: crash when deleting a copy of pasted procedure - check for nulls
|
|
if (pnl != null && pnl.MyStepTabPanel != null && pnl.MyStepTabPanel.MyStepTabRibbon != null) pnl.MyStepTabPanel.MyStepTabRibbon.SetPasteButtons(false);
|
|
}
|
|
|
|
return rtval;
|
|
}
|
|
|
|
private bool tv_PasteItemInfo(object sender, vlnTreeItemInfoPasteEventArgs args)
|
|
{
|
|
return tc.PasteRTBItem(args.MyItemInfo, args.CopyStartID, args.PasteType, (int)args.Type);
|
|
}
|
|
|
|
private ItemInfo tv_SearchIncTrans(object sender, vlnTreeItemInfoEventArgs args)
|
|
{
|
|
// C2020-033: Display the search panel with Incoming Transition info for the tree view and for the editor.
|
|
displaySearch1.SearchIncTransII = args.MyItemInfo;
|
|
toolsPanel.Expanded = true;
|
|
displaySearch1.UpdateSearchIncTransResults();
|
|
|
|
return args.MyItemInfo;
|
|
}
|
|
|
|
private ItemInfo tc_SearchIncTrans(object sender, vlnTreeItemInfoEventArgs args)
|
|
{
|
|
displaySearch1.SearchIncTransII = args.MyItemInfo;
|
|
toolsPanel.Expanded = true;
|
|
displaySearch1.UpdateSearchIncTransResults();
|
|
|
|
return args.MyItemInfo;
|
|
}
|
|
|
|
private bool _RemoveFromPROMSWindowForms = true;
|
|
public bool ClosingWithError = false; // B2019-098: prevent looping between error & exit dialog
|
|
private bool _WeAreExitingPROMS = false; // B2019-101 if exiting PROMS from main window don't prompt on each child window (separate windows)
|
|
|
|
private void frmVEPROMS_FormClosing(object sender, FormClosingEventArgs e)
|
|
{
|
|
// B2017-212 If the user uses the X button in Word to close the word attachment, PROMS thinks that the user wants to close out of PROMS as well
|
|
// trap for this and close only the Word tab in PROMS
|
|
// B2017-214 added a null reference check
|
|
// B2010-071 Since we cannot tell if the user click on the X in Word or the X in PROMS, ask if the current tab
|
|
// should be closed or if we should exit PROMS or just Cancel to continue working
|
|
if (tc._MyDisplayTabItems.Count < 1) // If all thabs are closed in the editor will indicate that in the database.
|
|
{
|
|
VEPROMS.CSLA.Library.Item.DeactivateStateDisplayTabTmp(MySessionInfo.UserID);
|
|
}
|
|
if (!_WeAreExitingPROMS && !ClosingWithError && tc.SelectedDisplayTabItem != null && tc._MyDisplayTabItems.Count > 0)
|
|
{
|
|
// B2019-071 dialog to ask user if we are to close one tab or exit
|
|
DlgCloseTabsOrExit dctoe = new DlgCloseTabsOrExit(MyParent == null, PROMSWindowForms.Count > 0);
|
|
dctoe.ShowDialog();
|
|
|
|
// B2019-101 flag that we are exiting from PROMS main window (separate windows)
|
|
_WeAreExitingPROMS = (MyParent == null && dctoe.ExitPROMS);
|
|
|
|
if (dctoe.Cancel) // B2019-071 user decided to not close any tab and not exit PROMS - so do nothing and continue working
|
|
{
|
|
e.Cancel = true;
|
|
dctoe.Close();
|
|
return;
|
|
}
|
|
|
|
string stk = Volian.Base.Library.vlnStackTrace.StackToString();
|
|
|
|
if (!stk.Contains("Exception"))
|
|
{
|
|
// B2018-091 Allow PROMS to close if only MSWord sections have been opened.
|
|
// B2019-071 we will now close one or all of the tabs (even step editor ones)
|
|
if (_WeAreExitingPROMS)
|
|
{
|
|
string DisplayTabID = "";
|
|
int pos;
|
|
int TabItemID;
|
|
string DisplayTabName = "";
|
|
int cnt = 0;
|
|
// Deactivate previous procedure tab state by user
|
|
VEPROMS.CSLA.Library.Item.DeactivateStateDisplayTabTmp(MySessionInfo.UserID);
|
|
// Save current procedure tab state
|
|
|
|
//B2024-082 Remember Tabs Not opening in correct order
|
|
foreach (DisplayTabItem dti in tc.MyBar.Items)
|
|
{
|
|
cnt++;
|
|
DisplayTabID = dti.MyKey;
|
|
TabItemID = dti.MyItemInfo.ItemID;
|
|
DisplayTabName = dti.ToString();
|
|
Item.AddDisplayTabsState(TabItemID, DisplayTabID, DisplayTabName, MySessionInfo.UserID, cnt);
|
|
}
|
|
}
|
|
|
|
int n = tc._MyDisplayTabItems.Count;
|
|
|
|
while (n-- > 0 && tc._MyDisplayTabItems.Count > 0)
|
|
{
|
|
|
|
tc.CloseTabItem(tc.SelectedDisplayTabItem);
|
|
|
|
// B2019-071 close just the current tab and continue working
|
|
if (!dctoe.ExitPROMS)
|
|
{
|
|
n = 0;
|
|
e.Cancel = true;
|
|
dctoe.Close();
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (tc.SelectedDisplayTabItem != null && tc._MyDisplayTabItems.Count > 0 && dctoe.ExitPROMS)
|
|
{
|
|
_MyLog.WarnFormat(string.Format("Stack Does not contain an Exception\r\n" +
|
|
"PROMS will Not Exit. Stack : \r\n{0}", stk));
|
|
e.Cancel = true; // If Display Items still exist don't close.
|
|
}
|
|
|
|
dctoe.Close();
|
|
}
|
|
}
|
|
|
|
//C2015-022 Separate Windows - if child windows are open and we are closing the main PROMS window, give user a chance to not close PROMS and that child windows
|
|
// B2019-101 if we are exiting from PROMS main window no need to prompt user about child windows.
|
|
if (MyParent == null && PROMSWindowForms != null && PROMSWindowForms.Count > 0 && !_WeAreExitingPROMS)
|
|
{
|
|
DialogResult dr = MessageBox.Show("Close all of the child windows and exit PROMS?", "Exit PROMS", MessageBoxButtons.YesNo);
|
|
if (dr == System.Windows.Forms.DialogResult.No)
|
|
{
|
|
e.Cancel = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// This keeps PROMS from Hanging under certain circumstances
|
|
tc.ShuttingDown = true;
|
|
|
|
// B2019-161 When shutting down output the timing information (to the error log)
|
|
if (VolianTimer.TimingsOn)
|
|
VolianTimer.ShowTimers();
|
|
|
|
foreach (DisplayTabItem dti in tc.MyBar.Items)
|
|
{
|
|
if (dti.MyDSOTabPanel != null)
|
|
dti.MyDSOTabPanel.CloseDSO();
|
|
else
|
|
MySessionInfo.CheckInItem(dti.OwnerID); //C2015-022 Separate Windows closing child form only left procedure ownership active
|
|
}
|
|
|
|
|
|
if (MyParent == null)
|
|
{
|
|
if (MyActivityTimer != null)
|
|
{
|
|
MyActivityTimer.Dispose();
|
|
_MyLog.Debug("VEPROMS FormClosing - dispose timer");
|
|
}
|
|
|
|
// C2015-022: part of separate windows upgrade close all of the child windows before closing the main PROMS window
|
|
if (PROMSWindowForms != null && PROMSWindowForms.Count > 0)
|
|
{
|
|
foreach (int k in PROMSWindowForms.Keys)
|
|
{
|
|
frmVEPROMS child = PROMSWindowForms[k];
|
|
_RemoveFromPROMSWindowForms = false;
|
|
child._RemoveFromPROMSWindowForms = false;
|
|
child._WeAreExitingPROMS = _WeAreExitingPROMS;
|
|
child.Close();
|
|
child.MySessionInfo.EndSession();
|
|
}
|
|
}
|
|
|
|
if (MySessionInfo != null) MySessionInfo.EndSession();
|
|
|
|
// Save the location and size of the VE-PROMS application for this user
|
|
if (this.WindowState == FormWindowState.Normal)
|
|
{
|
|
Settings.Default.Location = this.Location;
|
|
Settings.Default.Size = this.Size;
|
|
}
|
|
|
|
if (this.MyVersionWindowList != null)
|
|
{
|
|
Settings.Default.VersionWindows = this.MyVersionWindowList.ToSettings();
|
|
}
|
|
|
|
Settings.Default.WindowState = this.WindowState;
|
|
Settings.Default.QATItems = ribbonControl1.QatLayout;
|
|
|
|
SaveMRU();
|
|
|
|
//Settings.Default.Save();
|
|
Volian.Base.Library.DebugPagination.Close();
|
|
Volian.Base.Library.DebugText.Close();
|
|
Volian.Base.Library.BaselineMetaFile.Close(); // C2018-004 create meta file for baseline compares
|
|
}
|
|
}
|
|
|
|
void frmVEPROMS_FormClosed(object sender, System.Windows.Forms.FormClosedEventArgs e)
|
|
{
|
|
// Close any open documents
|
|
tc.Dispose();
|
|
|
|
// RHM 20121010
|
|
// Something was causing the process to remain in memory for an extended period of time
|
|
// after printing procedures. The following lines kills the process immediately.
|
|
if (MyParent == null)
|
|
{
|
|
try
|
|
{
|
|
System.Diagnostics.Process.GetCurrentProcess().Kill();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_MyLog.Warn("Attempting to Close", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get the "Procedures" Panel Heading (title).
|
|
// by default the heading is "Procedures" (handled in the getting from the config)
|
|
// the heading is stored in the "title" field of the folder config.
|
|
// we currently only use the "title" field for the top (VEPROMS) tree node.
|
|
private string getProcedurePanelHeading()
|
|
{
|
|
VETreeNode jj_vetn = (VETreeNode)tv.Nodes[0]; // the VEPROMS tree node
|
|
|
|
if (!PROMSWindowForms.ContainsKey(tc.VersionID)) //C2018-029 check if we are in a child window
|
|
return ((FolderConfig)jj_vetn.VEObject.MyConfig).Title; // get the panel heading
|
|
else
|
|
return jj_vetn.Text; // C2018-029 return the child window's procedure set name
|
|
}
|
|
|
|
private int getTimeout()
|
|
{
|
|
VETreeNode jj_vetn = (VETreeNode)tv.Nodes[0]; // the VEPROMS tree node
|
|
string s = ((FolderConfig)jj_vetn.VEObject.MyConfig).Timeout; // get the panel heading
|
|
int result = 30;
|
|
if (!int.TryParse(s, out result))
|
|
result = 30;
|
|
return result;
|
|
}
|
|
|
|
private Timer _RefreshTimer;
|
|
|
|
public Timer RefreshTimer
|
|
{
|
|
get
|
|
{
|
|
if (_RefreshTimer == null)
|
|
{
|
|
_RefreshTimer = new Timer();
|
|
_RefreshTimer.Interval = 20000; //
|
|
_RefreshTimer.Enabled = true;
|
|
_RefreshTimer.Tick += _RefreshTimer_Tick;
|
|
}
|
|
return _RefreshTimer;
|
|
}
|
|
}
|
|
|
|
private bool _RefreshTimerActive = false;
|
|
|
|
// B2019-161 When tracking timing time this action
|
|
private static VolianTimer _TimeActivity = new VolianTimer("frmVEPROMS.cs _RefreshTimer_Tick", 1346);
|
|
|
|
public bool RefreshTimerActive
|
|
{
|
|
get { return _RefreshTimerActive; }
|
|
set { _RefreshTimerActive = value; }
|
|
}
|
|
|
|
void _RefreshTimer_Tick(object sender, EventArgs e)
|
|
{
|
|
if (RefreshTimerActive)
|
|
{
|
|
RefreshTimerActive = false;
|
|
|
|
_TimeActivity.Open();
|
|
if (PauseRefresh) return;
|
|
RefreshChanged(this);
|
|
_TimeActivity.Close();
|
|
}
|
|
}
|
|
|
|
private void btnStepRTF_Click(object sender, System.EventArgs e)
|
|
{
|
|
// Only simulate Threaded Timer Ping if in the debugger
|
|
if (System.Diagnostics.Process.GetCurrentProcess().ProcessName.ToLower().EndsWith("vshost"))
|
|
{
|
|
PingSession(null);
|
|
StartRefreshChanged(null);
|
|
}
|
|
}
|
|
|
|
private SessionInfo _MySessionInfo;
|
|
public SessionInfo MySessionInfo
|
|
{
|
|
get
|
|
{
|
|
if (_MySessionInfo == null && MyParent != null)// B2017-152 Don't crash if MySessionInfo is null
|
|
_MySessionInfo = MyParent.MySessionInfo;
|
|
return _MySessionInfo;
|
|
}
|
|
set { _MySessionInfo = value; }
|
|
}
|
|
|
|
private System.Threading.Timer MyActivityTimer;
|
|
//private System.Threading.Timer MyRefreshTimer;
|
|
private DevComponents.DotNetBar.ButtonItem btnManageSecurity;
|
|
private DevComponents.DotNetBar.ButtonItem btnResetSecurity;
|
|
private DevComponents.DotNetBar.ButtonItem btnAdministrativeTools;
|
|
private DevComponents.DotNetBar.ButtonItem btnSecurity;
|
|
private DevComponents.DotNetBar.ButtonItem btnFormats;
|
|
|
|
private DevComponents.DotNetBar.ButtonItem btnGeneralTools;
|
|
|
|
private TabItemsToClose _MyCloseTabList = new TabItemsToClose();
|
|
|
|
public TabItemsToClose MyCloseTabList
|
|
{
|
|
get { return _MyCloseTabList; }
|
|
}
|
|
|
|
private bool _DisablePing = false;
|
|
public bool DisablePing
|
|
{
|
|
get { return _DisablePing; }
|
|
set
|
|
{
|
|
_DisablePing = value;
|
|
//_MyLog.WarnFormat("DisableSessionPing = {0}", value);
|
|
}
|
|
}
|
|
|
|
private void PingSession(Object obj)
|
|
{
|
|
MySemaphore.WaitOne();
|
|
|
|
if (!DisablePing)// If Ping is disabled don't do ping - This was causing a deadlock during import
|
|
{
|
|
List<int> myList = MySessionInfo.PingSession();
|
|
|
|
// B2017-247 Error Handler for Ping Session
|
|
if (myList != null)
|
|
{
|
|
foreach (DisplayTabItem dti in tc.MyBar.Items)
|
|
{
|
|
//C2019-036 View Only mode work with Checked Out Procedures
|
|
// View Only Mode is no longer checked out, so no longer has an OwnerID
|
|
// This will keep those tabs from auto-closing based on the timer
|
|
if (!myList.Contains(dti.OwnerID) && dti.MyStepTabPanel.MyStepPanel.VwMode != E_ViewMode.View)
|
|
{
|
|
MyCloseTabList.PushDTI(dti);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
MySemaphore.Release();
|
|
}
|
|
|
|
WindowsFormsSynchronizationContext mUIContext = new WindowsFormsSynchronizationContext();
|
|
|
|
public void MyFindNodeAndExpand(object obj)
|
|
{
|
|
if (tv == null || tv.SelectedNode == null) return;
|
|
|
|
IVEDrillDownReadOnly veObj1 = ((tv.SelectedNode as VETreeNode).VEObject as IVEDrillDownReadOnly);
|
|
int id = (int)obj;
|
|
ItemInfo ii = ItemInfo.Get(id);
|
|
ii.ResetParts();
|
|
|
|
using (Item i = Item.Get(id))
|
|
{
|
|
ItemInfo.Refresh(i);
|
|
}
|
|
|
|
tv.RefreshRelatedNode(ii);
|
|
IVEDrillDownReadOnly veObj2 = ((tv.SelectedNode as VETreeNode).VEObject as IVEDrillDownReadOnly);
|
|
|
|
if (veObj1.ToString() != veObj2.ToString())
|
|
{
|
|
VETreeNode tnNew = null;
|
|
|
|
foreach (VETreeNode tn in tv.SelectedNode.Nodes)
|
|
{
|
|
if (tn.VEObject.ToString() == veObj1.ToString())
|
|
tnNew = tn;
|
|
}
|
|
|
|
if (tnNew != null) tv.SelectedNode = tnNew;
|
|
}
|
|
|
|
MySemaphore.Release(); // ping session control
|
|
}
|
|
|
|
private void StartRefreshChanged(Object obj)
|
|
{
|
|
//_MyLog.Debug("StartRefreshChanged");
|
|
//if (SkipRefresh) return;
|
|
MySemaphore.WaitOne();
|
|
RefreshTimerActive = !PauseRefresh;
|
|
MySemaphore.Release();
|
|
}
|
|
|
|
private void RefreshChanged(Object obj)
|
|
{
|
|
//if (SkipRefresh) return;
|
|
//MySemaphore.WaitOne();
|
|
Int64 lastChanged = 0;
|
|
|
|
//_MyLog.WarnFormat(">>> RefreshChanged");
|
|
try
|
|
{
|
|
//Int64 lastChanged = 0;
|
|
// B2017-247 Error Handler for Ping Session
|
|
if (MySessionInfo.ChangedItems != null && MySessionInfo.ChangedItems.Count > 0)
|
|
{
|
|
foreach (int id in MySessionInfo.ChangedItems.Keys)
|
|
{
|
|
if (ItemInfo.IsInCache(id))
|
|
{
|
|
MyFindNodeAndExpand(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
// B2017-247 Error Handler for Ping Session
|
|
if (MySessionInfo.ChangedContents != null && MySessionInfo.ChangedContents.Count > 0)
|
|
{
|
|
foreach (int id in MySessionInfo.ChangedContents.Keys)
|
|
{
|
|
if (ContentInfo.IsInCache(id))
|
|
{
|
|
ContentInfo ci = ContentInfo.Get(id);
|
|
|
|
if (MySessionInfo.LastContentChange >= ci.LastChangedInt64)
|
|
{
|
|
using (Content c = Content.Get(id))
|
|
{
|
|
ContentInfo.Refresh(c);
|
|
}
|
|
}
|
|
}
|
|
|
|
lastChanged = MySessionInfo.ChangedContents[id];
|
|
}
|
|
}
|
|
|
|
MySessionInfo.ChangedItems.Clear();
|
|
MySessionInfo.ChangedContents.Clear();
|
|
|
|
if (lastChanged > 0)
|
|
{
|
|
MySessionInfo.LastContentChange = lastChanged;
|
|
RefreshLastChange();
|
|
}
|
|
}
|
|
catch { }
|
|
|
|
//MySemaphore.Release();
|
|
//_MyLog.DebugFormat("{0},{1:X},{2:X},{3:X}", DateTime.Now.ToLongTimeString(), lastChanged, MySessionInfo.LastContentChange, MySessionInfo.LastChangedInt64);
|
|
}
|
|
|
|
private int TotalCount(TreeNodeCollection tns)
|
|
{
|
|
int total = tns.Count;
|
|
|
|
foreach (TreeNode tn in tns)
|
|
{
|
|
total += TotalCount(tn.Nodes);
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
private bool ByteArrayIsEmpty(byte[] myArray)
|
|
{
|
|
for (int i = 0; i < myArray.Length; i++)
|
|
{
|
|
if (myArray[i] != 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public UserInfo MyUserInfo = null;
|
|
public static UserInfo SMyUserInfo = null; // C2021-010: Remove trailing returns/spaces & manual page breaks & allow save.
|
|
public VersionWindowList MyVersionWindowList;
|
|
public ContentInfo ci1;
|
|
public ContentInfo ci2;
|
|
public ContentInfo ci3;
|
|
public Timer tmrCloseTabItems;
|
|
public System.Threading.Semaphore MySemaphore = new System.Threading.Semaphore(1, 1);
|
|
private bool _frmVEPROMSloading = false;
|
|
|
|
private void frmVEPROMS_Load(object sender, EventArgs e)
|
|
{
|
|
// B2019-116 Use Volian.Base.Library.VlnItextFont
|
|
// This is a generic class for dealing with iTextSharp Fonts
|
|
// Code moved and consolidated from Volian.Print.Library, Volian PDF.Library and VG
|
|
Volian.Base.Library.VlnItextFont.RegisterPromsFonts();
|
|
InitializeSecurity();
|
|
UpdateUser();
|
|
|
|
btnSecurity = new ButtonItem("btnSecurity", "Security"); // C2019-002: move security & format items into submenus
|
|
btnFormats = new ButtonItem("btnFormats", "Formats");
|
|
btnAdmin.SubItems.Add(btnSecurity);
|
|
// btnAdmin.SubItems.Add(btnFormats); // C2024 - 041 remove from Admin(V button) menu
|
|
btnAdmin.SubItems.Add(btnUpdateFormats); // C2024 - 041 remove from Admin(V button) menu
|
|
btnManageSecurity = new ButtonItem("btnManageSecurity", "Manage Security");
|
|
btnSecurity.SubItems.Add(btnManageSecurity);
|
|
btnManageSecurity.Click += new EventHandler(btnManageSecurity_Click);
|
|
|
|
//added by jcb: menu item to reset security requires password to implement
|
|
btnResetSecurity = new ButtonItem("btnResetSecurity", "Reset Security");
|
|
btnSecurity.SubItems.Add(btnResetSecurity);
|
|
btnResetSecurity.Click += new EventHandler(btnResetSecurity_Click);
|
|
|
|
//batch refresh transitions
|
|
btnAdministrativeTools = new ButtonItem("btnAdministrativeTools", "Administrative Tools");
|
|
btnAdministrativeTools.Click += new EventHandler(btnAdministrativeTools_Click);
|
|
btnAdmin.SubItems.Add(btnAdministrativeTools);
|
|
|
|
//general Tools
|
|
btnGeneralTools = new ButtonItem("btnGeneralTools", "General Tools");
|
|
btnGeneralTools.Visible = btnGeneralTools.Enabled = true;
|
|
btnGeneralTools.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.ImageAndText;
|
|
btnGeneralTools.CanCustomize = false;
|
|
btnGeneralTools.Image = global::VEPROMS.Properties.Resources.toolbox;
|
|
btnGeneralTools.Click += new EventHandler(btnGeneralTools_Click);
|
|
itemContainer3.SubItems.Add(btnGeneralTools);
|
|
|
|
|
|
// C2025-031 added tool tip messages
|
|
this.superTooltip1.SetSuperTooltip(btnManageSecurity, new SuperTooltipInfo("Manage Security", "", "Add, Modify, and Delete PROMS User Access", null, null, eTooltipColor.Gray));
|
|
this.superTooltip1.SetSuperTooltip(btnResetSecurity, new SuperTooltipInfo("Reset Security", "", "WARNING this will \nREMOVE ALL PROMS USERS and Reset to the\nOriginal Volian Defaults", null, null, eTooltipColor.Gray));
|
|
this.superTooltip1.SetSuperTooltip(btnAdministrativeTools, new SuperTooltipInfo("Administrative Tools", "", "Open the PROMS Adminstration Tools Window", null, null, eTooltipColor.Gray));
|
|
this.superTooltip1.SetSuperTooltip(btnUpdateFormats, new SuperTooltipInfo("Update Formats", "", "Install New Formats \n or Re-Install Formats", null, null, eTooltipColor.Gray));
|
|
this.superTooltip1.SetSuperTooltip(btnGeneralTools, new SuperTooltipInfo("General Tools", "", "Open the PROMS General Tools Window", null, null, eTooltipColor.Gray));
|
|
|
|
try
|
|
{
|
|
MyUserInfo = UserInfo.GetByUserID(VlnSettings.UserID);
|
|
SMyUserInfo = MyUserInfo;
|
|
}
|
|
catch
|
|
{
|
|
MessageBox.Show("This database is not compatible with this version of PROMS. The PROMS program will terminate. Please contact Volian to assist in resolution.");
|
|
Application.Exit();
|
|
}
|
|
|
|
if (MyUserInfo == null)
|
|
{
|
|
User u = User.MakeUser(VlnSettings.UserID, "", "", "", "", "", "", "", "", "", "", DateTime.Now, VlnSettings.UserID);
|
|
Group g = Group.Get(securityRole);
|
|
Membership.MakeMembership(u, g, null, "");
|
|
MyUserInfo = UserInfo.Get(u.UID);
|
|
SMyUserInfo = MyUserInfo;
|
|
}
|
|
|
|
ctrlAnnotationDetails.MyUserInfo = MyUserInfo;
|
|
// re-set to old RTF initialization to older RFT string
|
|
ctrlAnnotationDetails.AnnotationRTFText= "{\\rtf1\\ansi\\ansicpg1252\\deff0\\deflang1033{\\fonttbl{\\f0\\fnil\\fcharset0 Microsoft Sans Serif;}}\r\n\\viewkind4\\uc1\\pard\\f0\\fs20\\par\r\n}\r\n";
|
|
|
|
DisplayRO.MyUserInfo = MyUserInfo; // set the user's security information in the properties RO panel
|
|
StepTabRibbon.MyUserInfo = MyUserInfo; // set the user's security information in the ribbon
|
|
DisplayTransition.MyUserInfo = MyUserInfo; // set the user's security information in the Transition panel
|
|
DisplayTags.MyUserInfo = MyUserInfo; // set the user's security information in the Tags panel
|
|
DisplaySearch.MyUserInfo = MyUserInfo; // set the user's security information in the Search panel
|
|
DisplayHistory.MyUserInfo = MyUserInfo; // set the user's security information in the History panel
|
|
DisplayApplicability.MyUserInfo = MyUserInfo; // set the user's security information in the Applicability panel
|
|
StepRTB.MyUserInfo = MyUserInfo; // set the user's security information in the StepRTB
|
|
VlnFlexGrid.MyUserInfo = MyUserInfo; // set the user's security information in the VlnFlexGrid
|
|
|
|
bool isVisible = MyUserInfo.IsAdministrator();
|
|
|
|
btnManageSecurity.Visible = isVisible;
|
|
btnUpdateFormats.Visible = isVisible;
|
|
btnResetSecurity.Visible = isVisible;
|
|
btnAdministrativeTools.Visible = (isVisible || HasSetAdministrator(MyUserInfo));
|
|
|
|
// C2020-034 hide the Formats and Security buttons if user is a Set Administrator
|
|
// if use is not an Administrator or Set Administrator then disable the Administrator button
|
|
btnFormats.Visible = isVisible;
|
|
btnSecurity.Visible = isVisible;
|
|
btnAdmin.Enabled = (isVisible || HasSetAdministrator(MyUserInfo));
|
|
|
|
tmrCloseTabItems = new Timer();
|
|
tmrCloseTabItems.Interval = 100;
|
|
tmrCloseTabItems.Tick += new EventHandler(tmrCloseTabItems_Tick);
|
|
tmrCloseTabItems.Enabled = true;
|
|
|
|
CloseSessionsNoLongerActive();
|
|
MySessionInfo = SessionInfo.BeginSession(Environment.MachineName, System.Diagnostics.Process.GetCurrentProcess().Id);
|
|
|
|
if (MySessionInfo == null)
|
|
{
|
|
MessageBox.Show("This database is locked by the Administrator. Please try again later", "PROMS is Locked");
|
|
Application.Exit();
|
|
}
|
|
|
|
this.LastContentChange = MySessionInfo.LastContentChange;
|
|
|
|
//_MyLog.WarnFormat("Original last content change {0}", this.LastContentChange);
|
|
RefreshLastChange();
|
|
tc.MySessionInfo = MySessionInfo;
|
|
tv.MySessionInfo = MySessionInfo;
|
|
tv.MyUserInfo = MyUserInfo;
|
|
StepTabRibbon.MySessionInfo = MySessionInfo;
|
|
|
|
// Initialize Caption with Server name and Database name.
|
|
SetCaption(tv.TopNode as VETreeNode);
|
|
System.Threading.AutoResetEvent autoEvent = new System.Threading.AutoResetEvent(false);
|
|
|
|
//System.Threading.TimerCallback timerDelegate = new System.Threading.TimerCallback(MySessionInfo.PingSession);
|
|
//System.Diagnostics.Process xyzzy = System.Diagnostics.Process.GetCurrentProcess();
|
|
|
|
if (!System.Diagnostics.Debugger.IsAttached)// running in Production Mode (Not in the debugger)
|
|
{
|
|
System.Threading.TimerCallback timerDelegate = new System.Threading.TimerCallback(this.PingSession);
|
|
if (this._MyParent == null)
|
|
{
|
|
MyActivityTimer = new System.Threading.Timer(timerDelegate, autoEvent, 10000, 10000);
|
|
}
|
|
}
|
|
|
|
|
|
// get the saved location and size of the VE-PROMS application for this user
|
|
this.txtSearch.KeyPress += new KeyPressEventHandler(txtSearch_KeyPress);
|
|
this.txtSearch.KeyUp += txtSearch_KeyUp; // RHM20150506 Multi-Line ItemID TextBox
|
|
this.txtSearch.TextChanged += txtSearch_TextChanged; // RHM20150506 Multi-Line ItemID TextBox
|
|
this.btnNext.Click += btnNext_Click; // RHM20150506 Multi-Line ItemID TextBox
|
|
this.btnPrint1.Click += btnPrint1_Click; // RHM20150506 Multi-Line ItemID TextBox
|
|
this.btnPrevious.Click += btnPrevious_Click; // RHM20150506 Multi-Line ItemID TextBox
|
|
if (Settings.Default["Location"] != null) this.Location = Settings.Default.Location;
|
|
if (Settings.Default["Size"] != null) this.Size = Settings.Default.Size;
|
|
//if (Settings.Default["WindowState"] != null) this.WindowState = Settings.Default.WindowState;
|
|
//if (Settings.Default.SaveTreeviewExpanded) epProcedures.Expanded = Settings.Default.TreeviewExpanded;
|
|
|
|
// if the Procedures panel was left open from the last session, then open it
|
|
epProcedures.Expanded = Settings.Default.TreeviewExpanded;
|
|
if (Settings.Default["QATItems"] != null) ribbonControl1.QatLayout = Settings.Default.QATItems;
|
|
|
|
// See if any database 'changes' need done and do them:
|
|
MakeDatabaseChanges();
|
|
|
|
if (Volian.Base.Library.VlnSettings.GetCommandFlag("NOMRU")) // B2017-193 Error occurred when a section in the MRU was being loaded as an iteminfo
|
|
_MyMRIList = new MostRecentItemList();
|
|
else
|
|
_MyMRIList = MostRecentItemList.GetMRILst((System.Collections.Specialized.StringCollection)(Properties.Settings.Default["MRIList"]));
|
|
|
|
_MyMRIList.AfterRemove += new ItemInfoEvent(_MyMRIList_AfterRemove);
|
|
SetupMRU();
|
|
|
|
// if the user selected to "Remember Last" (was "Save Expanded") then use the MRU list to expand the tree to the last opened procedure
|
|
if (MyParent == null)
|
|
{
|
|
if (Settings.Default.SaveTreeviewExpanded && _MyMRIList.Count > 0)
|
|
{
|
|
_frmVEPROMSloading = true; // C2015-022 so we don't try to create child windows when proms is first starting and position in the procedure tree
|
|
|
|
tv.AdjustTree(_MyMRIList[0].MyItemInfo.MyProcedure);
|
|
tv.SelectedNode.Expand();
|
|
SetCaption(tv.SelectedNode as VETreeNode);
|
|
|
|
_frmVEPROMSloading = false;
|
|
}
|
|
}
|
|
|
|
//get version windows settings
|
|
MyVersionWindowList = VersionWindowList.GetVersionWindowList(Properties.Settings.Default.VersionWindows);
|
|
tc.SyncEnhancedDocuments = Properties.Settings.Default.SyncEnhancedDocuments;
|
|
|
|
// Assign the Procedure Panel's title (heading)
|
|
epProcedures.TitleText = getProcedurePanelHeading(); // get the panel heading
|
|
Database.DefaultTimeout = 20 * getTimeout();
|
|
|
|
// Bug fix: B2013-89: if the procedure panel is expanded, make sure we enable the splitter so the user can resize the panel
|
|
expandableSplitter1.Enabled = epProcedures.Expanded;
|
|
|
|
displaySearch1.SetupAnnotationSearch(ctrlAnnotationDetails, tc);
|
|
AnnotationTypeInfoList.ListChanged += new AnnotationTypeInfoListEvent(AnnotationTypeInfoList_ListChanged);
|
|
ctrlAnnotationDetails.SetupAnnotations(displaySearch1);
|
|
tc.MyAnnotationDetails = ctrlAnnotationDetails;
|
|
SetupButtons();
|
|
|
|
displayBookMarks.MyDisplayTabControl = tc; // allows bookmark selection to bring up steps/docs
|
|
office2007StartButton1.MouseDown += new MouseEventHandler(office2007StartButton1_MouseDown);
|
|
//displayRO.EnabledChanged += new EventHandler(displayRO_EnabledChanged);
|
|
|
|
tc.Enter += new EventHandler(tc_Enter);
|
|
tc.Leave += new EventHandler(tc_Leave);
|
|
tc.StatusChanged += new DisplayTabControlStatusEvent(tc_StatusChanged);
|
|
tc.ToggleRibbonExpanded += new DisplayTabControlEvent(tc_ToggleRibbonExpanded);
|
|
tc.OpenInSeparateWindow += tc_OpenInSeparateWindow;
|
|
tc.RefreshEnhancedDocument += tc_RefreshEnhancedDocument;
|
|
tc.CopyStepSelected += tc_CopyStepSelected; // will extend CopyStep info to all child windows (separate windows upgrade)
|
|
|
|
this.Deactivate += new EventHandler(frmVEPROMS_Deactivate);
|
|
|
|
if (VlnSettings.DemoMode) StepRTB.MyFontFamily = GetFamily("Bookman Old Style");
|
|
displaySearch1.Enter += new EventHandler(displaySearch1_Enter);
|
|
displayHistory.Enter += new EventHandler(displayHistory_Enter);
|
|
ctrlAnnotationDetails.Enter += new EventHandler(ctrlAnnotationDetails_Enter);
|
|
|
|
Application.DoEvents();
|
|
|
|
if (RunningNewRevision && ShowEULA() != DialogResult.OK)
|
|
{
|
|
Timer tmrShutDown = new Timer();
|
|
tmrShutDown.Interval = 250;
|
|
tmrShutDown.Tick += new EventHandler(tmrShutDown_Tick);
|
|
tmrShutDown.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
tmrAutomatic.Enabled = true;
|
|
}
|
|
|
|
//// Shutoff UpdateFormats for Production Mode
|
|
//if (Volian.Base.Library.VlnSettings.ProductionMode)
|
|
// btnAdmin.Visible = false;
|
|
StepTabRibbon.PasteNoReturnsSetting = Properties.Settings.Default.PasteNoReturns;
|
|
StepTabRibbon.PastePlainTextSetting = Properties.Settings.Default.PastePlainText;
|
|
StepTabRibbon.SpecifiedVisioPath = Properties.Settings.Default.VisioPath;
|
|
Activate();
|
|
|
|
// RHM20150506 Multi-line ItemID TextBox
|
|
if (MyParent == null)
|
|
{
|
|
this.txtSearch.Text = Volian.Base.Library.VlnSettings.GetItemIDs().Replace(",", "\r\n");
|
|
|
|
// Open First Item
|
|
if (!string.IsNullOrEmpty(this.txtSearch.Text) && this.txtSearch.Text.Length > 0 && !this.txtSearch.Text.Contains("\r\n"))
|
|
{
|
|
CurrentID = txtSearch.Text;
|
|
}
|
|
}
|
|
|
|
// Add retrieve displaytabs state here.
|
|
openDisplaytabstate();
|
|
}
|
|
|
|
public void openDisplaytabstate()
|
|
{
|
|
// Retrieve edit tab state from database.
|
|
DataTable DisPlayTabState = VEPROMS.CSLA.Library.Item.GetDisplayTabs(VlnSettings.UserID);
|
|
|
|
//CSM - C2024-031 - Getting User Settings
|
|
//and set checkboxes based on what they are set to
|
|
UserSettings usersettings = new UserSettings(VlnSettings.UserID);
|
|
|
|
if (!Settings.Default.SeparateWindows && DisPlayTabState.Rows.Count > 0 && (usersettings.UserSetting_OpenTabs_AutoOpen || !usersettings.UserSetting_OpenTabs_Remember))
|
|
{
|
|
//will open tabs by default / ask by default
|
|
DialogResult result = DialogResult.Yes;
|
|
if (!usersettings.UserSetting_OpenTabs_Remember)
|
|
{
|
|
dlgCheckOpenTabs checkOpenTabs = new dlgCheckOpenTabs();
|
|
result = checkOpenTabs.ShowDialog();
|
|
|
|
//if checkbox was checked in form, then update User Settings in database
|
|
if (checkOpenTabs.Remember)
|
|
usersettings.SetUserSettings(true, result == DialogResult.Yes);
|
|
}
|
|
|
|
|
|
if (result == DialogResult.Yes)
|
|
{
|
|
foreach (DataRow TabState in DisPlayTabState.Rows)
|
|
{
|
|
int _ItemID = (int)TabState["ItemID"];
|
|
ItemInfo _Procedure = ItemInfo.Get(_ItemID);
|
|
// Open procedure in the editor.
|
|
if (_Procedure == null) continue; //skip and continue with foreach
|
|
OpenItem(_Procedure);
|
|
if (tc.MyEditItem == null) continue; // skip and continue with foreach
|
|
// SelectedStepTabPanel needs to be set so the print buttons on the ribbon will work.
|
|
SelectedStepTabPanel = tc.MyEditItem.MyStepPanel.MyStepTabPanel;
|
|
|
|
//CSM B2024-090 - if last displaytab item,
|
|
//select the steptab panel for it
|
|
//and set the EditItem for Find/Replace
|
|
//otherwise will cause PROMS to crash if Find clicked before a Tab is given Focus
|
|
if ((DisPlayTabState.Rows.IndexOf(TabState) == DisPlayTabState.Rows.Count - 1))
|
|
{
|
|
SelectedStepTabPanel.Select();
|
|
dlgFindReplace.MyEditItem = tc.MyEditItem;
|
|
SpellChecker.MyEditItem = tc.MyEditItem; //B2025-043 Remember Tabs is not setting the EditItem for the active window causing a PROMS crash when Spell Check
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void tc_RefreshEnhancedDocument(object sender, ItemSelectedChangedEventArgs args)
|
|
{
|
|
// if the procedure is opened then move to the select step
|
|
if (!Properties.Settings.Default.SeparateWindows)
|
|
{
|
|
tc.RefreshItem(args.MyItemInfo);
|
|
}
|
|
else
|
|
{
|
|
int versionID = args.MyItemInfo.MyDocVersion.VersionID;
|
|
frmVEPROMS child = null;
|
|
|
|
if (PROMSWindowForms.ContainsKey(versionID))
|
|
{
|
|
child = PROMSWindowForms[versionID];
|
|
child.RefreshItem(args.MyItemInfo);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Part of Separate Windows upgrade C2015-022
|
|
// Extend the CopyStep selection information to all of the child windows
|
|
void tc_CopyStepSelected(object sender, ItemChangedEventArgs e)
|
|
{
|
|
foreach (int k in PROMSWindowForms.Keys)
|
|
{
|
|
frmVEPROMS tmp = PROMSWindowForms[k];
|
|
|
|
if (tmp.MyDocVersion.VersionID != this.SelectedDVI.VersionID)
|
|
tmp.tc.MyCopyStep = tc.MyCopyStep;
|
|
else if (tmp.MyParent != null)
|
|
tmp.MyParent.tc.MyCopyStep = tc.MyCopyStep;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This looks for sessions associated with the current PC and user which are no longer active and removes them.
|
|
/// This will in-turn close any related procedure owner records and allow the user to re-open a previously open procedure.
|
|
/// </summary>
|
|
private void CloseSessionsNoLongerActive()
|
|
{
|
|
SessionInfoList sil = SessionInfoList.Get();
|
|
int i = 0;
|
|
|
|
foreach (SessionInfo si in sil)
|
|
{
|
|
if (si.DTSEnd == null && si.MachineName == Environment.MachineName && si.UserID == Volian.Base.Library.VlnSettings.UserID)
|
|
{
|
|
try
|
|
{
|
|
System.Diagnostics.Process p = System.Diagnostics.Process.GetProcessById(si.ProcessID);
|
|
}
|
|
catch (Exception ex)// Process not found
|
|
{
|
|
// Remove Session record associated with a closed process
|
|
Session.Delete(si.SessionID);
|
|
}
|
|
}
|
|
else if (si.DTSEnd == null)
|
|
{
|
|
i = i + 1;
|
|
}
|
|
}
|
|
|
|
// Turn-on Change Manger if there are no active Sessions
|
|
if (i == 0)
|
|
{
|
|
TurnChangeManagerOn.Execute();
|
|
}
|
|
}
|
|
|
|
// C2015-022 Separate Windows. This is a dictionary of child PROMS windows forms (frmVEPROMS)
|
|
//
|
|
Dictionary<int, frmVEPROMS> _PROMSWindowForms = null;
|
|
public Dictionary<int, frmVEPROMS> PROMSWindowForms
|
|
{
|
|
get
|
|
{
|
|
if (_PROMSWindowForms == null)
|
|
{
|
|
if (_MyParent == null)
|
|
_PROMSWindowForms = new Dictionary<int, frmVEPROMS>();
|
|
else
|
|
_PROMSWindowForms = MyParent.PROMSWindowForms;
|
|
}
|
|
return _PROMSWindowForms;
|
|
}
|
|
set { _PROMSWindowForms = value; }
|
|
}
|
|
|
|
// This gets called when user opens an enhanced document (ex Background) from the source (ex EOP)
|
|
// C2015-022 - This also get called if opening a procedure in a child (separate) window
|
|
void tc_OpenInSeparateWindow(object sender, ItemSelectedChangedEventArgs args)
|
|
{
|
|
int versionID = args.MyItemInfo.MyDocVersion.VersionID;
|
|
|
|
if (MyParent != null && args.MyItemInfo.MyDocVersion.DocVersionConfig.MyEnhancedDocuments.Count > 0
|
|
&& !args.MyItemInfo.MyDocVersion.DocVersionConfig.MyEnhancedDocuments.HasSourcePointer)
|
|
{
|
|
MyParent.OpenItem(args.MyItemInfo);
|
|
return;
|
|
}
|
|
|
|
frmVEPROMS child = null;
|
|
|
|
if (PROMSWindowForms.ContainsKey(versionID))
|
|
{
|
|
child = PROMSWindowForms[versionID]; // use existing child window
|
|
}
|
|
else
|
|
{
|
|
child = CreateChildPromsWindow(args.MyItemInfo.MyDocVersion); // create a new child window for the enhanced document procedure set
|
|
tv.AdjustTree(args.MyItemInfo); // find the position in the tree
|
|
VETreeNode _tn = tv.SelectedNode as VETreeNode; // get the tree node for args.MyItemInfo
|
|
|
|
while (!(_tn.VEObject is FolderInfo))
|
|
{
|
|
// back up to the first folder tree node
|
|
_tn = (VETreeNode)_tn.Parent;
|
|
}
|
|
|
|
_tn.Nodes.Clear(); // remove the child nodes from main window - child window now has this part of the procedure tree
|
|
_tn.ChildrenLoaded = false;
|
|
_tn.MovedToSeparateWindow = true; // flag used to reload children nodes if the child window is closed and user clicks on the tree node in the main window
|
|
}
|
|
|
|
child.OpenItem(args.MyItemInfo); // this opens to the enhanced document step and expands the tree to the related node (in the child window)
|
|
}
|
|
|
|
private frmVEPROMS CreateChildPromsWindow(DocVersionInfo dvi) // C2015-022 logic to create separate (child) windows for a procedure set
|
|
{
|
|
frmVEPROMS child;
|
|
|
|
// create a new window for this doc version (procedure set)
|
|
child = new frmVEPROMS(this, dvi);
|
|
PROMSWindowForms.Add(dvi.VersionID, child); // keep track of child windows
|
|
child.Visible = false;
|
|
child.Show();
|
|
|
|
if (MyVersionWindowList != null && MyVersionWindowList.Count > 0)
|
|
{
|
|
foreach (VersionWindow vw in MyVersionWindowList)
|
|
{
|
|
if (vw.VersionID == dvi.VersionID)
|
|
{
|
|
child.SetDesktopBounds(vw.MyRectangle.Left, vw.MyRectangle.Top, vw.MyRectangle.Width, vw.MyRectangle.Height);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
child.office2007StartButton1.Visible = false; // hide V button
|
|
child.qatCustomizeItem1.Visible = false; // hide quick access list
|
|
child.btnExit.Visible = false; // hide the exit button (closes all of PROMS not just the child window)
|
|
child.Visible = true;
|
|
child.Move += child_MoveOrSize;
|
|
child.Resize += child_MoveOrSize;
|
|
child.FormClosed += child_FormClosed;
|
|
|
|
// these next three lines of code will force the child window to display on top of all other windows on the screen
|
|
child.TopMost = true; // force child window to the display on top of all others
|
|
Application.DoEvents();
|
|
child.TopMost = false; // child window will remain on top but now other windows can be displayed on top of it
|
|
|
|
return child;
|
|
}
|
|
|
|
void child_FormClosed(object sender, FormClosedEventArgs e) // C2015-022 used for Separate Windows logic
|
|
{
|
|
if (_RemoveFromPROMSWindowForms)
|
|
PROMSWindowForms.Remove((sender as frmVEPROMS).MyDocVersion.VersionID);
|
|
}
|
|
void child_MoveOrSize(object sender, EventArgs e)
|
|
{
|
|
frmVEPROMS frm = sender as frmVEPROMS;
|
|
RectangleConverter rc = new RectangleConverter();
|
|
string str = string.Format("{0}~{1}", frm.MyDocVersion.VersionID, rc.ConvertToString(frm.DesktopBounds));
|
|
MyVersionWindowList.Add(new VersionWindow(str));
|
|
}
|
|
|
|
private bool HasSetAdministrator(UserInfo ui)
|
|
{
|
|
DocVersionInfoList dvil = DocVersionInfoList.Get();
|
|
|
|
foreach (DocVersionInfo dvi in dvil)
|
|
{
|
|
if (ui.IsSetAdministrator(dvi))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// RHM20150507 Table Scrunch
|
|
// B2018-033 VCS SAG-6 Steps 3 and 9 and SACRG1 Step 13
|
|
// Set default Scrunching flags
|
|
private TableScrunching _DefaultScrunchingRules = TableScrunching.AllPhases;
|
|
|
|
void btnPrint1_Click(object sender, EventArgs e)
|
|
{
|
|
string[] ids = txtSearch.Text.Split("\r\n ".ToCharArray());
|
|
Dictionary<int, ProcedureInfo> dicProcs = new Dictionary<int, ProcedureInfo>();
|
|
|
|
foreach (string id in ids)
|
|
{
|
|
if (!string.IsNullOrEmpty(id))
|
|
{
|
|
ItemInfo ii = GetItemInfoFromString(id);
|
|
|
|
if (ii != null && !dicProcs.ContainsKey(ii.MyProcedure.ItemID))// B2018-087 - Don't fail if it doesn't exist
|
|
dicProcs.Add(ii.MyProcedure.ItemID, ii.MyProcedure);
|
|
}
|
|
}
|
|
|
|
DialogResult dr = System.Windows.Forms.DialogResult.Yes;
|
|
|
|
// RHM20150507 Table Scrunch
|
|
Rtf2Pdf.AllowTableScrunching = cbScrunch.Checked ? _DefaultScrunchingRules : TableScrunching.None;
|
|
|
|
foreach (int key in dicProcs.Keys)
|
|
{
|
|
ProcedureInfo proc = dicProcs[key];
|
|
|
|
DlgPrintProcedure prnDlg = new DlgPrintProcedure(proc, true);
|
|
prnDlg.MySessionInfo = MySessionInfo;
|
|
prnDlg.Prefix = proc.MyDocVersion.VersionID.ToString() + "_";
|
|
prnDlg.Automatic = true;
|
|
prnDlg.OpenAfterCreate = (dr == System.Windows.Forms.DialogResult.Yes);
|
|
prnDlg.SetupForProcedure();
|
|
prnDlg.CreatePDF();
|
|
|
|
//prnDlg.ShowDialog(this); // RHM 20120925 - Center dialog over PROMS window
|
|
}
|
|
}
|
|
|
|
bool ProcessingPaste = false;
|
|
|
|
private void txtSearch_TextChanged(object sender, EventArgs e)
|
|
{
|
|
if (!ProcessingPaste) // RHM20150507 Multi-line ItemID TextBox
|
|
{
|
|
ProcessingPaste = true;
|
|
|
|
if (txtSearch.Text.Contains("\n"))
|
|
{
|
|
txtSearch.Text = txtSearch.Text.Trim("\r\n ".ToCharArray());
|
|
txtSearch.SelectionStart = 0;
|
|
CurrentID = GetCurrentLine();
|
|
}
|
|
|
|
bool isBtnVisible = txtSearch.Text.Contains("\r\n");
|
|
|
|
btnNext.Visible = isBtnVisible;
|
|
btnPrint1.Visible = isBtnVisible;
|
|
cbScrunch.Visible = isBtnVisible;
|
|
btnPrevious.Visible = isBtnVisible;
|
|
|
|
ProcessingPaste = false;
|
|
}
|
|
}
|
|
|
|
//C2024-036 IntelliSense
|
|
// Recursively Expand the Tree
|
|
// up to the procedure level
|
|
// Since items are only loaded as they are expanded,
|
|
// this is needed to search for matching text.
|
|
private void LoadAllProcedures(VETreeNode tn)
|
|
{
|
|
if (tn == null || tn.VEObject.IsProcedure)
|
|
return;
|
|
|
|
if (!tn.IsExpanded)
|
|
{ tn.Expand(); }
|
|
|
|
foreach (var nde in tn.Nodes)
|
|
LoadAllProcedures((VETreeNode)nde);
|
|
}
|
|
|
|
//C2024-036 IntelliSense
|
|
// Return a list containing all
|
|
// items in the Tree that match the entered text
|
|
// + any item that is a parent of those.
|
|
private List<IVEDrillDownReadOnly> GetMatchingTreeNodes(VETreeNode tn, string texttomatch)
|
|
{
|
|
List<IVEDrillDownReadOnly> matches = new List<IVEDrillDownReadOnly>();
|
|
|
|
//add any item that matches text
|
|
//and all parents back up to the top most item
|
|
if (tn.Text.ToLower().Contains(texttomatch.ToLower()))
|
|
{
|
|
matches.Add(tn.VEObject);
|
|
VETreeNode parent_tn = (VETreeNode) tn.Parent;
|
|
while (parent_tn != null)
|
|
{
|
|
if (!matches.Contains(parent_tn.VEObject))
|
|
{ matches.Add(parent_tn.VEObject); }
|
|
parent_tn = (VETreeNode)parent_tn.Parent;
|
|
}
|
|
}
|
|
|
|
if (!tn.VEObject.IsProcedure)
|
|
{
|
|
//if not at a procedure level,
|
|
//loop through sub items
|
|
//to check those for matches
|
|
foreach (VETreeNode nde in tn.Nodes.OfType<VETreeNode>())
|
|
{
|
|
if (nde.Text != "Dummy VETreeNode(IVEDrillDownReadOnly o)")
|
|
{
|
|
List<IVEDrillDownReadOnly> tmpmatches = GetMatchingTreeNodes(nde, texttomatch);
|
|
matches.AddRange(from mtch in tmpmatches
|
|
where !matches.Contains(mtch)
|
|
select mtch);
|
|
}
|
|
}
|
|
}
|
|
|
|
return matches;
|
|
}
|
|
|
|
//C2024-036 IntelliSense
|
|
// Recursively loop through the Child Nodes
|
|
// in the TreeView
|
|
// remove anything not in the list
|
|
private bool FilterTreeNodes(VETreeNode tn, List<IVEDrillDownReadOnly> filterlist)
|
|
{
|
|
if (tn == null)
|
|
return false;
|
|
|
|
if (!filterlist.Contains(tn.VEObject) && (tn != (VETreeNode) tv.Nodes[0])) //Note:Always keep the top node
|
|
{
|
|
return true;
|
|
}
|
|
else if (!tn.VEObject.IsProcedure)
|
|
{
|
|
//if not a procedure
|
|
//mark the sub-items that need removal
|
|
List<TreeNode> lst = (from VETreeNode nde in tn.Nodes.OfType<VETreeNode>()
|
|
where FilterTreeNodes(nde, filterlist)
|
|
select (TreeNode) nde).ToList();
|
|
|
|
//remove all items in the removal list
|
|
//need to do this separately as can't modify the collection while looping through it above
|
|
while (lst.Count > 0)
|
|
{
|
|
tn.Nodes.Remove(lst[0]);
|
|
lst.Remove(lst[0]);
|
|
}
|
|
|
|
//found a folder that matched that has no matching procedures
|
|
//if this is case, allow folder to be expanded
|
|
if (tn.Nodes.Count == 0 && filterlist.Contains(tn.VEObject))
|
|
{
|
|
tn.ChildrenLoaded = false;
|
|
tn.RefreshNode();
|
|
}
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
//C2024-036 IntelliSense
|
|
//Collection to block for task to complete
|
|
private BlockingCollection<string> blockingQueueFilter = new BlockingCollection<string>();
|
|
|
|
//C2024-036 IntelliSense
|
|
// When Text Changes, Perform the filtering
|
|
// Note that uses a blocking collection
|
|
// in case multiple events fire at the same time
|
|
// this is to prevent incorrect behavior when
|
|
//doing something like hitting backspace a bunch
|
|
private void SubmitFilter(object sender, EventArgs e)
|
|
{
|
|
//Consumer
|
|
Task.Run(() =>
|
|
{
|
|
//Blocks until a new filter is available
|
|
while (!blockingQueueFilter.IsCompleted)
|
|
{
|
|
string fltrtxt = blockingQueueFilter.Take();
|
|
ProcessFilter(fltrtxt);
|
|
}
|
|
});
|
|
|
|
//Producer
|
|
Task.Run(() => { blockingQueueFilter.Add(txtFilter?.Text); });
|
|
|
|
}
|
|
|
|
//C2024-036 IntelliSense
|
|
// When Enter Key is pressed in the TextBox
|
|
private void FilterEnterKey(object sender, KeyPressEventArgs e)
|
|
{
|
|
if (e.KeyChar == '\r') // enter key pressed
|
|
{
|
|
e.Handled = true;
|
|
SubmitFilter(sender, e);
|
|
}
|
|
}
|
|
|
|
//C2024-036 IntelliSense
|
|
// When Text Changes, Perform the filtering
|
|
// Note that uses Invoke to
|
|
// avoid multi-threaded problems
|
|
//with the blocking collection
|
|
private void ProcessFilter(string fltrtxt)
|
|
{
|
|
//Step 1: reload the base tree
|
|
VETreeNode tbase = (VETreeNode)tv.Nodes[0];
|
|
tbase.ChildrenLoaded = false;
|
|
this.Invoke((Action) (() => { tbase.RefreshNode(); }));
|
|
|
|
if (!string.IsNullOrEmpty(fltrtxt))
|
|
{
|
|
//Step 2: Expand all TreeNodes
|
|
this.Invoke((Action)(() => { LoadAllProcedures(tbase); }));
|
|
|
|
//Step 3: get items that match filter to those containing the title or number
|
|
List<IVEDrillDownReadOnly> filterlist = GetMatchingTreeNodes(tbase, fltrtxt);
|
|
|
|
//Step 4: filter to those containing the title or number
|
|
this.Invoke((Action)(() => {FilterTreeNodes(tbase, filterlist);}));
|
|
|
|
//Step 5: refresh the view
|
|
this.Invoke((Action)(() => {tv.Update();}));
|
|
|
|
//Step 6: select 1st procedure in tree view
|
|
this.Invoke((Action)(() => {SelectFirstProcedure(filterlist);}));
|
|
}
|
|
|
|
//Step 7: set progress bar as done
|
|
this.Invoke((Action)(() => {ProgBarText = "Filtering Complete";}));
|
|
|
|
}
|
|
|
|
//C2024-036 IntelliSense
|
|
//Gives Focus to last child in first section of treeview
|
|
//then given focus to treeview
|
|
//so that can click enter and open 1st found item/procedure
|
|
void SelectFirstProcedure(List<IVEDrillDownReadOnly> filterlist)
|
|
{
|
|
TreeNode tn = tv.Nodes[0];
|
|
while (tn.Nodes.Count > 0 && filterlist.Contains(((VETreeNode) tn).VEObject))
|
|
{
|
|
tn = tn.Nodes[0];
|
|
}
|
|
|
|
tv.SelectedNode = tn;
|
|
tv.Enabled = true;
|
|
tv.SelectedNode.Collapse();
|
|
tv.Focus();
|
|
}
|
|
|
|
void btnPrevious_Click(object sender, EventArgs e)
|
|
{
|
|
CurrentID = FindPreviousLine();
|
|
}
|
|
|
|
void btnNext_Click(object sender, EventArgs e)
|
|
{
|
|
CurrentID = FindNextLine();
|
|
}
|
|
|
|
public string CurrentID
|
|
{
|
|
get
|
|
{
|
|
return GetCurrentLine();
|
|
}
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
System.Media.SystemSounds.Beep.Play();
|
|
}
|
|
else
|
|
{
|
|
OpenMyItem(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
private string FindNextLine()
|
|
{
|
|
if (txtSearch.SelectionLength > 0)
|
|
txtSearch.SelectionLength = 0;
|
|
|
|
string sub = txtSearch.Text.Substring(txtSearch.SelectionStart);
|
|
|
|
if (sub.Contains("\n"))
|
|
{
|
|
txtSearch.SelectionStart += sub.IndexOf("\n") + 1;
|
|
txtSearch.ScrollToCaret();
|
|
return GetCurrentLine();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private string FindPreviousLine()
|
|
{
|
|
if (txtSearch.SelectionLength > 0)
|
|
txtSearch.SelectionLength = 0;
|
|
|
|
string sub = txtSearch.Text;
|
|
int selStart = 0;
|
|
|
|
if (txtSearch.SelectionStart == 0) return null;
|
|
if (txtSearch.SelectionStart > 2)
|
|
{
|
|
sub = txtSearch.Text.Substring(0, txtSearch.SelectionStart - 2);
|
|
if (sub.Contains("\n"))
|
|
{
|
|
selStart = sub.LastIndexOf("\r\n") + 2;
|
|
}
|
|
}
|
|
|
|
txtSearch.SelectionStart = selStart;
|
|
txtSearch.ScrollToCaret();
|
|
|
|
return GetCurrentLine();
|
|
}
|
|
|
|
void txtSearch_KeyUp(object sender, KeyEventArgs e)
|
|
{
|
|
if (e.Control && e.KeyCode == Keys.V)
|
|
{
|
|
txtSearch.SelectionStart = 0;
|
|
txtSearch.SelectionLength = txtSearch.TextLength;
|
|
txtSearch.SelectedText = Clipboard.GetText().TrimEnd("\r\n ".ToCharArray());
|
|
btnNext.Visible = btnPrint1.Visible = cbScrunch.Visible = btnPrevious.Visible = txtSearch.Text.Contains("\r\n");
|
|
txtSearch.SelectionLength = 0;
|
|
txtSearch.SelectionStart = 0;
|
|
txtSearch.ScrollToCaret();
|
|
CurrentID = GetCurrentLine();
|
|
e.Handled = true;
|
|
}
|
|
|
|
if (e.Control && e.KeyCode == Keys.A)
|
|
{
|
|
txtSearch.SelectionStart = 0;
|
|
txtSearch.SelectionLength = txtSearch.TextLength;
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
private string GetCurrentLine()
|
|
{
|
|
while (txtSearch.SelectionStart > 0 && txtSearch.Text[txtSearch.SelectionStart - 1] != '\n')
|
|
{
|
|
txtSearch.SelectionStart--;
|
|
}
|
|
|
|
string sub = txtSearch.Text.Substring(txtSearch.SelectionStart).TrimStart("\r\n ".ToCharArray());
|
|
if (sub.Contains("\r\n")) return sub.Substring(0, sub.IndexOf("\r\n"));
|
|
|
|
return sub;
|
|
}
|
|
|
|
void txtSearch_KeyPress(object sender, KeyPressEventArgs e) // used when running in debug mode, for text box where you enter an ItemID or ContextID number
|
|
{
|
|
if (e.KeyChar == '\r')
|
|
{
|
|
e.Handled = true;
|
|
|
|
if (txtSearch.Text.Length > 0)
|
|
{
|
|
if (txtSearch.Text.Contains("\r\n")) // RHM20150506 Multi-Line ItemID TextBox
|
|
CurrentID = GetCurrentLine();
|
|
else
|
|
OpenMyItem(txtSearch.Text);
|
|
}
|
|
}
|
|
|
|
if (e.KeyChar == 1 || e.KeyChar == 22)
|
|
{
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
private void OpenMyItem(string str) // RHM20150506 Multi-Line ItemID TextBox
|
|
{
|
|
ItemInfo ii = GetItemInfoFromString(str); // RHM20150506 Multi-Line ItemID TextBox
|
|
|
|
if (ii != null)
|
|
{
|
|
DisplayTabItem dti = tc.OpenItem(ii);// B2018-035 Allow procedure to be printed and property grid to be opened
|
|
// B2019-003: was crashing if another user was in same procedure (dti would have been null because procedure could not be opened):
|
|
if (dti == null) return;
|
|
|
|
SelectedStepTabPanel = dti.MyStepTabPanel;
|
|
tc.SelectedDisplayTabItem = dti;
|
|
dti.SelectedItemInfo = ii;
|
|
tv.AdjustTree(ii);
|
|
lblItemID.Text = string.Format("ItemID = {0}", ii.ItemID);
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show(string.Format("Looking for: {0}", str), "No item found");
|
|
}
|
|
}
|
|
|
|
private static ItemInfo GetItemInfoFromString(string str) // RHM20150506 Multi-Line ItemID TextBox
|
|
{
|
|
ItemInfo ii = null;
|
|
int id = 0;
|
|
ContentInfo ci = null;
|
|
|
|
if (str.ToUpper().StartsWith("C="))
|
|
{
|
|
if (int.TryParse(str.Substring(2), out id))
|
|
ci = ContentInfo.Get(id);
|
|
|
|
if (ci != null)
|
|
ii = ci.ContentItems[0];
|
|
}
|
|
else
|
|
{
|
|
if (int.TryParse(str, out id))
|
|
ii = ItemInfo.Get(id);
|
|
}
|
|
|
|
return ii;
|
|
}
|
|
|
|
void btnAdministrativeTools_Click(object sender, EventArgs e)
|
|
{
|
|
frmBatchRefresh frm = new frmBatchRefresh(MySessionInfo, this);
|
|
frm.ProgressBar = bottomProgBar;
|
|
frm.ShowDialog(this);
|
|
}
|
|
|
|
void btnGeneralTools_Click(object sender, EventArgs e)
|
|
{
|
|
frmGenTools frm = new frmGenTools(MySessionInfo, this);
|
|
frm.ProgressBar = bottomProgBar;
|
|
frm.ShowDialog(this);
|
|
}
|
|
|
|
private static VolianTimer _TimeActivity1 = new VolianTimer("frmVEPROMS.cs tmrCloseTabItems_Tick", 2108);
|
|
|
|
void tmrCloseTabItems_Tick(object sender, EventArgs e)
|
|
{
|
|
tmrCloseTabItems.Enabled = false;
|
|
|
|
_TimeActivity1.Open();
|
|
|
|
while (MyCloseTabList.CountDTI > 0)
|
|
{
|
|
DisplayTabItem dti = MyCloseTabList.PopDTI();
|
|
|
|
if (dti.MyDSOTabPanel != null)
|
|
{
|
|
dti.MyDSOTabPanel.OverrideClose = true;
|
|
// Add error log message for forced check-in
|
|
_MyLog.WarnFormat("===============Override Close====================");
|
|
}
|
|
|
|
tc.CloseTabItem(dti);
|
|
}
|
|
|
|
_TimeActivity1.Close();
|
|
|
|
tmrCloseTabItems.Enabled = true;
|
|
}
|
|
|
|
private void InitializeSecurity()
|
|
{
|
|
Folder f = Folder.Get(1);
|
|
GroupInfo gi = GroupInfo.Get(1);
|
|
|
|
if (f.FolderConfig.Security_Group == 0)
|
|
{
|
|
f.FolderConfig.Security_Group = gi.GID;
|
|
f.Save();
|
|
}
|
|
|
|
securityRole = f.FolderConfig.Security_Group;
|
|
}
|
|
|
|
private string proxyUser;
|
|
private void UpdateUser()
|
|
{
|
|
string newUser = VlnSettings.GetCommand("U", null);
|
|
|
|
if (newUser != null)
|
|
VlnSettings.UserID = newUser;
|
|
|
|
newUser = VlnSettings.GetCommand("V3Pr0m5" + GetSecurityKey(), null);
|
|
|
|
if (newUser != null)
|
|
{
|
|
VlnSettings.UserID = newUser;
|
|
UserInfo ui = UserInfo.GetByUserID(VlnSettings.UserID);
|
|
User u;
|
|
|
|
if (ui != null)
|
|
{
|
|
u = User.Get(ui.UID);
|
|
|
|
foreach (UserMembership um in u.UserMemberships)
|
|
{
|
|
if (um.EndDate == null || um.EndDate == string.Empty)
|
|
{
|
|
Membership m = Membership.Get(um.UGID);
|
|
m.EndDate = DateTime.Now.ToShortDateString();
|
|
m.Save();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
u = User.MakeUser(VlnSettings.UserID, "", "", "", "", "", "", "", "", "", "", DateTime.Now, VlnSettings.UserID);
|
|
Group g = Group.GetByGroupName("Administrators");
|
|
Membership.MakeMembership(u, g, null, "");
|
|
}
|
|
}
|
|
|
|
if (MyParent == null)
|
|
{
|
|
if (VlnSettings.GetCommandFlag("VeauLeeAnn" + GetSecurityKey()) || VlnSettings.GetCommandFlag("VeauLeeAnnXYZZY"))
|
|
{
|
|
//pop up user list to select from
|
|
ContextMenuStrip cms = BuildUserMenu();
|
|
|
|
while (proxyUser == null)
|
|
{
|
|
cms.Show(new System.Drawing.Point((System.Windows.Forms.Screen.PrimaryScreen.WorkingArea.Width - cms.Width) / 2, (System.Windows.Forms.Screen.PrimaryScreen.WorkingArea.Height - cms.Height) / 2));
|
|
System.Windows.Forms.Application.DoEvents();
|
|
}
|
|
|
|
VlnSettings.UserID = proxyUser;
|
|
}
|
|
}
|
|
|
|
lblUser.Text = VlnSettings.UserID;
|
|
lblUser.MouseDown += new MouseEventHandler(lblUser_MouseDown);
|
|
}
|
|
|
|
private string GetSecurityKey()
|
|
{
|
|
Random rnd = new Random(DateTime.Now.Year + DateTime.Now.DayOfYear * 1000);
|
|
return rnd.Next(10000).ToString();
|
|
}
|
|
|
|
void lblUser_MouseDown(object sender, MouseEventArgs e)
|
|
{
|
|
if (e.Button == MouseButtons.Right)
|
|
{
|
|
/*
|
|
- Devin- Volian0
|
|
- Diane- Volian0
|
|
- Jess- Volian0
|
|
- John- Volian0
|
|
- Kathy- Volian0
|
|
- Jake- Volian0
|
|
- Jim- JCB2-HP
|
|
- Rich- WINDOWS7-RHM
|
|
- Rich - RICH-WINDOWS10
|
|
- Paul- Paul-PC
|
|
- Michelle- Michelle-PC
|
|
- Harrys Mac- WIN-04QLPEH7JKH
|
|
- Harrys PC- Harry-7100
|
|
- Caitlin- Caitlin-PC
|
|
*/
|
|
if ("|VLN|RICH-WINDOWS10|WINDOWS7-RHM|PAUL-PC|MICHELLE-PC|WIN-O4QLPEH7JKH|HARRY-7100|CAITLIN-PC|".Contains("|" + Environment.UserDomainName.ToUpper() + "|"))
|
|
{
|
|
Random rnd = new Random(DateTime.Now.Year + DateTime.Now.DayOfYear * 1000);
|
|
MessageBox.Show(this, GetSecurityKey(), "Today's Security Key");
|
|
}
|
|
|
|
_MyLog.WarnFormat("Environment.UserName = '{0}'", Environment.UserName);
|
|
_MyLog.WarnFormat("Environment.UserDomainName = '{0}'", Environment.UserDomainName);
|
|
_MyLog.WarnFormat("Environment.MachineName = '{0}'", Environment.MachineName);
|
|
_MyLog.WarnFormat("Environment.OSVersion = '{0}'", Environment.OSVersion);
|
|
}
|
|
}
|
|
|
|
private ContextMenuStrip BuildUserMenu()
|
|
{
|
|
System.Windows.Forms.ContextMenuStrip cms = new System.Windows.Forms.ContextMenuStrip();
|
|
|
|
cms.Items.Add("Choose User");
|
|
System.Windows.Forms.ToolStripMenuItem tsmi = cms.Items[0] as System.Windows.Forms.ToolStripMenuItem;
|
|
tsmi.BackColor = System.Drawing.Color.FromKnownColor(System.Drawing.KnownColor.ActiveCaption);// System.Drawing.Color.Pink;
|
|
tsmi.ForeColor = System.Drawing.Color.FromKnownColor(System.Drawing.KnownColor.ActiveCaptionText);
|
|
tsmi.Font = new System.Drawing.Font(tsmi.Font, System.Drawing.FontStyle.Bold);
|
|
UserInfoList uil = UserInfoList.Get();
|
|
|
|
foreach (UserInfo ui in uil)
|
|
{
|
|
if (ui.UserMembershipCount > 0)
|
|
{
|
|
foreach (MembershipInfo mi in ui.UserMemberships)
|
|
{
|
|
if (mi.EndDate == string.Empty)
|
|
{
|
|
string txt = string.Format("{0} - {1}", ui.UserID, mi.MyGroup.GroupName);
|
|
ToolStripItem tsi = cms.Items.Add(txt, null, new EventHandler(User_Click));
|
|
tsi.Tag = ui;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return cms;
|
|
}
|
|
|
|
private void User_Click(object sender, EventArgs e)
|
|
{
|
|
ToolStripMenuItem tsmi = sender as ToolStripMenuItem;
|
|
|
|
if (tsmi != null)
|
|
{
|
|
UserInfo ui = tsmi.Tag as UserInfo;
|
|
proxyUser = ui.UserID;
|
|
}
|
|
}
|
|
|
|
void btnManageSecurity_Click(object sender, EventArgs e)
|
|
{
|
|
dlgManageSecurity dlg = new dlgManageSecurity();
|
|
dlg.ShowDialog(this);
|
|
}
|
|
|
|
void btnResetSecurity_Click(object sender, EventArgs e)
|
|
{
|
|
string password = string.Empty;
|
|
|
|
if (ShowInputDialog(ref password) == DialogResult.OK)
|
|
{
|
|
if (password == "V3Pr0m5")
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.AppendLine("***** WARNING *****");
|
|
sb.AppendLine();
|
|
sb.AppendLine("This action will delete all Groups, Users and Memberships from the database.");
|
|
sb.AppendLine("This action is NOT reversible.");
|
|
sb.AppendLine("Following this action the application will terminate.");
|
|
sb.AppendLine();
|
|
sb.AppendLine("Are you sure you want to continue?");
|
|
|
|
if (MessageBox.Show(sb.ToString(), "Confirm Security Reset", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Stop) == DialogResult.Yes)
|
|
{
|
|
ResetSecurity.Execute();
|
|
Application.Exit();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("You have entered an incorrect password.");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static DialogResult ShowInputDialog(ref string input)
|
|
{
|
|
System.Drawing.Size size = new System.Drawing.Size(200, 70);
|
|
Form inputBox = new Form();
|
|
|
|
inputBox.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
|
|
inputBox.ClientSize = size;
|
|
inputBox.Text = "Enter Password";
|
|
inputBox.StartPosition = FormStartPosition.CenterScreen;
|
|
|
|
System.Windows.Forms.TextBox textBox = new TextBox();
|
|
textBox.Size = new System.Drawing.Size(size.Width - 10, 23);
|
|
textBox.Location = new System.Drawing.Point(5, 5);
|
|
textBox.PasswordChar = '*';
|
|
textBox.Text = input;
|
|
inputBox.Controls.Add(textBox);
|
|
|
|
Button okButton = new Button();
|
|
okButton.DialogResult = System.Windows.Forms.DialogResult.OK;
|
|
okButton.Name = "okButton";
|
|
okButton.Size = new System.Drawing.Size(75, 23);
|
|
okButton.Text = "&OK";
|
|
okButton.Location = new System.Drawing.Point(size.Width - 80 - 80, 39);
|
|
inputBox.Controls.Add(okButton);
|
|
|
|
Button cancelButton = new Button();
|
|
cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
|
|
cancelButton.Name = "cancelButton";
|
|
cancelButton.Size = new System.Drawing.Size(75, 23);
|
|
cancelButton.Text = "&Cancel";
|
|
cancelButton.Location = new System.Drawing.Point(size.Width - 80, 39);
|
|
inputBox.Controls.Add(cancelButton);
|
|
|
|
|
|
DialogResult result = inputBox.ShowDialog();
|
|
input = textBox.Text;
|
|
|
|
return result;
|
|
}
|
|
|
|
void tc_StatusChanged(object sender, DisplayTabControlStatusEventArgs args)
|
|
{
|
|
switch (args.Type)
|
|
{
|
|
case VolianStatusType.Initialize:
|
|
ProgBarMax = args.Count;
|
|
ProgBarText = args.Text;
|
|
ProgBarValue = 0;
|
|
break;
|
|
|
|
case VolianStatusType.Update:
|
|
ProgBarText = args.Text;
|
|
ProgBarValue = args.Count;
|
|
break;
|
|
|
|
case VolianStatusType.Complete:
|
|
ProgBarText = args.Text;
|
|
ProgBarValue = 0;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void tmrShutDown_Tick(object sender, EventArgs e)
|
|
{
|
|
(sender as Timer).Enabled = false;
|
|
this.Close();
|
|
}
|
|
|
|
private DialogResult ShowEULA()
|
|
{
|
|
string eulaFile = string.Format(@"\{0}", VlnSettings.EULAfile);
|
|
string strEULA = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + eulaFile;
|
|
//string strEULA = System.Environment.CurrentDirectory + eulaFile;
|
|
frmViewTextFile ViewFile = new frmViewTextFile(strEULA, RichTextBoxStreamType.PlainText);
|
|
ViewFile.Text = "End-User License Agreement";
|
|
ViewFile.ButtonText = "Agree";
|
|
|
|
if (ViewFile.ShowDialog() == DialogResult.OK)
|
|
{
|
|
System.Version ver = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
|
|
string thisVersion = ver.Major.ToString() + "." + ver.Minor.ToString();
|
|
Properties.Settings.Default.LastVersion = thisVersion;
|
|
return DialogResult.OK;
|
|
}
|
|
|
|
return DialogResult.Cancel;
|
|
}
|
|
|
|
private bool RunningNewRevision
|
|
{
|
|
get
|
|
{
|
|
string lastVersion = Properties.Settings.Default.LastVersion;
|
|
System.Version ver = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
|
|
string thisVersion = ver.Major.ToString() + "." + ver.Minor.ToString();
|
|
return thisVersion != lastVersion;
|
|
}
|
|
}
|
|
|
|
void displayHistory_Enter(object sender, EventArgs e)
|
|
{
|
|
tc.HideCaret();
|
|
}
|
|
|
|
void AnnotationTypeInfoList_ListChanged()
|
|
{
|
|
displaySearch1.SetupAnnotationSearch(ctrlAnnotationDetails, tc);
|
|
ctrlAnnotationDetails.SetupAnnotations(displaySearch1);
|
|
}
|
|
|
|
private void RunAutomatic()
|
|
{
|
|
string[] parameters = System.Environment.CommandLine.Split(" ".ToCharArray());
|
|
bool ranAuto = false;
|
|
|
|
foreach (string parameter in parameters)
|
|
{
|
|
if (parameter.StartsWith("/P="))
|
|
{
|
|
MSWordToPDF.Automatic = true;
|
|
PromsPrinter.BaselineTesting = true;// Set Baseline Testing property for PROMsPrinter
|
|
string[] dvstrs = parameter.Substring(3).Split(",".ToCharArray());
|
|
|
|
foreach (string dvstr in dvstrs)
|
|
{
|
|
if (dvstr != string.Empty)
|
|
{
|
|
DocVersionInfo dvi = DocVersionInfo.Get(int.Parse(dvstr));
|
|
|
|
if (dvi != null)
|
|
{
|
|
DlgPrintProcedure prnDlg = new DlgPrintProcedure(dvi, true);
|
|
if (dvi.MultiUnitCount == 0)
|
|
{
|
|
prnDlg.SelectedSlave = -1;
|
|
}
|
|
else if (dvi.MultiUnitCount > 0)
|
|
{
|
|
string[] arguments = Environment.GetCommandLineArgs();
|
|
for (int i = 0; i < arguments.Length; i++)
|
|
{
|
|
if (arguments[i].Contains("/C="))
|
|
{
|
|
Console.WriteLine("In arguments loop");
|
|
//int num;
|
|
string[] childarg = arguments[i].Split('=');
|
|
if (int.TryParse(childarg[1], out int num))
|
|
{
|
|
prnDlg.SelectedSlave = num;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
prnDlg.AllowDateTimePrefixSuffix = false; //C2018-033 don't append any selected date/time pdf file prefix or suffix (defined in working draft properties)
|
|
prnDlg.ShowDialog(this); // RHM 20120925 - Center dialog over PROMS window
|
|
//prnDlg.FormClosed += new FormClosedEventHandler(prnDlg_FormClosed);
|
|
//while (!_RunNext) Application.DoEvents();
|
|
|
|
}
|
|
|
|
}
|
|
ranAuto = true;
|
|
}
|
|
|
|
if (ranAuto)
|
|
{
|
|
this.Close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private FontFamily GetFamily(string name)
|
|
{
|
|
foreach (FontFamily ff in FontFamily.Families)
|
|
if (ff.Name == name) return ff;
|
|
|
|
return null;
|
|
}
|
|
|
|
void tc_ToggleRibbonExpanded(object sender, EventArgs args)
|
|
{
|
|
//Volian.Base.Library.vlnStackTrace.ShowStackLocal("tc_ToggleRibbonExpanded {0}", ribbonControl1.Expanded);
|
|
ribbonControl1.Expanded = !ribbonControl1.Expanded;
|
|
}
|
|
|
|
void frmVEPROMS_Deactivate(object sender, EventArgs e)
|
|
{
|
|
tc.HideCaret(); // Hide the pseudo cursor (caret)
|
|
}
|
|
|
|
void tc_Leave(object sender, EventArgs e)
|
|
{
|
|
if (tc.ShuttingDown) return;
|
|
tc.ShowCaret();// Show the pseudo cursor (caret)
|
|
}
|
|
|
|
void tc_Enter(object sender, EventArgs e)
|
|
{
|
|
tc.HideCaret();// Hide the pseudo cursor (caret)
|
|
}
|
|
|
|
void displaySearch1_Enter(object sender, EventArgs e)
|
|
{
|
|
tc.HideCaret();// Hide the pseudo cursor (caret)
|
|
}
|
|
|
|
void ctrlAnnotationDetails_Enter(object sender, EventArgs e)
|
|
{
|
|
tc.HideCaret();// Hide the pseudo cursor (caret)
|
|
}
|
|
|
|
void _MyMRIList_AfterRemove(object sender)
|
|
{
|
|
SetupMRU();
|
|
}
|
|
|
|
private void SetupButtons()
|
|
{
|
|
if (!VlnSettings.DebugMode)
|
|
{
|
|
lblItemID.Visible = false;
|
|
btnItemInfo.Visible = false;
|
|
cmbFont.Visible = false;
|
|
btnEditItem.Visible = false;
|
|
lblResolution.Visible = false;
|
|
txtSearch.Visible = false;
|
|
lblLastChange.Visible = false;
|
|
btnStepRTF.Visible = false;
|
|
lblDummy.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
// C2024-007: On Proms main form, allow for control of whether the FontMenu
|
|
// combo box is displayed. Only done when running in debugmode
|
|
cmbFont.Visible = Volian.Base.Library.VlnSettings.GetCommandFlag("FontMenu");
|
|
lblDummy.Visible = !Volian.Base.Library.VlnSettings.GetCommandFlag("FontMenu");
|
|
}
|
|
}
|
|
|
|
#region MRU
|
|
private MostRecentItemList _MyMRIList;
|
|
private void SetupMRU()
|
|
{
|
|
icRecentDocs.SubItems.Clear();
|
|
if (_MyMRIList.Count > 0)
|
|
{
|
|
LabelItem lblItem = new LabelItem();
|
|
lblItem.Text = "Recent Documents:";
|
|
icRecentDocs.SubItems.Add(lblItem);
|
|
//icRecentDocs.SubItems.Add();
|
|
for (int i = 0; i < _MyMRIList.Count; i++)
|
|
{
|
|
MostRecentItem mri = _MyMRIList[i];
|
|
ButtonItem btnItem = new ButtonItem();
|
|
string menuTitle = mri.MenuTitle.Replace("\u2011", "-").Replace("\u2572", @"\");
|
|
if (i < 9)
|
|
btnItem.Text = string.Format("<b>&{0}.</b> {1}", i + 1, menuTitle);
|
|
else
|
|
btnItem.Text = string.Format(" {1}", i + 1, menuTitle);
|
|
btnItem.Tag = mri.ItemID;
|
|
btnItem.Tooltip = mri.ToolTip;
|
|
btnItem.Click += new EventHandler(btnItem_Click);
|
|
icRecentDocs.SubItems.Add(btnItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
void btnItem_Click(object sender, EventArgs e)
|
|
{
|
|
ButtonItem btnItem = (ButtonItem)sender;
|
|
MostRecentItem mri = _MyMRIList.Add((int)(btnItem.Tag));
|
|
//SaveMRU();
|
|
SetupMRU();
|
|
if (mri != null) tc.OpenItem(mri.MyItemInfo);
|
|
}
|
|
private void SaveMRU()
|
|
{
|
|
if (_MyMRIList != null) Properties.Settings.Default.MRIList = _MyMRIList.ToSettings();
|
|
Properties.Settings.Default.TreeviewExpanded = epProcedures.Expanded;
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
#endregion
|
|
|
|
#region Tree View
|
|
/// <summary>
|
|
/// Get the selected tree node's properties
|
|
/// </summary>
|
|
/// <param name="node">VETreeNode</param>
|
|
bool SetupNodes(VETreeNode node)
|
|
{
|
|
if (_MyMRIList.Add(node.VEObject) != null)
|
|
SetupMRU();
|
|
#region Sample Display Table Code
|
|
// display an exiting table in that rtf grid thing
|
|
//if ((_LastStepInfo.MyContent.Type == 20007) || (_LastStepInfo.MyContent.Type == 20009))
|
|
//{
|
|
// //MessageBox.Show("Source Grid");
|
|
// //frmTable newtable1 = new frmTable(_LastStepInfo.MyContent.Text);
|
|
// //newtable1.ShowDialog();
|
|
// //MessageBox.Show("IGrid");
|
|
// //frmIGrid newtable2 = new frmIGrid(_LastStepInfo.MyContent.Text);
|
|
// //newtable2.ShowDialog();
|
|
// //MessageBox.Show("GridView"); //standard Visual Studio Control
|
|
// //frmGridView newtable3 = new frmGridView(_LastStepInfo.MyContent.Text);
|
|
// //newtable3.ShowDialog();
|
|
// MessageBox.Show("FlexCell");
|
|
// frmFlexCell newtable4 = new frmFlexCell(_LastStepInfo.MyContent.Text);
|
|
// newtable4.ShowDialog();
|
|
//}
|
|
#endregion
|
|
ItemInfo ii = node.VEObject as ItemInfo;
|
|
if (ii != null) tc.OpenItem(ii);
|
|
SetCaption(node);
|
|
return (ii != null); // return if successful on opening item in step editor or word
|
|
}
|
|
// The following code is used to setup the user interface depending on what
|
|
// is selected on the tree view (see vlnTreeView.cs)
|
|
void tv_NodeNew(object sender, vlnTreeEventArgs args)
|
|
{
|
|
VETreeNode vNode = (VETreeNode)args.Node;
|
|
IVEDrillDownReadOnly veObj = vNode.VEObject;
|
|
SectionInfo mySection = veObj as SectionInfo;
|
|
if (mySection != null && mySection.MyContent.MyEntry != null)
|
|
{
|
|
// if it is a word section, find the DisplayTabItem;
|
|
DisplayTabItem tabItem = tc.GetProcDisplayTabItem(mySection);
|
|
if (tabItem != null) tabItem.MyStepTabPanel.MyStepPanel.Reset();
|
|
}
|
|
// Don't select the newly created Step. This will be handled by tmrTreeView
|
|
//SetupNodes((VETreeNode)args.Node);
|
|
}
|
|
private void tv_NodeSelect(object sender, vlnTreeEventArgs args)
|
|
{
|
|
SetupNodes((VETreeNode)args.Node);
|
|
}
|
|
private void SetCaption(VETreeNode tn)
|
|
{
|
|
StringBuilder caption = new StringBuilder();
|
|
string sep = string.Empty;
|
|
while (tn != null)
|
|
{
|
|
if (tn.VEObject.GetType() == typeof(FolderInfo) || tn.VEObject.GetType() == typeof(DocVersionInfo))
|
|
{
|
|
//caption.Append(sep + tn.Text);
|
|
caption.Insert(0, tn.Text + sep);
|
|
sep = " - ";
|
|
}
|
|
tn = (VETreeNode)tn.Parent;
|
|
}
|
|
caption.Insert(0, VEPROMS.CSLA.Library.Database.DBServer + sep);
|
|
this.Text = caption.ToString();
|
|
}
|
|
void tv_OpenItem(object sender, vlnTreeItemInfoEventArgs args)
|
|
{
|
|
tc.OpenItem(args.MyItemInfo);
|
|
}
|
|
/// <summary>
|
|
/// When the treeview is clicked - a timer is set
|
|
/// This is done because the focus is returned to the treeview after the click event
|
|
/// This approach did not work and was replaced with the code below.
|
|
/// The problem was that each time the treeview was clicked, the last selected node
|
|
/// was opened again, or the edit window was repositioned.
|
|
/// If the item was deleted and another treenode expanded, the click to expand the
|
|
/// node would cause the deleted node to be selected.
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
//private void tv_Click(object sender, EventArgs e)
|
|
//{
|
|
//tv.Enabled = false;
|
|
//tmrTreeView.Enabled = true;
|
|
//}
|
|
/// <summary>
|
|
/// This opens nodes if the mouse is within the bounds of a node.
|
|
/// By using the timer, the focus can be passed to the edit window.
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void tv_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
|
|
{
|
|
_ExpandingTree = false;
|
|
}
|
|
|
|
void tv_MouseUp(object sender, System.Windows.Forms.MouseEventArgs e)
|
|
{
|
|
if (_ExpandingTree)
|
|
{
|
|
_ExpandingTree = false;
|
|
return;
|
|
}
|
|
if (e.Button != MouseButtons.Right)
|
|
{
|
|
Point newPoint = new Point(e.X, e.Y);
|
|
VETreeNode tn = tv.GetNodeAt(newPoint) as VETreeNode;
|
|
// Check to make sure that a node has been selected and
|
|
// that the mouse is within the bounds of the node.
|
|
if (tn != null && tn.Bounds.Left < newPoint.X)
|
|
{
|
|
tv.SelectedNode = tn;
|
|
tv.Enabled = false;
|
|
tmrTreeView.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
if (tn != null && tn.Bounds.Left < newPoint.X + 30)
|
|
return;
|
|
if (tc.SelectedDisplayTabItem != null && tc.SelectedDisplayTabItem.SelectedItemInfo != null)
|
|
{
|
|
// this logic syncs up the place in the procedure tree with the place (step) in the procedure editor (when you click on white space in the tree panel)
|
|
tv.AdjustTree(tc.SelectedDisplayTabItem.SelectedItemInfo);
|
|
tc.SelectedDisplayTabItem.Focus();
|
|
SetCaption(tv.SelectedNode as VETreeNode);
|
|
}
|
|
}
|
|
if (MyParent == null && tn != null && tn.MovedToSeparateWindow)
|
|
{
|
|
if ((tn.VEObject is FolderInfo) && ((tn.VEObject as FolderInfo).FolderDocVersions != null && !PROMSWindowForms.ContainsKey((int)(tn.VEObject as FolderInfo).FolderDocVersions[0].VersionID)) && tn.Nodes.Count == 0 && !tn.ChildrenLoaded)
|
|
{
|
|
tn.MovedToSeparateWindow = false;
|
|
tn.RefreshNode();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
private frmVEPROMS selectedChildWindow = null; // C2015-022 used for separate windows
|
|
private static VolianTimer _TimeActivity2 = new VolianTimer("frmVEPROMS.cs tmrTreeView_Tick", 2697);
|
|
/// <summary>
|
|
/// This event is fired from the timer after the treeview click event completes
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void tmrTreeView_Tick(object sender, EventArgs e)
|
|
{
|
|
|
|
|
|
_TimeActivity2.Open();
|
|
bool giveTvFocus = true;
|
|
tmrTreeView.Enabled = false; // Timer has now fired
|
|
VETreeNode tn = tv.SelectedNode as VETreeNode;
|
|
if (tn != null) giveTvFocus = !SetupNodes(tn);
|
|
tv.Enabled = true;
|
|
if (giveTvFocus) tv.Focus();
|
|
_TimeActivity2.Close();
|
|
}
|
|
private static VolianTimer _TimeActivity3 = new VolianTimer("frmVEPROMS.cs tmrAutomatic_Tick", 2711);
|
|
|
|
private void tmrAutomatic_Tick(object sender, EventArgs e)
|
|
{
|
|
_TimeActivity3.Open();
|
|
tmrAutomatic.Enabled = false; // Timer has now fired
|
|
RunAutomatic();
|
|
_TimeActivity3.Close();
|
|
}
|
|
private bool _ExpandingTree = false;
|
|
private void tv_BeforeExpand(object sender, TreeViewCancelEventArgs e)
|
|
{
|
|
//_MyLog.DebugFormat("tv_BeforeExpand \n{0}",Volian.Base.Library.vlnStackTrace.StackToStringLocal(2,10));
|
|
VETreeNode tn = ((VETreeNode)e.Node);
|
|
if (tn == null)
|
|
return;
|
|
_ExpandingTree = true;
|
|
tn.LoadingChildrenDone -= new VETreeNodeEvent(tn_LoadingChildrenDone);
|
|
tn.LoadingChildrenDone += new VETreeNodeEvent(tn_LoadingChildrenDone);
|
|
tn.LoadingChildrenMax -= new VETreeNodeEvent(tn_LoadingChildrenMax);
|
|
tn.LoadingChildrenMax += new VETreeNodeEvent(tn_LoadingChildrenMax);
|
|
tn.LoadingChildrenValue -= new VETreeNodeEvent(tn_LoadingChildrenValue);
|
|
tn.LoadingChildrenValue += new VETreeNodeEvent(tn_LoadingChildrenValue);
|
|
tn.LoadingChildrenSQL -= new VETreeNodeEvent(tn_LoadingChildrenSQL);
|
|
tn.LoadingChildrenSQL += new VETreeNodeEvent(tn_LoadingChildrenSQL);
|
|
tn.LoadChildren(true);
|
|
}
|
|
#region Property Page and Grid
|
|
DialogResult tv_NodeOpenProperty(object sender, vlnTreePropertyEventArgs args)
|
|
{
|
|
this.Cursor = Cursors.WaitCursor;
|
|
DialogResult dr = DialogResult.Cancel;
|
|
if ((int)Settings.Default["PropPageStyle"] == (int)PropPgStyle.Grid)
|
|
{
|
|
frmPropGrid propGrid = new frmPropGrid(args.ConfigObject, args.Title);
|
|
dr = propGrid.ShowDialog();
|
|
}
|
|
else
|
|
{
|
|
if (args.FolderConfig != null)
|
|
{
|
|
string message = string.Empty;
|
|
if (!MySessionInfo.CanCheckOutItem(args.FolderConfig.MyFolder.FolderID, CheckOutType.Folder, ref message))
|
|
{
|
|
MessageBox.Show(this, message, "Folder Already Checked Out", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
this.Cursor = Cursors.Default;
|
|
return DialogResult.None;
|
|
}
|
|
int ownerID = MySessionInfo.CheckOutItem(args.FolderConfig.MyFolder.FolderID, CheckOutType.Folder);
|
|
frmFolderProperties frmfld = new frmFolderProperties(args.FolderConfig);
|
|
dr = frmfld.ShowDialog();
|
|
if (dr == DialogResult.OK)
|
|
{
|
|
epProcedures.TitleText = getProcedurePanelHeading();// get the panel heading
|
|
Database.DefaultTimeout = 20 * getTimeout();
|
|
}
|
|
MySessionInfo.CheckInItem(ownerID);
|
|
}
|
|
else if (args.DocVersionConfig != null)
|
|
{
|
|
string message = string.Empty;
|
|
if (!MySessionInfo.CanCheckOutItem(args.DocVersionConfig.MyDocVersion.VersionID, CheckOutType.DocVersion, ref message))
|
|
{
|
|
MessageBox.Show(this, message, "Working Draft Already Checked Out", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
this.Cursor = Cursors.Default;
|
|
return DialogResult.None;
|
|
}
|
|
int ownerID = MySessionInfo.CheckOutItem(args.DocVersionConfig.MyDocVersion.VersionID, CheckOutType.DocVersion);
|
|
frmVersionsProperties frmver = new frmVersionsProperties(args.DocVersionConfig);
|
|
frmver.ProgressBar = bottomProgBar;
|
|
frmver.DisplaySearch1 = displaySearch1; //B2017-230 provide access to global search
|
|
dr = frmver.ShowDialog();
|
|
if (frmver._showApplicSearchResults) //B2017-230 open global search with places that specifiy the applicabilty that the user tried to delete
|
|
{
|
|
toolsPanel.Expanded = true;
|
|
toolsTabs.SelectedTab = toolstabResults;
|
|
}
|
|
if (frmver._refreshProcedureList) tv.RefreshDocVersion(); //B2021-066: Refresh Procedure Numbers if Working Draft (docversion) applicability change?
|
|
MySessionInfo.CheckInItem(ownerID);
|
|
}
|
|
else if (args.ProcedureConfig != null)
|
|
{
|
|
string message = string.Empty;
|
|
if (!MySessionInfo.CanCheckOutItem(args.ProcedureConfig.MyProcedure.ItemID, CheckOutType.Procedure, ref message))
|
|
{
|
|
message = message.Replace("\r\nWould You like to open the procedure in View Only Mode?", "");
|
|
MessageBox.Show(this, message, "Procedure Already Checked Out", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
this.Cursor = Cursors.Default;
|
|
return DialogResult.None;
|
|
}
|
|
int ownerID = MySessionInfo.CheckOutItem(args.ProcedureConfig.MyProcedure.ItemID, CheckOutType.Procedure);
|
|
frmProcedureProperties frmproc = new frmProcedureProperties(args.ProcedureConfig);
|
|
dr = frmproc.ShowDialog();
|
|
MySessionInfo.CheckInItem(ownerID);
|
|
}
|
|
else if (args.SectionConfig != null)
|
|
{
|
|
//// If this is a word document, close any edit sessions...
|
|
//ItemInfo ii = null;
|
|
//using (Section tmp = args.SectionConfig.MySection)
|
|
//{
|
|
// ii = ItemInfo.Get(tmp.ItemID);
|
|
// if (!ii.IsStepSection) tc.CloseWordItem(ii);
|
|
//}
|
|
|
|
frmSectionProperties frmsec = new frmSectionProperties(args.SectionConfig);
|
|
string message = string.Empty;
|
|
if (!MySessionInfo.CanCheckOutItem(args.SectionConfig.MySection.MySectionInfo.MyProcedure.ItemID, CheckOutType.Procedure, ref message))
|
|
{
|
|
message = message.Replace("\r\nWould You like to open the procedure in View Only Mode?", "");
|
|
MessageBox.Show(this, message, "Procedure Already Checked Out", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
this.Cursor = Cursors.Default;
|
|
return DialogResult.None;
|
|
}
|
|
int ownerID;
|
|
if (args.SectionConfig.MySection.MyContent.MyEntry.MyDocument == null)
|
|
ownerID = MySessionInfo.CheckOutItem(args.SectionConfig.MySection.MySectionInfo.MyProcedure.ItemID, CheckOutType.Procedure);
|
|
else
|
|
ownerID = MySessionInfo.CheckOutItem(args.SectionConfig.MySection.MyContent.MyEntry.MyDocument.DocID, CheckOutType.Document);
|
|
dr = frmsec.ShowDialog();
|
|
if (dr == DialogResult.OK && displayLibDocs.LibDocList != null)
|
|
{
|
|
displayLibDocs.LibDocListFillIn(tc);
|
|
displayLibDocs.SetSelectedLibDoc();
|
|
}
|
|
|
|
// B2018-126: Refresh libdoc list in case user changed lib doc to non: so it doesn't show up in libdoc panel
|
|
if (dr == DialogResult.Cancel && displayLibDocs.LibDocList != null) displayLibDocs.LibDocListFillIn(tc);
|
|
|
|
MySessionInfo.CheckInItem(ownerID);
|
|
}
|
|
}
|
|
this.Cursor = Cursors.Default;
|
|
return dr;
|
|
}
|
|
#endregion
|
|
#endregion
|
|
|
|
#region ColorStuff
|
|
/// <summary>
|
|
/// Get a System.Drawing.Color from an Argb or color name
|
|
/// </summary>
|
|
/// <param name="strColor">Color Name or "[(alpha,)red,green,blue]"</param>
|
|
/// <returns></returns>
|
|
private static Color cGetColor(string strColor)
|
|
{
|
|
// This was copied from frmFolderProperties.CS
|
|
Color rtnColor;
|
|
if (strColor == null || strColor.Equals(""))
|
|
rtnColor = Color.White;
|
|
else
|
|
{
|
|
if (strColor[0] == '[')
|
|
{
|
|
string[] parts = strColor.Substring(1, strColor.Length - 2).Split(",".ToCharArray());
|
|
int parts_cnt = 0;
|
|
foreach (string s in parts)
|
|
{
|
|
parts[parts_cnt] = parts[parts_cnt].TrimStart(' '); // remove preceeding blanks
|
|
parts_cnt++;
|
|
}
|
|
if (parts_cnt == 3)
|
|
rtnColor = Color.FromArgb(Int32.Parse(parts[0]), Int32.Parse(parts[1]), Int32.Parse(parts[2]));
|
|
else
|
|
rtnColor = Color.FromArgb(Int32.Parse(parts[0].Substring(2)), Int32.Parse(parts[1].Substring(2)), Int32.Parse(parts[2].Substring(2)), Int32.Parse(parts[3].Substring(2)));
|
|
}
|
|
else rtnColor = Color.FromName(strColor);
|
|
}
|
|
return rtnColor;
|
|
}
|
|
//private void SetupEditorColors(DisplayPanel vlnCSLAPanel1, TabPage pg)
|
|
//{
|
|
// // setup color
|
|
// if (_LastFolderInfo == null)
|
|
// {
|
|
// // user didn't select a FolderInfo type of node.
|
|
// // walk up the tree to find the first FolderInfo node type
|
|
// VETreeNode tn = (VETreeNode)(tv.SelectedNode);
|
|
// while (tn != null && tn.VEObject.GetType() != typeof(FolderInfo))
|
|
// tn = (VETreeNode)tn.Parent;
|
|
// _LastFolderInfo = (FolderInfo)(tn.VEObject);
|
|
// _LastFolder = _LastFolderInfo.Get();
|
|
// }
|
|
|
|
// if ((_LastFolderInfo.FolderConfig.Color_editbackground != null) && !(_LastFolderInfo.FolderConfig.Color_editbackground.Equals("")))
|
|
// {
|
|
// vlnCSLAPanel1.ActiveColor = cGetColor(_LastFolderInfo.FolderConfig.Color_editbackground);
|
|
// }
|
|
// if ((_LastFolderInfo.FolderConfig.Default_BkColor != null) && !(_LastFolderInfo.FolderConfig.Default_BkColor.Equals("")))
|
|
// {
|
|
// vlnCSLAPanel1.InactiveColor = _LastFolderInfo.FolderConfig.Default_BkColor;
|
|
// vlnCSLAPanel1.TabColor = vlnCSLAPanel1.InactiveColor;
|
|
// vlnCSLAPanel1.PanelColor = vlnCSLAPanel1.InactiveColor;
|
|
// pg.BackColor = vlnCSLAPanel1.InactiveColor;
|
|
// }
|
|
//}
|
|
#endregion
|
|
|
|
#region Table Insert Sample Code
|
|
// TODO: for tables
|
|
//private void btnInsTable_Click(object sender, EventArgs e)
|
|
//{
|
|
// Point loc = btnInsTable.DisplayRectangle.Location;
|
|
// loc.X += 300;
|
|
// int top = this.Top + (btnInsTable.Size.Height * 2);
|
|
// TablePickerDlg(sender, e, loc, top);
|
|
//}
|
|
|
|
//private void TablePickerDlg(object sender, EventArgs e, Point loc, int top)
|
|
//{
|
|
// Accentra.Controls.TablePicker tp = new Accentra.Controls.TablePicker();
|
|
// tp.Location = loc;
|
|
// tp.Top += top;
|
|
// tp.Show();
|
|
// while (tp.Visible)
|
|
// {
|
|
// Application.DoEvents();
|
|
// System.Threading.Thread.Sleep(0);
|
|
// }
|
|
// // This was used to display a dialog containing a table grid
|
|
// // using a product called Source Grid - was for demo purposes only
|
|
// //
|
|
// //if (!tp.Cancel)
|
|
// //{
|
|
// // frmTable newtable = new frmTable(tp.SelectedRows, tp.SelectedColumns);
|
|
// // newtable.Show();
|
|
// //}
|
|
//}
|
|
#endregion
|
|
|
|
#region Progress Bar
|
|
|
|
/// <summary>
|
|
/// Used for the status bar in the lower left corner of the main screen
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
void tn_LoadingChildrenSQL(object sender, VETreeNodeEventArgs args)
|
|
{
|
|
ProgBarText = "Loading SQL";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Used for the status bar in the lower left corner of the main screen
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
void tn_LoadingChildrenValue(object sender, VETreeNodeEventArgs args)
|
|
{
|
|
ProgBarValue = args.Value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Used for the status bar in the lower left corner of the main screen
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
void tn_LoadingChildrenMax(object sender, VETreeNodeEventArgs args)
|
|
{
|
|
//_MyLog.DebugFormat("tn_LoadingChildrenMax \n{0}", Volian.Base.Library.vlnStackTrace.StackToStringLocal(2, 10));
|
|
ProgBarMax = args.Value;
|
|
ProgBarText = "Loading...";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Used for the status bar in the lower left corner of the main screen
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
void tn_LoadingChildrenDone(object sender, VETreeNodeEventArgs args)
|
|
{
|
|
if (VlnSettings.DebugMode)
|
|
ProgBarText = args.Info + " Seconds";
|
|
else
|
|
ProgBarText = "";
|
|
}
|
|
|
|
public int ProgBarMax
|
|
{
|
|
get { return bottomProgBar.Maximum; }
|
|
set { bottomProgBar.Maximum = value; }
|
|
}
|
|
|
|
public int ProgBarValue
|
|
{
|
|
get { return bottomProgBar.Value; }
|
|
set { bottomProgBar.Value = value; }
|
|
}
|
|
|
|
public string ProgBarText
|
|
{
|
|
get { return bottomProgBar.Text; }
|
|
set
|
|
{
|
|
bottomProgBar.TextVisible = true;
|
|
bottomProgBar.Text = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Find/Replace and Search
|
|
|
|
/// <summary>
|
|
/// Find/Replace button on the ribbon
|
|
/// Display the Find/Replace dialog
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
//private void btnFindRplDlg_Click_1(object sender, EventArgs e)
|
|
//{
|
|
// FindReplace frmFindRepl = new FindReplace();
|
|
// frmFindRepl.Show();
|
|
//}
|
|
|
|
/// <summary>
|
|
/// Global Search button on the ribbon
|
|
/// Opens the Information Pannel and selects the Results tab
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
//private void btnGlbSrch_Click(object sender, EventArgs e)
|
|
//{
|
|
// toolsPanel.Expanded = true;
|
|
// toolsTabs.SelectedTab = toolstabResults;
|
|
//}
|
|
|
|
#endregion
|
|
|
|
#region Similar Steps
|
|
|
|
/// <summary>
|
|
/// Similar Steps button on the ribbon
|
|
/// Opens the Information Pannel and selects the Results tab
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btnSimStps_Click(object sender, EventArgs e)
|
|
{
|
|
//infoPanel.Expanded = true;
|
|
//infoTabs.SelectedTab = toolstabResults;
|
|
//btnSimStpsRslt.Checked = true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Help/About
|
|
|
|
/// <summary>
|
|
/// About button on the ribbon
|
|
/// Display the About dialog
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btnAbout_Click(object sender, EventArgs e)
|
|
{
|
|
AboutVEPROMS about = new AboutVEPROMS();
|
|
about.ShowDialog();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Volian Web button on the ribbon
|
|
/// display the Volian web site on a pop up form
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btnVlnWeb_Click(object sender, EventArgs e)
|
|
{
|
|
//VlnWeb veWWW = new VlnWeb();
|
|
//veWWW.Show();
|
|
System.Diagnostics.Process sdp = System.Diagnostics.Process.Start("http://www.volian.com");
|
|
//sdp.WaitForInputIdle();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Ribbon
|
|
/// <summary>
|
|
/// This Opens the treeView or opens the selected item in the TreeView
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btnOpen_Click(object sender, EventArgs e)
|
|
{
|
|
if (!epProcedures.Expanded) // If panel not expanded - expand it.
|
|
{
|
|
epProcedures.Expanded = true;
|
|
if (tv.Nodes.Count > 0 && tv.SelectedNode == null)
|
|
tv.SelectedNode = tv.Nodes[0];
|
|
tv.Focus();
|
|
}
|
|
else
|
|
{
|
|
// TODO: DeleteMe
|
|
//VETreeNode tn = (VETreeNode)(tv.SelectedNode);
|
|
tv.OpenNode();
|
|
}
|
|
}
|
|
private void btnNew_Click(object sender, EventArgs e)
|
|
{
|
|
if (!epProcedures.Expanded) return;
|
|
VETreeNode vtn = tv.SelectedNode as VETreeNode;
|
|
if (vtn == null) return; // nothing was selected.
|
|
if (btnNew.SubItems.Count > 0) return; // submenu will be displayed
|
|
vtn.Expand();
|
|
|
|
// Determine type of 'new' based on tree node's object type. The
|
|
// only options here are those that would not have created, based on
|
|
// containers, a submenu (see the office2007buttonstartbutton1_click code)
|
|
FolderInfo fi = vtn.VEObject as FolderInfo;
|
|
if (fi != null)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.Folder);
|
|
return;
|
|
}
|
|
|
|
DocVersionInfo dvi = vtn.VEObject as DocVersionInfo;
|
|
if (dvi != null)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.Procedure);
|
|
return;
|
|
}
|
|
|
|
// All other types are handled with sub-menus.
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Options button on the dialog that appears when the V icon is clicked (top left of application window)
|
|
/// note that the "V icon" is also called the Office 2007 Start Button
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btnOptions_Click(object sender, EventArgs e)
|
|
{
|
|
frmSysOptions VeSysOpts = new frmSysOptions();
|
|
VeSysOpts.CanChangeSeparateWindowsSetting = !tc.MoreThanOneProcedureSetIsOpen;
|
|
VeSysOpts.ShowDialog();
|
|
StepTabRibbon.PasteNoReturnsSetting = Properties.Settings.Default.PasteNoReturns;
|
|
StepTabRibbon.PastePlainTextSetting = Properties.Settings.Default.PastePlainText;
|
|
StepTabRibbon.SpecifiedVisioPath = Properties.Settings.Default.VisioPath;
|
|
tc.SyncEnhancedDocuments = Properties.Settings.Default.SyncEnhancedDocuments;
|
|
tc.SeparateWindows = Properties.Settings.Default.SeparateWindows;
|
|
}
|
|
/// <summary>
|
|
/// Exit button on the dialog that appears when the V icon is clicked (top left of application window)
|
|
/// note that the "V icon" is also called the Office 2007 Start Button
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btnExit_Click(object sender, EventArgs e)
|
|
{
|
|
this.Close();
|
|
}
|
|
#endregion
|
|
|
|
#region InfoTabRO
|
|
|
|
private void infotabRO_Click(object sender, EventArgs e)
|
|
{
|
|
infoPanel.Expanded = true;
|
|
infoTabs.SelectedTab = infotabRO;
|
|
|
|
displayRO.ProgressBar = bottomProgBar;
|
|
|
|
displayRO.MyRTB = (SelectedStepTabPanel == null) ? null :
|
|
SelectedStepTabPanel.MyStepPanel.SelectedEditItem == null ? null : SelectedStepTabPanel.MyStepPanel.SelectedEditItem.MyStepRTB;
|
|
|
|
displayRO.LoadTree(); //B2022-026 RO Memory reduction coding (Jakes Merge)
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InfoTabTransition
|
|
|
|
private void infotabTransition_Click(object sender, EventArgs e)
|
|
{
|
|
if (tc == null || tc.SelectedDisplayTabItem == null) return;
|
|
if (SelectedStepTabPanel == null) return;
|
|
displayTransition.MyRTB = SelectedStepTabPanel.MyStepPanel.SelectedEditItem.MyStepRTB;
|
|
//displayTransition.RangeColor = global::VEPROMS.Properties.Settings.Default.TransitionRangeColor;
|
|
// RHM - The follwing line was reseting the settings on the transtion panel to "not" show the currently selected transition.
|
|
//displayTransition.CurTrans = null;
|
|
}
|
|
#endregion
|
|
|
|
#region InfoTabLibDocs
|
|
private void tabItemLibDocs_Click(object sender, EventArgs e)
|
|
{
|
|
displayLibDocs.RefreshLibDocPanel(tc);
|
|
//displayLibDocs.LibDocListFillIn(tc);
|
|
}
|
|
private void tv_SectionShouldClose(object sender, vlnTreeSectionInfoEventArgs args)
|
|
{
|
|
if (!args.MySectionInfo.IsStepSection) tc.CloseWordItem(args.MySectionInfo, args.IsDeleting);
|
|
else
|
|
{
|
|
if (tc == null) return;
|
|
StepTabPanel tp = tc.GetProcedureTabPanel(args.MySectionInfo as ItemInfo);
|
|
if (tp == null) return;
|
|
DisplayTabItem ti = tp.MyDisplayTabItem;
|
|
tc.CloseTabItem(ti);
|
|
}
|
|
}
|
|
private void tv_WordSectionDeleted(object sender, WordSectionEventArgs args)
|
|
{
|
|
// is it a library document - if so and libdoc panel is visible, update lists on panel.
|
|
// entry is null if it's a table of contents.
|
|
if ((!args.MySectionInfo.IsStepSection) && (args.MySectionInfo.MyContent.MyEntry != null) && ((args.MySectionInfo.MyContent.MyEntry.MyDocument.LibTitle ?? "") != "") && (toolsPanel.Expanded))
|
|
{
|
|
if (toolsTabs.SelectedTab == tabItemLibDocs)
|
|
{
|
|
displayLibDocs.RefreshLibDocPanel(tc);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region InfoTabTags
|
|
private void infotabTags_Click(object sender, EventArgs e)
|
|
{
|
|
infoPanel.Expanded = true;
|
|
infoTabs.SelectedTab = infotabTags;
|
|
displayTags.MyEditItem = (SelectedStepTabPanel == null) ? null : SelectedStepTabPanel.MyStepPanel.SelectedEditItem;
|
|
displayTags.Mydvi = SelectedDVI;
|
|
}
|
|
#endregion
|
|
|
|
#region InfoTabBookMarks
|
|
private void infotabBookMarks_Click(object sender, EventArgs e)
|
|
{
|
|
infoPanel.Expanded = true;
|
|
infoTabs.SelectedTab = infotabTags;
|
|
displayTags.MyEditItem = (SelectedStepTabPanel == null) ? null : SelectedStepTabPanel.MyStepPanel.SelectedEditItem;
|
|
}
|
|
#endregion
|
|
|
|
#region PanelSupport
|
|
private void tc_WordSectionClose(object sender, WordSectionEventArgs args)
|
|
{
|
|
if (!args.MySectionInfo.IsStepSection) tc.CloseWordItem(args.MySectionInfo);
|
|
}
|
|
private void tc_WordSectionDeleted(object sender, WordSectionEventArgs args)
|
|
{
|
|
// is it a library document - if so and libdoc panel is visible, update lists on panel.
|
|
if ((!args.MySectionInfo.IsStepSection) && (args.MySectionInfo.MyContent.MyEntry != null && (args.MySectionInfo.MyContent.MyEntry.MyDocument.LibTitle ?? "") != "") && (toolsPanel.Expanded))
|
|
{
|
|
if (toolsTabs.SelectedTab == tabItemLibDocs)
|
|
{
|
|
displayLibDocs.RefreshLibDocPanel(tc);
|
|
}
|
|
}
|
|
}
|
|
private void tc_ItemPasted(object sender, vlnTreeItemInfoPasteEventArgs args)
|
|
{
|
|
// all this needs to do is refresh the libdoc display - if it is visible
|
|
// and the current item is word section, i.e. it may be a lib doc & would
|
|
// require refresh of the lib doc panel.
|
|
if (toolsTabs.SelectedTab == tabItemLibDocs && args.MyItemInfo.IsSection)
|
|
{
|
|
SectionInfo si = args.MyItemInfo as SectionInfo;
|
|
if (si != null && (si.MyContent.MyEntry.MyDocument.LibTitle ?? "") != "") displayLibDocs.RefreshLibDocPanel(tc);
|
|
}
|
|
displayHistory.RefreshChangeList();
|
|
}
|
|
private void tc_PanelTabDisplay(object sender, StepPanelTabDisplayEventArgs args)
|
|
{
|
|
if (_SelectedDVI == null) return;
|
|
|
|
if (args.PanelTabName == "Bookmarks")
|
|
{
|
|
toolsPanel.Expanded = true;
|
|
toolsTabs.SelectedTab = toolsTabBookMarks;
|
|
if (_CurrentItem != null && !dlgFindReplace.Visible) displayBookMarks.AddBookMark(_CurrentItem);
|
|
}
|
|
else if (args.PanelTabName == "Global Search")
|
|
{
|
|
toolsPanel.Expanded = true;
|
|
toolsTabs.SelectedTab = toolstabResults;
|
|
}
|
|
else if (args.PanelTabName == "LibDocs")
|
|
{
|
|
toolsPanel.Expanded = true;
|
|
toolsTabs.SelectedTab = tabItemLibDocs;
|
|
toolsTabs.SelectedTab.PerformClick();
|
|
}
|
|
else if (args.PanelTabName == "Annots")
|
|
{
|
|
epAnnotations.Expanded = true;
|
|
}
|
|
else if (args.PanelTabName == "Change Step Type")
|
|
{
|
|
infoPanel.Expanded = true;
|
|
infoTabs.SelectedTab = infotabTags;
|
|
displayTags.HighlightChangeStep();
|
|
}
|
|
else if (args.PanelTabName == "Change Image Size")
|
|
{
|
|
// B2016-237 added context menu item to change image size
|
|
infoPanel.Expanded = true;
|
|
infoTabs.SelectedTab = infotabTags;
|
|
displayTags.FocusOnImageSize();
|
|
}
|
|
else if (args.PanelTabName == "FndRpl")
|
|
{
|
|
dlgFindReplace.InApproved = (_SelectedDVI != null && _SelectedDVI.VersionType == 127);
|
|
dlgFindReplace.Mydocversion = _SelectedDVI;
|
|
dlgFindReplace.Visible = true;
|
|
dlgFindReplace.MyDisplayBookMarks = displayBookMarks;
|
|
dlgFindReplace.SetFocusToTextBox(); // bug fix: B2016-107, when Find/Replace is initially opened, set the cursor focus to the Find Text box
|
|
}
|
|
else if (args.PanelTabName == "SpellChecker")
|
|
{
|
|
SpellChecker.DoSpellCheck();
|
|
}
|
|
else if (args.PanelTabName == "DisplayROUpdateROFST")
|
|
{
|
|
_SelectedROFst = null;
|
|
|
|
// need this to update RO Tree after UpdateRofst (B2015-226)
|
|
// B2022-026 RO Memory reduction coding (Jakes Merge)
|
|
displayRO.MyROFST = SelectedROFst;
|
|
displayRO.LoadTree();
|
|
|
|
// resetting the MyROFSTLookup for the search & reports panels will refresh the RO trees after UpdateRofst in each of those panels (B2015-226)
|
|
if (SelectedDVI != null)
|
|
{
|
|
displaySearch1.MyROFSTLookup = SelectedDVI.DocVersionAssociations[0].MyROFst.GetROFSTLookup(SelectedDVI);
|
|
displayReports.Mydocversion = SelectedDVI; // B2022-026 RO Memory reduction coding (Jakes Merge)
|
|
}
|
|
}
|
|
}
|
|
private void tc_SelectedDisplayTabItemChanged(object sender, EventArgs args)
|
|
{
|
|
if (tc.ShuttingDown) return; // B2022-026 RO Memory Reduction code - to prevent refreshing the RO tree again
|
|
// If the current procedure or section in the treeview doesn't match then change the treeview selection.
|
|
//jcb added for error B2012-117
|
|
ItemInfo tvii;
|
|
if (tv.SelectedNode == null)
|
|
tvii = null;
|
|
else
|
|
tvii = ((tv.SelectedNode as VETreeNode).VEObject) as ItemInfo;
|
|
|
|
if (tc.SelectedDisplayTabItem == null) return;
|
|
if (tc.SelectedDisplayTabItem.MyItemInfo == null) return; // library document.
|
|
|
|
if (tc.SelectedDisplayTabItem.MyItemInfo.IsProcedure)
|
|
{
|
|
if (tvii == null || tvii.IsSection || tc.SelectedDisplayTabItem.MyItemInfo.ItemID != tvii.MyProcedure.ItemID)
|
|
tv.AdjustTree(tc.SelectedDisplayTabItem.MyItemInfo);
|
|
}
|
|
else
|
|
{
|
|
if (tvii == null || tc.SelectedDisplayTabItem.MyItemInfo.ItemID != tvii.ItemID)
|
|
tv.AdjustTree(tc.SelectedDisplayTabItem.MyItemInfo);
|
|
}
|
|
|
|
// the following line will determine if the format uses the change id feature, and if so
|
|
// either prompts the user for change id, or uses an already input one if the procedure has been
|
|
// accessed. This gets run when the user clicks on procedure tabs in the step editor.
|
|
tc.HandleChangeId(tc.SelectedDisplayTabItem.MyItemInfo, tc.SelectedDisplayTabItem);
|
|
|
|
SetCaption(tv.SelectedNode as VETreeNode);
|
|
displayApplicability.MyDisplayTabItem = tc.SelectedDisplayTabItem;
|
|
|
|
if (tc.SelectedDisplayTabItem.MyItemInfo.MyDocVersion.DocVersionAssociationCount > 0)
|
|
{
|
|
displayRO.MyROFST = tc.SelectedDisplayTabItem.MyItemInfo.MyDocVersion.DocVersionAssociations[0].MyROFst;
|
|
}
|
|
else
|
|
{
|
|
displayRO.MyROFST = null;
|
|
}
|
|
|
|
// B2022-026 RO Memory reduction coding (Jakes Merge)
|
|
// B2022-123: RO Tab Treeview not showing correct RO values when switching between procedures. (Added True for the forceLoad parameter)
|
|
displayRO.LoadTree(true);
|
|
|
|
lblUser.Text = tc.SelectedDisplayTabItem.MyUserRole;
|
|
|
|
|
|
// Reset the ribbon buttons B2016-148 (ex. a copystep done in a different procedure tab my require the paste step options to be active
|
|
if (tc.SelectedDisplayTabItem != null && tc.SelectedDisplayTabItem.MyStepTabPanel != null) // MyStepTabPanel will be null if the active tab is a Word Attachment
|
|
{
|
|
StepPanel pnl = tc.SelectedDisplayTabItem.MyStepTabPanel.MyStepPanel;
|
|
if (pnl != null)
|
|
{
|
|
// C2021-021 change the tool tip for the Find and Find/Replace button based on the user's accessibility to the procedure.
|
|
// also change the text on the buttons to read either Find or Find/Replace
|
|
// also toggle the Replace tab on the dialog based on the user's accessibility to the procedure
|
|
bool isReviewer = !MyUserInfo.IsAllowedToEdit(tc.SelectedDisplayTabItem.MyItemInfo.MyDocVersion);
|
|
pnl.MyStepTabPanel.MyStepTabRibbon.SetButtonAndMenuEnabling(true);
|
|
this.dlgFindReplace.ToggleReplaceTab(isReviewer ? E_ViewMode.View : E_ViewMode.Edit);
|
|
pnl.MyStepTabPanel.MyStepTabRibbon.ToggleFindReplaceToolTip(isReviewer);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void tc_StepPanelModeChange(object sender, StepRTBModeChangeEventArgs args)
|
|
{
|
|
this.lblEditView.Text = args.ViewMode == E_ViewMode.Edit ? "Edit" : "View";
|
|
this.dlgFindReplace.ToggleReplaceTab(args.ViewMode);
|
|
// C2021-021 change the tool tip for the Find and Find/Replace button based on the user's accessibility to the procedure.
|
|
// also change the text on the buttons to read either Find or Find/Replace
|
|
// B2021-044 Added a null reference check. Happend when nothing is opened but a search for Incoming Transitions was done
|
|
// and you clicked on a found reference from the Search panel (the user had to have ViewOnly security setting)
|
|
if (tc.SelectedDisplayTabItem != null && tc.SelectedDisplayTabItem.MyStepTabPanel != null && tc.SelectedDisplayTabItem.MyStepTabPanel.MyStepTabRibbon != null)
|
|
tc.SelectedDisplayTabItem.MyStepTabPanel.MyStepTabRibbon.ToggleFindReplaceToolTip(args.ViewMode == E_ViewMode.View);
|
|
}
|
|
|
|
private ItemInfo _CurrentItem = null;
|
|
private StepRTB _LastStepRTB = null;
|
|
//private Timer _TmrRefreshItem = null;
|
|
//public Timer TmrRefreshItem
|
|
//{
|
|
// get
|
|
// {
|
|
// if (_TmrRefreshItem == null)
|
|
// {
|
|
// _TmrRefreshItem = new Timer();
|
|
// _TmrRefreshItem.Interval = 1000; // one second
|
|
// _TmrRefreshItem.Tick += _TmrRefreshItem_Tick;
|
|
// }
|
|
// return _TmrRefreshItem;
|
|
// }
|
|
//}
|
|
//private StepRTB _RefreshRTB = null;
|
|
//void _TmrRefreshItem_Tick(object sender, EventArgs e)
|
|
//{
|
|
// _TmrRefreshItem.Enabled = false;
|
|
// if (_RefreshRTB != null) _RefreshRTB.Focus();
|
|
//}
|
|
|
|
private void tc_ItemSelectedChanged(object sender, ItemSelectedChangedEventArgs args)
|
|
{
|
|
tc.HideTheCaret();
|
|
|
|
if (args != null && args.MyEditItem != null && !args.MyEditItem.MyStepPanel.ContainsFocus)
|
|
return;
|
|
|
|
if (_LastStepRTB != null && !_LastStepRTB.Disposing && !_LastStepRTB.Closed)
|
|
_LastStepRTB.EditModeChanged -= new StepRTBEvent(_LastStepRTB_EditModeChanged);
|
|
|
|
_LastStepRTB = args != null && args.MyEditItem != null ? args.MyEditItem.MyStepRTB : null;
|
|
if (_LastStepRTB != null)
|
|
{
|
|
_LastStepRTB.EditModeChanged -= new StepRTBEvent(_LastStepRTB_EditModeChanged);
|
|
_LastStepRTB.EditModeChanged += new StepRTBEvent(_LastStepRTB_EditModeChanged);
|
|
}
|
|
lblEditView.Text = " ";
|
|
|
|
if (args == null)
|
|
{
|
|
_CurrentItem = null;
|
|
ctrlAnnotationDetails.CurrentAnnotation = null;
|
|
ctrlAnnotationDetails.Annotations = null;
|
|
infotabFoldoutMaint.Visible = infotabRO.Visible = infotabTransition.Visible = infotabTags.Visible = infotabHistory.Visible = infotabApplicability.Visible = false;
|
|
ctrlAnnotationDetails.Enabled = false;
|
|
epAnnotations.Enabled = false;
|
|
epAnnotations.Expanded = false;
|
|
// When infotabTags is set to InVisible, the matching panel also needs to be set to invisible
|
|
infotabControlPanelTags.Visible = false;
|
|
displayTags.MyEditItem = null;
|
|
displayTags.Visible = false;
|
|
SelectedStepTabPanel = null;
|
|
lblItemID.Text = "No Item Selected";
|
|
lblItemID.ForeColor = Color.Yellow;
|
|
}
|
|
else
|
|
{
|
|
lblItemID.Text = string.Format("ItemID = {0}", args.MyItemInfo.ItemID);
|
|
lblItemID.ForeColor = Color.DarkBlue;
|
|
|
|
if (_CurrentItem != args.MyItemInfo)
|
|
{
|
|
if (_CurrentItem != null) _CurrentItem.Deleted -= new ItemInfoEvent(_CurrentItem_Deleted);
|
|
_CurrentItem = args.MyItemInfo;
|
|
}
|
|
|
|
if (args.MyEditItem == null)
|
|
{
|
|
ctrlAnnotationDetails.Enabled = false;
|
|
epAnnotations.Enabled = false;
|
|
infotabFoldoutMaint.Visible = false;
|
|
infotabTransition.Visible = false;
|
|
infotabRO.Visible = false;
|
|
|
|
if (args.MyItemInfo.MyDocVersion.DocVersionAssociations != null)
|
|
{
|
|
infotabRO.Visible = true;
|
|
|
|
// B2022-026 RO Memory reduction coding (Jakes Merge)
|
|
displayRO.MyRTB = null;
|
|
displayRO.LoadTree();
|
|
}
|
|
|
|
infotabTags.Visible = false;
|
|
infotabApplicability.Visible = false;
|
|
// Not sure why but the following line was causing a hang if
|
|
// you opened a procedure
|
|
// and then created a word section
|
|
// and then you selected the procedure "Tab"
|
|
infotabHistory.Visible = false;
|
|
displayBookMarks.MyEditItem = null;
|
|
displayFoldoutMaint.Visible = false;
|
|
//vlnStackTrace.ShowStack("enter tc_ItemSelectedChanged {0}", _CurrentItem);
|
|
}
|
|
else
|
|
{
|
|
epAnnotations.Enabled = true;
|
|
ctrlAnnotationDetails.Enabled = true;
|
|
|
|
if (args.MyEditItem.MyItemInfo.IsSection || args.MyEditItem.MyItemInfo.IsProcedure)
|
|
{
|
|
infotabRO.Visible = false; // B2022-039 Do NOT allow ROs to be inserted in section or procedures // B2017-245 Allow Ro Menu to be seen for Procedures and Sections
|
|
infotabTransition.Visible = false;
|
|
infotabTags.Visible = false;
|
|
displayTags.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
infotabTags.Visible = true;
|
|
|
|
if (_LastStepRTB != null)
|
|
{
|
|
infotabRO.Visible = _LastStepRTB.MyItemInfo.MyDocVersion.DocVersionAssociationCount > 0;
|
|
infotabTransition.Visible = !_CurrentItem.IsFigure && !_CurrentItem.IsRtfRaw;
|
|
// don't allow RO insert for a non-RO figure. First check that it is visible (from above line of code),
|
|
// and allow for non-figures or RO figures (for replace of existing RO figures)
|
|
infotabRO.Visible = infotabRO.Visible && (!_CurrentItem.IsRtfRaw && (!_CurrentItem.IsFigure || (_CurrentItem.IsFigure && _CurrentItem.MyContent.MyImage == null)));
|
|
displayRO.Enabled = _LastStepRTB.EditMode || _LastStepRTB.IsRoTable;
|
|
displayTransition.Enabled = _LastStepRTB.EditMode;
|
|
}
|
|
else
|
|
{
|
|
infotabRO.Visible = infotabTransition.Visible = false;
|
|
}
|
|
|
|
// When infotabTags is set to Visible, the matching panel also needs to be set to visible
|
|
// the other panels will appear as they are selected by the user.
|
|
infotabControlPanelTags.Visible = true;
|
|
displayTags.IsVisible = true;
|
|
}
|
|
|
|
infotabHistory.Visible = true;
|
|
// C2021-027: Procedure level PC/PC
|
|
// B2021-065: wasn't showing applicability tab for formats that didn't have procedure level flag.
|
|
if (args.MyItemInfo.MyDocVersion.MultiUnitCount > 1 && (!args.MyItemInfo.IsProcedure || args.MyItemInfo.ActiveFormat.PlantFormat.FormatData.ProcData.ProcAppl))//&& !args.MyItemInfo.IsProcedure)
|
|
{
|
|
infotabApplicability.Visible = true;
|
|
displayApplicability.MyItemInfo = args.MyEditItem.MyItemInfo;
|
|
}
|
|
else
|
|
{
|
|
infotabApplicability.Visible = false;
|
|
}
|
|
|
|
if (args.MyEditItem.MyItemInfo.ActiveFormat != null)
|
|
{
|
|
// see if format has floating foldouts, and if so, display the panel.
|
|
if (args.MyEditItem.MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.AlternateFloatingFoldout)
|
|
{
|
|
infotabFoldoutMaint.Visible = true;
|
|
|
|
displayFoldoutMaint.Visible = true;
|
|
displayFoldoutMaint.Enabled = true;
|
|
displayFoldoutMaint.MyItemInfo = args.MyItemInfo;
|
|
}
|
|
}
|
|
|
|
// When infotabTags is set to Visible, it is given focus. The next line returns focus to the StepRTB
|
|
args.MyEditItem.SetFocus();
|
|
displayTransition.MyRTB = args.MyEditItem.MyStepRTB;
|
|
|
|
// B2022-026 RO Memory reduction coding (Jakes Merge)
|
|
displayRO.ProgressBar = bottomProgBar;
|
|
displayRO.MyRTB = args.MyEditItem.MyStepRTB;
|
|
displayRO.LoadTree();
|
|
|
|
displayBookMarks.MyEditItem = args.MyEditItem;
|
|
displayHistory.MyEditItem = args.MyEditItem;
|
|
|
|
lblEditView.Text = args.MyEditItem.MyStepPanel.VwMode == E_ViewMode.Edit ? "Edit" : "View";
|
|
_CurrentItem.Deleted -= new ItemInfoEvent(_CurrentItem_Deleted);
|
|
_CurrentItem.Deleted += new ItemInfoEvent(_CurrentItem_Deleted);
|
|
dlgFindReplace.MyEditItem = args.MyEditItem;
|
|
SpellChecker.MyEditItem = args.MyEditItem;
|
|
}
|
|
|
|
if (args.MyEditItem != null)
|
|
{
|
|
SelectedStepTabPanel = args.MyEditItem.MyStepPanel.MyStepTabPanel;
|
|
displayTags.Mydvi = SelectedDVI;
|
|
displayTags.MyEditItem = args.MyEditItem;
|
|
|
|
displayRO.ROTypeFilter = SelectedStepTabPanel.MyStepPanel.SelectedEditItem is Volian.Controls.Library.GridItem && (SelectedStepTabPanel.MyStepPanel.SelectedEditItem as Volian.Controls.Library.GridItem).MyFlexGrid.IsRoTable ?
|
|
E_ROValueType.Table : (SelectedStepTabPanel.MyStepPanel.SelectedEditItem.MyItemInfo.IsFigure) ? E_ROValueType.Image : E_ROValueType.Text;
|
|
|
|
if (_LastStepRTB.IsRoTable && _LastStepRTB.MyItemInfo.MyContent.ContentRoUsageCount > 0)
|
|
displayRO.CurROLink = _LastStepRTB.MyItemInfo.MyContent.ContentRoUsages[0];
|
|
|
|
if (_LastStepRTB.IsRoFigure && _LastStepRTB.MyItemInfo.MyContent.ContentRoUsageCount > 0)
|
|
displayRO.CurROLink = _LastStepRTB.MyItemInfo.MyContent.ContentRoUsages[0];
|
|
|
|
|
|
// B2022-026 RO Memory reduction coding (Jakes Merge)
|
|
displayRO.SetFindDocROButton(false);
|
|
displayRO.LoadTree();
|
|
|
|
//C2019-036 View Only mode work with Checked Out Procedures
|
|
//In View Only Mode - Step Properties should be disabled
|
|
EnableDisableStepProperties(sender, new StepTabRibbonEventArgs(args.MyEditItem.MyItemInfo, 0, args.MyEditItem.MyStepPanel.VwMode));
|
|
|
|
}
|
|
else
|
|
{
|
|
//B2017-244 Open RO Panel for MSWord Sections
|
|
if (args.MyItemInfo != null && args.MyItemInfo.MyDocVersion != null && args.MyItemInfo.MyDocVersion.DocVersionAssociationCount > 0)
|
|
{
|
|
displayRO.MyROFST = args.MyItemInfo.MyDocVersion.DocVersionAssociations[0].MyROFst;
|
|
}
|
|
|
|
// B2022-026 RO Memory reduction coding (Jakes Merge)
|
|
SelectedDVI = args.MyItemInfo.MyDocVersion;
|
|
displayRO.MyDvi = SelectedDVI;
|
|
displayRO.ROTypeFilter = E_ROValueType.All; // allow all RO types for Word attachments (but fix)
|
|
|
|
displayRO.SetFindDocROButton(true);
|
|
displayRO.LoadTree();
|
|
}
|
|
}
|
|
|
|
if (ctrlAnnotationDetails.Enabled && epAnnotations.Enabled)
|
|
{
|
|
ctrlAnnotationDetails.UpdateAnnotationGrid(_CurrentItem);
|
|
AnnotationPanelView();
|
|
}
|
|
else if (_CurrentItem != null) // B2017-127, B2017-131 Send message when a MSWord section is opened.
|
|
{
|
|
ctrlAnnotationDetails.UpdateAnnotationGrid(_CurrentItem); // set the CurrentItem (send Message) when the MSWord section is opened.
|
|
}
|
|
|
|
}
|
|
|
|
//C2019-036 View Only mode work with Checked Out Procedures
|
|
//In View Only Mode - Step Properties should be disabled
|
|
public void EnableDisableStepProperties(object sender, StepTabRibbonEventArgs args)
|
|
{
|
|
if (args.ViewMode == E_ViewMode.View && (infoTabs.Enabled || infoTabs.SelectedTab != infotabTags))
|
|
{
|
|
infoTabs.Enabled = true;
|
|
infoTabs.SelectedTab = infotabTags;
|
|
infoTabs.Enabled = false;
|
|
}
|
|
else if (args.ViewMode != E_ViewMode.View && !infoTabs.Enabled)
|
|
{
|
|
infoTabs.Enabled = true;
|
|
}
|
|
}
|
|
|
|
void _LastStepRTB_EditModeChanged(object sender, EventArgs args)
|
|
{
|
|
if (_LastStepRTB.EditMode) // going into edit mode in a cell of the grid.
|
|
displayRO.Enabled = displayTransition.Enabled = _LastStepRTB.EditMode;
|
|
else // going out of edit mode in a cell of the grid.
|
|
{
|
|
if (this.ActiveControl != tc || (!_LastStepRTB.Parent.Focused && (infotabRO.IsSelected || infotabTransition.IsSelected))) return;
|
|
displayRO.Enabled = displayTransition.Enabled = _LastStepRTB.EditMode;
|
|
}
|
|
}
|
|
|
|
void _CurrentItem_Deleted(object sender)
|
|
{
|
|
//displayBookMarks.DeleteItemBookMarkPanel(_CurrentItem);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Annotations
|
|
|
|
/// <summary>
|
|
/// Display or hide the Annotation Details panel
|
|
/// </summary>
|
|
private void AnnotationPanelView()
|
|
{
|
|
if (ctrlAnnotationDetails.Annotations != null && ctrlAnnotationDetails.Annotations.Count != 0)
|
|
{
|
|
if (Settings.Default.AutoPopUpAnnotations) //cbAnnotationPopup.Checked
|
|
epAnnotations.Expanded = true;
|
|
else
|
|
epAnnotations.TitleStyle.BackColor1.Color = Color.Yellow;
|
|
}
|
|
else
|
|
{
|
|
if (!btnAnnoDetailsPushPin.Checked)
|
|
epAnnotations.Expanded = false;
|
|
epAnnotations.TitleStyle.BackColor1.Color = _CommentTitleBckColor;
|
|
ctrlAnnotationDetails.AnnotationText = null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region LinkSupport
|
|
|
|
private void tc_LinkActiveChanged(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
// determine if any infotabs are visisble, and if it is the Transition,
|
|
// change the curitem for the transition to the current item.
|
|
if (infoPanel.Expanded == true && infoTabs.SelectedTab == infotabTransition)
|
|
{
|
|
displayTransition.CurTrans = null;
|
|
}
|
|
}
|
|
|
|
private void tc_LinkModifyTran(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
infoPanel.Expanded = true;
|
|
infoTabs.SelectedTab = infotabTransition;
|
|
if (SelectedStepTabPanel == null) return;
|
|
//displayTransition.RangeColor = global::VEPROMS.Properties.Settings.Default.TransitionRangeColor;
|
|
displayTransition.MyRTB = SelectedStepTabPanel.MyStepPanel.SelectedEditItem.MyStepRTB;
|
|
displayTransition.CurTrans = args.MyLinkText.MyTransitionInfo;
|
|
}
|
|
|
|
private void tc_LinkModifyRO(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
if (_SelectedROFst == null && (SelectedDVI == null || SelectedDVI.DocVersionAssociationCount == 0)) return; // B2016-128, not RO path associated to the working draft
|
|
if (SelectedStepTabPanel == null) return;
|
|
|
|
infoPanel.Expanded = true;
|
|
infoTabs.SelectedTab = infotabRO;
|
|
|
|
displayRO.ROTypeFilter = SelectedStepTabPanel.MyStepPanel.SelectedEditItem is Volian.Controls.Library.GridItem && (SelectedStepTabPanel.MyStepPanel.SelectedEditItem as Volian.Controls.Library.GridItem).MyFlexGrid.IsRoTable ?
|
|
E_ROValueType.Table : (SelectedStepTabPanel.MyStepPanel.SelectedEditItem.MyItemInfo.IsFigure) ? E_ROValueType.Image : E_ROValueType.Text;
|
|
|
|
displayRO.ProgressBar = bottomProgBar;
|
|
displayRO.MyRTB = SelectedStepTabPanel.MyStepPanel.SelectedEditItem.MyStepRTB;
|
|
displayRO.CurROLink = args.MyLinkText.MyRoUsageInfo;
|
|
|
|
// B2022-026 RO Memory reduction coding (Jakes Merge)
|
|
displayRO.LoadTree();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region VButton
|
|
|
|
private void office2007StartButton1_Click(object sender, EventArgs e)
|
|
{
|
|
// If the V-Button is clicked, check to see what tree node is s selected
|
|
// to set up the New submenus. The New submenus are dependent on the type of
|
|
// object selected, i.e. folder, docversion, etc.
|
|
|
|
// reset in case previous selection changed items.
|
|
btnNew.SubItems.Clear();
|
|
btnNew.Enabled = false;
|
|
// if focus is in the step editor, position in the tree view to match the location in the step editor
|
|
if (!tv.Focused && tc.SelectedDisplayTabItem != null && tc.SelectedDisplayTabItem.SelectedItemInfo != null)
|
|
tv.AdjustTree(tc.SelectedDisplayTabItem.SelectedItemInfo);
|
|
|
|
VETreeNode vtn = tv.SelectedNode as VETreeNode;
|
|
if (vtn == null) return;
|
|
StepInfo stpinf = vtn.VEObject as StepInfo;
|
|
if (stpinf == null || !stpinf.IsRNOPart) //B2017-037 is this a RNO step type element - don't allow insert before/after
|
|
btnNew.Enabled = true;
|
|
vtn.Expand();
|
|
|
|
// Folders can have either folders & docversions, but
|
|
// not a mix.
|
|
FolderInfo fi = vtn.VEObject as FolderInfo;
|
|
if (fi != null)
|
|
{
|
|
// Enable/disable the New button based on the user's security settings at the current folder level
|
|
// B2015-193
|
|
btnNew.Enabled = UserInfo.CanCreateFolders(MyUserInfo, fi);
|
|
|
|
// if at top, 'VEPROMS', folder and childfolders below this only
|
|
// option is to create a new (sub)folder, i.e. no submenu items.
|
|
if (fi.ChildFolderCount > 0 && fi.MyParent == null) return;
|
|
|
|
// submenu folders/docversion
|
|
if (fi.MyParent != null && UserInfo.CanCreateFolders(MyUserInfo, fi))
|
|
{
|
|
ButtonItem fldbbtn = new ButtonItem("fldbtn", "Folder Before");
|
|
ButtonItem fldabtn = new ButtonItem("fldabtn", "Folder After");
|
|
btnNew.SubItems.Add(fldbbtn);
|
|
btnNew.SubItems.Add(fldabtn);
|
|
fldbbtn.Click += new EventHandler(fldbbtn_Click);
|
|
fldabtn.Click += new EventHandler(fldabtn_Click);
|
|
}
|
|
ButtonItem fldbtn = new ButtonItem("fldbtn", "Folder");
|
|
btnNew.SubItems.Add(fldbtn);
|
|
fldbtn.Click += new EventHandler(fldbtn_Click);
|
|
|
|
// offer adding a Working Draft only if the folder has no sub-folders and there is not already a Working Draft node
|
|
if (fi.ChildFolderCount == 0 && fi.FolderDocVersionCount == 0)
|
|
{
|
|
ButtonItem dvbtn = new ButtonItem("dvbtn", "Working Draft");
|
|
btnNew.SubItems.Add(dvbtn);
|
|
dvbtn.Click += new EventHandler(dvbtn_Click);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// DocVersions can only have procedures, so no sub-menu
|
|
DocVersionInfo dvi = vtn.VEObject as DocVersionInfo;
|
|
if (dvi != null)
|
|
{
|
|
if (!UserInfo.CanEdit(MyUserInfo, dvi))
|
|
btnNew.Enabled = false; // reviewers cannot create a new procedure B2015-193
|
|
return;
|
|
}
|
|
|
|
// Procedures can have a section added or a new procedure before
|
|
// or after.
|
|
ProcedureInfo pi = vtn.VEObject as ProcedureInfo;
|
|
if (pi != null)
|
|
{
|
|
// if user is a reviewer then don't allow adding new procedures
|
|
// bug B2015-193
|
|
if (!UserInfo.CanEdit(MyUserInfo, pi.MyDocVersion))
|
|
{
|
|
btnNew.Enabled = false;
|
|
return;
|
|
}
|
|
ButtonItem pbbtn = new ButtonItem("pfbtn", "Procedure Before");
|
|
ButtonItem pabtn = new ButtonItem("pabtn", "Procedure After");
|
|
ButtonItem sctbtn = new ButtonItem("sctbtn", "Section");
|
|
btnNew.SubItems.Add(pbbtn);
|
|
btnNew.SubItems.Add(pabtn);
|
|
btnNew.SubItems.Add(sctbtn);
|
|
pbbtn.Click += new EventHandler(pbbtn_Click);
|
|
pabtn.Click += new EventHandler(pabtn_Click);
|
|
sctbtn.Click += new EventHandler(sctbtn_Click);
|
|
return;
|
|
}
|
|
|
|
// Sections can have sections before, after, new subsections & if is
|
|
// a step section, can have steps
|
|
SectionInfo si = vtn.VEObject as SectionInfo;
|
|
if (si != null)
|
|
{
|
|
// if user is a reviewer then don't allow adding new sections
|
|
// bug B2015-193
|
|
if (!UserInfo.CanEdit(MyUserInfo, si.MyDocVersion))
|
|
{
|
|
btnNew.Enabled = false;
|
|
return;
|
|
}
|
|
ButtonItem sbbtn = new ButtonItem("sbbtn", "Section Before");
|
|
ButtonItem sabtn = new ButtonItem("sabtn", "Section After");
|
|
|
|
btnNew.SubItems.Add(sbbtn);
|
|
btnNew.SubItems.Add(sabtn);
|
|
sbbtn.Click += new EventHandler(sbbtn_Click);
|
|
sabtn.Click += new EventHandler(sabtn_Click);
|
|
|
|
if (si.IsStepSection)
|
|
{
|
|
// B2016-282: Don't allow insert of subsections off Word Section.
|
|
if (si.ActiveFormat.PlantFormat.FormatData.SectData.UseMetaSections)
|
|
{
|
|
ButtonItem subbtn = new ButtonItem("subbtn", "SubSection");
|
|
btnNew.SubItems.Add(subbtn);
|
|
subbtn.Click += new EventHandler(subbtn_Click);
|
|
}
|
|
ButtonItem stpbtn = new ButtonItem("stpbtn", "New Step");
|
|
btnNew.SubItems.Add(stpbtn);
|
|
stpbtn.Click += new EventHandler(stpbtn_Click);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Steps can have steps before or after only.
|
|
StepInfo stpi = vtn.VEObject as StepInfo;
|
|
if (stpi != null)
|
|
{
|
|
// if user is a reviewer then don't allow adding new procedures, sections, or steps
|
|
// bug B2015-193
|
|
if (!UserInfo.CanEdit(MyUserInfo, stpi.MyDocVersion))
|
|
{
|
|
btnNew.Enabled = false;
|
|
return;
|
|
}
|
|
ButtonItem stpbbtn = new ButtonItem("stpbbtn", "New Step Before");
|
|
ButtonItem stpabtn = new ButtonItem("stpabtn", "New Step After");
|
|
btnNew.SubItems.Add(stpbbtn);
|
|
btnNew.SubItems.Add(stpabtn);
|
|
stpbbtn.Click += new EventHandler(stpbbtn_Click);
|
|
stpabtn.Click += new EventHandler(stpabtn_Click);
|
|
return;
|
|
}
|
|
btnNew.Enabled = false; // should not get this far, but just in case turn off the New button
|
|
}
|
|
|
|
void fldabtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.FolderAfter);
|
|
}
|
|
|
|
void fldbbtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.FolderBefore);
|
|
}
|
|
|
|
void stpabtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.StepAfter);
|
|
}
|
|
|
|
void stpbbtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.StepBefore);
|
|
}
|
|
|
|
void subbtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.Section);
|
|
}
|
|
|
|
void sabtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.SectionAfter);
|
|
}
|
|
|
|
void sbbtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.SectionBefore);
|
|
}
|
|
|
|
void stpbtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.Step);
|
|
}
|
|
|
|
void sctbtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.Section);
|
|
}
|
|
|
|
void pabtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.ProcedureAfter);
|
|
}
|
|
|
|
void pbbtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.ProcedureBefore);
|
|
}
|
|
|
|
void dvbtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.DocVersion);
|
|
}
|
|
|
|
void fldbtn_Click(object sender, EventArgs e)
|
|
{
|
|
tv.tv_NodeNew(vlnTreeView.MenuSelections.Folder);
|
|
}
|
|
private void btnSave_Click(object sender, EventArgs e)
|
|
{
|
|
}
|
|
#endregion
|
|
|
|
#region PanelEvents
|
|
private void infoPanel_Click(object sender, EventArgs e)
|
|
{
|
|
displayTags.MyEditItem = (SelectedStepTabPanel == null) ? null : SelectedStepTabPanel.MyStepPanel.SelectedEditItem;
|
|
displayTags.Mydvi = SelectedDVI;
|
|
}
|
|
//private void tv_SectionShouldClose(object sender, vlnTreeSectionInfoEventArgs args)
|
|
//{
|
|
// if (!args.MySectionInfo.IsStepSection) tc.CloseWordItem(args.MySectionInfo);
|
|
//}
|
|
|
|
private void infotabResults_Click(object sender, EventArgs e)
|
|
{
|
|
toolsPanel.Expanded = true;
|
|
InitiateSearch(true);
|
|
}
|
|
private void InitiateSearch(bool searchFocus)
|
|
{
|
|
if (toolsPanel.Expanded)
|
|
{
|
|
if (displaySearch1.Mydocversion == null)//!displaySearch1.OpenDocFromSearch)
|
|
{
|
|
if (SelectedDVI != null)
|
|
{
|
|
displaySearch1.Mydocversion = SelectedDVI;
|
|
displaySearch1.StartAdvTreeStepTypesFillIn();// B2016-258 Hang after selecting a procedure if the Step Type panel is open on the search panel
|
|
}
|
|
displaySearch1.advTreeProcSetsFillIn(searchFocus);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void toosTabReports_Click(object sender, EventArgs e)
|
|
{
|
|
toolsPanel.Expanded = true;
|
|
InitiateDisplayReports(true);
|
|
}
|
|
|
|
private void InitiateDisplayReports(bool reportFocus)
|
|
{
|
|
if (toolsPanel.Expanded)
|
|
{
|
|
if (SelectedDVI != null)
|
|
displayReports.Mydocversion = SelectedDVI;
|
|
displayReports.advTreeProcSetsFillIn(reportFocus);
|
|
displayReports.advTreeROFillIn(reportFocus);
|
|
displayReports.SelectReferencedObjectTab(); // to enable RO selection
|
|
}
|
|
}
|
|
|
|
private void ribbonControl1_ExpandedChanged(object sender, EventArgs e)
|
|
{
|
|
Console.WriteLine("Size {0}", ribbonControl1.Expanded);
|
|
// TODO: Need to send message to all StepTabPanels and tell them to minimize their ribbons.
|
|
tc.RibbonExpanded = ribbonControl1.Expanded;
|
|
}
|
|
|
|
private void btnItemInfo_Click(object sender, EventArgs e)
|
|
{
|
|
if (tc.SelectedDisplayTabItem != null && tc.SelectedDisplayTabItem.SelectedItemInfo != null)
|
|
{
|
|
frmPropGrid pg = new frmPropGrid(tc.SelectedDisplayTabItem.SelectedItemInfo, tc.SelectedDisplayTabItem.SelectedItemInfo.ShortPath);
|
|
pg.Show();
|
|
}
|
|
else
|
|
MessageBox.Show("Select Item First", "Item not selected", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
|
|
}
|
|
private void lblItemID_Click(object sender, System.EventArgs e)
|
|
{
|
|
if (tc.SelectedDisplayTabItem != null && tc.SelectedDisplayTabItem.SelectedItemInfo != null)
|
|
{
|
|
ItemInfo myitem = tc.SelectedDisplayTabItem.SelectedItemInfo;
|
|
FolderInfo myfolder = myitem.MyDocVersion.MyFolder;
|
|
string sep = "";
|
|
string fPath = "";
|
|
while (myfolder.FolderID != myfolder.ParentID)
|
|
{
|
|
fPath = myfolder.Name + sep + fPath;
|
|
sep = "/";
|
|
myfolder = myfolder.MyParent;
|
|
}
|
|
Clipboard.Clear();
|
|
DataObject mydo = new DataObject(DataFormats.Text, string.Format("{0} - {1}", fPath, myitem.ShortPath));
|
|
Clipboard.SetDataObject(mydo);
|
|
}
|
|
}
|
|
|
|
private void epAnnotations_Resize(object sender, EventArgs e)
|
|
{
|
|
if (epAnnotations.Expanded && !_panelExpandedChanging)
|
|
{
|
|
// if the height of the panel is smaller than the titleheight+20
|
|
//(due to the user dragging the splitter down), then un-expand the
|
|
// panel and set the height to the titleheight+75
|
|
if (epAnnotations.Size.Height < epAnnotations.TitleHeight + 20)
|
|
{
|
|
Size sz = new Size(epAnnotations.Size.Width, epAnnotations.TitleHeight + 75);
|
|
epAnnotations.Size = sz;
|
|
epAnnotations.Expanded = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void resizeVerticalExpandedPanel(object sender, EventArgs e)
|
|
{
|
|
ExpandablePanel ep = (ExpandablePanel)sender;
|
|
if (ep.Expanded && !_panelExpandedChanging)
|
|
{
|
|
// if the width of the panel is smaller than the titleheight+20
|
|
//(due to the user dragging the splitter over), then un-expand the
|
|
// panel and set the width to the titleheight+50
|
|
if (ep.Size.Width < ep.TitleHeight + 10)
|
|
{
|
|
Size sz = new Size(ep.TitleHeight + 50, ep.Size.Height);
|
|
ep.Size = sz;
|
|
ep.Expanded = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void expandPanelExpandedChanging(object sender, ExpandedChangeEventArgs e)
|
|
{
|
|
_panelExpandedChanging = true;
|
|
}
|
|
|
|
private void toolsPanel_ExpandedChanged(object sender, ExpandedChangeEventArgs e)
|
|
{
|
|
_panelExpandedChanging = false;
|
|
expandableSplitter4.Enabled = toolsPanel.Expanded;
|
|
if (toolsPanel.Expanded)
|
|
{
|
|
InitiateSearch(true);
|
|
InitiateDisplayReports(true);
|
|
}
|
|
}
|
|
|
|
private void epAnnotations_ExpandedChanged(object sender, ExpandedChangeEventArgs e)
|
|
{
|
|
_panelExpandedChanging = false;
|
|
expandableSplitter2.Enabled = epAnnotations.Expanded;
|
|
}
|
|
|
|
private void epProcedures_ExpandedChanged(object sender, ExpandedChangeEventArgs e)
|
|
{
|
|
_panelExpandedChanging = false;
|
|
expandableSplitter1.Enabled = epProcedures.Expanded;
|
|
}
|
|
|
|
private void infoPanel_ExpandedChanged(object sender, ExpandedChangeEventArgs e)
|
|
{
|
|
_panelExpandedChanging = false;
|
|
expandableSplitter3.Enabled = infoPanel.Expanded;
|
|
// if our active tab is a Word attachment, call the Click even on the RO tab
|
|
// to ensure that the RO FST is loaded. This fixes a bug where if the first thing you
|
|
// open is a Word attachment, the RO panel would not have the RO's listed.
|
|
if (infoPanel.Expanded && _CurrentItem != null && _CurrentItem.HasWordContent && infotabRO.Visible)
|
|
infotabRO_Click(sender, e);
|
|
}
|
|
#endregion
|
|
|
|
private void btnShortCuts_Click(object sender, EventArgs e)
|
|
{
|
|
ShortcutLists scListdlg = new ShortcutLists();
|
|
scListdlg.Show();
|
|
}
|
|
|
|
private void cmbFont_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
StepRTB.MyFontFamily = cmbFont.SelectedValue as FontFamily;
|
|
}
|
|
|
|
|
|
|
|
private void lblResolution_Click(object sender, EventArgs e)
|
|
{
|
|
if (this.WindowState != FormWindowState.Normal)
|
|
{
|
|
this.WindowState = FormWindowState.Normal;
|
|
}
|
|
else if (this.Size.Width != 1280)
|
|
{
|
|
this.Size = new Size(1280, 800);
|
|
}
|
|
else
|
|
{
|
|
this.Size = new Size(1024, 768);
|
|
}
|
|
}
|
|
|
|
private void frmVEPROMS_Resize(object sender, EventArgs e)
|
|
{
|
|
lblResolution.Text = string.Format("Resolution {0} x {1}", Size.Width, Size.Height);
|
|
}
|
|
|
|
private void office2007StartButton1_MouseDown(object sender, MouseEventArgs e)
|
|
{
|
|
// Refresh the MostRecentlyUsedList
|
|
_MyMRIList.Refresh();
|
|
SetupMRU();
|
|
}
|
|
|
|
private void btnEditItem_Click(object sender, EventArgs e)
|
|
{
|
|
if (tc.SelectedDisplayTabItem != null && tc.SelectedDisplayTabItem.MyStepTabPanel.SelectedEditItem != null)
|
|
{
|
|
frmPropGrid pg = new frmPropGrid(tc.SelectedDisplayTabItem.MyStepTabPanel.SelectedEditItem, "EditItem");
|
|
pg.Show();
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Select Item First", "Item not selected", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
|
|
}
|
|
}
|
|
|
|
private void btnUpdateFormat_Click(object sender, EventArgs e)
|
|
{
|
|
UpdateFormats(null);
|
|
//C2025-060 When format is updated in PROMS, auto-update the format cache so it doesn't require exiting PROMS and going back in.
|
|
RefreshFormats(sender, null);
|
|
}
|
|
|
|
private void UpdateFormats(string mypath)
|
|
{
|
|
if (mypath == null)
|
|
{
|
|
string fmtPath = Properties.Settings.Default.FormatPath ?? "";
|
|
DirectoryInfo di = null;
|
|
|
|
do
|
|
{
|
|
fbd.Description = "Select folder containing FmtAll and GenMacAll folders to update formats";
|
|
fbd.SelectedPath = fmtPath;
|
|
DialogResult dr = fbd.ShowDialog();
|
|
if (dr == DialogResult.Cancel)
|
|
{
|
|
bottomProgBar.Text = "Format Update Cancelled";
|
|
return;
|
|
}
|
|
di = new DirectoryInfo(fbd.SelectedPath);
|
|
fmtPath = di.FullName;
|
|
} while (((fmtPath ?? "") == "") || (!di.Exists || !Directory.Exists(di.FullName + @"\fmtall") || !Directory.Exists(di.FullName + @"\genmacall")));
|
|
|
|
Properties.Settings.Default.FormatPath = fbd.SelectedPath;
|
|
Properties.Settings.Default.Save();
|
|
|
|
mypath = di.FullName;
|
|
}
|
|
|
|
string fmtPathAll = mypath + @"\fmtall";
|
|
string genmacPathAll = mypath + @"\genmacall";
|
|
|
|
Format.FormatLoaded += new FormatEvent(Format_FormatLoaded);
|
|
Format.UpdateFormats(fmtPathAll, genmacPathAll);
|
|
Format.FormatLoaded -= new FormatEvent(Format_FormatLoaded);
|
|
|
|
_MyLog.WarnFormat("Formats in {0} updated to {1}", Database.SelectedDatabase, fmtPathAll);
|
|
}
|
|
|
|
void Format_FormatLoaded(object sender, FormatEventArgs args)
|
|
{
|
|
if (args.Status.EndsWith("Formats to Load"))
|
|
{
|
|
bottomProgBar.Value = 0;
|
|
bottomProgBar.Maximum = int.Parse(args.Status.Split(" ".ToCharArray())[0]);
|
|
}
|
|
else
|
|
{
|
|
if (args.Status.StartsWith("Error"))
|
|
{
|
|
MessageBox.Show(args.Status, "Error Loading Format", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
else if (!args.Status.Contains("SubFormat"))
|
|
{
|
|
bottomProgBar.Value++;
|
|
}
|
|
}
|
|
|
|
bottomProgBar.Text = args.Status;
|
|
bottomProgBar.TextVisible = true;
|
|
|
|
Application.DoEvents();
|
|
Console.WriteLine(args.Status);
|
|
}
|
|
|
|
private void btnSendErrorLog_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
frmSendErrorLog frm = new frmSendErrorLog(Properties.Settings.Default.OutlookEmail, Properties.Settings.Default["SMTPServer"].ToString(), Properties.Settings.Default["SMTPUser"].ToString(), ErrorLogFileName);
|
|
|
|
if (frm.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
Properties.Settings.Default.OutlookEmail = frm.OutlookEmail;
|
|
Properties.Settings.Default.SMTPServer = frm.SMTPServer;
|
|
Properties.Settings.Default.SMTPUser = frm.SMTPUser;
|
|
Properties.Settings.Default.Save();
|
|
|
|
MessageBox.Show("PROMS Error Log successfully sent to Volian support");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Send Error Log");
|
|
_MyLog.Error("Send Error Log", ex);
|
|
}
|
|
}
|
|
|
|
private void btnShowErrFld_Click(object sender, EventArgs e)
|
|
{
|
|
string path = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
|
|
path = path + @"\Documents\VEPROMS";
|
|
if (Directory.Exists(path))
|
|
{
|
|
Process.Start("explorer.exe", path);
|
|
}
|
|
}
|
|
|
|
private void btnShowPrtFld_Click(object sender, EventArgs e)
|
|
{
|
|
string path = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
|
|
path = path + @"\AppData\Local\Temp\VEPROMS";
|
|
if (Directory.Exists(path))
|
|
{
|
|
Process.Start("explorer.exe", path);
|
|
}
|
|
}
|
|
|
|
private void btnHelpManual_Click(object sender, EventArgs e)
|
|
{
|
|
// C2019-024 Display the PROMS User Manual when user click on the option in the Help drop down menu
|
|
// PROMS looks for "PROMSmanual.pdf" in the executable folder. If not found, a message box will display.
|
|
|
|
string promsUserManual = System.Windows.Forms.Application.StartupPath + @"\PROMSManual.pdf";
|
|
|
|
try
|
|
{
|
|
if (File.Exists(promsUserManual))
|
|
{
|
|
System.Diagnostics.Process sdp = System.Diagnostics.Process.Start(promsUserManual);
|
|
sdp.WaitForInputIdle();
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("The PROMS User Manual is not available for viewing.\nDetails are in the error log.", "View User Manual");
|
|
_MyLog.WarnFormat("PROMS User Manual not found: {0}", promsUserManual);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show("Could not open the PROMS User Manual.\nDetails are in the error log.", "View User Manual");
|
|
string str = string.Format("Could not open {0}", promsUserManual);
|
|
_MyLog.Error(str, ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region (Lock stuff / used for multi-user support)
|
|
|
|
public class TabItemsToClose : Stack<DisplayTabItem>
|
|
{
|
|
public void PushDTI(DisplayTabItem dti)
|
|
{
|
|
lock (this)
|
|
{
|
|
if (!this.Contains(dti))
|
|
this.Push(dti);
|
|
}
|
|
}
|
|
|
|
public DisplayTabItem PopDTI()
|
|
{
|
|
lock (this)
|
|
{
|
|
return this.Pop();
|
|
}
|
|
}
|
|
|
|
public int CountDTI
|
|
{
|
|
get
|
|
{
|
|
lock (this)
|
|
{
|
|
return this.Count;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
public class VersionWindow
|
|
{
|
|
private int _VersionID;
|
|
public int VersionID
|
|
{
|
|
get { return _VersionID; }
|
|
set { _VersionID = value; }
|
|
}
|
|
|
|
private int _DBId;
|
|
public int DBId
|
|
{
|
|
get { return _DBId; }
|
|
set { _DBId = value; }
|
|
}
|
|
|
|
private Rectangle _MyRectangle;
|
|
public Rectangle MyRectangle
|
|
{
|
|
get { return _MyRectangle; }
|
|
set { _MyRectangle = value; }
|
|
}
|
|
|
|
public VersionWindow(string str)
|
|
{
|
|
string[] parts = str.Split('~');
|
|
_VersionID = int.Parse(parts[0]);
|
|
RectangleConverter rc = new RectangleConverter();
|
|
_MyRectangle = (Rectangle)rc.ConvertFromString(parts[1]);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
RectangleConverter rc = new RectangleConverter();
|
|
return string.Format("{0}~{1}", _VersionID, rc.ConvertToString(_MyRectangle));
|
|
}
|
|
}
|
|
|
|
public class VersionWindowList : List<VersionWindow>
|
|
{
|
|
public static VersionWindowList GetVersionWindowList(System.Collections.Specialized.StringCollection list)
|
|
{
|
|
VersionWindowList vwl = new VersionWindowList();
|
|
|
|
if (list != null)
|
|
{
|
|
foreach (string str in list)
|
|
{
|
|
vwl.Add(new VersionWindow(str));
|
|
}
|
|
}
|
|
|
|
return vwl;
|
|
}
|
|
|
|
public System.Collections.Specialized.StringCollection ToSettings()
|
|
{
|
|
if (Count == 0) return null;
|
|
|
|
System.Collections.Specialized.StringCollection retval = new System.Collections.Specialized.StringCollection();
|
|
|
|
foreach (VersionWindow vw in this)
|
|
{
|
|
retval.Add(vw.ToString());
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
public new void Add(VersionWindow versionWindow)
|
|
{
|
|
foreach (VersionWindow vw in this)
|
|
{
|
|
if (vw.VersionID == versionWindow.VersionID)
|
|
{
|
|
this.Remove(vw);
|
|
break;
|
|
}
|
|
}
|
|
|
|
base.Add(versionWindow);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|