2733 lines
106 KiB
C#
2733 lines
106 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Data;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.IO;
|
|
using System.Text.RegularExpressions;
|
|
using VEPROMS.CSLA.Library;
|
|
using Accentra.Controls;
|
|
using Volian.Base.Library;
|
|
|
|
namespace Volian.Controls.Library
|
|
{
|
|
public partial class StepTabRibbon : UserControl
|
|
{
|
|
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 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;
|
|
if (value != null)
|
|
{
|
|
MyStepRTB = value.MyStepRTB;
|
|
if (value is GridItem)
|
|
{
|
|
ToggleTableDesignButtons(true);
|
|
MyFlexGrid_SelChange(this, new EventArgs());
|
|
}
|
|
}
|
|
else
|
|
MyStepRTB = null;
|
|
}
|
|
}
|
|
// 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.ROFSTLookup;
|
|
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 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()
|
|
{
|
|
AddWROContext(btnCMRtfEdit);
|
|
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMRtfEdit);
|
|
}
|
|
|
|
#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.GetRoChildByAccPagID(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.GetRoChildByAccPagID(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.GetRoChildByAccPagID(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;
|
|
}
|
|
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;
|
|
}
|
|
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.DocVersionInfo.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); //ConvertSymbolsAndStuff(selectedChld.value);
|
|
MyStepRTB.OnRoInsert(this, new StepRTBRoEventArgs(valtxt, myvalue, linktxt, padroid, MyLookup.DocVersionInfo.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.DocVersionInfo.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); //ConvertSymbolsAndStuff(selectedChld.value);
|
|
MyStepRTB.OnRoInsert(this, new StepRTBRoEventArgs(valtxt, myvalue, linktxt, padroid, MyLookup.DocVersionInfo.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)
|
|
{
|
|
btnCMRtfEdit.Popup(loc);
|
|
}
|
|
private int _MyLastFormatID = -1;
|
|
private StepRTB _MyStepRTB;
|
|
public StepRTB MyStepRTB
|
|
{
|
|
get { return _MyStepRTB; }
|
|
set
|
|
{
|
|
_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 slected (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);
|
|
}
|
|
// Add symbols into the tab ribbon based on format selection. For now, only add symbols once
|
|
// because all symbols are same!!! If we start defining different symbols in different formats
|
|
// this will have to change, i.e. remove the second part of 'if' statement.
|
|
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)
|
|
{
|
|
MessageBox.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);
|
|
|
|
_MyLastFormatID = MyItemInfo.ActiveFormat.FormatID;
|
|
}
|
|
}
|
|
}
|
|
|
|
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
|
|
bool allow = (_MyStepRTB.TextLength > 0);
|
|
|
|
// turn ribbon items on/off base on whether there is text in the edit window
|
|
rbnSiblings.Enabled = rbnBreaks.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);
|
|
rbPdf.Enabled = allow;
|
|
|
|
// toggle context menus used with the shortcut key
|
|
btnCMInsHLS.Enabled = btnCMInsRNO.Enabled = btnCMInsSubStps.Enabled = btnCMInsCaution.Enabled =
|
|
btnCMInsNote.Enabled = btnCMInsTable.Enabled = btnCMInsFigure.Enabled = allow;
|
|
}
|
|
|
|
void MyFlexGrid_SelChange(object sender, EventArgs e)
|
|
{
|
|
if (MyFlexGrid == null)
|
|
return;
|
|
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);
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
}
|
|
void _MyStepRTB_SelectionChanged(object sender, EventArgs e)
|
|
{
|
|
SetButtonAndMenuEnabling(false);
|
|
}
|
|
//void _MyStepRTB_MouseUp(object sender, MouseEventArgs e)
|
|
//{
|
|
// //SetButtonAndMenuEnabling(false);
|
|
//}
|
|
|
|
//void _MyStepRTB_KeyUp(object sender, KeyEventArgs e)
|
|
//{
|
|
// //SetButtonAndMenuEnabling(false);
|
|
//}
|
|
|
|
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)
|
|
{
|
|
DevComponents.DotNetBar.ButtonItem btn = new DevComponents.DotNetBar.ButtonItem();
|
|
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.Click += new System.EventHandler(btnSym_Click);
|
|
gc1.SubItems.Add(btnCM1);
|
|
DevComponents.DotNetBar.ButtonItem btnCM2 = GetCMButton(sym);
|
|
btnCM2.Click += new System.EventHandler(btnSym_Click);
|
|
gc2.SubItems.Add(btnCM2);
|
|
DevComponents.DotNetBar.ButtonItem btnCM3 = GetCMButton(sym);
|
|
btnCM3.Click += new System.EventHandler(btnSym_Click);
|
|
gc3.SubItems.Add(btnCM3);
|
|
DevComponents.DotNetBar.ButtonItem btnCM4 = GetCMButton(sym);
|
|
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);
|
|
//}
|
|
#endregion
|
|
#region Constructor
|
|
public StepTabRibbon()
|
|
{
|
|
InitializeComponent();
|
|
_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
|
|
}
|
|
|
|
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 PrintRequest;
|
|
private void OnPrintRequest(StepTabRibbonEventArgs args)
|
|
{
|
|
if (PrintRequest != null)
|
|
PrintRequest(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)
|
|
btnCMGoTo.Enabled = btnGoTo.Enabled = true;
|
|
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
|
|
btnCMGoTo.Enabled = btnGoTo.Enabled = !_MyStepRTB.SelectedText.StartsWith("?");
|
|
}
|
|
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)
|
|
{
|
|
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 tabletype = (insdata.Length == 3)? insdata[2]:null;
|
|
// 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.
|
|
if (fromtype == 0 && !_MyEditItem.MyItemInfo.IsStepSection)
|
|
{
|
|
EditItem hlsEditItem = _MyEditItem;
|
|
while (!hlsEditItem.MyItemInfo.IsHigh)
|
|
hlsEditItem = hlsEditItem.ActiveParent;
|
|
hlsEditItem.AddSiblingAfter((int?)contenttype, true);
|
|
}
|
|
else if (InsertingTable(contenttype))
|
|
{
|
|
if (tabletype.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
|
|
{
|
|
_MyEditItem.AddChild((E_FromType)fromtype, contenttype);
|
|
}
|
|
}
|
|
// 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;
|
|
}
|
|
private void btnInsBefore_Click(object sender, EventArgs e)
|
|
{
|
|
_MyEditItem.AddSiblingBefore();
|
|
}
|
|
|
|
private void btnInsAfter_Click(object sender, EventArgs e)
|
|
{
|
|
_MyEditItem.AddSiblingAfter();
|
|
}
|
|
/// <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)
|
|
{
|
|
btnTblDgnMergeCells.Enabled = btnCmGridMergeCells.Enabled = !MyFlexGrid.IsInMergeRange();
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
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 = btnInsRO.Enabled = btnCMRO.Enabled = setting;
|
|
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;
|
|
}
|
|
}
|
|
private void SetButtonAndMenuEnabling(bool docontextmenus)
|
|
{
|
|
if (_MyStepRTB == null) return;
|
|
if (_MyStepRTB.FieldToEdit != E_FieldToEdit.StepText)
|
|
return; // No need to change menu that does not get used
|
|
DocVersionInfo dvi = MyEditItem.MyItemInfo.MyProcedure.ActiveParent as DocVersionInfo;
|
|
if (dvi == null) return;
|
|
if (dvi.VersionType > 127 || MyEditItem.MyStepPanel.VwMode == E_ViewMode.View)
|
|
{
|
|
SetButtonMenuEnabledDisabledOnSelection(false);
|
|
}
|
|
else
|
|
{
|
|
SetButtonMenuEnabledDisabledOnSelection(true);
|
|
|
|
if (_MyStepRTB.SelectionFont != null)
|
|
{
|
|
btnCMBold.Checked = btnBold.Checked = RTBAPI.IsBold(_MyStepRTB);
|
|
btnCMItalics.Checked = btnItalics.Checked = RTBAPI.IsItalic(_MyStepRTB);
|
|
btnCMUnderline.Checked = btnUnderline.Checked = RTBAPI.IsUnderline(_MyStepRTB);
|
|
btnCMSubscript.Checked = btnSubscript.Checked = RTBAPI.IsSubScript(_MyStepRTB);
|
|
btnCMSuperscript.Checked = btnSuperscript.Checked = RTBAPI.IsSuperScript(_MyStepRTB);
|
|
}
|
|
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.
|
|
IDataObject iData = Clipboard.GetDataObject();
|
|
//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 = (iData.GetDataPresent(DataFormats.Text) || iData.GetDataPresent(DataFormats.Rtf));
|
|
btnCMPasteText.Enabled = btnPasteText.Enabled = iData.GetDataPresent(DataFormats.Text);
|
|
btnCMPaste.Enabled = btnPasteStepText.Enabled = iData.GetDataPresent(DataFormats.Rtf);
|
|
}
|
|
// all selected copy while in either Edit or View mode
|
|
btnCMCopy.Enabled = btnCopy.Enabled = _MyStepRTB.SelectionLength > 0;
|
|
|
|
// 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);
|
|
}
|
|
|
|
private void SetPasteButtonEnabled()
|
|
{
|
|
// 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;
|
|
}
|
|
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
|
|
btnEditMode.Checked = btnCMEditMode1.Checked = MyEditItem.MyStepPanel.VwMode == E_ViewMode.View;
|
|
// if on procedure, 'Delete' buttons should be disabled.
|
|
btnDelelete.Enabled = btnDelStep.Enabled = !MyItemInfo.IsProcedure;
|
|
btnCpyStp.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 && !tmpGridItm.MyFlexGrid.IsRoTable;
|
|
// 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 = 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) ? 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);
|
|
}
|
|
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 = true;
|
|
btnInsCaut.Enabled = (actable & E_AccStep.AddingCaution) > 0;
|
|
btnInsNote.Enabled = (actable & E_AccStep.AddingNote) > 0;
|
|
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 && (actable & E_AccStep.AddingPrev) > 0;
|
|
btnInsAfter.Enabled = btnInsAftH.Enabled = !MyItemInfo.IsRNOPart && (actable & E_AccStep.AddingNext) > 0;
|
|
|
|
// if this step has a table or figure, disable both of those buttons.
|
|
if (MyItemInfo.Tables != null && MyItemInfo.Tables.Count > 0)
|
|
btnInsTable.Enabled = btnInsFig.Enabled = btnCMInsFigure.Enabled = btnCMInsTable.Enabled = false;
|
|
|
|
btnInsHLS.SubItems.Clear();
|
|
btnInsCaut.SubItems.Clear();
|
|
btnInsNote.SubItems.Clear();
|
|
btnInsRNO.SubItems.Clear();
|
|
btnInsFig.SubItems.Clear();
|
|
btnInsTable.SubItems.Clear();
|
|
btnInsSubstep.SubItems.Clear();
|
|
|
|
if (docontextmenus)
|
|
{
|
|
btnCMInsHLS.SubItems.Clear();
|
|
btnCMInsCaution.SubItems.Clear();
|
|
btnCMInsNote.SubItems.Clear();
|
|
btnCMInsFigure.SubItems.Clear();
|
|
btnCMInsTable.SubItems.Clear();
|
|
btnCMInsSubStps.SubItems.Clear();
|
|
btnCMInsRNO.SubItems.Clear();
|
|
}
|
|
|
|
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"));
|
|
|
|
// 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);
|
|
|
|
btnInsTrans.Enabled = btnCMTransition.Enabled = btnInsRO.Enabled = btnCMRO.Enabled = true;
|
|
|
|
_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"));
|
|
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);
|
|
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));
|
|
cmbi.Click += new System.EventHandler(btnInsStep_Click);
|
|
cmbtn.SubItems.Add(cmbi);
|
|
}
|
|
if (MyItemInfo.IsHigh && hlsSubType != -1 && sdr.Index == hlsSubType) bi.Checked = true;
|
|
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);
|
|
}
|
|
}
|
|
// 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.
|
|
if (btn.SubItems.Count == 1)
|
|
{
|
|
btn.Tag = btn.SubItems[0].Tag;
|
|
btn.SubItems.Clear();
|
|
DoTableSubMenu(btn);
|
|
}
|
|
else
|
|
{
|
|
foreach (DevComponents.DotNetBar.ButtonItem tabbtn in btn.SubItems)
|
|
DoTableSubMenu(tabbtn);
|
|
}
|
|
}
|
|
// 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);
|
|
}
|
|
}
|
|
|
|
}
|
|
rbnStepParts.Refresh();
|
|
}
|
|
|
|
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; // null if on property page for procedure & section number/title
|
|
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:
|
|
break;
|
|
MyStepRTB.Select(MyStepRTB.TextLength, 0);
|
|
default:
|
|
MyStepRTB.Select(0, 0);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void btnInsPgBrk_Click(object sender, EventArgs e)
|
|
{
|
|
rtabInsert.Select();
|
|
if (MyItemInfo.IsProcedure || MyItemInfo.IsSection) return;
|
|
|
|
// 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)
|
|
{
|
|
StartGridEditing(SelectionOption.Start);
|
|
_MyStepRTB.InsertIndent(MyEditItem.MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IndentToken);
|
|
}
|
|
private void btnCMIndent_Click(object sender, EventArgs e)
|
|
{
|
|
_MyStepRTB.InsertIndent(MyEditItem.MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IndentToken);
|
|
}
|
|
#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 = Regex.Replace(tmpForLink, @"#Link:ReferencedObject:[0-9]+ ", @"#Link:ReferencedObject:<NewID> ");
|
|
tmpForLink = Regex.Replace(tmpForLink, @"#Link:Transition:([0-9]+) [0-9]+ ", @"#Link:Transition:$1 <NewID> ");
|
|
tmpForLink = Regex.Replace(tmpForLink, @"#Link:TransitionRange:([0-9]+) [0-9]+ ", @"#Link:TransitionRange:$1 <NewID> ");
|
|
tmpForLink = tmpForLink.Replace(@"\u8212 \'96", @"-"); // Replace EM Dash with hyphen
|
|
tmpForLink = tmpForLink.Replace(@"\u8211 \'96", @"-"); // Replace EN Dash with hyphen
|
|
tmpForLink = tmpForLink.Replace(@"\u8212 ", @"-"); // Replace EM Dash with hyphen
|
|
tmpForLink = tmpForLink.Replace(@"\u8211 ", @"-"); // Replace EN Dash with hyphen
|
|
myRtb.SelectedRtf = tmpForLink;
|
|
}
|
|
|
|
}
|
|
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),
|
|
// tmp becomes null rather than from flexgrid or steptext.
|
|
if (tmp == null) return null;
|
|
}
|
|
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; // null if on property page for procedure & section number/title
|
|
Clipboard.Clear();
|
|
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)
|
|
{
|
|
StartGridEditing(SelectionOption.All);
|
|
RTBAPI.ToggleBold(!RTBAPI.IsBold(_MyStepRTB), _MyStepRTB, _MyStepRTB.SelectionLength == 0 ? RTBAPI.RTBSelection.SCF_DEFAULT : RTBAPI.RTBSelection.SCF_SELECTION);
|
|
btnCMBold.Checked = btnBold.Checked = RTBAPI.IsBold(_MyStepRTB);
|
|
}
|
|
private void btnItalics_Click(object sender, EventArgs e)
|
|
{
|
|
StartGridEditing(SelectionOption.All);
|
|
RTBAPI.ToggleItalic(!RTBAPI.IsItalic(_MyStepRTB), _MyStepRTB, _MyStepRTB.SelectionLength == 0 ? RTBAPI.RTBSelection.SCF_DEFAULT : RTBAPI.RTBSelection.SCF_SELECTION);
|
|
btnCMItalics.Checked = btnItalics.Checked = RTBAPI.IsItalic(_MyStepRTB);
|
|
}
|
|
private void btnUnderline_Click(object sender, EventArgs e)
|
|
{
|
|
StartGridEditing(SelectionOption.All);
|
|
RTBAPI.ToggleUnderline(!RTBAPI.IsUnderline(_MyStepRTB), _MyStepRTB, _MyStepRTB.SelectionLength == 0 ? RTBAPI.RTBSelection.SCF_DEFAULT : RTBAPI.RTBSelection.SCF_SELECTION);
|
|
btnCMUnderline.Checked = btnUnderline.Checked = RTBAPI.IsUnderline(_MyStepRTB);
|
|
}
|
|
|
|
private 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);
|
|
}
|
|
|
|
private 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)
|
|
{
|
|
StartGridEditing(SelectionOption.All);
|
|
_MyStepRTB.SetSelectedCase('U');
|
|
}
|
|
|
|
private void btnLowercase_Click(object sender, EventArgs e)
|
|
{
|
|
StartGridEditing(SelectionOption.All);
|
|
_MyStepRTB.SetSelectedCase('l');
|
|
}
|
|
|
|
private void btnTitleCase_Click(object sender, EventArgs e)
|
|
{
|
|
StartGridEditing(SelectionOption.All);
|
|
_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 transition.
|
|
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.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"))
|
|
{
|
|
MessageBox.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
|
|
{
|
|
LinkText lt = new LinkText(_MyStepRTB.MyLinkText);
|
|
myROID = lt.MyRoUsageInfo.ROID.ToLower();
|
|
myRODB = lt.MyRoUsageInfo.MyRODb;
|
|
}
|
|
//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))
|
|
{
|
|
MessageBox.Show(string.Format("RO Database directory does not exist: {0}", myRODB.FolderPath));
|
|
return;
|
|
}
|
|
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
|
|
|
|
private void btnToggleEditView_Click(object sender, EventArgs e)
|
|
{
|
|
MyEditItem.MyStepPanel.VwMode = MyEditItem.MyStepPanel.VwMode == E_ViewMode.Edit ? E_ViewMode.View : E_ViewMode.Edit;
|
|
MyEditItem.ToggleEditView(MyEditItem.MyStepPanel.VwMode);
|
|
SetButtonAndMenuEnabling(true);
|
|
SetStepButtonAndMenuEnabling(true);
|
|
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 btnROEdit_Click(object sender, EventArgs e)
|
|
{
|
|
if (VlnSettings.ReleaseMode.Equals("DEMO"))
|
|
{
|
|
MessageBox.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)
|
|
{
|
|
MessageBox.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);
|
|
MessageBox.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)
|
|
{
|
|
MessageBox.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))
|
|
{
|
|
MessageBox.Show(string.Format("RO Database directory does not exist: {0}", MyDVI.DocVersionAssociations[0].MyROFst.MyRODb.FolderPath));
|
|
return;
|
|
}
|
|
System.Diagnostics.Process.Start(roapp, roloc);
|
|
}
|
|
|
|
private void btnUpdROVal_Click(object sender, EventArgs e)
|
|
{
|
|
// 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)
|
|
{
|
|
MessageBox.Show("Error Updating ro.fst. No associated ro.fst");
|
|
return;
|
|
}
|
|
ROFstInfo roFstInfo = MyDVI.DocVersionAssociations[0].MyROFst;
|
|
|
|
string rofstPath = roFstInfo.MyRODb.FolderPath + @"\ro.fst";
|
|
if (!File.Exists(rofstPath))
|
|
{
|
|
MessageBox.Show("No existing ro.fst in path " + roFstInfo.MyRODb.FolderPath + ". Check for invalid path");
|
|
return;
|
|
}
|
|
FileInfo fiRofst = new FileInfo(rofstPath);
|
|
if (roFstInfo.DTS == fiRofst.LastWriteTimeUtc)
|
|
{
|
|
MessageBox.Show("ro.fst files are same for path " + roFstInfo.MyRODb.FolderPath + ", import of that ro.fst will not be done");
|
|
return;
|
|
}
|
|
if (roFstInfo.DTS > fiRofst.LastWriteTimeUtc)
|
|
{
|
|
MessageBox.Show("Cannot copy older ro.fst from " + roFstInfo.MyRODb.FolderPath + ", import of that ro.fst will not be done");
|
|
return;
|
|
}
|
|
Cursor = Cursors.WaitCursor;
|
|
|
|
using (DocVersion dv = DocVersion.Get(MyDVI.VersionID))
|
|
{
|
|
roFstInfo.ROTableUpdate += new ROFstInfoROTableUpdateEvent(roFstInfo_ROTableUpdate);
|
|
ROFst newrofst = ROFstInfo.UpdateRoFst(roFstInfo.MyRODb, dv.DocVersionAssociations[0], dv, roFstInfo);
|
|
roFstInfo.ROTableUpdate -= new ROFstInfoROTableUpdateEvent(roFstInfo_ROTableUpdate);
|
|
StepPanelTabDisplayEventArgs args = new StepPanelTabDisplayEventArgs("DisplayROUpdateROFST");
|
|
MyEditItem.MyStepPanel.OnTabDisplay(sender, args);
|
|
btnUpdROVal.Enabled = false;
|
|
}
|
|
Cursor = Cursors.Default;
|
|
}
|
|
|
|
public List<string> roFstInfo_ROTableUpdate(object sender, ROFstInfoROTableUpdateEventArgs 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 = true;
|
|
if (!NewerRoFst()) return;
|
|
btnUpdROVal.Enabled = true;
|
|
}
|
|
public bool NewerRoFst()
|
|
{
|
|
if (_MyDVI == null)return false;
|
|
return _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);
|
|
}
|
|
|
|
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 (MessageBox.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)
|
|
{
|
|
string msg = si.HasChildren ? "Are you sure you want to delete this section and its steps?" : "Are you sure you want to delete this section?";
|
|
DialogResult result = MessageBox.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();
|
|
if (!si.IsStepSection)
|
|
{
|
|
WordSectionEventArgs args = new WordSectionEventArgs(si);
|
|
MyEditItem.MyStepPanel.OnWordSectionDeleted(sender, args);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
StepInfo stpi = MyEditItem.MyItemInfo as StepInfo;
|
|
if (stpi == null) // not sure that it will every get here!
|
|
{
|
|
MessageBox.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);
|
|
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);
|
|
//string msgs = stpi.HasChildren ? "Are you sure you want to delete this step and its substeps?" : "Are you sure you want to delete this step?";
|
|
DialogResult results = MessageBox.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;
|
|
SetPasteButtonEnabled();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MyEditItem.RemoveItem();
|
|
if (clearCopyStep)
|
|
{
|
|
tmp.MyDisplayTabControl.MyCopyStep = null;
|
|
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 "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);
|
|
foreach (DevComponents.DotNetBar.ButtonItem bi in btnCMInsHLS.SubItems)
|
|
{
|
|
if (bi.Checked)
|
|
moveDown = cnt;
|
|
cnt++;
|
|
}
|
|
break;
|
|
case "InsRNO":
|
|
displayMenu = ((actable & E_AccStep.AddingRNO) > 0) && btnCMInsRNO.Enabled;
|
|
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsRNO);
|
|
break;
|
|
case "InsSubStps":
|
|
displayMenu = ((actable & E_AccStep.AddingSub) > 0) && btnCMInsSubStps.Enabled;
|
|
_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++;
|
|
}
|
|
break;
|
|
case "InsCaution":
|
|
displayMenu = ((actable & E_AccStep.AddingCaution) > 0) && btnCMInsCaution.Enabled;
|
|
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsCaution);
|
|
break;
|
|
case "InsNote":
|
|
displayMenu = ((actable & E_AccStep.AddingNote) > 0) && btnCMInsNote.Enabled;
|
|
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsNote);
|
|
break;
|
|
case "InsTable":
|
|
displayMenu = ((actable & E_AccStep.AddingTable) > 0) && btnCMInsTable.Enabled;
|
|
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsTable);
|
|
break;
|
|
case "InsFigure":
|
|
displayMenu = ((actable & E_AccStep.AddingTable) > 0) && btnCMInsFigure.Enabled;
|
|
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsFigure);
|
|
break;
|
|
case "StepPaste":
|
|
displayMenu = true;
|
|
if (MyFlexGrid != null)
|
|
_ContextMenuBar.SetContextMenuEx(MyFlexGrid, btnCMStepPaste);
|
|
else
|
|
_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMStepPaste);
|
|
break;
|
|
}
|
|
if (displayMenu)
|
|
{
|
|
SendKeys.Send("+{F10}{DOWN}"); // Display Context menu
|
|
while (moveDown > 0) // position to current type
|
|
{
|
|
SendKeys.Send("{DOWN}");
|
|
moveDown--;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void btnSpell_Click(object sender, EventArgs e)
|
|
{
|
|
//MessageBox.Show("Functionality not available.", "Spell Check");
|
|
StepPanelTabDisplayEventArgs args = new StepPanelTabDisplayEventArgs("SpellChecker");
|
|
MyEditItem.MyStepPanel.OnTabDisplay(sender, args);
|
|
}
|
|
//private FindReplace dlgFindReplace = null;
|
|
private void btnFindRplDlg_Click(object sender, EventArgs e)
|
|
{
|
|
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;
|
|
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;
|
|
|
|
btnDelStep_Click(MyStepRTB, null); // delete the empty step piece
|
|
}
|
|
|
|
if (MyItemInfo.IsHigh)
|
|
{
|
|
if (!deletedHLS)
|
|
{
|
|
if (deletedSubStep)
|
|
SetShortCutContextMenu("InsHLS");
|
|
else if (MyEditItem.MyRNOEditItems != null && MyEditItem.MyRNOEditItems.Count > 0)
|
|
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlRight); // jump to RNO
|
|
else if (deletedRNO)
|
|
{
|
|
AddSubStep();
|
|
}
|
|
else if (!deletedHLS)
|
|
{
|
|
if (MyItemInfo.ColumnMode > 0)
|
|
CreateNewRNO();
|
|
else
|
|
AddSubStep();
|
|
}
|
|
}
|
|
}
|
|
else if (MyItemInfo.IsRNOPart)
|
|
{
|
|
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlLeft);
|
|
if (MyItemInfo.IsHigh)
|
|
{
|
|
//if (MyEditItem != null && MyEditItem.NextDownEditItem != null && MyEditItem.NextDownEditItem.MyItemInfo.MyParent.Equals(MyEditItem.MyItemInfo))
|
|
if (MyEditItem != null && MyEditItem.NextDownEditItem != null && 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)
|
|
{
|
|
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlLeft);
|
|
CreateNewRNO();
|
|
}
|
|
else
|
|
InsertSiblingBeforeOrAfter("after");
|
|
}
|
|
else if (MyItemInfo.IsStepPart)
|
|
{
|
|
if (deletedSubStep)
|
|
{
|
|
//MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlUp); // jump to HLS
|
|
SetShortCutContextMenu("InsHLS"); // prompt for new HLS
|
|
}
|
|
//else if (deletedRNO || MyItemInfo.IsEquipmentList)
|
|
// InsertSiblingBeforeOrAfter("after");
|
|
else if (!MyItemInfo.IsSequential) // only add a sibling if substep type does not have sequential tabs
|
|
InsertSiblingBeforeOrAfter("after");
|
|
else if (deletedRNO)
|
|
{
|
|
|
|
if (MyItemInfo.SearchNext != null && MyItemInfo.SearchNext.IsTable)
|
|
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlDown);
|
|
else
|
|
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
|
|
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlDown);
|
|
}
|
|
else if (MyItemInfo.IsTable || MyItemInfo.IsFigure)
|
|
{
|
|
ItemInfo next = MyItemInfo.SearchNext;
|
|
MyFlexGrid.Select(0, 0); // make sure we are at the first row before doing an up arrow
|
|
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlUp);
|
|
if (MyItemInfo.IsHigh)
|
|
{
|
|
if (deletedSubStep)
|
|
SetShortCutContextMenu("InsHLS");
|
|
else if (next != null && next.IsFirstSubStep)
|
|
{
|
|
MyEditItem.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OpenItem(next);
|
|
InsertSiblingBeforeOrAfter("before");
|
|
}
|
|
else
|
|
SetShortCutContextMenu("InsSubStps");
|
|
}
|
|
else
|
|
InsertSiblingBeforeOrAfter("after");
|
|
}
|
|
}
|
|
|
|
private void AddSubStep()
|
|
{
|
|
EditItem nextDownEditItem = MyEditItem.NextDownEditItem;
|
|
//bool skipTable = false;
|
|
// //If the step has a table, move past it before adding a substep
|
|
//if (nextDownEditItem != null && nextDownEditItem.MyItemInfo.MyParent.ItemID == MyEditItem.MyID &&
|
|
// nextDownEditItem.MyItemInfo.IsTablePart)
|
|
//{
|
|
// nextDownEditItem = nextDownEditItem.NextDownEditItem;
|
|
// skipTable = true;
|
|
//}
|
|
if (nextDownEditItem != null && nextDownEditItem.MyItemInfo.MyParent.ItemID == MyEditItem.MyID)
|
|
{
|
|
MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlDown);
|
|
//if (skipTable) MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlDown);
|
|
InsertSiblingBeforeOrAfter("before");
|
|
}
|
|
else
|
|
SetShortCutContextMenu("InsSubStps");
|
|
}
|
|
|
|
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;
|
|
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;
|
|
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 = MessageBox.Show("Step as Marked?", "Identify Step To Be Copied", MessageBoxButtons.YesNo);
|
|
if (dr == DialogResult.Yes)
|
|
{
|
|
StepTabPanel tmp = Parent as StepTabPanel;
|
|
tmp.MyDisplayTabControl.MyCopyStep = MyItemInfo;
|
|
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;
|
|
EditItem oldEditItem = MyEditItem;
|
|
MyEditItem = MyEditItem.PasteReplace(tmp.MyDisplayTabControl.MyCopyStep.ItemID);
|
|
if (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));
|
|
}
|
|
#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 btnTblDgnInsertColumnAbove_Click(object sender, EventArgs e)
|
|
{
|
|
MyFlexGrid.InsertColumnBefore();
|
|
}
|
|
|
|
private void btnTblDgnInsertColumnBelow_Click(object sender, EventArgs e)
|
|
{
|
|
MyFlexGrid.InsertColumnAfter();
|
|
}
|
|
|
|
public void ToggleTableDesignButtons(bool enable)
|
|
{
|
|
btnTblDgnAlignText.Enabled = enable;
|
|
btnTblDgnCopy.Enabled = enable;
|
|
btnTblDgnRemove.Enabled = enable;
|
|
//btnTblDgnGridStyle.Enabled = enable;
|
|
//rbTblBorder.Enabled = enable;
|
|
rbnBorderlistBox.Enabled = enable;
|
|
rbnBorderSelectionPanel.Enabled = enable;
|
|
btnTblNoBorder.Enabled = enable;
|
|
btnTblOutline.Enabled = enable;
|
|
btnTblInside.Enabled = enable;
|
|
btnTblDgnInsertColumn.Enabled = enable;
|
|
btnTblDgnInsertRow.Enabled = enable;
|
|
btnTblDgnMergeCells.Enabled = enable;
|
|
btnCmGridPaste.Enabled =
|
|
btnTblDgnPaste.Enabled = ((VlnFlexGrid.MyCopyInfo.MyCopiedFlexGrid != null) && enable);
|
|
btnTblDgnSplitCells.Enabled = enable;
|
|
}
|
|
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);
|
|
bool enable = (MyFlexGrid != null);
|
|
//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;
|
|
btnCMRtfCellEdit.Enabled = enable && !MyFlexGrid.IsRoTable;
|
|
}
|
|
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;
|
|
ToggleTableDesignButtons(false);
|
|
//MyFlexGrid.ListStyles();
|
|
}
|
|
else
|
|
{
|
|
// set grid back to "normal" mode
|
|
MyFlexGrid.Cols.Fixed = 0;
|
|
MyFlexGrid.Rows.Fixed = 0;
|
|
MyFlexGrid.StyleBackColor = Color.White;
|
|
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 btnPasteStepText_Click(object sender, EventArgs e)
|
|
{
|
|
StartGridEditing(SelectionOption.End);
|
|
_PasteStepTextOvrRide = true;
|
|
btnPaste_Click(sender, e);
|
|
}
|
|
|
|
}
|
|
public enum E_FieldToEdit { StepText, Text, Number, PSI };
|
|
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);
|
|
|
|
}
|