Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity
SourceCode/PROMS/Volian.Controls.Library/StepTabRibbon.cs
John Jenko a79819bb65 B2023-104 Import procedure and Go To RO 
Added a check for a bad RO link when trying to do a Go To RO. A message box pops up telling the user to re-link that RO.

Fixed the Import logic so that an old RO link reference can be replaced with the new one that is generated when a procedure is processed during the Import function.  The Import caused the Bad RO link reported in this bug.  This bug was introduced when the ROID was standardized in length and formatting (new RO logic in 2022).
2023-10-16 15:33:45 -04:00

4766 lines
201 KiB
C#
Raw Blame History

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Text;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Text.RegularExpressions;
using VEPROMS.CSLA.Library;
using Accentra.Controls;
using Volian.Base.Library;
using DevComponents.DotNetBar;
using Microsoft.Win32;
using System.Diagnostics;
using JR.Utils.GUI.Forms;
namespace Volian.Controls.Library
{
public delegate void CellRangeApplyStyle();
public partial class StepTabRibbon : UserControl
{
private static string _SpecifiedVisioPath = null;
public static string SpecifiedVisioPath
{
get { return StepTabRibbon._SpecifiedVisioPath; }
set { StepTabRibbon._SpecifiedVisioPath = value; }
}
private static bool _PastePlainTextSetting = false;
public static bool PastePlainTextSetting
{
get { return _PastePlainTextSetting; }
set { _PastePlainTextSetting = value; }
}
private static bool _PasteNoReturnsSetting = false;
public static bool PasteNoReturnsSetting
{
get { return _PasteNoReturnsSetting; }
set { _PasteNoReturnsSetting = value; }
}
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
#region Properties
private bool EnableROEdit;
private VlnFlexGrid MyFlexGrid
{
get
{
if (MyEditItem is GridItem) return (MyEditItem as GridItem).MyFlexGrid;
return null;
}
}
private EditItem _MyEditItem;
public EditItem MyEditItem
{
get { return _MyEditItem; }
set
{
if (_MyEditItem == value) return; // Don't do this if the value is not different
_MyEditItem = value;
SetBtnInsSupInfoVisible();
ToggleTableFontSize(value is GridItem);
if (value != null)
{
(this.Parent as StepTabPanel).MyDisplayTabItem.SetupSecurity(MyItemInfo);
MyStepRTB = value.MyStepRTB;
if (btnInsSupInfo.Visible && btnInsSupInfo.Enabled) btnInsSupInfo.Tag = string.Format("{0} {1}", (int)E_FromTypes.SupInfos, 1040); // use 1040 to flag RNO (40) and special case handling (1000)
if (value is GridItem)
{
ToggleTableDesignButtons(true);
MyFlexGrid_SelChange(this, new EventArgs());
}
}
else
MyStepRTB = null;
//if (rtabChgId.Visible)
// txtBxChgId.Text = (this.Parent as StepTabPanel).MyDisplayTabControl.ChgId;
}
}
public void SetChangeId(string chgid, ItemInfo ii)
{
txtBxChgId.Text = chgid;
rtabChgId.Visible = (ii != null) ? ii.ActiveFormat.PlantFormat.FormatData.ProcData.ChangeBarData.ChangeIds : false;
}
// added jcb 20121221 to support set ro from word doc
private ROFSTLookup MyLookup;
private DocVersionInfo _Mydvi;
public DocVersionInfo Mydvi
{
get
{
if (_Mydvi != null) return _Mydvi;
if (_MyEditItem != null)
{
ItemInfo procInfo = _MyEditItem.MyItemInfo.MyProcedure as ItemInfo;
if (procInfo == null) return null;
_Mydvi = procInfo.ActiveParent as DocVersionInfo;
// added jcb 20121221 to support set ro from word doc
if (_Mydvi.DocVersionAssociations != null && _Mydvi.DocVersionAssociations.Count > 0)
MyLookup = _Mydvi.DocVersionAssociations[0].MyROFst.GetROFSTLookup(_Mydvi);
else
MyLookup = null;
return _Mydvi;
}
return null;
}
}
private ItemInfo MyItemInfo
{
get
{
if(_MyStepRTB != null && _MyStepRTB.MyItemInfo != null) return _MyStepRTB.MyItemInfo;
if(_MyEditItem != null && _MyEditItem.MyItemInfo != null) return _MyEditItem.MyItemInfo;
return null;
}
}
private static UserInfo _MyUserInfo = null;
public static UserInfo MyUserInfo
{
get { return _MyUserInfo; }
set { _MyUserInfo = value; }
}
private static SessionInfo _MySessionInfo;
public static SessionInfo MySessionInfo
{
get { return _MySessionInfo; }
set { _MySessionInfo = value; }
}
private DevComponents.DotNetBar.ButtonItem _DefaultContextMenu;
public void ClearContextMenu()
{
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, null);
}
#region Save ROs from Word Document jcb 20121221
private string MyLookupData;
private Dictionary<string, string> MyAvailableROs;
public void SetContextMenu(object sender)
{
AddEnhancedDocumentMenu(btnCMRtfEdit, sender);
AddWROContext(btnCMRtfEdit);
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMRtfEdit);
}
public void SetContextMenuImage(ImageItem imgItem)
{
btnCMCut.Enabled = false;
btnCMCopy.Enabled = false;
btnCMPaste.Enabled = false;
btnCMPasteText.Enabled = false;
btnCMRO.Enabled = false;
bool isInBuff = false;
try // image in clipboard - for 'paste'
{
System.Drawing.Image img = Clipboard.GetImage();
isInBuff = img != null;
}
catch (Exception ex)
{
isInBuff = false;
}
btnCMPasteImage.Enabled = isInBuff;
btnCMEditMode1.Enabled = false; //View mode (irrelevant for images)
btnCMGoTo.Enabled = MyItemInfo!=null && MyItemInfo.MyContent != null && MyItemInfo.MyContent.ContentRoUsageCount > 0;
// B2016-237 added context menu item to change image size
// B2017-124 - added a check for null references
btnCMImgSz.Enabled = MyEditItem != null && MyEditItem.MyItemInfo != null && MyEditItem.MyItemInfo.IsFigure && (MyEditItem.MyItemInfo.MyContent.MyImage != null || MyEditItem.MyItemInfo.MyContent.Text.ToUpper().Contains("#LINK"));
_ContextMenuBar.SetContextMenuEx(imgItem, btnCMRtfEdit);
}
private void AddEnhancedDocumentMenu(DevComponents.DotNetBar.ButtonItem myButtonItem, object sender)
{
DVEnhancedDocuments dveds = MyItemInfo.MyDocVersion.DocVersionConfig.MyEnhancedDocuments;
if (dveds == null || dveds.Count == 0) return; // No enhanced!
// for all enhanced documents, create the list of buttons as they should be for items in the docversion
// using the list of enhanced documents that are on the docversion. Note that later, some may be
// made invisible or menu text changed.
// first, get correct number of enhanced buttons. This is needed in case the selected item doesn't
// have links to enhanced, but should.
List<string> existingEnhancedButtons = new List<string>();
foreach (DevComponents.DotNetBar.ButtonItem bi in myButtonItem.SubItems)
if (bi.Name.StartsWith("btnEnhanced"))
existingEnhancedButtons.Add(bi.Name);
bool inSource = dveds[0].Type != 0;
int buttonsNeeded = inSource ? dveds.Count : (dveds.Count * 2); // enhanced items need unlink button also.
// if in view only mode, don't do unlink
if (!inSource && MyEditItem != null && MyEditItem.MyStepPanel.VwMode == E_ViewMode.View) buttonsNeeded--;
if (MyItemInfo.IsSection && !MyItemInfo.IsStepSection) buttonsNeeded = 0; // no buttons for word sections
if (buttonsNeeded > existingEnhancedButtons.Count) // add buttons
{
// may need to change the following to add more buttons if a new working draft level was made
foreach (DVEnhancedDocument dved in dveds)
{
string buttonName = string.Format("btnEnhancedTo{0}", dved.Type);
DevComponents.DotNetBar.ButtonItem biEnhanced = new DevComponents.DotNetBar.ButtonItem(buttonName, "Go To " + dved.Name + " Document");
biEnhanced.Click += btnEnhancedGoTo_Click;
myButtonItem.SubItems.Add(biEnhanced);
existingEnhancedButtons.Add(biEnhanced.Name);
// if in view only mode, don't do unlink
if (!inSource && MyEditItem != null && MyEditItem.MyStepPanel.VwMode != E_ViewMode.View)
{
// add unlink buttons:
buttonName = string.Format("btnEnhancedUnlink{0}", dved.Type);
biEnhanced = new DevComponents.DotNetBar.ButtonItem(buttonName, "Unlink " + dved.Name + " Document");
biEnhanced.Click += btnEnhancedGoTo_Click;
biEnhanced.BeginGroup = true; // C2019=003: add separator between go to & unlink
myButtonItem.SubItems.Add(biEnhanced);
existingEnhancedButtons.Add(biEnhanced.Name);
}
}
}
// Now handle specific cases for the Item that user is positioned on.
// If a link exists, the menu item should be 'go to' and 'Unlink' if on an enhanced item.
// If link doesn't exist
// if in source & on procedure, section, high, note or caution, the menu item should be 'create missing'
// else the menu item should be made invisible.
StepRTB myStepRTB = sender as StepRTB ?? _MyStepRTB;
EnhancedDocuments eds = myStepRTB.MyItemInfo.GetMyEnhancedDocuments();
foreach (string btnenh in existingEnhancedButtons)
{
DevComponents.DotNetBar.ButtonItem biEnhanced = myButtonItem.SubItems[btnenh] as DevComponents.DotNetBar.ButtonItem;
int edtypebtn = System.Convert.ToInt32(biEnhanced.Name.Substring(biEnhanced.Name.Length - 1));
bool itemHasLink = false;
if (myStepRTB.MyItemInfo.MyContent.Text == "") // empty text represents a newly inserted step - don't do any enhanced buttons until saved (moved off)
biEnhanced.Visible = false;
else
{
foreach (EnhancedDocument ed in eds)
{
if (edtypebtn == ed.Type) // this button is for this document:
{
if (biEnhanced.Name.StartsWith("btnEnhancedTo"))
{
biEnhanced.Visible = true;
biEnhanced.Text = "Go To " + dveds.GetByType(ed.Type).Name + " Document";
biEnhanced.Tag = ed.ItemID;
itemHasLink = true;
break;
}
else // this is for 'unlink'
{
biEnhanced.Visible = true;
biEnhanced.Tag = ed.ItemID;
itemHasLink = true;
break;
}
}
}
// if there is no link & item is in the 'source document', allow the user to create missing
// enhanced items
if (!itemHasLink && inSource)
{
// need to handle procedures, sections and steps differently:
if (MyItemInfo.IsProcedure)
{
biEnhanced.Visible = true;
biEnhanced.Text = string.Format("Create Missing Enhanced {0} Document Procedure", dveds.GetByType(edtypebtn).Name);
biEnhanced.Tag = MyItemInfo.ItemID;
}
else if (MyItemInfo.IsSection)
{
// verify that procedure has enhanced procedure for this type
EnhancedDocuments peds = MyItemInfo.MyProcedure.GetMyEnhancedDocuments();
bool didMenuItem = false;
foreach (EnhancedDocument ped in peds)
{
if (edtypebtn == ped.Type && MyItemInfo.IsStepSection) // this button is for this document:
{
biEnhanced.Visible = true;
biEnhanced.Text = string.Format("Create Missing Enhanced {0} Document Section", dveds.GetByType(edtypebtn).Name);
biEnhanced.Tag = MyItemInfo.ItemID;
didMenuItem = true;
break;
}
}
if (!didMenuItem) biEnhanced.Visible = false;
}
else if (MyItemInfo.IsHigh || MyItemInfo.IsCaution || MyItemInfo.IsNote)
{
// for HLS there could be multiple level of sections, so need to walk up tree until a procedure to see if one exists on section/subsections.
ItemInfo sect = MyItemInfo.ActiveSection;
bool didMenuItem = false;
while (!didMenuItem && sect.IsSection)
{
EnhancedDocuments seds = sect.GetMyEnhancedDocuments();
foreach (EnhancedDocument sed in seds)
{
if (sed.Type == edtypebtn)
{
// B2018-111: In the following line of code, added that if item is caution/note its parent must be a high level step.
if (MyItemInfo.IsHigh || ((MyItemInfo.IsCaution || MyItemInfo.IsNote) && MyItemInfo.MyParent.IsHigh && MyItemInfo.MyHLS.GetMyEnhancedDocuments().Count > 0))
{
biEnhanced.Visible = true;
biEnhanced.Text = string.Format("Create Missing Enhanced {0} Document Step", dveds.GetByType(edtypebtn).Name);
biEnhanced.Tag = MyItemInfo.ItemID;
didMenuItem = true;
break;
}
}
}
sect = sect.MyParent;
}
if (!didMenuItem) biEnhanced.Visible = false;
}
else
biEnhanced.Visible = false;
}
else if (!itemHasLink && !inSource)
biEnhanced.Visible = false;
}
}
#endregion
}
public ItemInfo enhUseExist = null;
public bool enhDoConv = false;
void btnEnhancedGoTo_Click(object sender, EventArgs e)
{
DevComponents.DotNetBar.BaseItem btn = sender as DevComponents.DotNetBar.BaseItem;
ItemInfo ii = ItemInfo.Get(int.Parse(btn.Tag.ToString()));
if (ii == null || ii.ItemID != MyItemInfo.ItemID) //B2018-116 null reference check - allow user to unlink a background step that has invalid ItemId
{
// if button name starts with btnEnhancedTo... open it, otherwise, unlink:
if (btn.Name.StartsWith("btnEnhancedTo"))
{
MyEditItem.SaveContents();
if(ii!=null) // B2018-142 to allow for the deletion of an un-linked background procedure
MyEditItem.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OpenItem(ii);
}
else if (btn.Name.Contains("Unlink"))
{
// C2019=003: add a confirmation dialog before unlinking a step:
if (FlexibleMessageBox.Show(this, "Do you want to unlink this step?", "Confirm Enhanced Step Unlink", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
MyEditItem.UnlinkEnhanced(MyEditItem.MyItemInfo);
}
}
else
{
// have to create it. This will bring up a dialog to either create a new step or
// link to an existing step:
enhUseExist = null;
int enhtype = System.Convert.ToInt32(btn.Name.Replace("btnEnhancedTo", ""));
dlgEnhMissingItem enhMissDlg = new dlgEnhMissingItem(this, ii, enhtype);
DialogResult dr = enhMissDlg.ShowDialog(this.Parent);
if (enhMissDlg.OKSelected || dr == DialogResult.OK)
{
if (enhUseExist == null)
{
ItemInfo newEnh = MyEditItem.AddMissingEnhancedStep(ii, enhtype);
if (ii.IsProcedure && newEnh != null) OnAddProcToDVInTree(new StepTabRibbonEventArgs(newEnh));
}
else if (!enhDoConv)
MyEditItem.CreateLinksEnhancedSingleItem(ii, enhUseExist, enhtype);
else
MyEditItem.CreateLinksEnhancedAllInProcedure(ii, enhUseExist, enhtype);
MyEditItem.SetFocus();
}
}
}
#region set up save ro menu jcb 20121221
private void AddWROContext(DevComponents.DotNetBar.ButtonItem myButtonItem)
{
MyAvailableROs = new Dictionary<string, string>();
DevComponents.DotNetBar.BaseItem btnSaveRO = null;
if (!myButtonItem.SubItems.Contains("btnSaveRO"))
{
btnSaveRO = new DevComponents.DotNetBar.ButtonItem("btnSaveRO", "Save RO");
btnSaveRO.Visible = false;
myButtonItem.SubItems.Add(btnSaveRO);
}
else
btnSaveRO = myButtonItem.SubItems["btnSaveRO"];
if (Clipboard.ContainsData(System.Windows.Forms.DataFormats.Text))
{
MyLookupData = Clipboard.GetData(System.Windows.Forms.DataFormats.Text).ToString();
if (MyLookupData.StartsWith("<STP") || MyLookupData.StartsWith("<MEL") || MyLookupData.StartsWith("<ARP"))
{
if (IsValidRO(MyLookupData))
{
btnSaveRO.SubItems.Clear();
btnSaveRO.Text = "Save RO";
foreach (string k in MyAvailableROs.Keys)
{
DevComponents.DotNetBar.BaseItem btn = new DevComponents.DotNetBar.ButtonItem(k, MyAvailableROs[k]);
btn.Tag = MyAvailableROs[k];
btn.Click += new EventHandler(SaveRO_Click);
btnSaveRO.SubItems.Add(btn);
if (MyStepRTB.SelectedText.Length > 0 && MyStepRTB.SelectedText.ToLower() != MyAvailableROs[k].ToLower())
{
btn = new DevComponents.DotNetBar.ButtonItem("_" + k, MyAvailableROs[k] + " with Annotation");
btn.Tag = MyAvailableROs[k];
btn.Click += new EventHandler(SaveROWithAnnotation_Click);
btnSaveRO.SubItems.Add(btn);
}
}
btnSaveRO.Visible = true;
}
else
{
btnSaveRO.SubItems.Clear();
btnSaveRO.Text = "No RO Found";
DevComponents.DotNetBar.BaseItem btn = new DevComponents.DotNetBar.ButtonItem("btnRONotFound", "Create Annotation");
btn.Tag = string.Format("Text '{0}' has no corresponding RO", MyStepRTB.SelectedText);
btn.Click += new EventHandler(NoROFound_Click);
btnSaveRO.SubItems.Add(btn);
btnSaveRO.Visible = true;
}
}
}
}
#endregion
private bool IsValidRO(string data)
{
bool rv = false;
MyAvailableROs = new Dictionary<string, string>();
if (Mydvi != null)
{
#region force arp without hi or lo jcb 20121221
//if (data == "<ARP CDS-LT002-1-MED-LO1 \\s\\l\\1>")
//{
// data = data.Replace("-LO1", "");
// Console.WriteLine("force null roc");
//}
#endregion
string accPageID = GetAccPageID(data);
ROFSTLookup.rochild? roc = MyLookup.GetROChildByAccPageID(accPageID, Mydvi.DocVersionConfig.RODefaults_setpointprefix, Mydvi.DocVersionConfig.RODefaults_graphicsprefix);
if (roc != null)
{
int index = GetROValueIndex(data);
if (index > -1)
{
MyAvailableROs.Add(((ROFSTLookup.rochild)roc).children[index].roid, ((ROFSTLookup.rochild)roc).children[index].value.Replace(@"\u160?", " "));
if (accPageID.StartsWith("MEL") && index == 0) // If equipment and 1st return value, then add option to add 4th Return Value
{
MyAvailableROs.Add(((ROFSTLookup.rochild)roc).children[3].roid, ((ROFSTLookup.rochild)roc).children[3].value.Replace(@"\u160?", " "));
MyAvailableROs.Add(((ROFSTLookup.rochild)roc).children[4].roid, ((ROFSTLookup.rochild)roc).children[4].value.Replace(@"\u160?", " "));
}
rv = true;
}
}
else
{
//see if arp then try HI 1,2,3 and LO 1,2,3
if (accPageID.StartsWith("ARP"))
{
string tmpAccPageID = string.Empty;
//try HI1,2,3
string suffix = "-HI";
for (int i = 1; i < 4; i++)
{
tmpAccPageID = accPageID + suffix + i.ToString();
roc = MyLookup.GetROChildByAccPageID(tmpAccPageID, Mydvi.DocVersionConfig.RODefaults_setpointprefix, Mydvi.DocVersionConfig.RODefaults_graphicsprefix);
if (roc != null)
{
int index = GetROValueIndex(data);
if (index > -1)
{
MyAvailableROs.Add(((ROFSTLookup.rochild)roc).children[index].roid, ((ROFSTLookup.rochild)roc).children[index].value.Replace(@"\u160?", " "));
rv = true;
}
}
}
//try LO1,2,3
suffix = "-LO";
for (int i = 1; i < 4; i++)
{
tmpAccPageID = accPageID + suffix + i.ToString();
roc = MyLookup.GetROChildByAccPageID(tmpAccPageID, Mydvi.DocVersionConfig.RODefaults_setpointprefix, Mydvi.DocVersionConfig.RODefaults_graphicsprefix);
if (roc != null)
{
int index = GetROValueIndex(data);
if (index > -1)
{
MyAvailableROs.Add(((ROFSTLookup.rochild)roc).children[index].roid, ((ROFSTLookup.rochild)roc).children[index].value.Replace(@"\u160?", " "));
rv = true;
}
}
}
}
}
}
return rv;
}
private string GetAccPageID(string txt)
{
//<MEL FWS-MP-02B \\n \\H>
//<STP L19 \\v \\E \\H \\P \\S >
//<ARP FWS-MP-02C-TMP1 \\s \\h \\1>
txt = txt.Replace("<MEL ", "MEL-");
txt = txt.Replace("<STP ", Mydvi.DocVersionConfig.RODefaults_setpointprefix + "-");
txt = txt.Replace("<ARP ", "ARP-");
int i = txt.IndexOf(" ");
txt = txt.Substring(0, i);
return txt;
}
private int GetROValueIndex(string data)
{
int rv = -1;
if (data.StartsWith("<ARP"))
{
// arp children = \n alarm, \s value, \t type, \d description
if (data.IndexOf(@"\n") > 0)
rv = 0;
else if (data.IndexOf(@"\s") > 0)
rv = 1;
else if (data.IndexOf(@"\t") > 0)
rv = 2;
else if (data.IndexOf(@"\d") > 0)
rv = 3;
else
rv = -1;
}
else if (data.StartsWith("<MEL"))
{
//mel children = \n name, \d description, \r room
if (data.IndexOf(@"\n") > 0)
rv = 0;
else if (data.IndexOf(@"\d") > 0)
rv = 1;
else if (data.IndexOf(@"\r") > 0)
rv = 2;
else
rv = -1;
}
else if (data.StartsWith("<STP"))
{
//stp children = \v value, \d description, \n id
if (data.IndexOf(@"\v") > 0)
rv = 0;
else if (data.IndexOf(@"\d") > 0)
rv = 1;
else if (data.IndexOf(@"\n") > 0)
rv = 2;
else
rv = -1;
}
return rv;
}
private void SaveRO_Click(object sender, EventArgs e)
{
DevComponents.DotNetBar.BaseItem btn = sender as DevComponents.DotNetBar.BaseItem;
string myroid = btn.Name;
string myvalue = btn.Tag.ToString();
// the roid may be 12 or 16 chars long, with the last 4 set if there is unit specific
// menuing. Pad to 12 to store in the rousage table.
string padroid = (myroid.Length <= 12) ? myroid + "0000" : myroid;
string linktxt = string.Format(@"#Link:ReferencedObject:<NewID> {0} {1}", padroid, MyLookup.MyDocVersionInfo.DocVersionAssociations[0].MyROFst.MyRODb.RODbID);
// Resolve symbols and scientific notation in the RO return value
string valtxt = MyLookup.GetTranslatedRoValue(padroid, MyStepRTB.MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.ConvertCaretToDelta, MyStepRTB.MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.UseTildaPoundCharsForSuperSubScriptInROValues,
false); //ConvertSymbolsAndStuff(selectedChld.value);
MyStepRTB.OnRoInsert(this, new StepRTBRoEventArgs(valtxt, myvalue, linktxt, padroid, MyLookup.MyDocVersionInfo.DocVersionAssociations[0].MyROFst.MyRODb.RODbID));
}
private void SaveROWithAnnotation_Click(object sender, EventArgs e)
{
DevComponents.DotNetBar.BaseItem btn = sender as DevComponents.DotNetBar.BaseItem;
string myroid = btn.Name.Replace("_", "");
string myvalue = btn.Tag.ToString();
using (Item itm = MyStepRTB.MyItemInfo.Get())
{
Annotation x = Annotation.MakeAnnotation(itm, AnnotationType.GetByName("RO Value Changed"), null, string.Format("RO Value '{0}' replaces text '{1}'", myvalue, MyStepRTB.SelectedText), null);
}
// the roid may be 12 or 16 chars long, with the last 4 set if there is unit specific
// menuing. Pad to 12 to store in the rousage table.
string padroid = (myroid.Length <= 12) ? myroid + "0000" : myroid;
string linktxt = string.Format(@"#Link:ReferencedObject:<NewID> {0} {1}", padroid, MyLookup.MyDocVersionInfo.DocVersionAssociations[0].MyROFst.MyRODb.RODbID);
// Resolve symbols and scientific notation in the RO return value
string valtxt = MyLookup.GetTranslatedRoValue(padroid, MyStepRTB.MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.ConvertCaretToDelta, MyStepRTB.MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.UseTildaPoundCharsForSuperSubScriptInROValues, false); //ConvertSymbolsAndStuff(selectedChld.value);
MyStepRTB.OnRoInsert(this, new StepRTBRoEventArgs(valtxt, myvalue, linktxt, padroid, MyLookup.MyDocVersionInfo.DocVersionAssociations[0].MyROFst.MyRODb.RODbID));
}
private void NoROFound_Click(object sender, EventArgs e)
{
DevComponents.DotNetBar.BaseItem btn = sender as DevComponents.DotNetBar.BaseItem;
string myvalue = btn.Tag.ToString();
using (Item itm = MyStepRTB.MyItemInfo.Get())
{
Annotation x = Annotation.MakeAnnotation(itm, AnnotationType.GetByName("RO Missing"), null, myvalue, null);
}
}
#endregion
public void SetGridCellContextMenu()
{
AddWROContext(btnCMRtfCellEdit);
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMRtfCellEdit);
}
public void SetGridContextMenu()
{
if (rtabTableGridTools.Visible)
_ContextMenuBar.SetContextMenuEx(MyFlexGrid, btnCMGrid);
}
public void OpenContextMenu(Point loc, object sender)
{
if (rtabTableGridTools != null && !rtabTableGridTools.Visible)
{
AddEnhancedDocumentMenu(btnCMRtfEdit, sender);
btnCMRtfEdit.Popup(loc);
}
else // in a table cell, use the table cell's context menu:
btnCMRtfCellEdit.Popup(loc);
}
private int _MyLastFormatID = -1;
private StepRTB _MyStepRTB;
public StepRTB MyStepRTB
{
get { return _MyStepRTB; }
set
{
_MyStepRTB = value;
SetBtnInsSupInfoVisible();
if (fiwc != null) fiwc.MyStepRTB = value;
if (value != null)
{
//Console.WriteLine(string.Format("StepTabRibbon: In set of MyStepRTB, Selected Text = {0}", MyStepRTB.SelectedText));
switch (_MyStepRTB.FieldToEdit)
{
case E_FieldToEdit.PSI:
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMPSI);
_DefaultContextMenu = btnCMPSI;
break;
case E_FieldToEdit.StepText:
if (MyFlexGrid != null)
{
// This happends when the FlexGrid (table) is selected (not when you edit a table cell)
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMRtfCellEdit);
_DefaultContextMenu = btnCMRtfCellEdit;
}
else
{
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMRtfEdit);
_DefaultContextMenu = btnCMRtfEdit;
}
break;
case E_FieldToEdit.Text:
case E_FieldToEdit.Number:
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMRtfEdit3);
_DefaultContextMenu = btnCMRtfEdit3;
break;
default:
break;
}
// The following two lines were replaced by the third line so that the Ribbon KeyTips will work properly.
// ex. Positon on a substep, press <shift><F6> <N> <S> <S>, to list the substep types
//_MyStepRTB.MouseUp += new MouseEventHandler(_MyStepRTB_MouseUp); //+= new MouseEventHandler(MyStepRTB_SelectionChanged);
//_MyStepRTB.KeyUp += new KeyEventHandler(_MyStepRTB_KeyUp); //+= new KeyEventHandler(MyStepRTB_SelectionChanged);
_MyStepRTB.SelectionChanged += new EventHandler(_MyStepRTB_SelectionChanged);
//_MyStepRTB.ModeChange += new StepRTBModeChangeEvent(_MyStepRTB_ModeChange);
if (_MyEditItem != null) _MyEditItem.Leave += new EventHandler(_MyEditItem_Leave);
//_MyStepRTB.Leave += new EventHandler(_MyStepRTB_Leave);
_MyStepRTB.LinkChanged += new StepRTBLinkEvent(_MyStepRTB_LinkChanged);
_MyStepRTB.TextChanged += new EventHandler(_MyStepRTB_TextChanged);
if (MyFlexGrid != null)
{
MyFlexGrid.CopyOptionChanged += new VlnFlexGridEvent(MyFlexGrid_CopyOptionChanged);
MyFlexGrid.SelChange+=new EventHandler(MyFlexGrid_SelChange);
}
// C2021-043: have Proms specific context menu, i.e. with Hard space, styles and symbols rather than Windows clipboard
// The frmSI dialog uses a StepRTB that ends up in this code to work with the symbol list. This occurs when the
// MyItemInfo is null.
if (MyItemInfo == null)
{
// get base symbol list & add.
FormatInfo fmt = FormatInfo.Get(1);
SymbolList sl = fmt.PlantFormat.FormatData.SymbolList;
if (sl == null || sl.Count <= 0)
{
FlexibleMessageBox.Show("No symbols are available, check with administrator");
return;
}
BuildSymbolGallery(sl, galleryContainerSymbolsCM, galleryContainerSymbolsCM3, galleryContainerSymbolsGrid, galleryContainerSymbolsCM4);
return;
}
if (MyItemInfo.ActiveFormat.FormatID != _MyLastFormatID && _MyLastFormatID == -1)
{
// Add symbols to the tabribbon & also to the context menu getting info from the format file...
// Note that the ButtonItems must be used in order to place the buttons on a gallery (cannot
// use buttonx or dotnet/windows/button). However, you cannot change the font on ButtonItems so
// the ribbon MUST use the Arial Unicode MS Font for this to work!!!!
FormatInfo fmt = MyItemInfo.ActiveFormat;
SymbolList sl = fmt.PlantFormat.FormatData.SymbolList;
if (sl == null || sl.Count <= 0)
{
FlexibleMessageBox.Show("No symbols are available, check with administrator");
return;
}
BuildSymbolGallery(sl, galleryContainerSymbolsCM, galleryContainerSymbolsCM3, galleryContainerSymbolsGrid, galleryContainerSymbolsCM4);
//BuildSymbolGallery(sl, galleryContainerSymbolsCM);
//BuildSymbolGallery(sl, galleryContainerSymbolsCM3);
//BuildSymbolGallery(sl, galleryContainerSymbolsGrid);
}
SetButtonAndMenuEnabling(true);
SetStepButtonAndMenuEnabling(true);
SetMenuEnablingForObjectsWOText();
_MyLastFormatID = MyItemInfo.ActiveFormat.FormatID;
}
}
}
private void SetBtnInsSupInfoVisible()
{
if (MyItemInfo == null) return;
if (!MyItemInfo.SupplementalInformation)
{
btnInsSupInfo.Visible = false;
return;
}
btnInsSupInfo.Visible = true;
// Any step type can insert supplemental information, unless within supplemental information:
if (MyItemInfo.IsSection || MyItemInfo.IsProcedure || MyItemInfo.IsInSupInfo || (MyItemInfo.SupInfos != null && MyItemInfo.SupInfos.Count > 0)) // || ParentHasSupInfo(MyItemInfo))
btnInsSupInfo.Enabled = false;
else
btnInsSupInfo.Enabled = true;
}
void _MyStepRTB_TextChanged(object sender, EventArgs e)
{
if (_MyStepRTB == null) return;
// if we are in view mode or the edit window is empty, then don't allow inserting steps/substeps,
// page breaks, copy step, nor creating a pdf
// B2021-083: Create PDF button on ribbon was disabled for reviewer (removed code). Note that this allow
// is only used for the Create Pdf button now - code has changed for any other use.
bool allow = (_MyStepRTB.TextLength > 0);
//// turn ribbon items on/off base on whether there is text in the edit window
//rbnSiblings.Enabled = rbnParagraph.Enabled = rbnStepParts.Enabled = allow;
//// only turn on the Insert Before/After and the CopyStep buttons if on a step part
////btnInsAftH.Enabled = btnInsBefH.Enabled = btnInsAfter.Enabled = btnInsBefore.Enabled = btnCpyStp.Enabled =
//// allow && !(MyItemInfo.IsProcedure || MyItemInfo.IsSection || MyItemInfo.IsFigure || MyItemInfo.IsTable || MyItemInfo.IsRNOPart);
btnPdfCreate.Enabled = allow || (MyFlexGrid != null); // allways allow if on a table even if table cell is empty
//// toggle context menus used with the shortcut key
//btnCMInsHLS.Enabled = btnCMInsRNO.Enabled = btnCMInsSubStps.Enabled = btnCMInsCaution.Enabled =
// btnCMInsNote.Enabled = btnCMInsTable.Enabled = btnCMInsFigure.Enabled = allow;
// C2014-009 Commented out to allow for inserting Note/Caution
// if in Calvert Alarms Condition/Response, disable insert of Cautions and Notes
//if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertAlarm)
//btnInsCaut.Enabled = btnInsNote.Enabled = btnCMInsCaution.Enabled = btnCMInsNote.Enabled = allow && !MyItemInfo.IsInCalvertConditionResponse;
// C2021 - 027: Procedure level PC/PC - if text changed, i.e. applicability may have changed, redo the print menus
if (MyItemInfo != null && MyItemInfo.MyDocVersion.MultiUnitCount > 1)
SetParentChildCreatePDFButton(MyItemInfo.MyDocVersion.UnitNames, MyItemInfo);
}
void MyFlexGrid_SelChange(object sender, EventArgs e)
{
if (MyFlexGrid == null)
return;
//B2017-156 Don't allow alignment or borders if the selection is not valid
// Alternatively allow alignment or borders if the selection is valid
rbTblBorder.Enabled = btnTblDgnAlignText.Enabled = MyFlexGrid.Selection.IsValid;
if (MyFlexGrid.Selection.c1 < 0 || MyFlexGrid.Selection.r1 < 0)
return;
if (MyFlexGrid.Selection.c1 >= MyFlexGrid.Cols.Count || MyFlexGrid.Selection.r1 >= MyFlexGrid.Rows.Count)
return;
if ((MyEditItem as GridItem).Initializing) return;
//C1.Win.C1FlexGrid.CellRange cr = MyFlexGrid.GetEvenSelection();
//rbnBorderSelectionPanel.InitializeBorder(MyFlexGrid.MyBorders, cr.r1, cr.c1, cr.r2, cr.c2);
rbnBorderSelectionPanel.InitializeBorder(MyFlexGrid, MyFlexGrid.Selection);
}
void _MyEditItem_Leave(object sender, EventArgs e)
{
// The following two lines were replaced by the third line so that the Ribbon KeyTips will work properly.
// ex. Positon on a substep, press <shift><F6> <N> <S> <S>, to list the substep types
//_MyStepRTB.KeyUp -=new KeyEventHandler(_MyStepRTB_KeyUp);
//_MyStepRTB.MouseUp -= new MouseEventHandler(_MyStepRTB_MouseUp);
if (_MyEditItem != null)
{
_MyEditItem.Leave -= new EventHandler(_MyEditItem_Leave);
_MyEditItem.Enter += new EventHandler(_MyEditItem_Enter);
}
//_MyStepRTB.Leave -= new EventHandler(_MyStepRTB_Leave);
if (_MyStepRTB != null)
{
_MyStepRTB.SelectionChanged -= new EventHandler(_MyStepRTB_SelectionChanged);
_MyStepRTB.LinkChanged -= new StepRTBLinkEvent(_MyStepRTB_LinkChanged);
}
if (MyFlexGrid != null)
{
MyFlexGrid.CopyOptionChanged -= new VlnFlexGridEvent(MyFlexGrid_CopyOptionChanged);
MyFlexGrid.SelChange -= new EventHandler(MyFlexGrid_SelChange);
}
}
public bool SiblingsButtonsEnabled
{
set
{
// turn ribbon items on/off base on whether there is text in the edit window
rbnSiblings.Enabled = rbnParagraph.Enabled = rbnStepParts.Enabled =value;
}
}
public bool InsertButtonsEnabled
{
set
{
// only turn on the Insert Before/After and the CopyStep buttons if on a step part
btnInsAftH.Enabled = btnInsBefH.Enabled = btnInsAfter.Enabled = btnInsBefore.Enabled = btnCpyStp.Enabled = value;
}
}
public void SetCopyStepButton(bool val)
{
btnCpyStp.Enabled = val;
}
void _MyEditItem_Enter(object sender, EventArgs e)
{
// The following two lines were replaced by the third line so that the Ribbon KeyTips will work properly.
// ex. Positon on a substep, press <shift><F6> <N> <S> <S>, to list the substep types
//_MyStepRTB.KeyUp -=new KeyEventHandler(_MyStepRTB_KeyUp);
//_MyStepRTB.MouseUp -= new MouseEventHandler(_MyStepRTB_MouseUp);
if (_MyEditItem != null)
{
_MyEditItem.Leave += new EventHandler(_MyEditItem_Leave);
_MyEditItem.Enter -= new EventHandler(_MyEditItem_Enter);
}
//_MyStepRTB.Leave -= new EventHandler(_MyStepRTB_Leave);
if (_MyStepRTB != null)
{
_MyStepRTB.LinkChanged += new StepRTBLinkEvent(_MyStepRTB_LinkChanged);
_MyStepRTB.SelectionChanged += new EventHandler(_MyStepRTB_SelectionChanged);
}
if (MyFlexGrid != null)
{
MyFlexGrid.CopyOptionChanged += new VlnFlexGridEvent(MyFlexGrid_CopyOptionChanged);
MyFlexGrid.SelChange += new EventHandler(MyFlexGrid_SelChange);
//Console.WriteLine("Turn on SelChange");
}
}
void MyFlexGrid_CopyOptionChanged(object sender, EventArgs args)
{
btnTblDgnPaste.Enabled = true;
btnCmGridPaste.Enabled = true;
switch (VlnFlexGrid.MyCopyInfo.MyCopyOption)
{
case GridCopyOption.Row:
btnTblDgnPasteRow.Visible = true;
btnCmGridPasteRow.Visible = true;
btnTblDgnPasteColumn.Visible = false;
btnCmGridPasteCol.Visible = false;
break;
case GridCopyOption.Column:
btnTblDgnPasteRow.Visible = false;
btnCmGridPasteRow.Visible = false;
btnTblDgnPasteColumn.Visible = true;
btnCmGridPasteCol.Visible = true;
break;
case GridCopyOption.Selection:
btnTblDgnPasteRow.Visible = false;
btnCmGridPasteRow.Visible = false;
btnTblDgnPasteColumn.Visible = false;
btnCmGridPasteCol.Visible = false;
break;
default:
break;
}
}
private ItemInfo lastItem = null;
private int lastStart = -1;
private int lastLength = -1;
private string lastText = null;
// B2019-161 When tracking timing time this action
private static VolianTimer _TimeActivity = new VolianTimer("StepTabRibbon.cs _MyStepRTB_SelectionChanged",837);
void _MyStepRTB_SelectionChanged(object sender, EventArgs e)
{
if (_MyStepRTB == null) return;
_TimeActivity.Open();
//B2019-154 This will prevent duplicate processing of the ribbon menu and refresh of step items, speeding up the editing experience
if (_MyStepRTB != null && _MyStepRTB.MyItemInfo == lastItem && _MyStepRTB.SelectionStart == lastStart && _MyStepRTB.SelectionLength == lastLength && _MyStepRTB.SelectedText == lastText)
return;
lastItem = _MyStepRTB.MyItemInfo;
lastStart = _MyStepRTB.SelectionStart;
lastLength = _MyStepRTB.SelectionLength;
lastText = _MyStepRTB.SelectedText;
SetButtonAndMenuEnabling(false);
_TimeActivity.Close();
}
//void _MyStepRTB_MouseUp(object sender, MouseEventArgs e)
//{
// //SetButtonAndMenuEnabling(false);
//}
//void _MyStepRTB_KeyUp(object sender, KeyEventArgs e)
//{
// //SetButtonAndMenuEnabling(false);
//}
private Bitmap createTextBitmap(char ch)
{
string txt = string.Format("{0}", ch);
Bitmap objBmpImage = new Bitmap(1, 1);
int intWidth = 0;
int intHeight = 0;
// Create the Font object for the image text drawing.
// later on, we could add logic to use either FreeMono or Arial Unicode MS based on the format being used
// but for now, we are going to use FreeMono to create the symbol list
Font objFont = new Font("FreeMono", 18, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Pixel);
//Font objFont = new Font("Arial Unicode MS", 18, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Pixel);
// Create a graphics object to measure the text's width and height.
Graphics objGraphics = Graphics.FromImage(objBmpImage);
// This is where the bitmap size is determined.
intWidth = (int)objGraphics.MeasureString(txt, objFont).Width;
intHeight = (int)objGraphics.MeasureString(txt, objFont).Height;
// Create the bmpImage again with the correct size for the text and font.
objBmpImage = new Bitmap(objBmpImage, new Size(intWidth, intHeight));
// Add the colors to the new bitmap.
objGraphics = Graphics.FromImage(objBmpImage);
// Set Background color
objGraphics.Clear(Color.Transparent); //.White);
objGraphics.SmoothingMode = SmoothingMode.AntiAlias;
objGraphics.TextContrast = 0;
objGraphics.TextRenderingHint = TextRenderingHint.AntiAlias;
//objGraphics.DrawString(txt, objFont, new SolidBrush(Color.FromArgb(102, 102, 102)), 0, 0);
objGraphics.DrawString(txt, objFont, new SolidBrush(Color.Black),0,0);
objGraphics.Flush();
return (objBmpImage);
}
private void BuildSymbolGallery(SymbolList sl, DevComponents.DotNetBar.GalleryContainer gc1, DevComponents.DotNetBar.GalleryContainer gc2, DevComponents.DotNetBar.GalleryContainer gc3, DevComponents.DotNetBar.GalleryContainer gc4)
{
foreach (Symbol sym in sl)
{
// get an image of the symbol character
// found the we cannot change the font being used for the button text
Bitmap symCharBtmp = createTextBitmap((char)sym.Unicode);
DevComponents.DotNetBar.ButtonItem btn = new DevComponents.DotNetBar.ButtonItem();
btn.Image = symCharBtmp;
//btn.Text = string.Format("{0}", (char)sym.Unicode);
// to name button use unicode rather than desc, desc may have spaces or odd chars
btn.Name = "btn" + sym.Unicode.ToString();
btn.Tooltip = sym.Desc;
btn.Tag = string.Format(@"{0}", sym.Unicode);
//btn.FontBold = true;
btn.Click += new System.EventHandler(btnSym_Click);
galleryContainerSymbols.SubItems.Add(btn);
DevComponents.DotNetBar.ButtonItem btnCM1 = GetCMButton(sym);
btnCM1.Image = symCharBtmp;
btnCM1.Click += new System.EventHandler(btnSym_Click);
gc1.SubItems.Add(btnCM1);
DevComponents.DotNetBar.ButtonItem btnCM2 = GetCMButton(sym);
btnCM2.Image = symCharBtmp;
btnCM2.Click += new System.EventHandler(btnSym_Click);
gc2.SubItems.Add(btnCM2);
DevComponents.DotNetBar.ButtonItem btnCM3 = GetCMButton(sym);
btnCM3.Image = symCharBtmp;
btnCM3.Click += new System.EventHandler(btnSym_Click);
gc3.SubItems.Add(btnCM3);
DevComponents.DotNetBar.ButtonItem btnCM4 = GetCMButton(sym);
btnCM4.Image = symCharBtmp;
btnCM4.Click += new System.EventHandler(btnSym_Click);
gc4.SubItems.Add(btnCM4);
}
}
private static DevComponents.DotNetBar.ButtonItem GetCMButton(Symbol sym)
{
DevComponents.DotNetBar.ButtonItem btnCM3 = new DevComponents.DotNetBar.ButtonItem();
//btnCM3.Text = string.Format("{0}", (char)sym.Unicode);
// to name button use unicode rather than desc, desc may have spaces or odd chars
btnCM3.Name = "btnCM" + sym.Unicode.ToString();
btnCM3.Tooltip = sym.Desc;
btnCM3.Tag = string.Format(@"{0}", sym.Unicode);
//btnCM3.FontBold = true;
return btnCM3;
}
//void _MyStepRTB_ModeChange(object sender, StepRTBModeChangeEventArgs args)
//{
// SetButtonAndMenuEnabling(true);
//}
#region Constructor
public StepTabRibbon()
{
InitializeComponent();
this.btnInsSupInfo.Tag = string.Format("{0} {1}", (int)E_FromTypes.SupInfos, 1040); // Make type of rno (40) & special case 1000
SetChangeIdRibbon();
EnableROEdit = true;
_RibbonControl.AutoSize = true;
_RibbonControl.SizeChanged += new EventHandler(_RibbonControl_SizeChanged);
// When AutoExpand is set to true, [CTRL][F1] and double click will hide/expand the ribbon bar
// causing its state to be out of sync with that of the QAT menu option to
// expand/hide the ribbon.
// We now set AutoExpand to false and issue an event to expand/collapse the ribbon
// in a generic event method (ribbonTab_DoubleClick)
// and assigned it to the DoubleClick event of each tab in the ribbon.
// (see ribbonTab_DoubleClick() for more information) -jsj 07-APR-2011
// Note: the QAT menu is to the right of the V start button in the upper left
_RibbonControl.AutoExpand = false;
_RibbonControl.Items[0].RaiseClick(); // initially default to HOME tab
rbnBorderlistBox.Resize += new EventHandler(rbnBorderlistBox_Resize);
rbnBorderlistBox.SetupFontAndSize(6); // 6 Point Font
// added per Harry to hide refresh buttons
btnRefObjRefresh.Visible = btnTranRefresh.Visible = false;
// hide the import from Word file if not running in Debug mode
if (!VlnSettings.DebugMode)
rbnImpWrd.Visible = false;
}
void _RibbonControl_SizeChanged(object sender, EventArgs e)
{
this.Size = _RibbonControl.Size;
}
public bool Expanded
{
get { return _RibbonControl.Expanded; }
set { _RibbonControl.Expanded = value; }
}
#endregion
#region Events
//public event StepTabRibbonEvent OpenEnhancedDocument;
//private void OnOpenEnhancedDocument(StepTabRibbonEventArgs args)
//{
// if (OpenEnhancedDocument != null)
// OpenEnhancedDocument(this, args);
//}
public event StepTabRibbonEvent PrintRequest;
private void OnPrintRequest(StepTabRibbonEventArgs args)
{
if (PrintRequest != null)
PrintRequest(this, args);
}
public event StepTabRibbonEvent ContActionSummaryRequest;
private void OnContActionSummaryRequest(StepTabRibbonEventArgs args)
{
if (ContActionSummaryRequest != null)
ContActionSummaryRequest(this, args);
}
// F2022-024 Time Critical Action Summary
public event StepTabRibbonEvent TimeCriticalActionSummaryRequest;
private void OnTimeCriticalActionSummaryRequest(StepTabRibbonEventArgs args)
{
if (TimeCriticalActionSummaryRequest != null)
TimeCriticalActionSummaryRequest(this, args);
}
public event StepTabRibbonEvent AddProcToDVInTree;
private void OnAddProcToDVInTree(StepTabRibbonEventArgs args)
{
if (AddProcToDVInTree != null)
AddProcToDVInTree(this, args);
}
void _MyStepRTB_LinkChanged(object sender, StepPanelLinkEventArgs args)
{
// do all Transition and ReferencedObject menu items/buttons based on whether a 'link is selected' and the link type.
SetupGoToButton();
if (btnCMGoTo.Enabled == true && _MyStepRTB.MyLinkText != null) // must have some link test, use it to set edit of transition or ro...
{
btnCMEditTran.Enabled = _MyStepRTB.MyLinkText.IndexOf("Transition") > -1; // selected link must be a transition
btnCMEditRO.Enabled = _MyStepRTB.MyLinkText.IndexOf("ReferencedObject") > -1; // selected link must be ro
}
else
{
btnCMEditTran.Enabled = false;
btnCMEditRO.Enabled = false;
}
}
private void SetupGoToButton()
{
if (MyEditItem is GridItem && (MyEditItem as GridItem).MyFlexGrid.IsRoTable)
// B2016-127 - disable if is an RO table type but no RO was selected.
btnCMGoTo.Enabled = btnGoTo.Enabled = UserInfo.CanEditROs(MyUserInfo, Mydvi) && (MyEditItem as GridItem).MyFlexGrid.ROID != null;//Don't allow Writers and Reviews run the RO Editor
else
{
if (_MyStepRTB == null) return;
if (_MyStepRTB.IsSelectionLinked(_MyStepRTB.SelectionStart, _MyStepRTB.SelectionLength))
{
// if selected text = ?, i.e. a missing/undefined destination, don't allow go to
// if the selected link is an RO then check to see if the user is allowed to run the RO Editor (writers and reviewers cannot run the RO Editor)
btnCMGoTo.Enabled = btnGoTo.Enabled = !_MyStepRTB.SelectedText.StartsWith("?") && (_MyStepRTB.SelectedText.Contains("Transition") || (_MyStepRTB.SelectedText.Contains("ReferencedObject") && UserInfo.CanEditROs(MyUserInfo, Mydvi)));
}
else
btnCMGoTo.Enabled = btnGoTo.Enabled = false;
}
}
void _MyStepRTB_Leave(object sender, EventArgs e)
{
// The following two lines were replaced by the third line so that the Ribbon KeyTips will work properly.
// ex. Positon on a substep, press <shift><F6> <N> <S> <S>, to list the substep types
//_MyStepRTB.KeyUp -=new KeyEventHandler(_MyStepRTB_KeyUp);
//_MyStepRTB.MouseUp -= new MouseEventHandler(_MyStepRTB_MouseUp);
_MyStepRTB.SelectionChanged -= new EventHandler(_MyStepRTB_SelectionChanged);
_MyStepRTB.Leave -= new EventHandler(_MyStepRTB_Leave);
_MyStepRTB.LinkChanged -= new StepRTBLinkEvent(_MyStepRTB_LinkChanged);
}
void btnInsStep_Click(object sender, EventArgs e)
{
// Fix B2016-238 Fix B2017-139 account for image sub-steps
// C2017-028 don't display message if on a table (allow sup info off of a table)
if (_MyEditItem.MyStepRTB.Text == "" && !(_MyEditItem is ImageItem) && !(_MyEditItem is GridItem))
{
FlexibleMessageBox.Show(this, "Cannot insert step from empty step.", "Insert step", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
string cautNoteOrder = _MyEditItem.MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.CautionNoteOrder;
DevComponents.DotNetBar.ButtonItem b = (DevComponents.DotNetBar.ButtonItem)sender;
if (b.Tag == null) return;
char[] sep = { ' ' };
string[] insdata = b.Tag.ToString().Split(sep);
if (insdata.Length < 2) return;
int fromtype = Convert.ToInt32(insdata[0]);
int contenttype = Convert.ToInt32(insdata[1]) + 20000;
string tabOrFigType = (insdata.Length == 3) ? insdata[2] : null;
// if CautionNoteOrder format variable is set then use it to determine the placement of the
// Caution, Note, Warning, or Message (calvert format)
if (cautNoteOrder != null && ("," + cautNoteOrder + ",").Contains("," + (contenttype % 10000).ToString() + ",") && (_MyEditItem.MyItemInfo.Cautions != null || _MyEditItem.MyItemInfo.Notes != null))
{
EditItem stepBefore = FindStepBefore(cautNoteOrder, contenttype);
if (stepBefore != null)
stepBefore.AddSiblingAfter((int?)contenttype, true);
else
{
EditItem stepAfter = FindStepAfter(cautNoteOrder, contenttype);
if (stepAfter != null)
stepAfter.AddSiblingBefore((int?)contenttype, true);
}
}
// if from type == 0, we've inserted a hls.
// if inserting from section, insert first child
// else do a after from current HLS - if not at HLS, go up parents until find it.
else if (fromtype == 0 && !_MyEditItem.MyItemInfo.IsStepSection)
{
SaveTableChanges(); // B2018-055 Save Current Changes to the table
EditItem hlsEditItem = _MyEditItem;
while (!hlsEditItem.MyItemInfo.IsHigh)
hlsEditItem = hlsEditItem.ActiveParent;
hlsEditItem.AddSiblingAfter((int?)contenttype, true);
}
else if (contenttype == 21040)
{
SaveTableChanges(); // B2018-055 Save Current Changes to the table
_MyEditItem.AddChild((E_FromType)fromtype, 20040);
}
else if (InsertingTable(contenttype))
{
if (tabOrFigType.Contains("RO"))
{
VlnFlexGrid grd = new VlnFlexGrid();
grd.Rows.Count = 1;
grd.Cols.Count = 1;
grd.IsRoTable = true;
_MyEditItem.AddChild((E_FromType)fromtype, contenttype, grd);
StepTabPanel tmp = Parent as StepTabPanel;
tmp.MyDisplayTabControl.OnLinkModifyRO(this, new StepPanelLinkEventArgs(null));
}
else
{
VlnFlexGrid grd = CreateNewTable();
if (grd != null) _MyEditItem.AddChild((E_FromType)fromtype, contenttype, grd);
}
}
else if (InsertingFigure(contenttype))
{
if (tabOrFigType.Contains("RO"))
{
_MyEditItem.AddChild((E_FromType)fromtype, contenttype, ImageItem.E_ImageSource.RoFigure);
StepTabPanel tmp = Parent as StepTabPanel;
tmp.MyDisplayTabControl.OnLinkModifyRO(this, new StepPanelLinkEventArgs(null));
}
else
{
System.Drawing.Image img = Clipboard.GetImage();
if (img == null && tabOrFigType.Contains("CL"))
{
FlexibleMessageBox.Show("Clipboard does not contain image data. Cannot create figure.", "Clipboard Error");
return;
}
_MyEditItem.AddChild((E_FromType)fromtype, contenttype, tabOrFigType.Contains("CL") ? ImageItem.E_ImageSource.Clipboard : ImageItem.E_ImageSource.File);
}
if (_MyEditItem.MyItemInfo.IsFigure && tabOrFigType.Contains("RO"))
btnInsRO_Click(sender, e);
}
else if (InsertingEquation(contenttype))
{
// launch Ole Object Editor - added support for Visio
switch (OleObjectEditors)
{
case 0: // None
FlexibleMessageBox.Show("The Equation Editor needs to be started.", "Reminder", MessageBoxButtons.OK);
break;
case 1: // Equation Editor
Process.Start(EqnEdtPath);
break;
case 2: // Visio
Process.Start(VisioPath);
break;
case 3: // Both
string editor = (sender as ButtonItem).Tag.ToString();
if (editor.EndsWith("Visio"))
Process.Start(VisioPath);
else
Process.Start(EqnEdtPath);
break;
}
_MyEditItem.AddChild((E_FromType)fromtype, contenttype);
}
else
{
_MyEditItem.AddChild((E_FromType)fromtype, contenttype);
}
}
// the following launches the equation editor based on registry setting:
private static string GetEqnEdt()
{
string retval = null;
try
{
RegistryKey key = Registry.ClassesRoot;
string rootName = key.Name;
string curVer = GetDefaultKeyValue(key.Name + "\\Equation\\CurVer");
string clsid = GetDefaultKeyValue(key.Name + "\\" + curVer + "\\CLSID");
retval = GetDefaultKeyValue(key.Name + "\\CLSID\\" + clsid + "\\LocalServer32");
}
catch (Exception ex)
{
_MyLog.WarnFormat("Equation Editor is not correctly configured in the registry.");
string folderPath = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
folderPath += @"\Common Files\Microsoft Shared\EQUATION\EQNEDT32.EXE";
System.IO.FileInfo fi = new System.IO.FileInfo(folderPath);
if (fi.Exists) return fi.FullName;
folderPath = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles).Replace(" (x86)", "");
folderPath += @"\Common Files\Microsoft Shared\EQUATION\EQNEDT32.EXE";
fi = new System.IO.FileInfo(folderPath);
if (fi.Exists) return fi.FullName;
folderPath = @"C:\Program Files\Common Files\Microsoft Shared\EQUATION\EQNEDT32.EXE";
fi = new System.IO.FileInfo(folderPath);
if (fi.Exists) return fi.FullName;
return null;
}
if (retval == null)
_MyLog.WarnFormat("Equation Editor executable could not be found.");
return retval;
}
// B2018-038 MathType Replacement for EQNEDT32.EXE
private static string GetMathType()
{
string retval = null;
try
{
RegistryKey key = Registry.ClassesRoot;
string rootName = key.Name;
string clsid = GetDefaultKeyValue(key.Name + "\\DSEquations\\CLSID");
retval = GetDefaultKeyValue(key.Name + "\\CLSID\\" + clsid + "\\LocalServer32");
}
catch (Exception ex)
{
_MyLog.WarnFormat("MathType Equation Editor is not correctly configured in the registry.");
string folderPath = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
folderPath += @"\MathType\MathType.EXE";
System.IO.FileInfo fi = new System.IO.FileInfo(folderPath);
if (fi.Exists) return fi.FullName;
folderPath = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles).Replace(" (x86)", "");
folderPath += @"\MathType\MathType.EXE";
fi = new System.IO.FileInfo(folderPath);
if (fi.Exists) return fi.FullName;
folderPath = @"C:\Program Files\\MathType\MathType.EXE";
fi = new System.IO.FileInfo(folderPath);
if (fi.Exists) return fi.FullName;
return null;
}
if (retval == null)
_MyLog.WarnFormat("Equation Editor executable could not be found.");
return retval;
}
private static string GetVisio() // Added support for Visio
{
string retval = _SpecifiedVisioPath; // use the Visio path specified by the user
if (!string.IsNullOrEmpty(retval))
{
if (!retval.ToUpper().EndsWith(".EXE"))
retval += (retval.EndsWith("\\")) ? "visio.exe" : "\\visio.exe";
if (!File.Exists(retval)) // visio path was invalid, so try the registry next
{
_MyLog.WarnFormat("Specified Visio Path is Invalid: {0}",retval);
retval = null; // look in the registry
}
}
if (!string.IsNullOrEmpty(retval))
{
try
{
RegistryKey regVersionString = Registry.ClassesRoot.OpenSubKey("Visio.Drawing\\CurVer");
RegistryKey regClassId = Registry.ClassesRoot.OpenSubKey(regVersionString.GetValue("") + "\\CLSID");
RegistryKey regInstallPath = Registry.ClassesRoot.OpenSubKey("CLSID\\" + regClassId.GetValue("") + "\\LocalServer32");
retval = Path.GetFullPath(regInstallPath.GetValue("").ToString()); // this will convert a short file/folder names to long file/folder names
}
catch
{
_MyLog.WarnFormat("Visio was not found in the registry.");
}
}
return retval;
}
private static string _EqnEdtPath = null;
public static string EqnEdtPath
{
get { return StepTabRibbon._EqnEdtPath; }
}
private static string _VisioPath = null;
public static string VisioPath
{
get { return StepTabRibbon._VisioPath; }
}
private int _OleObjectEditors = -1;
public int OleObjectEditors
{
get
{
if (_OleObjectEditors == -1)
{
_OleObjectEditors = 0;// no OLE Object Editors
_EqnEdtPath = GetEqnEdt();
if (_EqnEdtPath == null) _EqnEdtPath = GetMathType();// B2018-038 MathType Replacement for EQNEDT32.EXE
// B2017-067 check for empty string as well as a null for paths to the Equation Editor and Visio
if (_EqnEdtPath != null && _EqnEdtPath != "") _OleObjectEditors += 1;
_VisioPath = GetVisio();
if (_VisioPath != null && _VisioPath != "") _OleObjectEditors += 2;
}
return _OleObjectEditors;
}
}
private static string FindFile(DirectoryInfo di, string fileName)
{
try
{
foreach (FileInfo fi in di.GetFiles(fileName))
return fi.FullName;
foreach (DirectoryInfo sub in di.GetDirectories())
{
string path = FindFile(sub, fileName);
if (path != null)
return path;
}
}
catch (Exception)
{
;
}
return null;
}
public static String GetDefaultKeyValue(String key)
{
object xxx = null;
return Registry.GetValue(key, "", xxx).ToString();
}
private EditItem FindStepAfter(string types, int contenttype)
{
string[] order = types.Split(",".ToCharArray()); //"29,7,6,22"
bool found = false;
List<int> lOrder = new List<int>();
foreach (string type in order)
{
if (found)
lOrder.Add(int.Parse(type));
if (int.Parse(type) == contenttype % 10000) found = true;
}
//_MyEditItem.MyItemInfo.RefreshItemParts();
_MyEditItem.MyItemInfo.ResetParts();
if (_MyEditItem.MyItemInfo.Cautions != null)
foreach (ItemInfo ii in _MyEditItem.MyItemInfo.Cautions)
{
if (lOrder.Contains((int)ii.MyContent.Type % 10000))
return _MyEditItem.MyStepPanel.FindItem(ii);
}
if (_MyEditItem.MyItemInfo.Notes != null)
foreach (ItemInfo ii in _MyEditItem.MyItemInfo.Notes)
{
if (lOrder.Contains((int)ii.MyContent.Type % 10000))
return _MyEditItem.MyStepPanel.FindItem(ii);
}
return null;
}
private EditItem FindStepBefore(string types, int contenttype)
{
string[] order = types.Split(",".ToCharArray()); //"29,7,6,22"
List<int> lOrder = new List<int>();
foreach (string type in order)
{
lOrder.Add(int.Parse(type));
if (lOrder.Contains(contenttype % 10000))
break;
}
ItemInfo itemBefore = null;
//_MyEditItem.MyItemInfo.RefreshItemParts();
_MyEditItem.MyItemInfo.ResetParts();
if (_MyEditItem.MyItemInfo.Cautions != null)
foreach (ItemInfo ii in _MyEditItem.MyItemInfo.Cautions)
{
if (lOrder.Contains((int)ii.MyContent.Type % 10000))
itemBefore = ii;
}
if (_MyEditItem.MyItemInfo.Notes != null)
foreach (ItemInfo ii in _MyEditItem.MyItemInfo.Notes)
{
if (lOrder.Contains((int)ii.MyContent.Type % 10000))
itemBefore = ii;
}
if (itemBefore != null)
{
//Console.WriteLine("findStepBefore {0}", itemBefore.DisplayText);
return _MyEditItem.MyStepPanel.FindItem(itemBefore);
}
return null;
}
// Table Grid
private bool InsertingTable(int contenttype)
{
bool rtnval = false;
switch (contenttype)
{
case 20008: // Centered table
case 20010: // AER table
case 20033: // AER table without boarder
case 20034: // Centered table without boarder
rtnval = true;
break;
}
return rtnval;
}
// Figure (embedded images)
private bool InsertingFigure(int contenttype)
{
bool rtnval = false;
switch (contenttype)
{
case 20036: // Centered
case 20037: // AER (left)
case 20038: // AER (left) without boarder
case 20039: // Centered without boarder
rtnval = true;
break;
}
return rtnval;
}
// Equation
private bool InsertingEquation(int contenttype)
{
bool rtnval = false;
switch (contenttype)
{
case 21000:
case 21001:
case 21002:
case 21003:
rtnval = true;
break;
}
return rtnval;
}
private void btnInsBefore_Click(object sender, EventArgs e)
{
SaveTableChanges(); // B2018-055 Save Current Changes to the table
_MyEditItem.AddSiblingBefore();
}
private void btnInsAfter_Click(object sender, EventArgs e)
{
SaveTableChanges(); // B2018-055 Save Current Changes to the table
_MyEditItem.AddSiblingAfter();
}
private void SaveTableChanges()
{
if (_MyEditItem.MyItemInfo.IsTable) // B2018-005 Save Current Changes to the table
if (_MyEditItem.MyParentEditItem != null)// B2018-055 Move to Parent if it exists
_MyEditItem.MyParentEditItem.Select(); // Next
else if (_MyEditItem.MyPreviousEditItem != null)// B2018-055 Move to Previous if it exists
_MyEditItem.MyPreviousEditItem.Select();
}
/// <summary>
/// Using style for step type, enable/disable formatting buttons
/// </summary>
private void SetButtonForStyle()
{
btnBold.Enabled = btnCMBold.Enabled = (!((_MyStepRTB.MyStyleFont.Style & E_Style.Bold) == E_Style.Bold || (_MyStepRTB.MyStyleFont.Style & E_Style.MmBold) == E_Style.MmBold));
btnUnderline.Enabled = btnCMUnderline.Enabled = (!((_MyStepRTB.MyStyleFont.Style & E_Style.Underline) == E_Style.Underline));
btnItalics.Enabled = btnCMItalics.Enabled = (!((_MyStepRTB.MyStyleFont.Style & E_Style.Italics) == E_Style.Italics));
}
public void SetTableButtonsForMergeRangeSelection()
{
if (MyFlexGrid != null )
{
// B2017-128 added check for only one cell selected (should not be alowed to merge just a single cell)
btnTblDgnMergeCells.Enabled = btnCmGridMergeCells.Enabled = !MyFlexGrid.IsRoTable && !MyFlexGrid.IsInMergeRange() && !MyFlexGrid.Selection.IsSingleCell;
}
}
private void SetButtonMenuEnabledDisabledOnSelection(bool setting)
{
btnCMBold.Enabled = btnBold.Enabled = setting;
btnCMItalics.Enabled = btnItalics.Enabled = setting;
btnCMUnderline.Enabled = btnUnderline.Enabled = setting;
btnCMSubscript.Enabled = btnSubscript.Enabled = setting;
btnCMSuperscript.Enabled = btnSuperscript.Enabled = setting;
btnCMCut.Enabled = btnCut.Enabled = setting;
btnCMUndo.Enabled = btnUndo.Enabled = setting;
btnCMRedo.Enabled = btnRedo.Enabled = setting;
//btnEdit3CMPaste.Enabled = btnPasteText.Enabled = btnCMPasteText.Enabled = btnCMPaste.Enabled = btnPaste.Enabled = setting;
btnCMPaste.Enabled = btnCMPasteText.Enabled = btnPasteText.Enabled = btnPasteStepText.Enabled = btnPaste.Enabled = setting;
btnCMCopy.Enabled = btnCopy.Enabled = setting;
btnPasteAfter.Enabled = btnPasteBefore.Enabled = btnStepPaste.Enabled = btnPasteReplace.Enabled = setting;
btnCMGrid.Enabled = setting;
btnCMPasteImage.Enabled = setting;
}
private void SetButtonMenuEnabledDisabledOnStepType(bool setting)
{
btnPageBreak.Enabled = btnInsPgBrk.Enabled = setting;
btnCMChgStep.Enabled = btnChgTyp.Enabled = setting;
btnInsHLS.Enabled = btnInsCaut.Enabled = btnInsNote.Enabled = btnInsRNO.Enabled = btnInsFig.Enabled =
btnInsTable.Enabled = btnInsSubstep.Enabled = btnInsBefore.Enabled = btnInsAfter.Enabled = setting;
btnInsTrans.Enabled = btnCMTransition.Enabled = setting;
btnInsRO.Enabled = btnCMRO.Enabled = setting && Mydvi.DocVersionAssociationCount > 0; // 2016-128 don't enable if RO Path was not selected at the Working Draft node
btnInsAftH.Enabled = btnInsBefH.Enabled = setting;
btnCMChgCase.Enabled = btnChgCase.Enabled = setting;
btnCMHardSpace.Enabled = btnInsHrdSpc.Enabled = setting;
btnCMSymbol.Enabled = btnSymbols.Enabled = setting;
btnIndent.Enabled = setting;
btnDelelete.Enabled = btnDelStep.Enabled = setting;
btnSpell.Enabled = setting;
rtabTableGridTools.Visible = setting;
btnCMGrid.Enabled = setting;
if (MyItemInfo.IsSection && MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.AllowNoteCautionAdd)
{
btnInsNote.Enabled = true;
btnInsCaut.Enabled = true;
}
// C2014-009 Commented out to allow for inserting Note/Caution
// if in Calvert Alarms Condition/Response, disable insert of Cautions and Notes
//if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertAlarm)
//btnInsCaut.Enabled = btnInsNote.Enabled = btnCMInsCaution.Enabled = btnCMInsNote.Enabled = setting && !MyItemInfo.IsInCalvertConditionResponse;
// B2016-237 added context menu item to change image size
btnCMImgSz.Enabled = MyEditItem.MyItemInfo.IsFigure && (MyEditItem.MyItemInfo.MyContent.MyImage != null || MyEditItem.MyItemInfo.MyContent.Text.ToUpper().Contains("#LINK"));
if (MyItemInfo.IsSupInfoPart) btnInsAfter.Enabled = btnInsAftH.Enabled = btnInsBefore.Enabled = btnInsBefH.Enabled = false;
// C2018-005: disable the change step type button when on procedure or section:
if (MyItemInfo.IsProcedure || MyItemInfo.IsSection) btnCMChgStep.Enabled = btnChgTyp.Enabled = false;
}
public void SetButtonAndMenuEnabling(bool docontextmenus)
{
if (_MyStepRTB == null) return;
// B2020-052: context menu items for setting text styles, fix for properties:
if ((_MyStepRTB.FieldToEdit != E_FieldToEdit.Number && _MyStepRTB.FieldToEdit != E_FieldToEdit.Text && _MyStepRTB.FieldToEdit != E_FieldToEdit.PSI) && _MyStepRTB.FieldToEdit != E_FieldToEdit.StepText && !MyItemInfo.IsFigure && !MyItemInfo.IsRtfRaw) // want menu enabling for figures & aations
return; // No need to change menu that does not get used
DocVersionInfo dvi = MyEditItem != null ? MyEditItem.MyItemInfo.MyProcedure.ActiveParent as DocVersionInfo : MyItemInfo.MyProcedure.ActiveParent as DocVersionInfo;
if (dvi == null) return;
// enable the following in case they were disabled for enhanced steps - only do for formats that have enhanced:
if (!MyItemInfo.IsEnhancedStep && !MyItemInfo.IsEnhancedSection &&
(((MyItemInfo.ActiveFormat.PlantFormat.FormatData.PurchaseOptions.Value & E_PurchaseOptions.EnhancedBackgrounds) == E_PurchaseOptions.EnhancedBackgrounds) ||
((MyItemInfo.ActiveFormat.PlantFormat.FormatData.PurchaseOptions.Value & E_PurchaseOptions.EnhancedDeviations) == E_PurchaseOptions.EnhancedDeviations)))
SetButtonEnablingForEnhanced(MyUserInfo.IsAllowedToEdit(dvi)); // B2018-112 - set context menu and ribbon buttons based on user's PROMS Security setting
if (dvi.VersionType > 127 || (MyEditItem != null && MyEditItem.MyStepPanel.VwMode == E_ViewMode.View))
{
SetButtonMenuEnabledDisabledOnSelection(false);
}
else if (MyItemInfo != null && MyItemInfo.IsEnhancedStep || MyItemInfo.IsEnhancedSection)
{
SetButtonEnablingForEnhanced(false);
}
else
{
SetButtonMenuEnabledDisabledOnSelection(true);
if (_MyStepRTB.SelectionFont != null)
{
// B2017-208 added (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode)
// toggle on/off attributes button checks when you edit table cells, going from one cell to another
// Also don't keep the attributes buttons checked after setting a group of table cells all at one time
btnCMBold.Checked = btnBold.Checked = RTBAPI.IsBold(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
btnCMItalics.Checked = btnItalics.Checked = RTBAPI.IsItalic(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
btnCMUnderline.Checked = btnUnderline.Checked = RTBAPI.IsUnderline(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
btnCMSubscript.Checked = btnSubscript.Checked = RTBAPI.IsSubScript(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
btnCMSuperscript.Checked = btnSuperscript.Checked = RTBAPI.IsSuperScript(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
}
SetButtonForStyle();
btnCMCut.Enabled = btnCut.Enabled = _MyStepRTB.SelectionLength > 0;
btnCMUndo.Enabled = btnUndo.Enabled = _MyStepRTB.CanUndo;
btnCMRedo.Enabled = btnRedo.Enabled = _MyStepRTB.CanRedo;
// for paste, see if there is clipboard data, & if so, of a type we can use.
btnCMPasteImage.Enabled = false;
try // RHM20150506 Multiline ItemID TextBox
{
IDataObject iData = Clipboard.GetDataObject();
// B2019-154 clean up the Windows Clipboard - Word on Windows 10 computers seems to have placed extra information (not needed by PROMS) on the clipboard
if (iData.GetFormats().Length > 1)
{
DataObject myDO = new DataObject();
foreach (string objname in iData.GetFormats())
{
switch (objname)
{
//case "Object Descriptor":
//case "HTML Format":
case "EnhancedMetafile":
//case "MetaFilePict":
//case "Embed Source":
//case "Link Source":
//case "Link Source Descriptor":
//case "ObjectLink":
//case "HyperlinkWordBkmk":
//case "Hyperlink":
break;
default:
//case "Text":
//case "Rich Text Format":
myDO.SetData(objname, iData.GetData(objname));
break;
}
}
Clipboard.Clear();
Clipboard.SetDataObject(myDO); // this saves the cleaned up information to the Windows clipboard
}
iData = Clipboard.GetDataObject();
bool noEquationData = true;
// part of bug B2017-117 we were running out of window handles when printing, found this similar use of
// creating a new richtextbox just for some processing. Put a Using around this to ensure the window handle
// is free'd
using (System.Windows.Forms.RichTextBox richTextBox1 = new System.Windows.Forms.RichTextBox())
{
DataFormats.Format frm = DataFormats.GetFormat("Embed Source");
//System.Windows.Forms.RichTextBox richTextBox1;
//richTextBox1 = new System.Windows.Forms.RichTextBox();
richTextBox1.Location = new System.Drawing.Point(35, 32);
richTextBox1.Name = "richTextBox1";
richTextBox1.Size = new System.Drawing.Size(67, 58);
richTextBox1.TabIndex = 0;
richTextBox1.Text = "";
richTextBox1.ScrollBars = System.Windows.Forms.RichTextBoxScrollBars.None;
//bool noEquationData = true;
try
{
richTextBox1.Paste(frm);
if (richTextBox1.Rtf.ToUpper().Contains("OBJCLASS EQU")) noEquationData = false;
if (richTextBox1.Rtf.ToUpper().Contains("OBJCLASS VIS")) noEquationData = false;
}
catch (Exception ex)
{
noEquationData = false;
}
} // end using
//btnEdit3CMPaste.Enabled = btnPasteText.Enabled = btnCMPasteText.Enabled = btnCMPaste.Enabled = btnPaste.Enabled = (iData.GetDataPresent(DataFormats.Text) || iData.GetDataPresent(DataFormats.Rtf));
//btnPasteText.Enabled = btnPasteStepText.Enabled = btnPaste.Enabled = (iData.GetDataPresent(DataFormats.Text) || iData.GetDataPresent(DataFormats.Rtf));
btnPaste.Enabled = noEquationData && (iData.GetDataPresent(DataFormats.Text) || iData.GetDataPresent(DataFormats.Rtf));
btnCMPasteText.Enabled = btnPasteText.Enabled = noEquationData && iData.GetDataPresent(DataFormats.Text);
btnCMPaste.Enabled = btnPasteStepText.Enabled = noEquationData && iData.GetDataPresent(DataFormats.Rtf);
}
catch (Exception) // Error while trying to access the clipboard
{ // This happens when the ItemID Text Box at the bottom of the screen is used to paste
// a list of IDs using the context menu (Right-Click, Paste)
btnPaste.Enabled = false;
btnCMPasteText.Enabled = btnPasteText.Enabled = false;
btnCMPaste.Enabled = btnPasteStepText.Enabled = false;
}
}
// all selected copy while in either Edit or View mode
btnCMCopy.Enabled = btnCopy.Enabled = _MyStepRTB.SelectionLength > 0 && !MyItemInfo.IsRtfRaw;
// paste step only available if a step was copied. Also, check for valid types:
SetPasteButtonEnabled();
// do all Transition and ReferencedObject menu items/buttons based on whether a 'link is selected' and the link type.
//btnCMGoTo.Enabled = btnGoTo.Enabled = _MyStepRTB.IsSelectionLinked(_MyStepRTB.SelectionStart, _MyStepRTB.SelectionLength); //(_MyStepRTB.MyLinkText != null);
SetupGoToButton();
if (btnCMGoTo.Enabled == true && _MyStepRTB.MyLinkText != null) // must have some link test, use it to set edit of transition or ro...
{
btnCMEditTran.Enabled = _MyStepRTB.MyLinkText.IndexOf("Transition") > -1; // selected link must be a transition
btnCMEditRO.Enabled = _MyStepRTB.MyLinkText.IndexOf("ReferencedObject") > -1; // selected link must be ro
}
else
{
btnCMEditTran.Enabled = false;
btnCMEditRO.Enabled = false;
}
// OLD: SetStepButtonAndMenuEnabling(docontextmenus);
SetMenuEnablingForObjectsWOText();
}
private void SetMenuEnablingForObjectsWOText()
{
if (MyItemInfo.IsFigure || MyItemInfo.IsRtfRaw)
{
btnInsTrans.Enabled = btnCMTransition.Enabled = false;
btnInsRO.Enabled = btnCMRO.Enabled = false;
btnCMSymbol.Enabled = btnSymbols.Enabled = false;
btnCMHardSpace.Enabled = btnInsHrdSpc.Enabled = false;
btnIndent.Enabled = false;
btnCMBold.Enabled = btnBold.Enabled = false;
btnCMItalics.Enabled = btnItalics.Enabled = false;
btnCMUnderline.Enabled = btnUnderline.Enabled = false;
btnCMSubscript.Enabled = btnSubscript.Enabled = false;
btnCMSuperscript.Enabled = btnSuperscript.Enabled = false;
btnCMCut.Enabled = btnCut.Enabled = false;
btnCMUndo.Enabled = btnUndo.Enabled = false;
btnCMRedo.Enabled = btnRedo.Enabled = false;
btnChgCase.Enabled = false;
btnPaste.Enabled = false;
btnCMPaste.Enabled = false;
btnCMPasteText.Enabled = false;
if (MyItemInfo.IsRtfRaw)
{
btnCopy.Enabled = false;
btnCMCopy.Enabled = false;
}
}
}
private void SetButtonEnablingForEnhanced(bool setting)
{
btnPaste.Enabled = btnCut.Enabled = setting;
btnUndo.Enabled = btnRedo.Enabled = setting;
rbFont.Enabled = rbStepType.Enabled = setting;
// if disabling the step buttons, first check if the step has 'linked' config data. If it does not,
// it can be deleted:
bool allowDel = false;
EnhancedDocuments eds = MyItemInfo.GetMyEnhancedDocuments();
// note in follow if statements, 'setting' == false when in enhanced document:
if (setting && MyItemInfo.IsStep && (eds == null || eds.Count == 0)) // this step is in enhanced, but not linked // B2018-112 and is allowed to edit
allowDel = true; // allow delete if not linked
btnCpyStp.Enabled = setting;
//B20170-158 Allow a Unlinked Step to be pasted before or after a linked step.
StepTabPanel tmp = Parent as StepTabPanel;
//B2020-058: crash on null reference
if (tmp != null && tmp.MyDisplayTabControl != null && tmp.MyDisplayTabControl.MyCopyStep != null)
{
//B2017-180: The fix for B2017-158 also needed the 'HasEnhancedLinkedStep' to check if the copied step is a source step
if (!tmp.MyDisplayTabControl.MyCopyStep.IsEnhancedStep && !tmp.MyDisplayTabControl.MyCopyStep.HasEnhancedLinkedStep)
{
if (MyItemInfo.IsEnhancedStep) btnPasteReplace.Enabled = btnCMPasteReplace.Enabled = false;
}
}
else
btnStepPaste.Enabled = setting;
rbnCharacters.Enabled = rbnParagraph.Enabled = rbnLinks.Enabled = setting;
btnCMEdit.Enabled = setting;
btnDelStep.Enabled = setting; // context menu item
btnDelelete.Enabled = setting;
if (allowDel)
{
btnDelStep.Enabled = true;
btnDelelete.Enabled = true;
}
btnPageBreak.Enabled = setting; // context menu item
btnCMHardSpace.Enabled = btnCMTransition.Enabled = btnCMRO.Enabled = btnCMSymbol.Enabled = setting;
btnFindRplDlg.Enabled = setting; // no find replace button is available when in an enhanced document
btnEditMode.Enabled = btnCMEditMode1.Enabled = setting;
if (((MyItemInfo.ActiveFormat.PlantFormat.FormatData.PurchaseOptions.Value & E_PurchaseOptions.EnhancedBackgrounds) == E_PurchaseOptions.EnhancedBackgrounds) ||
((MyItemInfo.ActiveFormat.PlantFormat.FormatData.PurchaseOptions.Value & E_PurchaseOptions.EnhancedDeviations) == E_PurchaseOptions.EnhancedDeviations))
{
btnCASCreate.Enabled = false;
btnTCASCreate.Enabled = false; // F2022-024 Time Critical Action Summary button
}
else
{
btnCASCreate.Enabled = (MyEditItem != null) ? (MyEditItem.MyStepPanel.ApplDisplayMode > 0) : false;
btnTCASCreate.Enabled = btnCASCreate.Enabled; // F2022-024 Time Critical Action Summary button
}
// B2016-237 added context menu item to change image size
// B2020-058 added check for null MyEditItem
btnCMImgSz.Enabled = MyEditItem!=null && MyEditItem.MyItemInfo.IsFigure && (MyEditItem.MyItemInfo.MyContent.MyImage != null || MyEditItem.MyItemInfo.MyContent.Text.ToUpper().Contains("#LINK"));
}
// Made a public method so that it can be called when a step is deleted from the tree view.
// part of bug fix for B2016-005 - jsj 4-19-2016
public void SetPasteButtons(bool enable)
{
btnPasteBefore.Enabled = btnCMPasteBefore.Enabled = enable;
btnPasteAfter.Enabled = btnCMPasteAfter.Enabled = enable;
//B20170-158 Don't allow a step to replace a linked step
//B2017-180: The fix for B2017-158 also needed the 'HasEnhancedLinkedStep' to check if the copied step is a source step
btnPasteReplace.Enabled = btnCMPasteReplace.Enabled = enable && !MyItemInfo.IsEnhancedStep && !MyItemInfo.HasEnhancedLinkedStep;
}
private void SetPasteButtonEnabled()
{
#region new code
StepTabPanel tmp = Parent as StepTabPanel;
if (tmp == null) return;
//turn all on
SetPasteButtons(true);
//copy item is null, turn all off and return
if (tmp.MyDisplayTabControl.MyCopyStep == null)
{
SetPasteButtons(false);
return;
}
//if copy item is equation, can only paste if from an equation
if ((tmp.MyDisplayTabControl.MyCopyStep.IsRtfRaw && !MyItemInfo.IsRtfRaw) || (!tmp.MyDisplayTabControl.MyCopyStep.IsRtfRaw && MyItemInfo.IsRtfRaw))
{
SetPasteButtons(false);
return;
}
//copy item is procedure, turn all off and return must be done from tree
if(tmp.MyDisplayTabControl.MyCopyStep.IsProcedure)
{
SetPasteButtons(false);
return;
}
//copy item is section
if (tmp.MyDisplayTabControl.MyCopyStep.IsSection && !MyItemInfo.IsSection)
{
SetPasteButtons(false);
return;
}
if (tmp.MyDisplayTabControl.MyCopyStep.IsSection && MyItemInfo.IsSection && tmp.MyDisplayTabControl.MyCopyStep.ItemID == MyItemInfo.ItemID)
{
btnPasteReplace.Enabled = btnCMPasteReplace.Enabled = false; // don't replace itself
return;
}
// B2019-010 also don't allow paste step before/after if on an RNO step type (20040)
if (MyItemInfo.IsSupInfoPart || ((int)MyItemInfo.MyContent.Type) == 20040) // before and after are always false:
{
btnPasteAfter.Enabled = btnCMPasteAfter.Enabled = false;
btnPasteBefore.Enabled = btnCMPasteBefore.Enabled = false;
}
// for now (Jan 2016 - initial implementation of enhanced document support) do NOT paste any step (MyCopyStep) that has enhanced data associated
// with it unless pasting within a enhanced source document. The reason is that code would need to handle clearing the pasted enhanced config
// data if it is pasted into a non-enhanced location.
StepConfig stepToCfg = null;
bool fromSourceHasEnhancedLinks = false;
bool toSourceHasEnhancedLinks = false;
if (tmp.MyDisplayTabControl.MyCopyStep.IsHigh)
{
stepToCfg = tmp.MyDisplayTabControl.MyCopyStep.MyConfig as StepConfig;
if (stepToCfg.MyEnhancedDocuments != null && stepToCfg.MyEnhancedDocuments.Count > 0 && stepToCfg.MyEnhancedDocuments[0].Type != 0) fromSourceHasEnhancedLinks = true;
if (MyItemInfo.IsHigh)
{
stepToCfg = MyItemInfo.MyConfig as StepConfig;
if (stepToCfg.MyEnhancedDocuments != null && stepToCfg.MyEnhancedDocuments.Count > 0 && stepToCfg.MyEnhancedDocuments[0].Type != 0) toSourceHasEnhancedLinks = true;
}
}
// enhanced: if 'from' step is not enhanced, only allow paste before/after
if (MyItemInfo.IsHigh && !MyItemInfo.IsEnhancedStep)
{
stepToCfg = MyItemInfo.MyConfig as StepConfig;
if (stepToCfg.MyEnhancedDocuments != null && stepToCfg.MyEnhancedDocuments.Count > 0 && stepToCfg.MyEnhancedDocuments[0].Type != 0)
{
// Current selected step is source (i.e. has enhanced links to enhanced steps)
// check if 'from' step is non. If so, allow paste before/after but not replace
if (tmp.MyDisplayTabControl.MyCopyStep.IsHigh)
{
StepConfig fromCfg = tmp.MyDisplayTabControl.MyCopyStep.MyConfig as StepConfig;
if (fromCfg != null && (fromCfg.MyEnhancedDocuments==null || fromCfg.MyEnhancedDocuments.Count==0))
{
btnPasteReplace.Enabled = btnCMPasteReplace.Enabled = false;
return;
}
}
}
}
//copy item is high level step
// Allow a High Level step to be pasted to a sub-step, but not to a table, figure, section or procedure type
if (tmp.MyDisplayTabControl.MyCopyStep.IsHigh && (MyItemInfo.IsTable || MyItemInfo.IsFigure || MyItemInfo.IsSection || MyItemInfo.IsProcedure))
{
// commenting these lines out allows us to use Copy Step to copy a High Level Step
// to a sub-step level. - 05/18/2015 jsj
// changed above if so the the high level step cannot be paste to a Table, Figure, Section (on the editor panel), Procedure (on the editor panel) - jsj 09/17/2015
SetPasteButtons(false);
return;
}
// don't allow a paste of a substep into a table, figure, sectino,or procedure type
// this also allows a substep (text) to be copyed to a high level step type C2015-011
if (tmp.MyDisplayTabControl.MyCopyStep.IsSubStep && (MyItemInfo.IsTable || MyItemInfo.IsFigure || MyItemInfo.IsSection || MyItemInfo.IsProcedure))
{
SetPasteButtons(false);
return;
}
// copy item is a table of figure - don't allow pasting at High Level Step, Caution or Note level, as well as not at a section or procedure level)
// Bug fix B2015-152
if (tmp.MyDisplayTabControl.MyCopyStep.IsTable && !MyItemInfo.IsTable || tmp.MyDisplayTabControl.MyCopyStep.IsFigure && !MyItemInfo.IsFigure)
{
SetPasteButtons(false);
return;
}
//otherwise everything is ok except for same item prevent replace
if (tmp.MyDisplayTabControl.MyCopyStep.ItemID == MyItemInfo.ItemID)
{
btnPasteReplace.Enabled = btnCMPasteReplace.Enabled = false; // don't replace itself
return;
}
#endregion
#region original code
//// if there is no 'copied' step, or if a procedure is copied, just turn all buttons off, this can only
//// be done from the tree.
//StepTabPanel tmp = Parent as StepTabPanel;
//if (tmp.MyDisplayTabControl.MyCopyStep == null || tmp.MyDisplayTabControl.MyCopyStep.IsProcedurePart)
//{
// btnPasteReplace.Enabled = btnPasteBefore.Enabled = btnPasteAfter.Enabled = btnStepPaste.Enabled = false;
// return;
//}
//// If a section is copied, it can be pasted as a section (before/after/replace). If can also
//// be pasted as a subsection if the format allows it.
//if (tmp.MyDisplayTabControl.MyCopyStep.IsSectionPart)
//{
// btnPasteBefore.Enabled = btnPasteAfter.Enabled = btnPasteReplace.Enabled = MyItemInfo.IsSectionPart;
// // when doing 'substep' part of paste, need to check if format allows subsection.
//}
//else if (tmp.MyDisplayTabControl.MyCopyStep.IsCautionPart || tmp.MyDisplayTabControl.MyCopyStep.IsNotePart)
// // Part type of copied step must be same as Part type of destination, with exceptions of caution/note and step/rno
// // can be pasted into each other.
// // Part types are procedure - 1, section = 2, step = 6, caution = 3, note = 4, RNO (IsRNO), = 5 table/figure = 7.
// btnPasteBefore.Enabled = btnPasteAfter.Enabled = btnPasteReplace.Enabled = (MyItemInfo.IsCautionPart || MyItemInfo.IsNotePart);
//else if (tmp.MyDisplayTabControl.MyCopyStep.IsRNOPart || tmp.MyDisplayTabControl.MyCopyStep.IsStepPart)
// btnPasteBefore.Enabled = btnPasteAfter.Enabled = btnPasteReplace.Enabled = (MyItemInfo.IsRNOPart || MyItemInfo.IsStepPart);
//else if (tmp.MyDisplayTabControl.MyCopyStep.IsTable && MyItemInfo.IsTable)
//{
// btnPasteBefore.Enabled = btnPasteAfter.Enabled = btnCMPasteBefore.Enabled = btnCMPasteAfter.Enabled = false;
// btnPasteReplace.Enabled = btnCMPasteReplace.Enabled = true;
//}
//else if (tmp.MyDisplayTabControl.MyCopyStep.IsTable && !MyItemInfo.IsTable)
//{
// btnPasteBefore.Enabled = btnPasteAfter.Enabled = btnCMPasteBefore.Enabled = btnCMPasteAfter.Enabled = false;
// btnPasteReplace.Enabled = btnCMPasteReplace.Enabled = false;
//}
//// Can't replace step with same step
//if (tmp.MyDisplayTabControl.MyCopyStep.ItemID == MyItemInfo.ItemID) btnPasteReplace.Enabled = false;
#endregion
}
private void SetChangeIdRibbon()
{
if (MyItemInfo == null)
{
FolderInfo fi = FolderInfo.Get(1);
FormatInfo frmI = FormatInfo.Get(fi.FormatID ?? 1);
rtabChgId.Visible = frmI.PlantFormat.FormatData.ProcData.ChangeBarData.ChangeIds;
}
else
rtabChgId.Visible = MyItemInfo.ActiveFormat.PlantFormat.FormatData.ProcData.ChangeBarData.ChangeIds;
}
#region submenu for printing child procedures
// C2020-013 add unit (child) submenu to create PDF and create CAS buttons
private void miMultiUnit_Click(object sender, EventArgs e)
{
if (MyItemInfo == null) return; // if creating a pdf before rtb exists, return;
DevComponents.DotNetBar.ButtonItem mi = sender as DevComponents.DotNetBar.ButtonItem;
DevComponents.DotNetBar.ButtonItem mip = mi.Parent as DevComponents.DotNetBar.ButtonItem;
int selectedChild = (int)mi.Tag;
if (selectedChild == 0) return; // unit (child) not selected
MyItemInfo.MyProcedure.ProcedureConfig.SelectedSlave = (int) mi.Tag;
switch (mip.Text)
{
case "Create":
btnPdfCreate_Click(sender, e);
break;
case "Cont. Act\r\nSummary":
btnCASCreate_Click(sender, e);
break;
}
MyItemInfo.MyProcedure.ProcedureConfig.SelectedSlave = 0; // unselect the unit (child)
}
public void SetParentChildCreatePDFButton(string[] unitNames, ItemInfo ii)
{
btnPdfCreate.SubItems.Clear();
btnPdfCreate.Tag = null;
btnPdfCreate.Click -= new System.EventHandler(btnPdfCreate_Click);
btnCASCreate.SubItems.Clear();
btnCASCreate.Tag = null;
btnCASCreate.Click -= new System.EventHandler(btnCASCreate_Click);
btnReviewCreatePDF.SubItems.Clear();
btnReviewCreatePDF.Tag = null;
btnReviewCreatePDF.Click -= new System.EventHandler(btnPdfCreate_Click);
int k = 0;
foreach (string s in unitNames)
{
// C2021-027: Procedure level PC/PC - see if menu items for unit should be enabled
bool procAppl = ii.MyProcedure.ApplIncludeFromStr(s);
k++;
ButtonItem btn = MakeSubMenuButton(s, k, miMultiUnit_Click);
btn.Enabled = procAppl;
btnPdfCreate.SubItems.Add(btn);
btn = MakeSubMenuButton(s, k, miMultiUnit_Click);
btn.Enabled = procAppl;
btnReviewCreatePDF.SubItems.Add(btn);
btn = MakeSubMenuButton(s, k, miMultiUnit_Click);
btn.Enabled = procAppl;
btnCASCreate.SubItems.Add(btn);
}
btnPdfCreate.AutoExpandOnClick = true;
btnReviewCreatePDF.AutoExpandOnClick = true;
btnCASCreate.AutoExpandOnClick = true;
}
private DevComponents.DotNetBar.ButtonItem MakeSubMenuButton(string s, object tag, EventHandler ehandler)
{
DevComponents.DotNetBar.ButtonItem bi = new DevComponents.DotNetBar.ButtonItem();
bi.Text = s;
bi.Tag = tag;
bi.Click += new System.EventHandler(ehandler);
return bi;
}
#endregion // add submenu items to print child procedure
private void SetStepButtonAndMenuEnabling(bool docontextmenus)
{
if (MyEditItem == null) return;
DocVersionInfo dvi = MyEditItem.MyItemInfo.MyProcedure.ActiveParent as DocVersionInfo;
if (dvi == null) return;
if (dvi.VersionType > 127)
btnCMEditMode1.Enabled = btnEditMode.Enabled = false; // in approved
if (dvi.VersionType > 127 || MyEditItem.MyStepPanel.VwMode == E_ViewMode.View)
{
if (rtabTableGridTools.Checked)
rtabHome.Select();
rtabTableGridTools.Visible = false;
SetButtonMenuEnabledDisabledOnStepType(false);
this.Refresh();
return;
}
else
SetButtonMenuEnabledDisabledOnStepType(true);
btnInsPgBrk.Checked = false;
// see if manual page break - only available on HLS
if (MyItemInfo.IsHigh)
{
StepConfig cfg = MyItemInfo.MyConfig as StepConfig;
btnInsPgBrk.Checked = cfg == null ? false : cfg.Step_NewManualPagebreak;
}
btnInsPgBrk.Enabled = MyItemInfo.IsHigh;
btnPageBreak.Enabled = MyItemInfo.IsHigh; // edit context menu
btnIndent.Checked = (_MyStepRTB.EditMode && _MyStepRTB.SelectionHangingIndent != 0);
btnEditMode.Checked = btnCMEditMode1.Checked = MyEditItem.MyStepPanel.VwMode == E_ViewMode.View;
// if on procedure, 'Delete' buttons should be disabled.
btnDelelete.Enabled = btnDelStep.Enabled = !MyItemInfo.IsProcedure;
// Only display the table edit tools if in a grid (table) and that grid (table) is not an RO Table.
GridItem tmpGridItm = MyEditItem as GridItem;
if (btnTblDgnAdjustSize.Checked)
{
btnTblDgnAdjustSize.Checked = false;
ToggleTableDesignButtons(true);
}
rtabTableGridTools.Visible = tmpGridItm != null;
// If no longer on a table (grid) or the newly selectd table is an RO table
// then select the Home tab (since the Table tab is not visable)
if ((!(MyEditItem is GridItem) && rtabTableGridTools.Checked)) // || ((MyEditItem is GridItem) && !rtabTableGridTools.Visible))
{
rtabHome.Select();
}
// if on procedure or section, 'change type' & 'insert' buttons should be disabled.
if (MyItemInfo.IsProcedure || MyItemInfo.IsSection)
{
btnInsCaut.Enabled = btnInsNote.Enabled = btnInsRNO.Enabled = btnInsFig.Enabled =
btnInsTable.Enabled = btnInsSubstep.Enabled = btnInsBefore.Enabled = btnInsAfter.Enabled = btnInsEquation.Enabled = false;
// if on a section, allow note/caution. May want to add condition that this is a subsection?
if (MyItemInfo.IsSection && MyItemInfo.IsStepSection && MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.AllowNoteCautionAdd)
{
btnInsNote.Enabled = true;
btnInsCaut.Enabled = true;
btnInsCaut.SubItems.Clear();
btnInsNote.SubItems.Clear();
if (docontextmenus)
{
btnCMInsCaution.SubItems.Clear();
btnCMInsNote.SubItems.Clear();
}
GalleryForSubTypes(MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.Caution, MyItemInfo.FormatStepData, btnInsCaut, (int)E_FromType.Caution, btnCMInsCaution, docontextmenus);
GalleryForSubTypes(MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.Note, MyItemInfo.FormatStepData, btnInsNote, (int)E_FromType.Note, btnCMInsNote, docontextmenus);
}
// if on a procedure or section title, don't allow for insert of ROs or Transitions:
// disable buttons. Info panels for ROs and Transitions are made invisible in frmVEPROMS.cs
btnInsTrans.Enabled = btnCMTransition.Enabled = btnInsRO.Enabled = btnCMRO.Enabled = false;
btnInsAftH.Enabled = btnInsBefH.Enabled = false;
//btnInsHLS.Enabled = (!MyItemInfo.IsStepSection || (MyItemInfo.IsStepSection && MyItemInfo.IsEnhancedSection)) ? false : true; // allow hls from step section
btnInsHLS.Enabled = !MyItemInfo.IsStepSection ? false : true; // allow hls from step section
// if active item is a section and format has metasections, check that a hls can be added.
if (MyItemInfo.IsStepSection)
{
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.UseMetaSections)
// The 'editable' data config must be set to allow new steps to be created.
{
SectionConfig sc = MyItemInfo.MyConfig as SectionConfig;
if (sc != null && MyItemInfo.Sections != null && MyItemInfo.Sections.Count > 0 && sc.SubSection_Edit != "Y")
btnInsHLS.Enabled = false;
}
}
if (btnInsHLS.Enabled)
{
btnInsHLS.SubItems.Clear();
GalleryForSubTypes(MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.HLS, MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.HLS, btnInsHLS, (int)E_FromType.Step, btnCMInsHLS, docontextmenus);
}
// B2016-237 added context menu item to change image size
btnCMImgSz.Enabled = MyEditItem.MyItemInfo.IsFigure && (MyEditItem.MyItemInfo.MyContent.MyImage != null || MyEditItem.MyItemInfo.MyContent.Text.ToUpper().Contains("#LINK"));
if (MyItemInfo.IsSupInfoPart) btnInsAfter.Enabled = btnInsAftH.Enabled = btnInsBefore.Enabled = btnInsBefH.Enabled = false;
this.Refresh();
return;
}
btnChgTyp.Enabled = true;
// set up insert buttons based on format
E_AccStep? actable = 0;
StepData sd = MyItemInfo.FormatStepData;
actable = sd.StepEditData.AcTable;
if (actable == null) actable = 0;
btnInsHLS.Enabled = MyItemInfo.MyHLS != null;
btnInsCaut.Enabled = ((actable & E_AccStep.AddingCaution) > 0) && !MyItemInfo.IsEnhancedStep;
btnInsNote.Enabled = ((actable & E_AccStep.AddingNote) > 0) && !MyItemInfo.IsEnhancedStep;
btnInsRNO.Enabled = (actable & E_AccStep.AddingRNO) > 0;
btnInsFig.Enabled = (actable & E_AccStep.AddingTable) > 0;
btnInsTable.Enabled = (actable & E_AccStep.AddingTable) > 0;
btnInsSubstep.Enabled = (actable & E_AccStep.AddingSub) > 0;
btnInsBefore.Enabled = btnInsBefH.Enabled = !MyItemInfo.IsRNOPart && !MyItemInfo.IsSupInfoPart && (actable & E_AccStep.AddingPrev) > 0;
btnInsAfter.Enabled = btnInsAftH.Enabled = !MyItemInfo.IsRNOPart && !MyItemInfo.IsSupInfoPart && (actable & E_AccStep.AddingNext) > 0;
btnInsEquation.Enabled = (actable & E_AccStep.AddingTable) > 0;
// if this step has a table, figure or equation, disable both of those buttons.
if (MyItemInfo.Tables != null && MyItemInfo.Tables.Count > 0)
btnInsTable.Enabled = btnInsFig.Enabled = btnInsEquation.Enabled = btnCMInsFigure.Enabled = btnCMInsTable.Enabled = btnCMInsEquation.Enabled = false;
btnInsHLS.SubItems.Clear();
btnInsCaut.SubItems.Clear();
btnInsNote.SubItems.Clear();
btnInsRNO.SubItems.Clear();
btnInsFig.SubItems.Clear();
btnInsEquation.SubItems.Clear();
btnInsTable.SubItems.Clear();
btnInsSubstep.SubItems.Clear();
if (docontextmenus)
{
btnCMInsHLS.SubItems.Clear();
btnCMInsCaution.SubItems.Clear();
btnCMInsNote.SubItems.Clear();
btnCMInsFigure.SubItems.Clear();
btnCMInsEquation.SubItems.Clear();
btnCMInsTable.SubItems.Clear();
btnCMInsSubStps.SubItems.Clear();
btnCMInsRNO.SubItems.Clear();
btnCMInsEquation.Enabled = btnInsEquation.Enabled;
btnCMInsFigure.Enabled = btnInsFig.Enabled;
}
btnInsRNO.Enabled = btnCMInsRNO.Enabled = btnInsRNO.Enabled && (MyItemInfo.RNOs == null || MyItemInfo.RNOs.Count == 0); // don't insert an RNO if has an RNO
// if (rno is enabled, set the tag:
if (btnInsRNO.Enabled)
btnInsRNO.Tag = string.Format("{0} {1}", (int)E_FromTypes.RNOs, MyEditItem.MyItemInfo.ActiveFormat.PlantFormat.FormatData.GetIndexFromType("RNOType"));
// Proms Express/Message when substep level > 4 may have reset tooltip, so reset:
if (btnInsSubstep.Enabled) this.superTooltipRibbon.SetSuperTooltip(this.btnInsSubstep, new DevComponents.DotNetBar.SuperTooltipInfo("Insert Substep [Ctrl] [Shift] [S]", "", "", null, null, DevComponents.DotNetBar.eTooltipColor.Gray));
// add subitems depending on whether parent type is enabled:
if (btnInsHLS.Enabled) GalleryForSubTypes(MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.HLS, sd, btnInsHLS, 0, btnCMInsHLS, docontextmenus);
if (btnInsCaut.Enabled) GalleryForSubTypes(MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.Caution, sd, btnInsCaut, (int)E_FromType.Caution, btnCMInsCaution, docontextmenus);
if (btnInsNote.Enabled) GalleryForSubTypes(MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.Note, sd, btnInsNote, (int)E_FromType.Note, btnCMInsNote, docontextmenus);
if (btnInsFig.Enabled) GalleryForSubTypes(MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.Fig, sd, btnInsFig, (int)E_FromType.Table, btnCMInsFigure, docontextmenus);
if (btnInsTable.Enabled) GalleryForSubTypes(MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.Table, sd, btnInsTable, (int)E_FromType.Table, btnCMInsTable, docontextmenus);
if (btnInsSubstep.Enabled) GalleryForSubTypes(MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.Substep, sd, btnInsSubstep, (int)E_FromType.Step, btnCMInsSubStps, docontextmenus);
if (btnInsRNO.Enabled) GalleryForSubTypes(MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.RNO, sd, btnInsRNO, 0, btnCMInsRNO, docontextmenus);
if (btnInsEquation.Enabled) GalleryForSubTypes(MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.Equation, sd, btnInsEquation, (int)E_FromType.Table, btnCMInsEquation, docontextmenus);
btnInsTrans.Enabled = btnCMTransition.Enabled = !MyItemInfo.IsFigure && !MyItemInfo.IsRtfRaw;
btnInsRO.Enabled = btnCMRO.Enabled = Mydvi.DocVersionAssociationCount > 0; // 2016-128 don't enable if RO Path was not selected at the Working Draft node
// C2014-009 Commented out to allow for inserting Note/Caution
//if in Calvert Alarms Condition/Response, disable insert of Cautions and Notes
//if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertAlarm)
//btnInsCaut.Enabled = btnInsNote.Enabled = btnCMInsCaution.Enabled = btnCMInsNote.Enabled = !MyItemInfo.IsInCalvertConditionResponse;
_RibbonControl.Refresh(); // jsj- added this because Table Design ribbon tab grouping was not going away when not on a table step type
}
/// <summary>
/// set up a gallery of step types whose parent are defined by input StepData. Can be below
/// more than one level, for example. Substep, EquipmentList, EquipmentWBlank - both equipment
/// lists would be put in gallery
/// </summary>
/// <param name="sdc">StepData: find subtypes related to this</param>
/// <param name="selType">StepData: this should be selected button</param>
/// <param name="btn">DevComponents.DotNetBar.ButtonItem: if items in the gallery, add gallery to this button</param>
/// <param name="cmbtn">DevComponents.DotNetBar.ButtonItem: if items in the gallery, add btns to context menu</param>
private void GalleryForSubTypes(StepData sdc, StepData selType, DevComponents.DotNetBar.ButtonItem btn, int fromtype, DevComponents.DotNetBar.ButtonItem cmbtn, bool docontextmenus)
{
int cursel = -1;
// The first argument (boolean) in StepGetLevelTypes provides the option to get a complete list of step types
// regardless of whether in the AER or RNO column (set to true). For all types, get both except for figures
// and tables.
bool getall = !(btn.Name == "btnInsFig" || btn.Name == "btnInsTable" || btn.Name == "btnInsEquation");
List<StepDataRetval> sdl = MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepGetLevelTypes(getall, sdc, ref cursel, selType==null?"Section":selType.Type, MyItemInfo);
if (sdl != null && sdl.Count > 0)
{
Char kt = 'A'; // start with letter A for KeyTips
// if doing the insert substep button, check for substeps already there and if so must match type.
if (btn.Name == "btnInsSubstep")
{
if (MyItemInfo.Steps != null && MyItemInfo.Steps.Count > 0)
{
ItemInfo ichld = MyItemInfo.Steps[0];
btn.Click -= new System.EventHandler(btnInsStep_Click);
btn.Click += new System.EventHandler(btnInsStep_Click);
btn.Tag = string.Format("{0} {1}", fromtype, ichld.MyContent.Type - 20000);
// B2013-175: add the single substep type to the context menu too
int cmtype = (int)ichld.MyContent.Type - 20000; // content type is the index into the stepdatalist
StepData sdcm = MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList[cmtype];
DevComponents.DotNetBar.ButtonItem cmbix = new DevComponents.DotNetBar.ButtonItem("cmbtn" + sdcm.Type, sdcm.Type);
cmbix.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbix.Text = sdcm.StepEditData.TypeMenu.MenuItem;
cmbix.Tag = string.Format("{0} {1}", fromtype, sdcm.Index); // index of type to insert it when button is clicked
cmbix.Click += new System.EventHandler(btnInsStep_Click);
cmbtn.SubItems.Add(cmbix);
return;
}
else
{
btn.Tag = null;
btn.Click -= new System.EventHandler(btnInsStep_Click);
}
}
foreach (StepDataRetval sdr in sdl)
{
bool addit = true;
StepData sd = MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList[sdr.Index];
int hlsSubType = -1; // if on hls, use this to set default on substep menu to first child
if (MyItemInfo.IsHigh && MyItemInfo.Steps != null && MyItemInfo.Steps.Count > 0)
{
hlsSubType = (int)MyItemInfo.Steps[0].MyContent.Type - 20000;
}
// unfortunately, there are some special cases to be handled.
// if high level step, don't put the rno button on
// if caution don't add note button (the StepGetLevelTypes method returns cautions/notes together
if (btn.Name == "btnInsHLS" && sd.Type == "RNOType") addit = false;
if (btn.Name == "btnInsCaut" && sd.Type.Length >= 4 && sd.Type.Substring(0, 4) == "Note") addit = false;
if (btn.Name == "btnInsNote" && sd.Type.Length >= 7 && sd.Type.Substring(0, 7) == "Caution") addit = false;
if (btn.Name == "btnInsSubstep" && MyItemInfo.Steps != null && MyItemInfo.Steps.Count > 0) addit = false;
if (addit)
{
DevComponents.DotNetBar.ButtonItem bi = new DevComponents.DotNetBar.ButtonItem("btn" + sd.Type, sd.Type);
bi.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
bi.Text = sdr.Name;
bi.Tag = string.Format("{0} {1}", fromtype, sdr.Index); // index of type to insert it when button is clicked
bi.Checked = (selType == null || (sd.Type == selType.Type));
if (docontextmenus)
{
DevComponents.DotNetBar.ButtonItem cmbi = new DevComponents.DotNetBar.ButtonItem("cmbtn" + sd.Type, sd.Type);
cmbi.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbi.Text = sdr.Name;
cmbi.Tag = string.Format("{0} {1}", fromtype, sdr.Index); // index of type to insert it when button is clicked
cmbi.Checked = (selType == null || (sd.Type == selType.Type));
if(!AddVisioOrEqnEdt(cmbi)) // Added support for Visio
cmbi.Click += new System.EventHandler(btnInsStep_Click);
cmbtn.SubItems.Add(cmbi);
}
if (MyItemInfo.IsHigh && hlsSubType != -1 && sdr.Index == hlsSubType) bi.Checked = true;
if(!AddVisioOrEqnEdt(bi)) // Added support for Visio
bi.Click += new System.EventHandler(btnInsStep_Click);
// Assign only A-Z to the KeyTips in the list (i.e. assign only the first 24 in the list)
// Note that KeyTips logic support only single characters at this level (can't have 'AA' for example)
if (kt != '0')
{
bi.KeyTips = kt.ToString();
if (kt == 'Z')
kt = '0';
else
kt++;
}
btn.SubItems.Add(bi);
}
}
//handle various cases for figures:
if (btn.Name == "btnInsFig" && docontextmenus) DoFigureMenuing(btn, cmbtn, sdl);
// if this is a table, then need to add RO/Text table options
if (btn.Name == "btnInsTable" && docontextmenus)
{
// If there is only one 'table' type from format under the ribbon's table item,
// eliminate that button and move up the RO & Text Table buttons.
// This is done for single column mode, or if in the calvertconditionresponse table (dual column) and in the rno column. Note
// the '&&' in if check because when in the calvertconditionresponse table, the section is in 'single column' mode even though
// the condition response table is dual column. This fixes B2014-105.
SectionConfig sc = (SectionConfig)MyItemInfo.ActiveSection.MyConfig;
// One Column Mode or Two Column Mode in the RNO Column or Caution or Note
if ((sc.Section_ColumnMode == SectionConfig.SectionColumnMode.One && (!MyItemInfo.IsInCalvertConditionResponse || MyItemInfo.IsInRNO))
|| (sc.Section_ColumnMode == SectionConfig.SectionColumnMode.Two && MyItemInfo.IsInRNO)
|| ( MyItemInfo.IsCautionOrNotePart)) // single column step editor
{
// setup the sub menus for the insert table ribbon button
btn.Tag = btn.SubItems[0].Tag;
btn.SubItems.Clear();
DoTableSubMenu(btn);
// setup the sub menus for the context menu used with the keyborad shortcut <shift><ctrl><T>
cmbtn.Tag = cmbtn.SubItems[0].Tag;
cmbtn.SubItems.Clear();
DoTableSubMenu(cmbtn);
}
else
{
// setup the sub menus for the insert table ribbon button
foreach (DevComponents.DotNetBar.ButtonItem tabbtn in btn.SubItems)
DoTableSubMenu(tabbtn);
// setup the sub menus for the context menu used with the keyborad shortcut <shift><ctrl><T>
foreach (DevComponents.DotNetBar.ButtonItem cmtabbtn in cmbtn.SubItems)
DoTableSubMenu(cmtabbtn);
}
}
// if only 1, be sure event exists on button to insert item & if more than 1 remove event because
// we want the drop down to appear.
if (btn.Name != "btnInsRNO")
btn.Click -= new System.EventHandler(btnInsStep_Click);
if (docontextmenus)
cmbtn.Click -= new System.EventHandler(btnInsStep_Click);
if (btn.SubItems.Count == 1)
{
btn.SubItems.Clear();
if (btn.Name != "btnInsRNO")
{
btn.Tag = string.Format("{0} {1}", fromtype, sdc.Index);
btn.Click += new System.EventHandler(btnInsStep_Click);
}
if (docontextmenus)
{
cmbtn.SubItems.Clear();
DevComponents.DotNetBar.ButtonItem cmbi = new DevComponents.DotNetBar.ButtonItem("cmbtn" + sdc.Type, sdc.Type);
cmbi.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbi.Text = btn.Text;
if (btn.Name == "btnInsRNO")
cmbi.Tag = btn.Tag;
else
cmbi.Tag = string.Format("{0} {1}", fromtype, sdc.Index); // index of type to insert it when button is clicked
cmbi.Click += new System.EventHandler(btnInsStep_Click);
cmbtn.SubItems.Add(cmbi);
}
}
}
// F2021-009 If in Proms Express, let user know if they are going to create a new substep deeper than the defined number of sub-step.
// This uses the tool tip to display the message.
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.Express && btn.Name == "btnInsSubstep" && (MyItemInfo.Steps == null || MyItemInfo.Steps.Count == 0))
{
if (MyItemInfo.GetStepLevel() >= MyItemInfo.GetDefinedSubStepCount())
{
string tpMsg = "Steps with excessive sub-step levels can be difficult to follow." +
"\nConsider rewriting the step using less sub-steps levels.";
this.superTooltipRibbon.SetSuperTooltip(this.btnInsSubstep, new DevComponents.DotNetBar.SuperTooltipInfo(tpMsg, "", "", null, null, DevComponents.DotNetBar.eTooltipColor.Red));
}
}
rbnStepParts.Refresh();
}
// Added Support for Visio
private bool AddVisioOrEqnEdt(DevComponents.DotNetBar.ButtonItem cmbi)
{
if (cmbi.Text.Contains("Equation") && OleObjectEditors == 3)
{
DevComponents.DotNetBar.ButtonItem btn1 = new DevComponents.DotNetBar.ButtonItem("btnEquation", "Equation Editor");
btn1.Click += new System.EventHandler(btnInsStep_Click);
btn1.Tag = cmbi.Tag + " EqnEdt";
btn1.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
//btn1.Tag = string.Format("Equation"); // index of type to insert it when button is clicked
cmbi.SubItems.Add(btn1);
DevComponents.DotNetBar.ButtonItem btn2 = new DevComponents.DotNetBar.ButtonItem("btnVisio", "Visio");
btn2.Click += new System.EventHandler(btnInsStep_Click);
btn2.Tag = cmbi.Tag + " Visio";
btn2.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbi.SubItems.Add(btn2);
return true;
}
return false;
}
// From Figure menuing, need to map those strings to the index in the StepdataList for setting item's content type:
//<Step Index="36" Type="Figure" ParentType="Base" />
//<Step Index="37" Type="AERFigure" ParentType="Figure" />
//<Step Index="38" Type="BorderlessFigure" ParentType="Figure" />
//<Step Index="39" Type="BorderlessAERFigure" ParentType="AERFigure" />
private int Centered = 36; // will always be top level.
private void DoFigureMenuing(ButtonItem btn, ButtonItem cmbtn, List<StepDataRetval> sdl)
{
// Figure menuing:
// Figure (from ribbon)
// If in AER Column:
// Centered
// Left
// From both Centered & Left:
// With Border
// Without Border
// From both w/wo Border:
// RO Figure
// Figure from Clipboard
// Figure From File
// If in RNO column or single column mode (see comment below for this menu):
// With Border
// Without Border
// From both w/wo Border:
// RO Figure
// Figure from Clipboard
// Figure From File
// This is done for single column mode, or if in the calvertconditionresponse table (dual column) and in the rno column. Note
// the '&&' in if check because when in the calvertconditionresponse table, the section is in 'single column' mode even though
// the condition response table is dual column.
SectionConfig sc = (SectionConfig)MyItemInfo.ActiveSection.MyConfig;
// One Column Mode or Two Column Mode in the RNO Column or Caution or Note
if ((sc.Section_ColumnMode == SectionConfig.SectionColumnMode.One && (!MyItemInfo.IsInCalvertConditionResponse || MyItemInfo.IsInRNO))
|| (sc.Section_ColumnMode == SectionConfig.SectionColumnMode.Two && MyItemInfo.IsInRNO)
|| (MyItemInfo.IsCautionOrNotePart)) // single column step editor
{
// setup the sub menus for the insert table ribbon button
btn.Tag = btn.SubItems[0].Tag;
btn.SubItems.Clear();
DoFigureW_WOborderSubMenu(btn);
// setup the sub menus for the context menu used with the keyborad shortcut <shift><ctrl><T>
cmbtn.Tag = cmbtn.SubItems[0].Tag;
cmbtn.SubItems.Clear();
DoFigureW_WOborderSubMenu(cmbtn);
}
else
{
// this is AER column in dual column-need to add 'Centered' & 'Left'
char[] sp = { ' ' };
btn.Tag = btn.SubItems[0].Tag;
btn.SubItems.Clear();
string[] insdata = btn.Tag.ToString().Split(sp);
int ftype = Convert.ToInt32(insdata[0]);
int sdtype = Convert.ToInt32(insdata[1]);
DevComponents.DotNetBar.ButtonItem cmbt = new DevComponents.DotNetBar.ButtonItem("cmbtnt" + sdtype + "CENT", "Centered");
cmbt.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbt.Text = "Centered";
cmbt.Tag = string.Format("{0} {1} {2}", ftype, 36, "CENT");
cmbt.Click += new System.EventHandler(btnInsStep_Click);
btn.SubItems.Add(cmbt);
cmbt = new DevComponents.DotNetBar.ButtonItem("cmbtnt" + sdtype + "LT", "Left");
cmbt.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbt.Text = "Left";
cmbt.Tag = string.Format("{0} {1} {2}", ftype, 37, "LT"); // Text table
cmbt.Click += new System.EventHandler(btnInsStep_Click);
btn.SubItems.Add(cmbt);
btn.Tag = null;
btn.Click -= new System.EventHandler(btnInsStep_Click);
// setup the sub menus for the insert figure ribbon button
foreach (DevComponents.DotNetBar.ButtonItem tabbtn in btn.SubItems)
DoFigureW_WOborderSubMenu(tabbtn);
// setup the sub menus for the context menu used with the keyborad shortcut <shift><ctrl><T>
foreach (DevComponents.DotNetBar.ButtonItem cmtabbtn in cmbtn.SubItems)
DoFigureW_WOborderSubMenu(cmtabbtn);
}
}
private void DoFigureW_WOborderSubMenu(DevComponents.DotNetBar.ButtonItem tabbtn)
{
char[] sp = { ' ' };
string[] insdata = tabbtn.Tag.ToString().Split(sp);
int ftype = Convert.ToInt32(insdata[0]);
int sdtype = Convert.ToInt32(insdata[1]);
int with = sdtype == Centered ? 36 : 37;
DevComponents.DotNetBar.ButtonItem cmbt = new DevComponents.DotNetBar.ButtonItem("cmbtnt" + sdtype + "BD", "With Border");
cmbt.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbt.Text = "With Border";
cmbt.Tag = string.Format("{0} {1} {2}", ftype, sdtype, "BD");
cmbt.Click += new System.EventHandler(btnInsStep_Click);
tabbtn.SubItems.Add(cmbt);
DoFigureFromSubMenu(cmbt);
int wo = sdtype == Centered ? 38 : 39;
cmbt = new DevComponents.DotNetBar.ButtonItem("cmbtnt" + wo + "NB", "Without Border");
cmbt.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbt.Text = "Without Border";
cmbt.Tag = string.Format("{0} {1} {2}", ftype, wo, "NB");
cmbt.Click += new System.EventHandler(btnInsStep_Click);
tabbtn.SubItems.Add(cmbt);
DoFigureFromSubMenu(cmbt);
tabbtn.Tag = null;
tabbtn.Click -= new System.EventHandler(btnInsStep_Click);
}
private void DoFigureFromSubMenu(DevComponents.DotNetBar.ButtonItem tabbtn)
{
char[] sp = { ' ' };
string[] insdata = tabbtn.Tag.ToString().Split(sp);
int ftype = Convert.ToInt32(insdata[0]);
int sdtype = Convert.ToInt32(insdata[1]);
DevComponents.DotNetBar.ButtonItem cmbt = new DevComponents.DotNetBar.ButtonItem("cmbtnt" + sdtype + "RO", "RO Figure");
cmbt.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbt.Text = "RO Figure";
cmbt.Tag = string.Format("{0} {1} {2}", ftype, sdtype, "RO");
cmbt.Click += new System.EventHandler(btnInsStep_Click);
tabbtn.SubItems.Add(cmbt);
cmbt = new DevComponents.DotNetBar.ButtonItem("cmbtnt" + sdtype + "CL", "From Clipboard");
cmbt.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbt.Text = "From Clipboard";
cmbt.Tag = string.Format("{0} {1} {2}", ftype, sdtype, "CL");
cmbt.Click += new System.EventHandler(btnInsStep_Click);
tabbtn.SubItems.Add(cmbt);
cmbt = new DevComponents.DotNetBar.ButtonItem("cmbtnt" + sdtype + "FL", "From File");
cmbt.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbt.Text = "From File";
cmbt.Tag = string.Format("{0} {1} {2}", ftype, sdtype, "FL"); // Text table
cmbt.Click += new System.EventHandler(btnInsStep_Click);
tabbtn.SubItems.Add(cmbt);
tabbtn.Tag = null;
tabbtn.Click -= new System.EventHandler(btnInsStep_Click);
}
private void DoTableSubMenu(DevComponents.DotNetBar.ButtonItem tabbtn)
{
char[] sp = { ' ' };
string[] insdata = tabbtn.Tag.ToString().Split(sp);
int ftype = Convert.ToInt32(insdata[0]);
int sdtype = Convert.ToInt32(insdata[1]);
DevComponents.DotNetBar.ButtonItem cmbt = new DevComponents.DotNetBar.ButtonItem("cmbtnt" + sdtype + "RO", "RO Table");
cmbt.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbt.Text = "RO Table";
cmbt.Tag = string.Format("{0} {1} {2}", ftype, sdtype, "RO");
//cmbt.Checked = (sd.Type == selType.Type);
cmbt.Click += new System.EventHandler(btnInsStep_Click);
tabbtn.SubItems.Add(cmbt);
cmbt = new DevComponents.DotNetBar.ButtonItem("cmbtnt" + sdtype + "TX", "Text Table");
cmbt.ButtonStyle = DevComponents.DotNetBar.eButtonStyle.TextOnlyAlways;
cmbt.Text = "Text Table";
cmbt.Tag = string.Format("{0} {1} {2}", ftype, sdtype, "TX"); // Text table
//cmbt.Checked = (sd.Type == selType.Type);
cmbt.Click += new System.EventHandler(btnInsStep_Click);
tabbtn.SubItems.Add(cmbt);
tabbtn.Tag = null;
tabbtn.Click -= new System.EventHandler(btnInsStep_Click);
}
#endregion
#region Insert Tab
private void btnSym_Click(object sender, EventArgs e)
{
DevComponents.DotNetBar.ButtonItem b = (DevComponents.DotNetBar.ButtonItem)sender;
StartGridEditing(SelectionOption.Start); // If in a FlexGrid, start the editor for a cell
_MyStepRTB.InsertSymbol(Convert.ToInt32(b.Tag));
}
private enum SelectionOption
{
Start,
All,
End
}
/// <summary>
/// If in a FlexGrid, start the editor for a cell
/// </summary>
/// <param name="selectAll">If false cursor will be placed at the begining</param>
private void StartGridEditing(SelectionOption selOpt)
{
// Bug fix: B2012-203, B2012-204
// Need to check if the selected table cell is in edit mode already.
// if already in edit mode, we don't want to do the StartEditing code below, because it
// will override the current cursor positioning and selection range.
Control ctrl = FindActiveControl();
if (ctrl == null) return; // B2018-008 If a null is returned, don't do anything
if (ctrl is VlnFlexGrid)
{
// Selected table cell is not in edit mode. Go into edit mode and position acording
// to the pass in selOpt.
if (MyFlexGrid != null && MyFlexGrid.Editor == null)
{
MyFlexGrid.StartEditing();
switch (selOpt)
{
case SelectionOption.Start:
MyStepRTB.Select(0, 0);
break;
case SelectionOption.All:
MyStepRTB.SelectAll();
break;
case SelectionOption.End:
MyStepRTB.Select(MyStepRTB.TextLength, 0);
break;
default:
MyStepRTB.Select(0, 0);
break;
}
}
}
}
// C2016-029 apply a style (bold,italics,underline,text case) to the selected grid cells
// This method will apply the past in style to either the selected grid cells or to the currently selected step type
private void ApplyStyleToCurrentStepOrGridSelection(SelectionOption selOpt, CellRangeApplyStyle applyStyle)
{
// Need to check if the selected table cell is in edit mode already.
// if already in edit mode, we don't want to do the StartEditing code below, because it
// will override the current cursor positioning and selection range.
Control ctrl = FindActiveControl();
if (ctrl == null) return; // B2018-008 if a null is returned don't do anything
if (ctrl is VlnFlexGrid)
{
// Selected table cell is not in edit mode. Go into edit mode and position according
// to the pass in selOpt.
if (MyFlexGrid != null && MyFlexGrid.Editor == null)
{
C1.Win.C1FlexGrid.CellRange cr = MyFlexGrid.Selection; // get the selected grid cell range
for (int r = cr.r1; r <= cr.r2; r++)
for (int c = cr.c1; c <= cr.c2; c++)
{
MyFlexGrid.Select(r, c);
MyFlexGrid.StartEditing();
switch (selOpt)
{
case SelectionOption.Start:
MyStepRTB.Select(0, 0);
break;
case SelectionOption.All:
MyStepRTB.SelectAll();
break;
case SelectionOption.End:
MyStepRTB.Select(MyStepRTB.TextLength, 0);
break;
default:
MyStepRTB.Select(0, 0);
break;
}
applyStyle();
}
MyFlexGrid.Select(cr);
}
}
else
applyStyle(); // not in a grid, apply style to current step type
}
//C2021-005 the font size for the selected table cell(s)
private float GetTableCellFontSize(SelectionOption selOpt)
{
// return 0 if there are multiple font sizes or just an invalid selection
float rtnFontSize = -1;
// Need to check if the selected table cell is already in edit mode.
// if already in edit mode, we don't want to do the StartEditing code below, because it
// will override the current cursor positioning and selection range.
Control ctrl = FindActiveControl();
if (ctrl == null) return rtnFontSize; // B2018-008 if a null is returned don't do anything
if (ctrl is VlnFlexGrid)
{
// Selected table cell is not in edit mode. Go into edit mode and position according
// to the pass in selOpt.
// B2021-090 don't try to get the font size on an RO table
// B2022-137 Table performance improvements
if (MyFlexGrid != null && MyFlexGrid.Editor == null && !MyFlexGrid.IsRoTable)
{
rtnFontSize = StepRTB.GetRTFFontSize(MyFlexGrid.Selection.Clip);
}
else
rtnFontSize = MyStepRTB.GetRTFFontSize(); // returns 0 when there are mulitiple font sizes
}
return rtnFontSize;
}
// C2021-005 change the font size of the selected table cell(s) or cell text
private void ChangeFontSize(SelectionOption selOpt, float newSize)
{
// ChangeFontSize: similar to code that sets styles (above) except do the font size instead.
// Need to check if the selected table cell is already in edit mode.
// if already in edit mode, we don't want to do the StartEditing code below, because it
// will override the current cursor positioning and selection range.
Control ctrl = FindActiveControl();
if (ctrl == null) return; // B2018-008 if a null is returned don't do anything
if (ctrl is VlnFlexGrid)
{
// Selected table cell is not in edit mode. Go into edit mode and position according
// to the pass in selOpt.
if (MyFlexGrid != null && MyFlexGrid.Editor == null)
{
C1.Win.C1FlexGrid.CellRange cr = MyFlexGrid.Selection; // get the selected grid cell range
for (int r = cr.r1; r <= cr.r2; r++)
for (int c = cr.c1; c <= cr.c2; c++)
{
MyFlexGrid.Select(r, c);
MyFlexGrid.StartEditing();
switch (selOpt)
{
case SelectionOption.Start:
MyStepRTB.Select(0, 0);
break;
case SelectionOption.All:
MyStepRTB.SelectAll();
break;
case SelectionOption.End:
MyStepRTB.Select(MyStepRTB.TextLength, 0);
break;
default:
MyStepRTB.Select(0, 0);
break;
}
ChangeTableTextFontSize(newSize); // Apply font size to selected cells
}
MyFlexGrid.Select(cr);
}
else
{
int ss = MyStepRTB.SelectionStart;
int sl = MyStepRTB.SelectionLength;
MyStepRTB.OnReturnToEditor(this, new EventArgs());
MyStepRTB.Select(ss, sl);
ChangeTableTextFontSize(newSize);
}
}
else
{
if (MyStepRTB != null)
{
// the table cell editor lost focus when the font size dropdown is active
// Save the text selection information because when we re-activate it the selection
// will be lost.
// the logic below was copied from the Save Transition button function
int ss = MyStepRTB.SelectionStart;
int sl = MyStepRTB.SelectionLength;
MyStepRTB.OnReturnToEditor(this, new EventArgs());
MyStepRTB.Select(ss, sl);
ChangeTableTextFontSize(newSize);
}
}
}
// B2021-052 table cell text that ends with a link (RO or Transition) was not accepting a change in font size
private void ChangeTableTextFontSize(float newSize)
{
int ss = MyStepRTB.SelectionStart;
int sl = MyStepRTB.SelectionLength;
bool addedSpace = false;
// B2021-052 if the table cell text end with a link, then append a space to the end and reselect the text
if ((sl == MyStepRTB.TextLength || MyStepRTB.SelectedText.EndsWith("[END>")) && MyStepRTB.Text.EndsWith("[END>"))
{
addedSpace = true;
MyStepRTB.OnReturnToEditor(this, new EventArgs()); //reset and refocus to the table cell rtf edtior
MyStepRTB.AppendText(" ");
MyStepRTB.Select(ss, sl);
}
MyStepRTB.SetFontSize(newSize); // change the font size of the selection
// B2021-052 if a space as added, remove the space
if (addedSpace)
{
MyStepRTB.OnReturnToEditor(this, new EventArgs());
MyStepRTB.Select(MyStepRTB.TextLength - 1, 1); // select the space at the end of the text
MyStepRTB.SelectedText = ""; // remove the space
MyStepRTB.Select(ss, sl);
}
}
private void ToggleBold()
{
RTBAPI.ToggleBold(!RTBAPI.IsBold(_MyStepRTB), _MyStepRTB, _MyStepRTB.SelectionLength == 0 ? RTBAPI.RTBSelection.SCF_DEFAULT : RTBAPI.RTBSelection.SCF_SELECTION);
}
public void btnInsPgBrk_Click(object sender, EventArgs e)
{
//rtabInsert.Select(); // insert page break is no longer visible on the ribbon
if (MyItemInfo.IsProcedure || MyItemInfo.IsSection || !MyItemInfo.IsHigh) return;
MyEditItem.SaveContents();
// toggle manual page break
StepConfig cfg = MyItemInfo.MyConfig as StepConfig;
cfg.Step_NewManualPagebreak = !cfg.Step_NewManualPagebreak;
btnPageBreak.Checked = btnInsPgBrk.Checked = cfg.Step_NewManualPagebreak;
}
private void btnIndent_Click(object sender, EventArgs e)
{
if (MyItemInfo.IsProcedure || MyItemInfo.IsSection) return;
// Use the button as a toggle, i.e. if indent is on - turn it off. If indent is off, use the current cursor
// location to turn it on.
// The print tool (iTextSharp) only supports 1 indent per paragraph, i.e. steprtb (that is also a table cell)
// so the user interface only allows for 1 indent. Note that soft returns maintain the hanging indent & hard
// returns do not maintain it for the FIRST line after the hard return, but any wrapping lines will indent to
// the hanging indent location.
// The following code sets the hanging indent for the entire rtb by selecting all. Without
// this multiple hanging indents could be done - but it didn't appear that way in the user
// interface since the button just toggled on/off.
int savIndent = _MyStepRTB.GetPositionFromCharIndex(_MyStepRTB.SelectionStart).X;
int selStart = _MyStepRTB.SelectionStart;
int selLength = _MyStepRTB.SelectionLength;
_MyStepRTB.SelectAll();
if (_MyStepRTB.SelectionHangingIndent != 0) // this is what does the 'toggle' indent off
_MyStepRTB.SelectionHangingIndent = 0;
else
_MyStepRTB.SelectionHangingIndent = savIndent;
btnIndent.Checked = _MyStepRTB.SelectionHangingIndent != 0;
_MyStepRTB.SelectionStart = selStart;
_MyStepRTB.SelectionLength = selLength;
}
private void btnCMIndent_Click(object sender, EventArgs e)
{
if (_MyStepRTB.SelectionHangingIndent != 0)
_MyStepRTB.SelectionHangingIndent = 0;
else
_MyStepRTB.SelectionHangingIndent = _MyStepRTB.GetPositionFromCharIndex(_MyStepRTB.SelectionStart).X;
btnIndent.Checked = _MyStepRTB.SelectionHangingIndent != 0;
}
#endregion
#region Home Tab
private bool _PastePlainTextOvrRide = false;
private bool _PasteStepTextOvrRide = false;
private void btnPaste_Click(object sender, EventArgs e)
{
StartGridEditing(SelectionOption.End);
IDataObject myDO = Clipboard.GetDataObject();
RichTextBox myRtb = _MyStepRTB;
Control ctrl = FindActiveControl(); // null if on property page for procedure & section number/title
if (ctrl != null && !_MyStepRTB.Focused)
{
if (ctrl is RichTextBox)
{
myRtb = ctrl as RichTextBox;
}
else if (ctrl is ComboBox)
{
ComboBox cmb = ctrl as ComboBox;
if (myDO.GetDataPresent(DataFormats.UnicodeText))
cmb.SelectedText = myDO.GetData(DataFormats.UnicodeText).ToString();
else if (myDO.GetDataPresent(DataFormats.Text))
cmb.SelectedText = myDO.GetData(DataFormats.Text).ToString();
_PastePlainTextOvrRide = false;
_PasteStepTextOvrRide = false;
return;
}
else
{
SaveErrorInLogProblemWithType(ctrl);
_PastePlainTextOvrRide = false;
_PasteStepTextOvrRide = false;
return;
}
}
// check if rtf is coming from Word, i.e. if it has 'SCHEMAS.MICROSOFT.COM/OFFICE/WORD'.
// If it is coming from Word, it will be pasted as text so as not to get any rtf commands
// that PROMS does not support such as odd Fonts, other symbols, etc. This isn't a complete
// solution, clipboard data may come from other 3rd-party tools and unsupported Rtf may get
// pasted in. But the hope is that this will happen less often than getting it from MS Word.
if (myDO.GetDataPresent(DataFormats.Rtf) && (_PasteStepTextOvrRide || (!_PastePlainTextOvrRide && !PastePlainTextSetting)))
{
string tmpForLink = myDO.GetData(DataFormats.Rtf).ToString().Replace("\r\n", "");
if (tmpForLink.ToUpper().Contains(@"SCHEMAS.MICROSOFT.COM/OFFICE/WORD"))
myRtb.SelectedText = _MyStepRTB.GetPasteText(PasteNoReturnsSetting, myDO);
else
{
tmpForLink = ItemInfo.ReplaceLinkWithNewID(tmpForLink);
myRtb.SelectedRtf = tmpForLink;
// Fix for B2014-071: if link, save after paste so that goto's don't crash (grid & step run through this code)
if (tmpForLink.Contains("<NewID>")) _MyStepRTB.OnDoSaveContents(this, new EventArgs());
}
}
else if (myDO.GetDataPresent(DataFormats.Text))
myRtb.SelectedText = _MyStepRTB.GetPasteText(PasteNoReturnsSetting, myDO);
if (myRtb.SelectionLength == 0 && myRtb is StepRTB) myRtb.SelectionFont = (myRtb as StepRTB).MyStyleFont.WindowsFont;
_PastePlainTextOvrRide = false;
_PasteStepTextOvrRide = false;
}
private void SaveErrorInLogProblemWithType(Control ctrl)
{
StringBuilder errormsg = new StringBuilder(string.Format("Failed clipboard action with control {0} a {1} ", ctrl.Name, ctrl.GetType().Name));
Type typ = ctrl.GetType();
while (typ.Name != "Control")
{
errormsg.Append(string.Format(", dervied from {0}", typ.BaseType.Name));
typ = typ.BaseType;
}
_MyLog.Error(errormsg);
}
private Control FindActiveControl()
{
// added the flag below because a table (grid) could have a cell selected (a control)
// but it might not have focus (in edit mode)
bool beenThereDoneThat = false; // flag to prevent infinate loop
Control tmp = this;
while (!(tmp.Parent is Form))
{
tmp = tmp.Parent;
// if coming from property page (properties of procedure & section number/title),
// B2018-008 tmp becomes _MyStepRTB rather than from flexgrid or steptext.
if (tmp == null) return _MyStepRTB;
}
Form frm = tmp.Parent as Form;
tmp = frm.ActiveControl;
while (!beenThereDoneThat && tmp.Controls.Count > 0)
{
beenThereDoneThat = true;
foreach (Control ctrl in tmp.Controls)
if (ctrl.ContainsFocus)
{
tmp = ctrl;
beenThereDoneThat = false;
break;
}
}
return tmp;
}
private void btnCut_Click(object sender, EventArgs e)
{
StartGridEditing(SelectionOption.All);
MoveSelectedToClipboard(true);
}
private void MoveSelectedToClipboard(bool isCut)
{
Control ctrl = FindActiveControl();
if (ctrl == null) return; // B2018-008 If a null is returned, don't do anything
Clipboard.Clear();
//if (_MyStepRTB == null) return;
if (_MyStepRTB.SelectedText == null || _MyStepRTB.SelectedText == "")
return; // nothing to copy onto clipboard, just return
DataObject myDO = new DataObject(); ;
if (ctrl is RichTextBox)
{
//myDO = new DataObject("Rich Text Format", (ctrl as RichTextBox).SelectedRtf);
string tmp2 = _MyStepRTB.SelectedText;
string tmp = _MyStepRTB.GetSelectionForClipBoard();
tmp2 = Regex.Replace(tmp2, @"#Link:ReferencedObject:[0-9]+ +[0-9a-zA-Z]+ [0-9]+", @"");
tmp2 = Regex.Replace(tmp2, @"#Link:Transition:([0-9]+) [0-9]+ [1-9]+", @"");
tmp2 = Regex.Replace(tmp2, @"#Link:TransitionRange:([0-9]+) [0-9]+ [0-9]+ [0-9]+", "");
tmp2 = tmp2.Replace("<START]", "");
tmp2 = tmp2.Replace("[END>", "");
myDO.SetText(tmp2, TextDataFormat.Text);
//myDO.SetText(_MyStepRTB.SelectedRtf, TextDataFormat.Rtf);
myDO.SetText(tmp, TextDataFormat.Rtf);
if (isCut) (ctrl as RichTextBox).SelectedText = "";
}
else if (ctrl is ComboBox)
{
//myDO = new DataObject("Text Format", (ctrl as ComboBox).SelectedText);
myDO.SetText((ctrl as ComboBox).SelectedText, TextDataFormat.Text);
if (isCut) (ctrl as ComboBox).SelectedText = "";
}
else if (ctrl is TextBox)
{
//myDO = new DataObject("Text Format", (ctrl as TextBox).SelectedText);
myDO.SetText((ctrl as TextBox).SelectedText, TextDataFormat.Text);
if (isCut) (ctrl as TextBox).SelectedText = "";
}
else
{
SaveErrorInLogProblemWithType(ctrl);
return;
}
//DataObject myDO;
//if (ctrl is RichTextBox)
//{
// myDO = new DataObject("Rich Text Format", (ctrl as RichTextBox).SelectedRtf);
// myDO.SetText(_MyStepRTB.SelectedText);
// if(isCut) (ctrl as RichTextBox).SelectedText = "";
//}
//else if (ctrl is ComboBox)
//{
// myDO = new DataObject("Text Format", (ctrl as ComboBox).SelectedText);
// if (isCut) (ctrl as ComboBox).SelectedText = "";
//}
//else if (ctrl is TextBox)
//{
// myDO = new DataObject("Text Format", (ctrl as TextBox).SelectedText);
// if (isCut) (ctrl as TextBox).SelectedText = "";
//}
//else
//{
// SaveErrorInLogProblemWithType(ctrl);
// return;
//}
Clipboard.SetDataObject(myDO);
}
private void btnCopy_Click(object sender, EventArgs e)
{
StartGridEditing(SelectionOption.All);
MoveSelectedToClipboard(false);
}
private void btnBold_Click(object sender, EventArgs e)
{
ApplyStyleToCurrentStepOrGridSelection(SelectionOption.All,ToggleBold);
// B2017-208 toggle on/off attributes button checks when you edit table cells, going from one cell to another
// Also don't keep the attributes buttons checked after setting a group of table cells all at one time
btnCMBold.Checked = btnBold.Checked = RTBAPI.IsBold(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
}
private void btnItalics_Click(object sender, EventArgs e)
{
ApplyStyleToCurrentStepOrGridSelection(SelectionOption.All,ToggleItalic);
// B2017-208 toggle on/off attributes button checks when you edit table cells, going from one cell to another
// Also don't keep the attributes buttons checked after setting a group of table cells all at one time
btnCMItalics.Checked = btnItalics.Checked = RTBAPI.IsItalic(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
}
private void ToggleItalic()
{
RTBAPI.ToggleItalic(!RTBAPI.IsItalic(_MyStepRTB), _MyStepRTB, _MyStepRTB.SelectionLength == 0 ? RTBAPI.RTBSelection.SCF_DEFAULT : RTBAPI.RTBSelection.SCF_SELECTION);
}
private void btnUnderline_Click(object sender, EventArgs e)
{
ApplyStyleToCurrentStepOrGridSelection(SelectionOption.All, ToggleUnderline);
// B2017-208 toggle on/off attributes button checks when you edit table cells, going from one cell to another
// Also don't keep the attributes buttons checked after setting a group of table cells all at one time
btnCMUnderline.Checked = btnUnderline.Checked = RTBAPI.IsUnderline(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
}
private void ToggleUnderline()
{
RTBAPI.ToggleUnderline(!RTBAPI.IsUnderline(_MyStepRTB), _MyStepRTB, _MyStepRTB.SelectionLength == 0 ? RTBAPI.RTBSelection.SCF_DEFAULT : RTBAPI.RTBSelection.SCF_SELECTION);
}
public void btnSuperscript_Click(object sender, EventArgs e)
{
StartGridEditing(SelectionOption.All);
RTBAPI.ToggleSuperscript(!RTBAPI.IsSuperScript(_MyStepRTB), _MyStepRTB, _MyStepRTB.SelectionLength == 0 ? RTBAPI.RTBSelection.SCF_DEFAULT : RTBAPI.RTBSelection.SCF_SELECTION);
btnCMSuperscript.Checked = btnSuperscript.Checked = RTBAPI.IsSuperScript(_MyStepRTB);
}
public void btnSubscript_Click(object sender, EventArgs e)
{
StartGridEditing(SelectionOption.All);
RTBAPI.ToggleSubscript(!RTBAPI.IsSubScript(_MyStepRTB), _MyStepRTB, _MyStepRTB.SelectionLength == 0 ? RTBAPI.RTBSelection.SCF_DEFAULT : RTBAPI.RTBSelection.SCF_SELECTION);
btnCMSubscript.Checked = btnSubscript.Checked = RTBAPI.IsSubScript(_MyStepRTB);
}
private void btnUppercase_Click(object sender, EventArgs e)
{
ApplyStyleToCurrentStepOrGridSelection(SelectionOption.All, SetUpperCase);
}
private void SetUpperCase()
{
_MyStepRTB.SetSelectedCase('U');
}
private void btnLowercase_Click(object sender, EventArgs e)
{
ApplyStyleToCurrentStepOrGridSelection(SelectionOption.All, SetLowerCase);
}
private void SetLowerCase()
{
_MyStepRTB.SetSelectedCase('l');
}
private void btnTitleCase_Click(object sender, EventArgs e)
{
ApplyStyleToCurrentStepOrGridSelection(SelectionOption.All, SetTitleCase);
}
private void SetTitleCase()
{
_MyStepRTB.SetSelectedCase('T');
}
private void btnInsTrans_Click(object sender, EventArgs e)
{
StartGridEditing(SelectionOption.Start);
// see if user is positioned 'on' a transition within the rtb, if so do a modify, otherwise,
// insert transition.
StepTabPanel tmp = Parent as StepTabPanel;
tmp.MyDisplayTabControl.OnLinkModifyTran(this, new StepPanelLinkEventArgs(MyStepRTB.MyLinkText));
}
private void btnInsHrdSpc_Click(object sender, EventArgs e)
{
StartGridEditing(SelectionOption.Start);
_MyStepRTB.InsertSymbol(@"\u160?");
}
private void btnInsRO_Click(object sender, EventArgs e)
{
StartGridEditing(SelectionOption.Start);
// see if user is positioned 'on' an ReferencedObject within the rtb, if so do a modify, otherwise,
// insert referenced object.
StepTabPanel tmp = Parent as StepTabPanel;
tmp.MyDisplayTabControl.OnLinkModifyRO(this, new StepPanelLinkEventArgs(MyStepRTB.MyLinkText));
}
private void btnRedo_Click(object sender, EventArgs e)
{
_MyStepRTB.Redo();
btnCMUndo.Enabled = btnUndo.Enabled = _MyStepRTB.CanUndo;
btnCMRedo.Enabled = btnRedo.Enabled = _MyStepRTB.CanRedo;
}
private void btnUndo_Click(object sender, EventArgs e)
{
_MyStepRTB.Undo();
if (_MyStepRTB.WasXDelete && _MyStepRTB.SelectionStart > 0 && _MyStepRTB.TextLength > 0 && (_MyStepRTB.Text[_MyStepRTB.SelectionStart - 1] == 'X'))
{
_MyStepRTB.Undo();
_MyStepRTB.WasXDelete = false;
// only allow one of these - not best case, but at least can get
// one undo
_MyStepRTB.ClearUndo();
}
btnCMRedo.Enabled = btnRedo.Enabled = _MyStepRTB.CanRedo;
btnCMUndo.Enabled = btnUndo.Enabled = _MyStepRTB.CanUndo;
}
private void btnGoTo_Click(object sender, EventArgs e)
{
// if on a transition, go to the selected transition 'to'. If on
// a referenced object, bring up ReferencedObject Editor (for now, just put up a message box.
if (_MyStepRTB.MyLinkText != null && _MyStepRTB.MyLinkText.IndexOf("Transition") > -1)
{
_MyEditItem.MyStepPanel.OnLinkClicked(sender, new StepPanelLinkEventArgs(_MyStepRTB.MyLinkText));
}
else
{
if (VlnSettings.ReleaseMode.Equals("DEMO"))
{
FlexibleMessageBox.Show("Referenced Object Editor not available in the Demo version.", "PROMS Demo Version");
return;
}
string myROID;
RODbInfo myRODB;
if (MyFlexGrid != null && MyFlexGrid.IsRoTable)
{
myROID = MyFlexGrid.ROID.ToLower();
myRODB = RODbInfo.Get(MyFlexGrid.RODbId);
}
else if (MyItemInfo.IsFigure && MyItemInfo.MyContent.ContentRoUsages != null && MyItemInfo.MyContent.ContentRoUsages.Count > 0)
{
myROID = MyItemInfo.MyContent.ContentRoUsages[0].ROID;
myRODB = MyItemInfo.MyContent.ContentRoUsages[0].MyRODb;
}
else
{
LinkText lt = new LinkText(_MyStepRTB.MyLinkText);
//B2023-104 If we could not get the MyRoUsageInfo then we have a bad RO Link. Tell user to re-link the RO
if (lt.MyRoUsageInfo != null)
{
myROID = lt.MyRoUsageInfo.ROID.ToLower();
myRODB = lt.MyRoUsageInfo.MyRODb;
}
else
{
FlexibleMessageBox.Show("Invalid RO link information.\n\n Please re-link this RO value.", "Invalid RO Reference", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
}
if (myROID == null) return;
if (myROID.StartsWith("ffff"))
{
FlexibleMessageBox.Show("Unit Information RO's cannot be edited", "Unit Information RO", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
//string roapp = Environment.GetEnvironmentVariable("roapp");
string roapp = Volian.Base.Library.ExeInfo.GetROEditorPath(); // get the path to the RO Editor Executable
string args = "\"" + myRODB.FolderPath + "\" " + myROID;
if (!Directory.Exists(myRODB.FolderPath))
{
FlexibleMessageBox.Show(string.Format("RO Database directory does not exist: {0}", myRODB.FolderPath));
return;
}
// C2017-003: ro data in sql server, check for sql connection string
if (myRODB.DBConnectionString != "cstring") args = args + " \"" + myRODB.DBConnectionString + "\"";
// C2021-026 pass in Parent/Child information (list of the children)
// B2022-019 look at all DocVersions to find ParentChild information
// to ensure we pass in Parent/Child even when not coming from a Parent/Child procedure set
// B2022-073 Break out of the foreach when we find a set with parent/child information
DocVersionInfoList dvil = DocVersionInfoList.Get();
foreach (DocVersionInfo dvi in dvil)
{
DocVersionConfig dvc = dvi.DocVersionConfig as DocVersionConfig;
if (dvc != null && dvc.Unit_Name != "" && dvc.Unit_Name != "0")
{
args += " \"PC=" + dvc.Unit_Name + "\"";
break;
}
}
System.Diagnostics.Process.Start(roapp, args);
}
}
private void btnChgTyp_Click(object sender, EventArgs e)
{
StepPanelTabDisplayEventArgs args = new StepPanelTabDisplayEventArgs("Change Step Type");
MyEditItem.MyStepPanel.OnTabDisplay(sender, args);
}
#endregion
#region RHM debug
//#if DEBUG
// // The following code generates an XML output for the selected item for print testing.
// private void btnPageBreak_Click(object sender, EventArgs e)
// {
// // This is here temporarily to get a node and all of it's children for print testing.
// OutputAllChildren(MyRTBItem);
// }
// private void OutputAllChildren(RTBItem myRTBItem)
// {
// OutputAllChildren(myRTBItem.MyBeforeRTBItems);
// OutputStepInfo(myRTBItem);
// OutputAllChildren(myRTBItem.MyAfterRTBItems);
// OutputAllChildren(myRTBItem.MyRNORTBItems);
// }
// private void OutputStepInfo(RTBItem myRTBItem)
// {
// Label lbl = myRTBItem.MyLabel;
// if (lbl.Text.Trim() != "")
// Console.WriteLine("<text x='{0}In' y='{1}In' font-family='{2}' font-size='{3}Pt'>{4}</text>",
// ToInches(myRTBItem.Left + lbl.Left), ToInches(myRTBItem.Top + lbl.Top),
// lbl.Font.FontFamily.Name,lbl.Font.SizeInPoints,lbl.Text);
// StepRTB rtb = myRTBItem.MyStepRTB;
// Console.WriteLine("<foreignObject x='{0}In' y='{1}In' width='{2}In' " +
// "requiredExtensions='http://Volian.Com/EmbeddedRTF'>{3}</foreignObject>",
// ToInches(myRTBItem.Left + rtb.Left), ToInches(myRTBItem.Top + rtb.Top), ToInches(rtb.Width), myRTBItem.MyItemInfo.MyContent.Text);
//// ToInches(myRTBItem.Left + rtb.Left), ToInches(myRTBItem.Top + rtb.Top), ToInches(rtb.Width), rtb.Rtf);
// }
// private float ToInches(int val)
// {
// return Convert.ToSingle(val)/96F;
// }
// private void OutputAllChildren(List<RTBItem> list)
// {
// if(list != null)
// foreach (RTBItem itm in list)
// OutputAllChildren(itm);
// }
//#endif
#endregion
// 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
public void ToggleFindReplaceToolTip(bool isReviewer)
{
string tipMsg = string.Format("Find {0} [Ctrl] [F]", isReviewer ? "" : "/ Replace");
superTooltipRibbon.SetSuperTooltip(btnReviewFind, new DevComponents.DotNetBar.SuperTooltipInfo(tipMsg, "", "", null, null, DevComponents.DotNetBar.eTooltipColor.Gray));
superTooltipRibbon.SetSuperTooltip(btnFindRplDlg, new DevComponents.DotNetBar.SuperTooltipInfo(tipMsg, "", "", null, null, DevComponents.DotNetBar.eTooltipColor.Gray));
btnFindRplDlg.Text = btnReviewFind.Text = (isReviewer)?"Find": "Find /\r\nReplace";
}
public void SetupReviewerMode()
{
if (MyEditItem != null && MyEditItem.MyStepPanel.VwMode == E_ViewMode.Edit)
{
btnToggleEditView_Click(null, new EventArgs());
rtabView.Visible = false;
rtabHome.Visible = false;
rtabInsert.Visible = false;
rtabAdmin.Visible = false;
rtabReview.Select();
btnCMEditMode1.Enabled = btnEditMode.Enabled = false; // don't allow reviewer toggle out of view mode
}
}
public void SetupROEditorMode()
{
if (MyEditItem != null && MyEditItem.MyStepPanel.VwMode == E_ViewMode.Edit)
{
// bug fix B2015-188
// user with ROEditor only security also has Review privledges
btnToggleEditView_Click(null, new EventArgs());
rtabView.Visible = false;
rtabHome.Visible = false;
rtabInsert.Visible = false;
rtabAdmin.Select();
btnCMEditMode1.Enabled = btnEditMode.Enabled = false;
}
}
public void SetupWriterMode()
{
EnableROEdit = false;
rtabAdmin.Visible = false;
}
public void SetupSetAdminMode()
{
}
public void SetupAdminMode()
{
}
private void btnToggleEditView_Click(object sender, EventArgs e)
{
if (MyEditItem == null) return;
MyEditItem.MyStepPanel.VwMode = MyEditItem.MyStepPanel.VwMode == E_ViewMode.Edit ? E_ViewMode.View : E_ViewMode.Edit;
MyEditItem.ToggleEditView(MyEditItem.MyStepPanel.VwMode);
SetButtonAndMenuEnabling(true);
SetStepButtonAndMenuEnabling(true);
SetMenuEnablingForObjectsWOText();
MyEditItem.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OnModeChange(this, new StepRTBModeChangeEventArgs(MyEditItem.MyStepPanel.VwMode));
btnEditMode.Checked = btnCMEditMode1.Checked = MyEditItem.MyStepPanel.VwMode == E_ViewMode.View;
MyEditItem.MyStepRTB.SpellCheckContextMenuOn(MyEditItem.MyStepPanel.VwMode != E_ViewMode.View);
}
//private void btnEnhancedDocSync_Click(object sender, System.EventArgs e)
//{
// btnEnhancedDocSync.Checked = !btnEnhancedDocSync.Checked;
//}
private void btnROEdit_Click(object sender, EventArgs e)
{
if (VlnSettings.ReleaseMode.Equals("DEMO"))
{
FlexibleMessageBox.Show("Referenced Object Editor not available in the Demo version.", "PROMS Demo Version");
return;
}
//string roapp = Environment.GetEnvironmentVariable("roapp");
string roapp = Volian.Base.Library.ExeInfo.GetROEditorPath(); // get the path to the RO Editor Executable
if (roapp == null || roapp == string.Empty)
{
FlexibleMessageBox.Show("The 'roapp' environment variable needs to be set to the path of the RO Editor\n\n Ex: C:\\VE-PROMS.NET\\Bin\\roeditor.exe", "Environment Variable Error");
return;
}
if (!File.Exists(roapp))
{
string errtxt = string.Format("Could not find path to Referenced Objects Editor:\n\n roapp = {0}\n\n Verify the path assigned to the 'roapp' environment variable", roapp);
FlexibleMessageBox.Show(errtxt, "Environment Variable Error");
//MessageBox.Show("Could not find path to Ro Editor, check 'roapp' environment variable","Environment Variable Error");
return;
}
//if (roapp == null)
//{
// MessageBox.Show("Could not find path to Ro Editor, check 'roapp' environment variable");
// return;
//}
if (Mydvi == null || Mydvi.DocVersionAssociationCount < 1)
{
FlexibleMessageBox.Show("Could not find associated path for ro data.", "No RO Data", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
string roloc = "\"" + Mydvi.DocVersionAssociations[0].MyROFst.MyRODb.FolderPath + "\"";
if (!Directory.Exists(Mydvi.DocVersionAssociations[0].MyROFst.MyRODb.FolderPath))
{
FlexibleMessageBox.Show(string.Format("RO Database directory does not exist: {0}", Mydvi.DocVersionAssociations[0].MyROFst.MyRODb.FolderPath));
return;
}
// C2017-003: ro data in sql server, check for sql connection string
if (Mydvi.DocVersionAssociations[0].MyROFst.MyRODb.DBConnectionString != "cstring") roloc = roloc + " \"" + Mydvi.DocVersionAssociations[0].MyROFst.MyRODb.DBConnectionString + "\"";
// C2021-026 pass in Parent/Child information (list of the children)
// B2022-019 look at all DocVersions to find ParentChild information
// to ensure we pass in Parent/Child even when not coming from a Parent/Child procedure set
// B2022-073 Break out of the foreach when we find a set with parent/child information
DocVersionInfoList dvil = DocVersionInfoList.Get();
foreach (DocVersionInfo dvi in dvil)
{
DocVersionConfig dvc = dvi.DocVersionConfig as DocVersionConfig;
if (dvc != null && dvc.Unit_Name != "" && dvc.Unit_Name != "0")
{
roloc += " \"PC=" + dvc.Unit_Name + "\"";
break;
}
}
System.Diagnostics.Process.Start(roapp, roloc);
}
private void btnUpdROVal_Click(object sender, EventArgs e)
{
InitialProgressBarMessage = "Updating ROs";
// use rodb directory path of the first rofst for the this document version. Later, will need
// to modify code to get which one (when there is more than one)
if (Mydvi.DocVersionAssociations.Count < 1)
{
FinalProgressBarMessage = "No ROs associated";
FlexibleMessageBox.Show("Error Updating ro.fst", "No associated ro.fst"); //B2017-125 added title to messagebox
return;
}
ROFstInfo roFstInfo = Mydvi.DocVersionAssociations[0].MyROFst;
string rofstPath = roFstInfo.MyRODb.FolderPath + @"\ro.fst";
if (!File.Exists(rofstPath))
{
FinalProgressBarMessage = "No existing RO.FST";
FlexibleMessageBox.Show("No existing ro.fst in path " + roFstInfo.MyRODb.FolderPath + ". Check for invalid path", "No existing RO.FST"); //B2017-125 added title to messagebox
return;
}
// B2017-130 code no longer needed. Was checking the DTS but always was different by miliseconds
//FileInfo fiRofst = new FileInfo(rofstPath);
//if (roFstInfo.DTS == fiRofst.LastWriteTimeUtc)
//{
// FinalProgressBarMessage = "RO.FST up to date";
// MessageBox.Show("ro.fst files are same for path " + roFstInfo.MyRODb.FolderPath + ", import of that ro.fst will not be done", "RO.FST up to date"); //B2017-125 added title to messagebox
// return;
//}
//if (roFstInfo.DTS > fiRofst.LastWriteTimeUtc)
//{
// FinalProgressBarMessage = "RO.FST is older";
// MessageBox.Show("Cannot copy older ro.fst from " + roFstInfo.MyRODb.FolderPath + ", import of that ro.fst will not be done", "RO.FST is older"); //B2017-125 added title to messagebox
// return;
//}
Cursor = Cursors.WaitCursor;
// C2023-001: Check whether docversion can be checked out before continuing with update of ro.fst
string message = string.Empty;
if (!MySessionInfo.CanCheckOutItem(Mydvi.VersionID, CheckOutType.DocVersion, ref message))
{
FlexibleMessageBox.Show(this, message, "Working Draft Has Items Already Checked Out", MessageBoxButtons.OK, MessageBoxIcon.Warning);
FinalProgressBarMessage = "Cannot check-out Working Draft";
Cursor = Cursors.Default;
return;
}
using (DocVersion dv = DocVersion.Get(Mydvi.VersionID))
{
swROUpdate = new System.IO.StreamWriter(ROFstInfo.ROUpdateResultsPath(Mydvi));
// B2022-026 RO Memory Reduction code - first load the new ro.fst so that we can assign the ROTableUpdate event to the correct roFstInfo
if (dv.ROfstLoadingFigures || dv.NewerRoFst) // B2017-125 see if loading figures was completed
{
// only load the RO.fst
ROFstInfo.UpdateRoFst(roFstInfo.MyRODb, dv, roFstInfo, DoProgressBarRefresh);
roFstInfo = Mydvi.DocVersionAssociations[0].MyROFst;
}
roFstInfo.ROTableUpdate += new ROFstInfoROTableUpdateEvent(roFstInfo_ROTableUpdate);
ContentInfo.StaticContentInfoChange += ContentInfo_StaticContentInfoChange; // write changes to a text file
ROFst newrofst = ROFstInfo.RefreshROFst(dv, roFstInfo, DoProgressBarRefresh, null);
swROUpdate.Close();
ContentInfo.StaticContentInfoChange -= ContentInfo_StaticContentInfoChange;
roFstInfo.ROTableUpdate -= new ROFstInfoROTableUpdateEvent(roFstInfo_ROTableUpdate);
StepPanelTabDisplayEventArgs args = new StepPanelTabDisplayEventArgs("DisplayROUpdateROFST");
MyEditItem.MyStepPanel.OnTabDisplay(sender, args);
}
Cursor = Cursors.Default;
FinalProgressBarMessage = "ROs values updated";
}
private System.IO.StreamWriter swROUpdate;
// write the RO reference changes to a text file, include the old/new text, location, and the itemid of the step element
void ContentInfo_StaticContentInfoChange(object sender, StaticContentInfoEventArgs args)
{
if (args.Type == "RO")
swROUpdate.Write(string.Format("Fixed Referenced Object for {1}({4}){0}Old Text: {2}{0}New Text: {3}{0}{0}", Environment.NewLine, (sender as ItemInfo).ShortPath, args.OldValue, args.NewValue, (sender as ItemInfo).ItemID));
}
private ProgressBarItem _ProgressBar = null;
public ProgressBarItem ProgressBar
{
get { return _ProgressBar; }
set { _ProgressBar = value; }
}
private void DoProgressBarRefresh(int value, int max, string text)
{
if (ProgressBar == null) return;
ProgressBar.Maximum = max;
ProgressBar.Value = value;
ProgressBar.Text = text;
ProgressBar.TextVisible = true; //B2017-125 text was not always visible
Application.DoEvents();
}
private string InitialProgressBarMessage
{
set
{
if (ProgressBar == null) return;
ProgressBar.Value = 0;
ProgressBar.Maximum = 100;
ProgressBar.Text = value;
Application.DoEvents();
}
}
private string FinalProgressBarMessage
{
set
{
if (ProgressBar == null) return;
ProgressBar.Value = 100;
ProgressBar.Maximum = 100;
ProgressBar.Text = value;
Application.DoEvents();
}
}
public List<string> roFstInfo_ROTableUpdate(object sender, ROFstInfoROTableUpdateEventArgs args)
{
return VlnFlexGrid.ROTableUpdate(sender, args);
//string xml = null;
//string srchtxt = null;
//Content content = (Content)sender;
//using (VlnFlexGrid myGrid = new VlnFlexGrid(content.ContentItems[0]))
//{
// using (StringReader sr = new StringReader(args.OldGridXml))
// {
// myGrid.ReadXml(sr);
// sr.Close();
// }
// string roid = content.ContentRoUsages[0].ROID; //myGrid.ROID;
// int rodbid = content.ContentRoUsages[0].RODbID; //myGrid.RODbId;
// ////Font GridFont = myGrid.Font;
// //myGrid.MergedRanges.Clear();
// //myGrid.Clear();
// //myGrid.ParseTableFromText(args.ROText);
// //myGrid.AutoSizeCols();
// //myGrid.AutoSizeRows();
// //myGrid.MakeRTFcells();
// //myGrid.RODbId = rodbid;
// //myGrid.ROID = roid;
// //myGrid.IsRoTable = true;
// myGrid.Visible = false;
// myGrid.ConvertTableROToGrid(args.ROText, rodbid, roid);
// myGrid.FixTableCellsHeightWidth();
// myGrid.AdjustGridControlSize();
// myGrid.Visible = true;
// using (StringWriter sw = new StringWriter())
// {
// myGrid.WriteXml(sw);
// xml = sw.GetStringBuilder().ToString();
// sw.Close();
// }
// srchtxt = myGrid.GetSearchableText();
//}
//List<string> retlist = new List<string>();
//retlist.Add(srchtxt);
//retlist.Add(xml);
//return retlist;
}
private void rtabAdmin_Click(object sender, EventArgs e)
{
ribbonTab_SingleClick(sender, e);
btnUpdROVal.Enabled = false;
if (Mydvi.DocVersionAssociations == null || Mydvi.DocVersionAssociations.Count < 1)
{
btnROEdit.Enabled = false;
return;
}
btnROEdit.Enabled = EnableROEdit;
if (!NewerRoFst()) return;
btnUpdROVal.Enabled = true;
}
public bool NewerRoFst()
{
if (_Mydvi == null)return false;
// only allow update if association, and the RO update was not done and/or not completed
return !_Mydvi.ROfstLastCompleted || _Mydvi.NewerRoFst;
}
public void SetUpdRoValBtn(bool en)
{
btnUpdROVal.Enabled = en;
}
private void btnBookmarks_Click(object sender, EventArgs e)
{
StepPanelTabDisplayEventArgs args = new StepPanelTabDisplayEventArgs("Bookmarks");
MyEditItem.MyStepPanel.OnTabDisplay(sender, args);
}
private void btnSearch_Click(object sender, EventArgs e)
{
StepPanelTabDisplayEventArgs args = new StepPanelTabDisplayEventArgs("Global Search");
MyEditItem.MyStepPanel.OnTabDisplay(sender, args);
}
private void btnLibDocs_Click(object sender, EventArgs e)
{
StepPanelTabDisplayEventArgs args = new StepPanelTabDisplayEventArgs("LibDocs");
MyEditItem.MyStepPanel.OnTabDisplay(sender, args);
}
// C2020-033: Support the Review/Incoming Transition button to bring up Search/Incoming Transitions panel
private void btnSearchIncTrans_Click(object sender, EventArgs e)
{
MyEditItem.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OnSearchIncTrans(this, new vlnTreeItemInfoEventArgs(MyStepRTB.MyItemInfo));
}
public void btnAnnots_Click(object sender, EventArgs e)
{
StepPanelTabDisplayEventArgs args = new StepPanelTabDisplayEventArgs("Annots");
MyEditItem.MyStepPanel.OnTabDisplay(sender, args);
}
public void btnDelStep_Click(object sender, EventArgs e)
{
bool clearCopyStep = false;
StepTabPanel tmp = Parent as StepTabPanel;
if (tmp.MyDisplayTabControl.MyCopyStep != null &&
tmp.MyDisplayTabControl.MyCopyStep.ItemID == MyEditItem.MyItemInfo.ItemID)
{
if (FlexibleMessageBox.Show("Are you sure?\n\nIf you delete this step you will not able to paste it.\nYou should paste it before you delete it.", "Attempting to delete copied step.", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No) return;
clearCopyStep = true;
}
bool surpressMessageBox = (e == null);
SectionInfo si = MyEditItem.MyItemInfo as SectionInfo;
if (si != null)
{
//C2020-026 specific description of what user is trying to delete
string msg = "Are you sure you want to delete this Section" + (si.HasChildren ? " and its steps?" : "?");
DialogResult result = FlexibleMessageBox.Show(msg, "Verify Delete", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (result == DialogResult.Yes)
{
if (!si.IsStepSection)
{
WordSectionEventArgs args = new WordSectionEventArgs(si);
MyEditItem.MyStepPanel.OnWordSectionClose(sender, args);
}
MyEditItem.RemoveItem();
}
return;
}
StepInfo stpi = MyEditItem.MyItemInfo as StepInfo;
if (stpi == null) // not sure that it will every get here!
{
FlexibleMessageBox.Show("Unknown type {0}, cannot delete!", MyEditItem.MyItemInfo.GetType().Name);
return;
}
if (!surpressMessageBox)
{
string typeDescription = MyEditItem.MyStepData.StepEditData.TypeMenu.MenuItem;
string msgs = "";
if (MyFlexGrid != null) MyEditItem.IdentifyMe(true);
MyEditItem.IdentifyChildren(true);
//C2020-026 specific description of what user is trying to delete
if (stpi.HasChildren)
msgs = string.Format("Are you sure you want to delete this \"{0}\" and its substeps?", typeDescription);
else
msgs = string.Format("Are you sure you want to delete this \"{0}\"?", typeDescription);
if (stpi.HasEnhancedLinkedStep)
msgs = msgs + "\n\n The linked Enhanced step will also be deleted!";
DialogResult results = FlexibleMessageBox.Show(msgs, "Verify Delete", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (MyFlexGrid != null)
{
MyFlexGrid.Styles.Fixed.BackColor = MyFlexGrid.DefaultFixedBackgroundColor;
MyFlexGrid.StyleBackColor = MyFlexGrid.DefaultCellBackgroundcolor;
}
MyEditItem.IdentifyChildren(false);
if (results == DialogResult.Yes)
{
MyEditItem.RemoveItem();
if (clearCopyStep)
{
tmp.MyDisplayTabControl.MyCopyStep = null;
tmp.MyDisplayTabControl.OnCopyStepSelected(null); // C2015-022 event to save copystep info in all of the separate windows
SetPasteButtonEnabled();
}
}
}
else
{
MyEditItem.RemoveItem();
if (clearCopyStep)
{
tmp.MyDisplayTabControl.MyCopyStep = null;
tmp.MyDisplayTabControl.OnCopyStepSelected(null); // C2015-022 event to save copystep info in all of the separate windows
SetPasteButtonEnabled();
}
}
}
private void btnCMIns_PopupClose(object sender, EventArgs e)
{
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, _DefaultContextMenu);
}
public void SetShortCutContextMenu(string menuName)
{
bool displayMenu = false;
int moveDown = 0;
int cnt = 0;
E_AccStep? actable = 0;
if (menuName.Contains("PSI")) Console.WriteLine("menu = {0}", menuName);
StepData sd = MyItemInfo==null?null:MyItemInfo.FormatStepData;
if (sd != null) // will be null if section
{
actable = sd.StepEditData.AcTable;
if (actable == null) actable = 0;
}
//btnInsCaut.Enabled = (actable & E_AccStep.AddingCaution) > 0;
switch (menuName)
{
case "OpenRtfRawContextMenu":
ClearContextMenu();
FlexibleMessageBox.Show("No context menu for equations.");
break;
case "PSI":
displayMenu = true;
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMPSI);
break;
case "InsHLS":
displayMenu = btnCMInsHLS.Enabled;
Cursor.Position = new Point(0, 0); // Enter Key hit, move mouse pointer out of way of context menu
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsHLS);
string lookfor = "XXX";
if(_MyStepRTB.MyItemInfo.MyHLS != null)
lookfor = " " + (_MyStepRTB.MyItemInfo.MyHLS.MyContent.Type - 20000).ToString();
foreach (DevComponents.DotNetBar.ButtonItem bi in btnCMInsHLS.SubItems)
{
if (bi.Checked)
moveDown = cnt;
if(((string) bi.Tag).EndsWith(lookfor))
moveDown = cnt;
cnt++;
}
break;
case "InsRNO":
displayMenu = ((actable & E_AccStep.AddingRNO) > 0) && btnCMInsRNO.Enabled;
LetUserKnowIfTheyCannotAdd(actable, E_AccStep.AddingRNO,"RNO"); // B2018-014 Inform user that they cannot add the specified step type
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsRNO);
break;
case "InsSubStps":
displayMenu = ((actable & E_AccStep.AddingSub) > 0) && btnCMInsSubStps.Enabled;
LetUserKnowIfTheyCannotAdd(actable, E_AccStep.AddingSub,"Sub-step"); // B2018-014 Inform user that they cannot add the specified step type
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsSubStps);
if (displayMenu) Cursor.Position = new Point(0, 0); // Enter Key hit, move mouse pointer out of way of context menu
foreach (DevComponents.DotNetBar.ButtonItem bi in btnCMInsSubStps.SubItems)
{
if (bi.Checked)
moveDown = cnt;
cnt++;
}
// F2021-009 If in Proms Express, let user know if they are going to create a new substep deeper than the defined sub-step levels
if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.Express && MyItemInfo.GetStepLevel() >= MyItemInfo.GetDefinedSubStepCount())
{
string msg = "Professional procedure writing standards (PPA) discourages\n" +
"excessive sub-step levels. With each sub-step level, there\n" +
"is less room for text, which could lead to steps that are\n" +
"difficult to follow.";
FlexibleMessageBox.Show(msg, "PPA Writing Standards", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
case "InsCaution":
displayMenu = ((actable & E_AccStep.AddingCaution) > 0) && btnCMInsCaution.Enabled;
LetUserKnowIfTheyCannotAdd(actable, E_AccStep.AddingCaution,"Caution"); // B2018-014 Inform user that they cannot add the specified step type
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsCaution);
break;
case "InsNote":
displayMenu = ((actable & E_AccStep.AddingNote) > 0) && btnCMInsNote.Enabled;
LetUserKnowIfTheyCannotAdd(actable, E_AccStep.AddingNote,"Note"); // B2018-014 Inform user that they cannot add the specified step type
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsNote);
break;
case "InsTable":
displayMenu = ((actable & E_AccStep.AddingTable) > 0) && btnCMInsTable.Enabled;
LetUserKnowIfTheyCannotAdd(actable, E_AccStep.AddingTable,"Table"); // B2018-014 Inform user that they cannot add the specified step type
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsTable);
break;
case "InsFigure":
displayMenu = ((actable & E_AccStep.AddingTable) > 0) && btnCMInsFigure.Enabled;
LetUserKnowIfTheyCannotAdd(actable, E_AccStep.AddingTable,"Figure"); // B2018-014 Inform user that they cannot add the specified step type
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsFigure);
break;
case "InsEquation":
displayMenu = ((actable & E_AccStep.AddingTable) > 0) && btnCMInsEquation.Enabled;
LetUserKnowIfTheyCannotAdd(actable, E_AccStep.AddingTable,"Equation"); // B2018-014 Inform user that they cannot add the specified step type
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsEquation);
break;
case "StepPaste":
displayMenu = true;
if (MyFlexGrid != null)
_ContextMenuBar.SetContextMenuEx(MyFlexGrid, btnCMStepPaste);
else
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMStepPaste);
break;
}
if (displayMenu && UserInfo.CanEdit(MyUserInfo, Mydvi))
{
SendKeys.Send("+{F10}{DOWN}"); // Display Context menu
while (moveDown > 0) // position to current type
{
SendKeys.Send("{DOWN}");
moveDown--;
}
}
}
private void LetUserKnowIfTheyCannotAdd(E_AccStep? actable, E_AccStep e_AccStep, string stepType) // B2018-014 Inform user that they cannot add the specified step type
{
if ((actable & e_AccStep) > 0) return;
string msg = string.Format("Cannot add a {0} to this step type. If this is desired please contact Volian to change your format", stepType);
string cpt = string.Format("Cannot add {0}", stepType);
FlexibleMessageBox.Show(msg, cpt, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
private void btnSpell_Click(object sender, EventArgs e)
{
//MessageBox.Show("Functionality not available.", "Spell Check");
MyEditItem.SaveContents();
StepPanelTabDisplayEventArgs args = new StepPanelTabDisplayEventArgs("SpellChecker");
MyEditItem.MyStepPanel.OnTabDisplay(sender, args);
}
private void btnTranRefresh_Click(object sender, System.EventArgs e)
{
// This code is disabled - Button is not visible
this.Cursor = Cursors.WaitCursor;
ProcedureInfo.RefreshTransitions(MyItemInfo.MyProcedure as ProcedureInfo);
this.Cursor = Cursors.Default;
// B2018-002 - Invalid Transitions - Display Transition Refresh Statistics
FlexibleMessageBox.Show(this, string.Format("Checked {0} transitions, modified {1} transitions, converted to text {2} transitions", ProcedureInfo.TranCheckCount, ProcedureInfo.TranFixCount, ProcedureInfo.TranConvertCount), "Results of Refresh Transitions", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
private void btnRefObjRefresh_Click(object sender, System.EventArgs e)
{
//// This code is disabled - Button is not visible
//this.Cursor = Cursors.WaitCursor;
// ProcedureInfo.ResetROCounters();
// ProcedureInfo.RefreshReferenceObjects(MyItemInfo.MyProcedure as ProcedureInfo);
// this.Cursor = Cursors.Default;
//FlexibleMessageBox.Show(this, string.Format("Checked {0} referenced objects, fixed {1} referenced objects", ProcedureInfo.ROCheckCount, ProcedureInfo.ROFixCount), "Results of Refresh Referenced Objects", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
//private FindReplace dlgFindReplace = null;
private void btnFindRplDlg_Click(object sender, EventArgs e)
{
if (MyEditItem == null || MyEditItem.MyStepPanel == null) return;
StepPanelTabDisplayEventArgs args = new StepPanelTabDisplayEventArgs("FndRpl");
MyEditItem.MyStepPanel.OnTabDisplay(sender, args);
}
private void InsertSiblingBeforeOrAfter(string b4aftr)
{
E_AccStep? actable = 0;
StepData sd = MyItemInfo.FormatStepData;
actable = sd.StepEditData.AcTable;
if (actable == null) actable = 0;
switch (b4aftr)
{
case "after":
if ((actable & E_AccStep.AddingNext) > 0)
MyEditItem.AddSiblingAfter();
break;
case "before":
if ((actable & E_AccStep.AddingPrev) > 0)
MyEditItem.AddSiblingBefore();
break;
}
}
public void ProcessEnterKey()
{
bool deletedEmpty = false;
bool deletedHLS = false;
bool deletedSubStep = false;
bool deletedRNO = false;
bool deletedNote = false;
bool deletedCaution = false;
ItemInfo parentOfDeleted = null;
if (!MyItemInfo.IsTable && MyStepRTB.Text.Length < 1) //empty step text
{
deletedEmpty = true;
deletedHLS = MyItemInfo.IsHigh;
deletedSubStep = MyItemInfo.IsStepPart;
deletedRNO = MyItemInfo.IsRNOPart;
deletedNote = MyItemInfo.IsNote;
deletedCaution = MyItemInfo.IsCaution;
parentOfDeleted = MyItemInfo.MyParent; // B2020-015 save the parent of the empty step part that was deleted
btnDelStep_Click(MyStepRTB, null); // delete the empty step piece
}
if (MyItemInfo.IsHigh)
{
bool processed = true;
if (!deletedHLS)
{
if (deletedSubStep)
{
// B2019-136 if only one high level step type, don't display a pop up menu of high level step types
if (btnCMInsHLS.SubItems.Count > 1)
SetShortCutContextMenu("InsHLS");
else
InsertSiblingBeforeOrAfter("after");
}
else if (MyEditItem.MyRNOEditItems != null && MyEditItem.MyRNOEditItems.Count > 0)
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlRight); // jump to RNO
else if (deletedRNO)
{
processed = AddSubStep(); // B2020-015 see comment below
}
else if (!deletedHLS)
{
if (MyItemInfo.ColumnMode > 0)
CreateNewRNO();
else
processed = AddSubStep(); // B2020-015 see comment below
}
}
if (processed) return;
}
// B2020-015 Replaced the "else if" with just an "if". The code above processes pressing the Enter Key when starting on a high level step.
// We needed to have a special case when, during the processing of the enter key, we ended up on a table or figure. In those cases
// it was inserting a new table or figure before the existing one. Instead, we want it to process it as if we starting pressing
// the enter key while on the table or figure. By returning a "false" from AddSubStep(), we can let it fall through so that
// it is processed properly.
if (MyItemInfo.IsRNOPart)
{
// B2013-154: if in single column mode, enter key from an RNO part should insert an RNO part:
if (MyItemInfo.ColumnMode == 0)
{
CreateNewRNO();
return;
}
// B2020-015 We are on an RNO step type. Spin up the first non-RNO parent then decide what step part to add.
// Prior to this fix, an un-typed step part was created when you pressed Enter from a second RNO
ItemInfo ii = MyItemInfo;
while (ii.IsRNOPart) ii = ii.MyParent;
MyEditItem.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OpenItem(ii);
if (MyItemInfo.IsHigh)
{
if (MyEditItem != null && MyEditItem.NextDownEditItem != null &&
!MyEditItem.NextDownEditItem.MyItemInfo.IsTable && !MyEditItem.NextDownEditItem.MyItemInfo.IsFigure &&
MyEditItem.NextDownEditItem.MyItemInfo.MyParent.ItemID == MyEditItem.MyItemInfo.ItemID)
{
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlDown);
InsertSiblingBeforeOrAfter("before");
}
else
SetShortCutContextMenu("InsSubStps");
}
else
InsertSiblingBeforeOrAfter("after");
}
else if (MyItemInfo.IsInRNO && MyItemInfo.IsStepPart)
{
if (deletedEmpty)
{
MyEditItem.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OpenItem(parentOfDeleted);
if (parentOfDeleted.IsHigh)
{
if (!AddSubStep())
SetShortCutContextMenu("InsSubStps");
}
else if (!MyItemInfo.IsRNOPart)
InsertSiblingBeforeOrAfter("after");
}
else
InsertSiblingBeforeOrAfter("after");
}
else if (MyItemInfo.IsInRNO &&( MyItemInfo.IsTable || MyItemInfo.IsFigure))
{
if (deletedEmpty)
{
while (parentOfDeleted.IsRNOPart)
parentOfDeleted = parentOfDeleted.MyParent;
MyEditItem.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OpenItem(parentOfDeleted);
if (parentOfDeleted.IsHigh)
{
if (!AddSubStep())
SetShortCutContextMenu("InsSubStps");
}
else
InsertSiblingBeforeOrAfter("after");
}
else
{
ItemInfo tItemInfo = MyItemInfo.MyParent;
while (tItemInfo.IsRNOPart) tItemInfo = tItemInfo.MyParent;
MyEditItem.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OpenItem(tItemInfo);
if (MyItemInfo.IsHigh)
{
if (!AddSubStep())
SetShortCutContextMenu("InsSubStps");
}
else
InsertSiblingBeforeOrAfter("after");
}
}
else if (MyItemInfo.IsStepPart)
{
if (deletedSubStep)
{
// B2020-015 jump to the parent of the empty step part that was deleted
MyEditItem.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OpenItem(parentOfDeleted);
if (MyItemInfo.IsHigh)
SetShortCutContextMenu("InsHLS"); // prompt for new HLS
else
InsertSiblingBeforeOrAfter("after");
}
else if (!MyItemInfo.IsSequential) // only add a sibling if substep type does not have sequential tabs
InsertSiblingBeforeOrAfter("after");
else if (deletedRNO)
{
InsertSiblingBeforeOrAfter("after");
}
else if (MyEditItem.MyRNOEditItems != null && MyEditItem.MyRNOEditItems.Count > 0)
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlRight); // jump to RNO
else
if (MyItemInfo.ColumnMode > 0)
CreateNewRNO();
else
InsertSiblingBeforeOrAfter("after");
}
else if (MyItemInfo.IsCaution)
{
if (deletedEmpty)
{
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlDown);
if (deletedCaution)
CreateNewNote();
}
else
InsertSiblingBeforeOrAfter("after");
}
else if (MyItemInfo.IsNote)
{
if (!deletedEmpty)
InsertSiblingBeforeOrAfter("after");
else if (!deletedCaution)
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlDown);
}
else if (MyItemInfo.IsTable || MyItemInfo.IsFigure || MyItemInfo.IsRtfRaw) //is Table, Figure, or Equation
{
ItemInfo next = (deletedEmpty && !deletedHLS)? parentOfDeleted : MyItemInfo.MyParent;
while (next.IsTable || next.IsFigure || next.IsRtfRaw) next = next.MyParent;
MyEditItem.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OpenItem(next);
if (MyItemInfo.IsHigh)
{
if (!deletedHLS)
{
if (deletedSubStep)
SetShortCutContextMenu("InsHLS");
else if (!deletedNote && !deletedCaution)
SetShortCutContextMenu("InsSubStps");
}
}
else if (!deletedNote && !deletedCaution)
InsertSiblingBeforeOrAfter("after");
}
}
private bool AddSubStep()
{
EditItem nextDownEditItem = MyEditItem.NextDownEditItem;
if (nextDownEditItem != null && nextDownEditItem.MyItemInfo.MyParent.ItemID == MyEditItem.MyID)
{
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlDown);
// B2020-015 when nextDownEditItem is a table or figure, we want to treat it as if we started pressing the Enter Key while on that table or figure.
// Return "false' in this case so it can be processed properly
if (nextDownEditItem.MyItemInfo.IsTable || nextDownEditItem.MyItemInfo.IsFigure)
return false;
InsertSiblingBeforeOrAfter("before");
}
else
SetShortCutContextMenu("InsSubStps");
return true;
}
private void CreateNewRNO()
{
if (btnInsRNO.SubItems.Count > 1)
SetShortCutContextMenu("InsRNO");
else
btnInsRNO.RaiseClick();
}
private void CreateNewNote()
{
if (btnInsNote.SubItems.Count > 1)
SetShortCutContextMenu("InsNote");
else
btnInsNote.RaiseClick();
}
private void btnPasteAfter_Click(object sender, EventArgs e)
{
StepTabPanel tmp = Parent as StepTabPanel;
if (tmp.MyDisplayTabControl.MyCopyStep == null) return;
// B2016-009 check source and desintation types and display message box if needed
// C2022-017 check for user canceling the paste step
if (!ItemInfo.CheckSourceDestinationType(tmp.MyDisplayTabControl.MyCopyStep.ItemID, MyItemInfo)) return;
SaveTableChanges(); // B2018-055 Save Current Changes to the table
// F2021-009 display a message if pasting step will results in more sub-step levels than are defined in the format
ItemInfo.PasteStepIsWithinDefinedSubStepLevels(tmp.MyDisplayTabControl.MyCopyStep.ItemID, MyItemInfo, false);
MyEditItem.PasteSiblingAfter(tmp.MyDisplayTabControl.MyCopyStep.ItemID);
}
private void btnPasteBefore_Click(object sender, EventArgs e)
{
StepTabPanel tmp = Parent as StepTabPanel;
if (tmp.MyDisplayTabControl.MyCopyStep == null) return;
// B2016-009 check source and desintation types and display message box if needed
// C2022-017 check for user canceling the paste step
if (!ItemInfo.CheckSourceDestinationType(tmp.MyDisplayTabControl.MyCopyStep.ItemID, MyItemInfo)) return;
SaveTableChanges(); // B2018-055 Save Current Changes to the table
// F2021-009 display a message if pasting step will results in more sub-step levels than are defined in the format
ItemInfo.PasteStepIsWithinDefinedSubStepLevels(tmp.MyDisplayTabControl.MyCopyStep.ItemID, MyItemInfo, false);
MyEditItem.PasteSiblingBefore(tmp.MyDisplayTabControl.MyCopyStep.ItemID);
}
private void btnStepPaste_Click(object sender, EventArgs e)
{
// just return
}
private void btnCpyStp_Click(object sender, EventArgs e)
{
DoCopyStep();
}
public void DoCopyStep()
{
// highlight selected step(s) and prompt to see if selection is what user wants:
if (MyFlexGrid != null) MyEditItem.IdentifyMe(true);
MyEditItem.IdentifyChildren(true);
DialogResult dr = FlexibleMessageBox.Show("Step as Marked?", "Identify Step To Be Copied", MessageBoxButtons.YesNo);
if (dr == DialogResult.Yes)
{
StepTabPanel tmp = Parent as StepTabPanel;
tmp.MyDisplayTabControl.MyCopyStep = MyItemInfo;
tmp.MyDisplayTabControl.OnCopyStepSelected(null); // C2015-022 event to save copystep info in all of the separate windows
btnStepPaste.Enabled = true;
SetPasteButtonEnabled();
}
if (MyFlexGrid != null)
{
MyFlexGrid.Styles.Fixed.BackColor = MyFlexGrid.DefaultFixedBackgroundColor;
MyFlexGrid.StyleBackColor = MyFlexGrid.DefaultCellBackgroundcolor;
}
MyEditItem.IdentifyChildren(false);
}
private void btnPasteReplace_Click(object sender, EventArgs e)
{
StepTabPanel tmp = Parent as StepTabPanel;
if (tmp.MyDisplayTabControl.MyCopyStep == null) return;
// B2016-009 check source and desintation types and display message box if needed
// C2022-017 check for user canceling the paste step
if (!ItemInfo.CheckSourceDestinationType(tmp.MyDisplayTabControl.MyCopyStep.ItemID, MyItemInfo)) return;
// F2021-009 display a message if pasting step will results in more sub-step levels than are defined in the format
ItemInfo.PasteStepIsWithinDefinedSubStepLevels(tmp.MyDisplayTabControl.MyCopyStep.ItemID, MyItemInfo, true);
EditItem oldEditItem = MyEditItem;
MyEditItem = MyEditItem.PasteReplace(tmp.MyDisplayTabControl.MyCopyStep.ItemID);
if (MyEditItem == null) oldEditItem.IdentifyMe(false); // B2017-179 if null then we didn't do the replace but did position to the first transition that needs resolved
if (MyEditItem != null && MyEditItem.MyItemInfo.ItemID != oldEditItem.MyItemInfo.ItemID) oldEditItem.Dispose();
}
private void btnPdfCreate_Click(object sender, EventArgs e)
{
if (MyItemInfo == null) return; // if creating a pdf before rtb exists, return;
if (MyEditItem != null) MyEditItem.SaveCurrentAndContents();
OnPrintRequest(new StepTabRibbonEventArgs(MyItemInfo.MyProcedure));
}
private void btnCASCreate_Click(object sender, EventArgs e)
{
if (MyItemInfo == null) return; // if creating a Continuous Action Summary before rtb exists, return;
if (MyEditItem != null) MyEditItem.SaveCurrentAndContents();
OnContActionSummaryRequest(new StepTabRibbonEventArgs(MyItemInfo.MyProcedure));
}
#region Table Grid
#region TablePicker 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 VlnFlexGrid CreateNewTable()
{
Point pt = Cursor.Position;
int left = pt.X;
VlnFlexGrid grd = null;
TablePicker tpdlg = new TablePicker();
tpdlg.Location = pt;
tpdlg.Left = left;
tpdlg.MaxCols = 20;
tpdlg.MaxRows = 30;
DialogResult dr = tpdlg.ShowDialog();
while (tpdlg.Visible)
{
Application.DoEvents();
}
if (dr != DialogResult.Cancel) //!tpdlg.Cancel)
{
// Create a new grid to store the selected size
grd = new VlnFlexGrid();
grd.Rows.Count = tpdlg.SelectedRows;
grd.Cols.Count = tpdlg.SelectedColumns;
VE_Font vefont = MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.Table.Font;
Font GridFont = new Font(vefont.Family, (float)vefont.Size);
grd.Font = GridFont;
grd.FitTableToPageWidth((int)(MyItemInfo.MyDocStyle.Layout.PageWidth - MyItemInfo.MyDocStyle.Layout.LeftMargin));
}
return grd;
}
//private void InitializeNewGrid(C1FlexGrid grd)
//{
// int numCols = grd.Cols.Count - 1;
// int numRows = grd.Rows.Count - 1;
// string defText = "";
// if (textBoxX1.Text.Length > 0)
// defText = textBoxX1.Text;
// else
// defText = textBoxX1.WatermarkText;
// grd.SetData(grd.GetCellRange(0, 0, numRows, numCols), defText);
//}
#endregion
#region Table Grid Copy/Paste
private void btnTblDgnCopyRow_Click(object sender, EventArgs e)
{
MyFlexGrid.CopyRow();
}
private void btnTblDgnCopyColumn_Click(object sender, EventArgs e)
{
MyFlexGrid.CopyColumn();
}
private void btnTblDgnCopySelection_Click(object sender, EventArgs e)
{
MyFlexGrid.CopyCellSelection();
}
private void btnTblDgnPasteRowAbove_Click(object sender, EventArgs e)
{
// create new rows before current position and copy clipboard data
MyFlexGrid.PasteRows(VlnFlexGrid.enmPastePos.Before);
GridItem tmp = MyEditItem as GridItem;
if (tmp!=null) tmp.SavePastedCellRoTran();
}
private void btnTblDgnPasteRowBelow_Click(object sender, EventArgs e)
{
// create new rows after current position and copy clipboard data
MyFlexGrid.PasteRows(VlnFlexGrid.enmPastePos.After);
GridItem tmp = MyEditItem as GridItem;
if (tmp != null) tmp.SavePastedCellRoTran();
}
private void btnTblDgnPasteReplaceRow_Click(object sender, EventArgs e)
{
// replace rows with current clipboard data starting as current row
MyFlexGrid.PasteRows(VlnFlexGrid.enmPastePos.Replace);
GridItem tmp = MyEditItem as GridItem;
if (tmp != null) tmp.SavePastedCellRoTran();
}
private void btnTblDgnPasteColumnLeft_Click(object sender, EventArgs e)
{
MyFlexGrid.PasteColumns(VlnFlexGrid.enmPastePos.Before);
GridItem tmp = MyEditItem as GridItem;
if (tmp != null) tmp.SavePastedCellRoTran();
}
private void btnTblDgnPasteColumnRight_Click(object sender, EventArgs e)
{
MyFlexGrid.PasteColumns(VlnFlexGrid.enmPastePos.After);
GridItem tmp = MyEditItem as GridItem;
if (tmp != null) tmp.SavePastedCellRoTran();
}
private void btnTblDgnPasteColumnReplace_Click(object sender, EventArgs e)
{
MyFlexGrid.PasteColumns(VlnFlexGrid.enmPastePos.Replace);
GridItem tmp = MyEditItem as GridItem;
if (tmp != null) tmp.SavePastedCellRoTran();
}
private void btnTblDgnPasteIntoSelection_Click(object sender, EventArgs e)
{
MyFlexGrid.PasteCopiedCells();
GridItem tmp = MyEditItem as GridItem;
if (tmp != null) tmp.SavePastedCellRoTran();
}
#endregion
#region Table Grid Delete
private void btnTblDgnRemoveRow_Click(object sender, EventArgs e)
{
if (MyFlexGrid.AllRowsSelected())
btnDelStep_Click(sender, e);
else
MyFlexGrid.RemoveSelectedRow();
}
private void btnTblDgnRemoveColumn_Click(object sender, EventArgs e)
{
if (MyFlexGrid.AllColumnsSelected())
btnDelStep_Click(sender, e);
else
MyFlexGrid.RemoveSelectedColumn();
}
#endregion
#region Table Grid Cell Style
//private void cpHighlight_SelectedColorChanged(object sender, EventArgs e)
//{
// string strColor = string.Format("{0}, {1}, {2};", cpTblDgnHighlight.SelectedColor.R, cpTblDgnHighlight.SelectedColor.G, cpTblDgnHighlight.SelectedColor.B);
// MyFlexGrid.ChangeBackgroundColor(strColor);
//}
private void btnTblDgnAlgnTxTopLeft_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellAlign(MyFlexGrid.Selection, C1.Win.C1FlexGrid.TextAlignEnum.LeftTop);
MyFlexGrid.RTFTextAlignment(MyFlexGrid.Selection, HorizontalAlignment.Left);
}
private void btnTblDgnAlgnTxTopCenter_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellAlign(MyFlexGrid.Selection, C1.Win.C1FlexGrid.TextAlignEnum.CenterTop);
MyFlexGrid.RTFTextAlignment(MyFlexGrid.Selection, HorizontalAlignment.Center);
}
private void btnTblDgnAlgnTxTopRight_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellAlign(MyFlexGrid.Selection, C1.Win.C1FlexGrid.TextAlignEnum.RightTop);
MyFlexGrid.RTFTextAlignment(MyFlexGrid.Selection, HorizontalAlignment.Right);
}
private void btnTblDgnAlgnTxCenterLeft_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellAlign(MyFlexGrid.Selection, C1.Win.C1FlexGrid.TextAlignEnum.LeftCenter);
MyFlexGrid.RTFTextAlignment(MyFlexGrid.Selection, HorizontalAlignment.Left);
}
private void btnTblDgnAlgnTxCenterCenter_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellAlign(MyFlexGrid.Selection, C1.Win.C1FlexGrid.TextAlignEnum.CenterCenter);
MyFlexGrid.RTFTextAlignment(MyFlexGrid.Selection, HorizontalAlignment.Center);
}
private void btnTblDgnAlgnTxCenterRight_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellAlign(MyFlexGrid.Selection, C1.Win.C1FlexGrid.TextAlignEnum.RightCenter);
MyFlexGrid.RTFTextAlignment(MyFlexGrid.Selection, HorizontalAlignment.Right);
}
private void btnTblDgnAlgnTxBottomLeft_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellAlign(MyFlexGrid.Selection, C1.Win.C1FlexGrid.TextAlignEnum.LeftBottom);
MyFlexGrid.RTFTextAlignment(MyFlexGrid.Selection, HorizontalAlignment.Left);
}
private void btnTblDgnAlgnTxBottomCenter_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellAlign(MyFlexGrid.Selection, C1.Win.C1FlexGrid.TextAlignEnum.CenterBottom);
MyFlexGrid.RTFTextAlignment(MyFlexGrid.Selection, HorizontalAlignment.Center);
}
private void btnTblDgnAlgnTxBottomRight_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellAlign(MyFlexGrid.Selection, C1.Win.C1FlexGrid.TextAlignEnum.RightBottom);
MyFlexGrid.RTFTextAlignment(MyFlexGrid.Selection, HorizontalAlignment.Right);
}
#endregion
#region Table Grid Merge/Split
private void btnTblDgnSplitCells_ToRows_Click(object sender, EventArgs e)
{
// without the BeginUpdate/EndUpdate, you will see the table jump around while
// it is being adjusted
MyFlexGrid.BeginUpdate();
MyFlexGrid.SplitSelection(false);
MyFlexGrid.EndUpdate();
}
#endregion
private void btnTblDgnSplitCellsToCols_Click(object sender, EventArgs e)
{
// without the BeginUpdate/EndUpdate, you will see the table jump around while
// it is being adjusted
MyFlexGrid.BeginUpdate();
MyFlexGrid.SplitSelection(true);
MyFlexGrid.EndUpdate();
}
private void btnTblDgnMergeCells_Click(object sender, EventArgs e)
{
MyFlexGrid.MergeSelection();
}
#endregion
#region Table Grid Design
private void btnTblDgnInsertRowAbove_Click(object sender, EventArgs e)
{
MyFlexGrid.InsertRowBefore();
}
private void btnTblDgnInsertRowBelow_Click(object sender, EventArgs e)
{
MyFlexGrid.InsertRowAfter();
}
private void btnTblDgnInsertColumnBefore_Click(object sender, EventArgs e)
{
MyFlexGrid.InsertColumnBefore();
}
private void btnTblDgnInsertColumnAfter_Click(object sender, EventArgs e)
{
MyFlexGrid.InsertColumnAfter();
}
public void ToggleTableFontSize(bool visible)
{
bool visl = visible;
if (MyFlexGrid != null)
{
if (MyFlexGrid.IsRoTable) visl = false;
}
btnCMChgFontSize.Visible = visl;
// C2021-005 - setup the font size dropdowns for the table ribbon and context menu
// A list of font sizes is set in the base format file and can be overidden in a plant's format file
string tfntszs = MyItemInfo.ActiveFormat.PlantFormat.FormatData.FontSizes.TableFontSizes;
// B2021-090 If the current formats were not updated then there will be no list of table font sizes
// so in this case we want to disable the font size dropdown list in the table ribbon and in the context menu
if (tfntszs == null)
{
btnCMChgFontSize.Enabled = false;
rbTblFont.Enabled = false;
rbTblFntSz.Enabled = false;
cmFontSizeList.Enabled = false;
return;
}
rbTblFntSz.Items.Clear();
cmFontSizeList.Items.Clear();
rbTblFntSz.Items.AddRange(tfntszs.Replace(" ", "").Split(",".ToCharArray())); // dropdown on table ribbon
cmFontSizeList.Items.AddRange(tfntszs.Replace(" ", "").Split(",".ToCharArray())); // dropdown on context menu
}
public void ToggleTableDesignButtons(bool enable)
{
bool enableContent = enable;
if (MyFlexGrid != null)
{
if (MyFlexGrid.IsRoTable) enableContent = false;
//B2017-156 Don't allow alignment or borders if the selection is not valid
rbTblBorder.Enabled = btnTblDgnAlignText.Enabled = MyFlexGrid.Selection.IsValid && enable; // B2017-194 moved to inside the test for a null MyFlexGrid
}
btnTblDgnCopy.Enabled = enableContent;
btnTblDgnRemove.Enabled = enableContent;
btnCmGridInsert.Enabled = enableContent;
btnCmGridCopy.Enabled = enableContent;
btnCmGridRemove.Enabled = enableContent;
//btnTblDgnGridStyle.Enabled = enable;
//rbTblBorder.Enabled = enable;
rbnBorderlistBox.Enabled = enable;
rbnBorderSelectionPanel.Enabled = enable;
btnTblNoBorder.Enabled = enable;
btnTblOutline.Enabled = enable;
btnTblInside.Enabled = enable;
btnTblDgnInsertColumn.Enabled = enableContent;
btnTblDgnInsertRow.Enabled = enableContent;
btnTblDgnMergeCells.Enabled = enableContent;
btnCmGridMergeCells.Enabled = enableContent;
btnCmGridPaste.Enabled =
btnTblDgnPaste.Enabled = ((VlnFlexGrid.MyCopyInfo.MyCopiedFlexGrid != null) && enableContent);
btnTblDgnSplitCells.Enabled = enableContent;
btnCmGridSplitCell.Enabled = enableContent;
//B2021-090 don't enable the font size selection on RO tables - was crashing trying to read font sizes on an RO table
// enableContent is set to false (above) when on an RO table
rbTblFont.Enabled = enableContent;
}
public void SetRibbonForGridCellIndent()
{
if (_MyStepRTB != null)
btnIndent.Checked = _MyStepRTB.SelectionHangingIndent != 0;
}
public void SetRibbonForGridCellIndentClear()
{
btnIndent.Checked = false;
}
public void SetRibbonForGrid()
{
// for paste, see if there is clipboard data, & if so, of a type we can use.
IDataObject iData = Clipboard.GetDataObject();
// set to true if editing cell, otherwise false for grids
//bool enable = (MyFlexGrid != null && MyFlexGrid.Editor != null);
// B2017-208 toggle on/off attributes button checks when you edit table cells, going from one cell to another
// Also don't keep the attributes buttons checked after setting a group of table cells all at one time
btnCMBold.Checked = btnBold.Checked = RTBAPI.IsBold(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
btnCMItalics.Checked = btnItalics.Checked = RTBAPI.IsItalic(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
btnCMUnderline.Checked = btnUnderline.Checked = RTBAPI.IsUnderline(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
btnCMSubscript.Checked = btnSubscript.Checked = RTBAPI.IsSubScript(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
btnCMSuperscript.Checked = btnSuperscript.Checked = RTBAPI.IsSuperScript(_MyStepRTB) && (MyFlexGrid == null || MyFlexGrid.TableCellEditor.EditMode);
bool enable = (MyFlexGrid != null && MyEditItem.MyStepPanel.VwMode == E_ViewMode.Edit);
//btnPasteText.Enabled = btnPasteStepText.Enabled = btnPaste.Enabled = enable;
btnPaste.Enabled = (iData.GetDataPresent(DataFormats.Text) || iData.GetDataPresent(DataFormats.Rtf)) && enable;
btnCMPasteText.Enabled = btnPasteText.Enabled = iData.GetDataPresent(DataFormats.Text) && enable;
btnCMPaste.Enabled = btnPasteStepText.Enabled = iData.GetDataPresent(DataFormats.Rtf ) && enable;
btnCopy.Enabled = enable;
btnCut.Enabled = enable;
btnBold.Enabled = enable && !MyFlexGrid.IsRoTable;// ;
btnItalics.Enabled = enable && !MyFlexGrid.IsRoTable;// ;
btnUnderline.Enabled = enable && !MyFlexGrid.IsRoTable;// ;
btnSubscript.Enabled = enable && !MyFlexGrid.IsRoTable;// ;
btnSuperscript.Enabled = enable && !MyFlexGrid.IsRoTable;// ;
btnChgCase.Enabled = enable && !MyFlexGrid.IsRoTable;// ;
btnInsHrdSpc.Enabled = enable && !MyFlexGrid.IsRoTable;// enable;
btnSymbols.Enabled = enable && !MyFlexGrid.IsRoTable;// enable;
btnIndent.Enabled = enable && !MyFlexGrid.IsRoTable;// ;enable;
btnInsTrans.Enabled = enable && !MyFlexGrid.IsRoTable;// ;
btnInsRO.Enabled = enable && Mydvi.DocVersionAssociationCount > 0; // 2016-128 don't enable if RO Path was not selected at the Working Draft node
btnCMRtfCellEdit.Enabled = enable && !MyFlexGrid.IsRoTable;
}
private bool _initTblFontSizeDropdown = true; // C2021-005 flag to allow setting font size in dropdown without triggering the dropdown item select
// C2021-005 get the font size being used in the selected table cell(s) then ititialize the font dropdown
public void SetFontSizeDropDown()
{
float sz = GetTableCellFontSize(SelectionOption.All);
SetFontSizeDropDownText(sz);
}
// C2021-005 Initialize the font size dropdown
public void SetFontSizeDropDownText(float fsz)
{
_initTblFontSizeDropdown = true;
rbTblFntSz.SelectedIndex = -1;
rbTblFntSz.Text = fsz.ToString();
cmFontSizeList.SelectedIndex = -1;
cmFontSizeList.Text = fsz.ToString();
_initTblFontSizeDropdown = false;
}
private void btnTblDgnAdjustSize_Click(object sender, EventArgs e)
{
if (MyFlexGrid.Cols.Fixed == 0) // allow change of size.
{
// set all the rows and columns to Fixed so that user can adjust the row/column size
if (MyFlexGrid.Cols[0].Width == -1) MyFlexGrid.Cols[0].Width = MyFlexGrid.Cols.DefaultSize;
MyFlexGrid.Cols.Fixed = MyFlexGrid.Cols.Count;
MyFlexGrid.Rows.Fixed = MyFlexGrid.Rows.Count;
MyFlexGrid.StyleBackColor = MyFlexGrid.DefaultFixedBackgroundColor; // C2021-004 force the fixed background color
ToggleTableDesignButtons(false);
//MyFlexGrid.ListStyles();
}
else
{
// set grid back to "normal" mode
MyFlexGrid.Cols.Fixed = 0;
MyFlexGrid.Rows.Fixed = 0;
MyFlexGrid.ShowTableCellShading(); // C2021-004 show the table cell colors
ToggleTableDesignButtons(true);
//MyFlexGrid.ListStyles();
}
}
#endregion
#region Table Grid Border
private void btnTblDgnTableBorderNone_Click(object sender, EventArgs e)
{
MyFlexGrid.SetTableBorder(C1.Win.C1FlexGrid.Util.BaseControls.BorderStyleEnum.None);
}
private void btnTblDgnTableBorderFixedSingle_Click(object sender, EventArgs e)
{
MyFlexGrid.SetTableBorder(C1.Win.C1FlexGrid.Util.BaseControls.BorderStyleEnum.FixedSingle);
}
private void btnTblDgnTableBorderFixed3D_Click(object sender, EventArgs e)
{
MyFlexGrid.SetTableBorder(C1.Win.C1FlexGrid.Util.BaseControls.BorderStyleEnum.Fixed3D);
}
private void btnTblDgnTableBorderLight3D_Click(object sender, EventArgs e)
{
MyFlexGrid.SetTableBorder(C1.Win.C1FlexGrid.Util.BaseControls.BorderStyleEnum.Light3D);
}
private void btnTblDgnTableBorderXPThemes_Click(object sender, EventArgs e)
{
MyFlexGrid.SetTableBorder(C1.Win.C1FlexGrid.Util.BaseControls.BorderStyleEnum.XpThemes);
}
#endregion
#region Table Grid Grid Style
private void btnTblDgnGridStyleNone_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellBorder(MyFlexGrid.Selection, C1.Win.C1FlexGrid.BorderStyleEnum.None);
}
private void btnTblDgnGridStyleFlat_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellBorder(MyFlexGrid.Selection, C1.Win.C1FlexGrid.BorderStyleEnum.Flat);
}
private void btnTblDgnGridStyleDouble_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellBorder(MyFlexGrid.Selection, C1.Win.C1FlexGrid.BorderStyleEnum.Double);
}
private void btnTblDgnGridStyleRaised_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellBorder(MyFlexGrid.Selection, C1.Win.C1FlexGrid.BorderStyleEnum.Raised);
}
private void btnTblDgnGridStyleInset_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellBorder(MyFlexGrid.Selection, C1.Win.C1FlexGrid.BorderStyleEnum.Inset);
}
private void btnTblDgnGridStyleGroove_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellBorder(MyFlexGrid.Selection, C1.Win.C1FlexGrid.BorderStyleEnum.Groove);
}
private void btnTblDgnGridStyleFillet_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellBorder(MyFlexGrid.Selection, C1.Win.C1FlexGrid.BorderStyleEnum.Fillet);
}
private void btnTblDgnGridStyleDotted_Click(object sender, EventArgs e)
{
MyFlexGrid.ChangeCellBorder(MyFlexGrid.Selection, C1.Win.C1FlexGrid.BorderStyleEnum.Dotted);
}
#endregion
private void rbnBorderlistBox_SelectedIndexChanged(object sender, EventArgs e)
{
rbnBorderSelectionPanel.SelectedBorder = rbnBorderlistBox.SelectedLinePattern;
}
private void rbnBorderSelectionPanel_BordersChanged(object sender, EventArgs args)
{
//C1.Win.C1FlexGrid.CellRange cr = MyFlexGrid.GetEvenSelection();
MyFlexGrid.SetBorders(MyFlexGrid.Selection, rbnBorderSelectionPanel.TopBorder, rbnBorderSelectionPanel.InsideHorizontalBorder,
rbnBorderSelectionPanel.BottomBorder, rbnBorderSelectionPanel.LeftBorder, rbnBorderSelectionPanel.InsideVerticalBorder, rbnBorderSelectionPanel.RightBorder);
MyEditItem.Invalidate();
MyFlexGrid.Invalidate();
}
private void btnTblNoBorder_Click(object sender, EventArgs e)
{
rbnBorderSelectionPanel.AllBorders = GridLinePattern.None;
}
private void btnTblOutline_Click(object sender, EventArgs e)
{
rbnBorderSelectionPanel.OutlineBorder = rbnBorderlistBox.SelectedLinePattern;
}
private void btnTblInside_Click(object sender, EventArgs e)
{
rbnBorderSelectionPanel.InsideBorders = rbnBorderlistBox.SelectedLinePattern;
}
private void rbnBorderlistBox_Resize(object sender, EventArgs e)
{
rbnBorderSelectionPanel.Size = rbnBorderlistBox.Size;
_RibbonControl.Height = rbnBorderlistBox.Height + _RibbonControl.Height - _RibbonControl.ClientSize.Height;
//_RibbonControl.Height = rbnBorderlistBox.Height + _RibbonControl.Height - _RibbonControl.ClientSize.Height;
}
#region Expand/Collaspe Ribbon
// In MS Word, a Double Click of a ribbon tab will toggle (Expand/Collapse) the ribbon.
// Once collapsed, a Single Click of a ribbon tab will temporarily expand the ribbon but does not push the text window
// down to make room. Thus your edit cursor could end up behind the ribbon.
// In our implementation of the ribbon interface, when we double click to collapse/expand the
// ribbon, the QAT menu on the main form gets out of sync, so we need to handle this manually, turning off AutoExpand
// on the ribbon control. (see StepTabRibbon() constructor) and issue an event to expand/collapse the ribbon.
// As a result of turning off the AutoExpand, a single click is not recongized internally.
// To get around this, we handle the single click event.
// Our single click event will expand the ribbon tabs if needed but not temporarily.
// Instead, it acts like a double click which is not the same a MS Word, but on the plus side,
// it elimates the risk of the ribbon expanding on top of the current edit window.
//-----------------------------
// This is assigned the DoubleClick event on all of the ribbon tabs
// Note that a single mouse click will expand the tabs if collapsed
// Note too that a double click also fires the single click event
// the "didSingleClick" variable handle this case
private void ribbonTab_DoubleClick(object sender, EventArgs e)
{
if (TimeSpan.FromTicks(DateTime.Now.Ticks - _LastClick.Ticks).TotalMilliseconds > 500)
{
//SendKeys.Send("^{F1}"); // toggle expand/collapse ribbon tabs <CTRL><F1>
MyEditItem.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OnToggleRibbonExpanded(this, new EventArgs());
_LastDoubleClick = DateTime.Now;
}
}
private DateTime _LastClick = DateTime.Now;
private DateTime _LastDoubleClick = DateTime.Now;
// This is assigned the Click event on all of the ribbon tabs
// If the tabs are collapsed, then expand them on a single click of the tab
private void ribbonTab_SingleClick(object sender, EventArgs e)
{
if ((!_RibbonControl.Expanded) && TimeSpan.FromTicks(DateTime.Now.Ticks - _LastDoubleClick.Ticks).TotalMilliseconds > 500)
{
//SendKeys.Send("^{F1}"); // Expand the ribbon tabs <CTRL><F1>
MyEditItem.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OnToggleRibbonExpanded(this, new EventArgs());
_LastClick = DateTime.Now;
}
}
#endregion // Expand/Collapse Ribbon
private void btnPasteText_Click(object sender, EventArgs e)
{
StartGridEditing(SelectionOption.End);
_PastePlainTextOvrRide = true;
btnPaste_Click(sender, e);
}
private void btnPasteImage_Click(object sender, EventArgs e)
{
if (MyEditItem is ImageItem) (MyEditItem as ImageItem).PasteImage();
}
private void btnPasteStepText_Click(object sender, EventArgs e)
{
StartGridEditing(SelectionOption.End);
_PasteStepTextOvrRide = true;
btnPaste_Click(sender, e);
}
private void btnSaveChgId_Click(object sender, EventArgs e)
{
(this.Parent as StepTabPanel).MyDisplayTabControl.ChgId = txtBxChgId.Text;
(this.Parent as StepTabPanel).MyDisplayTabControl.ItemsChangeIds.Remove(_MyEditItem.MyStepRTB.MyItemInfo.MyProcedure.ItemID);
(this.Parent as StepTabPanel).MyDisplayTabControl.ItemsChangeIds.Add(_MyEditItem.MyStepRTB.MyItemInfo.MyProcedure.ItemID, txtBxChgId.Text);
}
private frmImportWordContents fiwc = null;
// open the Import Word Text dialog
private void rbnImpWrd_ItemClick(object sender, EventArgs e)
{
if (fiwc == null) fiwc = new frmImportWordContents();
fiwc.MyStepRTB = this.MyStepRTB;
// B2019-108 When closed set value to null
fiwc.FormClosed += fiwc_FormClosed;
fiwc.Show();
}
void fiwc_FormClosed(object sender, FormClosedEventArgs e)
{
fiwc = null;
}
private void btnCMImgSz_Click(object sender, EventArgs e)
{
StepPanelTabDisplayEventArgs args = new StepPanelTabDisplayEventArgs("Change Image Size");
MyEditItem.MyStepPanel.OnTabDisplay(sender, args);
}
// C2021-005 user selected a font size from the dropdown (table ribbon)
private void rbTblFntSz_SelectedIndexChanged(object sender, EventArgs e)
{
if (!_initTblFontSizeDropdown)
{
float newSize = Convert.ToSingle(rbTblFntSz.SelectedItem); // font size selction from dropdown
ChangeFontSize(SelectionOption.All, newSize); // newSize is the font pt size not the RFT font size (which is twice the pt size)
}
}
// C2021-005 user selected a font size from the dropdown (context menu)
private void cmFontSizeList_SelectedIndexChanged(object sender, EventArgs e)
{
if (!_initTblFontSizeDropdown)
{
float newSize = Convert.ToSingle(cmFontSizeList.SelectedItem);
ChangeFontSize(SelectionOption.All, newSize);
}
}
#region Table Cell Shading
// C2021-004 Table Cell Shading
private void btnTblDgnCellShading_SelectedColorChanged(object sender, EventArgs e)
{
Color newshading = btnCellShading.SelectedColor;
MyFlexGrid.SetShading(MyFlexGrid.Selection, newshading); // assign the selected color the selected cell(s)
MyEditItem.Invalidate();
MyFlexGrid.Invalidate();
}
// This adds a button named "More Shading Options..." to the DotNetBar defined Color Selector button
private bool _CustomButtonAdded = false;
private void btnCellShading_PopupShowing(object sender, EventArgs e)
{
if (MyItemInfo == null || MyItemInfo.ActiveFormat.PlantFormat.FormatData.ShadingOptionList == null) return; //not shading options defined in format
if (!_CustomButtonAdded)
{
ButtonItem button = new ButtonItem();
button.Text = "More Shading Options...";
button.BeginGroup = true;
foreach (ShadingOption ShadeOpt in MyItemInfo.ActiveFormat.PlantFormat.FormatData.ShadingOptionList)
{
ButtonItem btn = new ButtonItem();
btn.Tag = ShadeOpt;
btn.Text = ShadeOpt.ToString();
btn.Click += new EventHandler(MoreShadingOptionsClick);
button.SubItems.Add(btn);
}
btnCellShading.SubItems.Add(button);
((MenuPanel)((PopupItem)button.Parent).PopupControl).RecalcLayout();
_CustomButtonAdded = true;
}
}
private void MoreShadingOptionsClick(object sender, EventArgs e)
{
ShadingOption sopt = (ShadingOption)((BaseItem)sender).Tag;
/* debug information
//string str = string.Format("Alpha {0}\n Red {1}\nBlue {2}\nGreen{3}", sopt.Alpha, sopt.Red, sopt.Blue, sopt.Green);
//MessageBox.Show(str,"more shading click");
*/
MyFlexGrid.SetShading(MyFlexGrid.Selection, sopt);
MyEditItem.Invalidate();
MyFlexGrid.Invalidate();
}
#endregion
// F2022-024 Time Critical Action Summary
private void btnTCASCreate_Click(object sender, EventArgs e)
{
if (MyItemInfo == null) return; // if creating a Time Critical Action Summary before rtb exists, return;
if (MyEditItem != null) MyEditItem.SaveCurrentAndContents();
OnTimeCriticalActionSummaryRequest(new StepTabRibbonEventArgs(MyItemInfo.MyProcedure));
}
}
public class StepTabRibbonEventArgs : EventArgs
{
public StepTabRibbonEventArgs() { ; }
public StepTabRibbonEventArgs(ItemInfo proc)
{
_Proc = proc;
}
private ItemInfo _Proc;
public ItemInfo Proc
{
get { return _Proc; }
set { _Proc = value; }
}
}
public delegate void StepTabRibbonEvent(object sender, StepTabRibbonEventArgs args);
}
Reference in New Issue View Git Blame Copy Permalink