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;

namespace Volian.Controls.Library
{
	public partial class StepTabRibbon : UserControl
	{
		#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 
			{ 
				_MyEditItem = value;
				if (value != null)
				{
					MyStepRTB = value.MyStepRTB;
					if (value is GridItem)
					{
						ToggleTableDesignButtons(true);
					}
				}
			}
		}
		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;
					return _MyDVI;
				}
				return null;
			}
		}
		private ItemInfo MyItemInfo
		{ get { return _MyStepRTB==null?null:_MyStepRTB.MyItemInfo; } }

		private DevComponents.DotNetBar.ButtonItem _DefaultContextMenu;

		public void ClearContextMenu()
		{
			_ContextMenuBar.SetContextMenuEx(_MyStepRTB, null);
		}
		public void SetContextMenu()
		{
			_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMRtfEdit);
		}
		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.StepText:
							_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);
					_MyStepRTB.Leave += new EventHandler(MyStepRTB_Leave);
					_MyStepRTB.LinkChanged += new StepRTBLinkEvent(_MyStepRTB_LinkChanged);
					// 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);
						BuildSymbolGallery(sl, galleryContainerSymbolsCM3);
					}
					SetButtonAndMenuEnabling(true);
					SetStepButtonAndMenuEnabling(true);
					
					_MyLastFormatID = MyItemInfo.ActiveFormat.FormatID;
				}
			}
		}

		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 gc)
		{
			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 btnCM = new DevComponents.DotNetBar.ButtonItem();
				btnCM.Text = string.Format("{0}", (char)sym.Unicode);
				// to name button use unicode rather than desc, desc may have spaces or odd chars
				btnCM.Name = "btnCM" + sym.Unicode.ToString();
				btnCM.Tooltip = sym.Desc;
				btnCM.Tag = string.Format(@"{0}", sym.Unicode);
				btnCM.FontBold = true;
				btnCM.Click += new System.EventHandler(btnSym_Click);
				gc.SubItems.Add(btnCM);
			}
		}

		//void _MyStepRTB_ModeChange(object sender, StepRTBModeChangeEventArgs args)
		//{
		//    SetButtonAndMenuEnabling(true);
		//}
		#endregion
		#region Constructor
		public StepTabRibbon()
		{
			InitializeComponent();
			_RibbonControl.SizeChanged += new EventHandler(_RibbonControl_SizeChanged);
			// When AutoExpand is set to true, [CTRL][F1] 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.
			// 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
		}

		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.
			btnCMGoTo.Enabled = btnGoTo.Enabled = _MyStepRTB.IsSelectionLinked(_MyStepRTB.SelectionStart, _MyStepRTB.SelectionLength);
			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;
			}
		}
		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;

			// 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 (MessageBox.Show("Do you want to insert an RO Table?", "Table Insert", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
					{
						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);
					}
				}
			}
		}
		// 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));
		}
		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;
			btnCMPaste.Enabled = btnPaste.Enabled = setting;
			btnCMCopy.Enabled = btnCopy.Enabled = setting;
			btnPasteAfter.Enabled = btnPasteBefore.Enabled = btnStepPaste.Enabled = btnPasteReplace.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;
		}
		private void SetButtonAndMenuEnabling(bool docontextmenus)
		{
			if (_MyStepRTB.FieldToEdit != E_FieldToEdit.StepText)
				return; // No need to change menu that does not get used
			if (_MyStepRTB == null) return;
			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();
				btnCMPaste.Enabled = btnPaste.Enabled = (iData.GetDataPresent(DataFormats.Text) || 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);
			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)
			{
				SetButtonMenuEnabledDisabledOnStepType(false);
				return;
			}
			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_ManualPagebreak;
			}
			btnInsPgBrk.Enabled = MyItemInfo.IsHigh;
			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;
			if (!(MyEditItem is GridItem) && rtabTableGridTools.Checked)
			{
				rtabHome.Select();
			}
			// 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;
			rtabTableGridTools.Visible = tmpGridItm != null && !tmpGridItm.MyFlexGrid.IsRoTable;

			// if on procedure or section, 'change type' & 'insert' buttons should be disabled.
			if (MyItemInfo.IsProcedure || MyItemInfo.IsSection)
			{
				btnChgTyp.Enabled = false;
				
				btnInsCaut.Enabled = btnInsNote.Enabled = btnInsRNO.Enabled = btnInsFig.Enabled =
					btnInsTable.Enabled = btnInsSubstep.Enabled = btnInsBefore.Enabled = btnInsAfter.Enabled = false;
				// 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 (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;

			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.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)
					{
						ItemInfo ichld = MyItemInfo.Steps[0];
						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)
					{
						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) 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 = (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 = (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 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();
		}
		#endregion
		#region Insert Tab
		private void btnSym_Click(object sender, EventArgs e)
		{
			DevComponents.DotNetBar.ButtonItem b = (DevComponents.DotNetBar.ButtonItem)sender;
			_MyStepRTB.InsertSymbol(Convert.ToInt32(b.Tag));
		}
		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_ManualPagebreak = !cfg.Step_ManualPagebreak;
			btnInsPgBrk.Checked = cfg.Step_ManualPagebreak;
		}
		private void btnIndent_Click(object sender, EventArgs e)
		{
			_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 void btnPaste_Click(object sender, EventArgs e)
		{
			IDataObject myDO = Clipboard.GetDataObject();
			if (myDO.GetDataPresent(DataFormats.Rtf))
			{
				string tmpForLink = myDO.GetData(DataFormats.Rtf).ToString();
				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> ");
				_MyStepRTB.SelectedRtf = tmpForLink;
			}
			else if (myDO.GetDataPresent(DataFormats.Text))
				_MyStepRTB.SelectedText = myDO.GetData(DataFormats.Text).ToString();
			if (_MyStepRTB.SelectionLength == 0) _MyStepRTB.SelectionFont = _MyStepRTB.MyStyleFont.WindowsFont;
		}
		private void btnCut_Click(object sender, EventArgs e)
		{
			Clipboard.Clear();
			DataObject myDO = new DataObject("Rich Text Format", _MyStepRTB.SelectedRtf);
			myDO.SetText(_MyStepRTB.SelectedText);
			Clipboard.SetDataObject(myDO);
			_MyStepRTB.SelectedText = "";
 		}
		private void btnCopy_Click(object sender, EventArgs e)
		{
			Clipboard.Clear();
			DataObject myDO = new DataObject("Rich Text Format", _MyStepRTB.SelectedRtf);
			myDO.SetText(_MyStepRTB.SelectedText);
			Clipboard.SetDataObject(myDO);
		}
		private void btnBold_Click(object sender, EventArgs e)
		{
			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)
		{
			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)
		{
			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)
		{
			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)
		{
			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)
		{
			_MyStepRTB.SetSelectedCase('U');
		}

		private void btnLowercase_Click(object sender, EventArgs e)
		{
			_MyStepRTB.SetSelectedCase('l');
		}

		private void btnTitleCase_Click(object sender, EventArgs e)
		{
			_MyStepRTB.SetSelectedCase('T');
		}
		private void btnInsTrans_Click(object sender, EventArgs e)
		{
			// 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)
		{
			_MyStepRTB.InsertSymbol(@"\u160?");
		}

		private void btnInsRO_Click(object sender, EventArgs e)
		{
			// 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.IndexOf("Transition") > -1)
			{
				_MyEditItem.MyStepPanel.OnLinkClicked(sender, new StepPanelLinkEventArgs(_MyStepRTB.MyLinkText));
			}
			else
			{
				string roapp = Environment.GetEnvironmentVariable("roapp");
				LinkText lt = new LinkText(_MyStepRTB.MyLinkText);
				string args = "\"" + lt.MyRoUsageInfo.MyRODb.FolderPath + "\" " + lt.MyRoUsageInfo.ROID.ToLower();
				if (!Directory.Exists(lt.MyRoUsageInfo.MyRODb.FolderPath))
				{
					MessageBox.Show(string.Format("RO Database directory does not exist: {0}", lt.MyRoUsageInfo.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
		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;
		}
		#endregion

		private void btnROEdit_Click(object sender, EventArgs e)
		{
			string roapp = Environment.GetEnvironmentVariable("roapp");
			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.");
				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.LastWriteTime)
			{
				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.LastWriteTime)
			{
				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;
			using (VlnFlexGrid myGrid = new VlnFlexGrid())
			{
				using (StringReader sr = new StringReader(args.OldGridXml))
				{
					myGrid.ReadXml(sr);
					sr.Close();
				}
				string roid = myGrid.ROID;
				int rodbid = myGrid.RODbId;
				Font GridFont = myGrid.Font;
				myGrid.Clear();
				myGrid.ParseTableFromText(args.ROText);
				myGrid.AutoSizeCols();
				myGrid.AutoSizeRows();
				myGrid.MakeRTFcells();
				myGrid.RODbId = rodbid;
				myGrid.ROID = roid;
				myGrid.IsRoTable = 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)
		{
			btnUpdROVal.Enabled = false;
			if (MyDVI.DocVersionAssociations.Count < 1) return;
			if (!NewerRoFst()) return;
			btnUpdROVal.Enabled = true;
		}
		public bool NewerRoFst()
		{
			if (_MyDVI == null) return false;
			ROFstInfo roFstInfo = _MyDVI.DocVersionAssociations[0].MyROFst;
			RODbInfo rdi = RODbInfo.Get(roFstInfo.RODbID);
			string rofstPath = rdi.FolderPath + @"\ro.fst";
			if (!File.Exists(rofstPath)) return false;
			FileInfo fiRofst = new FileInfo(rofstPath);

			// if the database Ro.Fst is newer or if the files have identical DTS, 
			// assume that they are the same file.
			if (roFstInfo.DTS >= fiRofst.LastWriteTime) return false;

			// next see if the data is the same size, i.e. byte count of record and byte count
			// of file.  If different sizes, the date/time stamp check will hold.
			if (fiRofst.Length != roFstInfo.ROLookup.Length) return fiRofst.LastWriteTime > roFstInfo.DTS;

			// if we can't tell by the DTS or size, compare the contents.  Get all of the rodb's
			// rofsts of the size of the file & compare bytes. If 
			ROFstInfoList fstList = ROFstInfoList.GetBySize(rdi.RODbID, (int)fiRofst.Length);
			if (fstList.Count > 0)
			{
				FileStream fsIn = new FileStream(rofstPath, FileMode.Open, FileAccess.Read, FileShare.Read);
				// Create an instance of StreamReader that can read characters from the FileStream.
				BinaryReader r = new BinaryReader(fsIn);
				byte[] ab = r.ReadBytes((int)fsIn.Length);
				fsIn.Close();
				foreach (ROFstInfo irofst in fstList)
				{
					// compare contents by comparing each byte.
					for (int i = 0; i < fiRofst.Length; i++)
						if (ab[i] != irofst.ROLookup[i]) return true;
				}
			}
			return false;
		}
		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 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, cannot delete!");
				return;
			}
			if (!surpressMessageBox)
			{
				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 (results == DialogResult.Yes)
					MyEditItem.RemoveItem();
			}
			else
				MyEditItem.RemoveItem();
		}

		private void btnCMIns_PopupClose(object sender, EventArgs e)
		{
			_ContextMenuBar.SetContextMenuEx(_MyStepRTB, _DefaultContextMenu);
		}

		public void SetShortCutContextMenu(string menuName)
		{
			bool displayMenu = false;
			E_AccStep? actable = 0;
			StepData sd = 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 "InsHLS":
					displayMenu = true;
					_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsHLS);
					break;
				case "InsRNO":
					displayMenu = (actable & E_AccStep.AddingRNO) > 0;
					_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsRNO);
					break;
				case "InsSubStps":
					displayMenu = (actable & E_AccStep.AddingSub) > 0;
					_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsSubStps);
					break;
				case "InsCaution":
					displayMenu = (actable & E_AccStep.AddingCaution) > 0;
					_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsCaution);
					break;
				case "InsNote":
					displayMenu = (actable & E_AccStep.AddingNote) > 0;
					_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsNote);
					break;
				case "InsTable":
					displayMenu = (actable & E_AccStep.AddingTable) > 0;
					_ContextMenuBar.SetContextMenuEx(_MyStepRTB, btnCMInsTable);
					break;
				case "InsFigure":
					displayMenu = (actable & E_AccStep.AddingTable) > 0;
					_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
			}
		}

		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 (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 (MyRTBItem.NextDownRTBItem.MyItemInfo.MyParent.ItemID == MyRTBItem.MyItemInfo.ItemID) //.Equals(MyRTBItem.MyItemInfo))
						{
						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 (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)
			{
				MyStepRTB.StepRTB_ArrowPressed(E_ArrowKeys.CtrlUp);
				if (MyItemInfo.IsHigh)
					SetShortCutContextMenu("InsHLS");
				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:
			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();
			}
			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;
			DialogResult dr = tpdlg.ShowDialog();
			while (tpdlg.Visible)
			{
				Application.DoEvents();
				System.Threading.Thread.Sleep(0);
			}
			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;
			}
			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.ClipBoardCopyRow();
		}

		private void btnTblDgnCopyColumn_Click(object sender, EventArgs e)
		{
			MyFlexGrid.ClipBoardCopyColumn();
		}

		private void btnTblDgnCopySelection_Click(object sender, EventArgs e)
		{
			MyFlexGrid.ClipBoardCopySelection();
		}

		private void btnTblDgnPasteRowBefore_Click(object sender, EventArgs e)
		{
			// create new rows before current position and copy clipboard data
			MyFlexGrid.ClipBoardPasteRows(VlnFlexGrid.enmPastePos.Before);
		}

		private void btnTblDgnPasteRowAfter_Click(object sender, EventArgs e)
		{
			// create new rows after current position and copy clipboard data
			MyFlexGrid.ClipBoardPasteRows(VlnFlexGrid.enmPastePos.After);
		}

		private void btnTblDgnPasteReplaceRow_Click(object sender, EventArgs e)
		{
			// replace rows with current clipboard data starting as current row
			MyFlexGrid.ClipBoardPasteRows(VlnFlexGrid.enmPastePos.Replace);
		}

		private void btnTblDgnPasteColumnBefore_Click(object sender, EventArgs e)
		{
			MyFlexGrid.ClipBoardPasteColumns(VlnFlexGrid.enmPastePos.Before);
		}

		private void btnTblDgnPasteColumnAfter_Click(object sender, EventArgs e)
		{
			MyFlexGrid.ClipBoardPasteColumns(VlnFlexGrid.enmPastePos.After);
		}

		private void btnTblDgnPasteColumnReplace_Click(object sender, EventArgs e)
		{
			MyFlexGrid.ClipBoardPasteColumns(VlnFlexGrid.enmPastePos.Replace);
		}

		private void btnTblDgnPasteIntoSelection_Click(object sender, EventArgs e)
		{
			MyFlexGrid.ClipBoardPasteIntoSelection();
		}
		private void btnTblDgnClear_Click(object sender, EventArgs e)
		{
			MyFlexGrid.ClearSelectedCellText();
		}

		#endregion
		#region Table Grid Delete
		private void btnTblDgnDeleteRow_Click(object sender, EventArgs e)
		{
			MyFlexGrid.RemoveSelectedRow();
		}

		private void btnTblDgnDeleteColumn_Click(object sender, EventArgs e)
		{
			MyFlexGrid.RemoveSelectedColumn();
		}

		private void btnTblDgnDeleteSelected_Click(object sender, EventArgs e)
		{
			MyFlexGrid.RemoveSelectedCells();
		}
		#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 btnTblDgnAlignLeft_Click(object sender, EventArgs e)
		{
			MyFlexGrid.RTFTextAlignment(MyFlexGrid.Selection, HorizontalAlignment.Left);
		}

		private void btnTblDgnAlignCentered_Click(object sender, EventArgs e)
		{
			MyFlexGrid.RTFTextAlignment(MyFlexGrid.Selection, HorizontalAlignment.Center);
		}

		private void btnTblDgnAlignRight_Click(object sender, EventArgs e)
		{
			MyFlexGrid.RTFTextAlignment(MyFlexGrid.Selection, HorizontalAlignment.Right);
		}
		#endregion
		#region Table Grid Merge/Split
		private void btnTblDgnSplitCells_ToRows_Click(object sender, EventArgs e)
		{
			MyFlexGrid.SplitSelection(false);
		}
		#endregion

		private void btnTblDgnSplitCellsToCols_Click(object sender, EventArgs e)
		{
			MyFlexGrid.SplitSelection(true);
		}

		private void btnTblDgnMergeCells_Click(object sender, EventArgs e)
		{
			MyFlexGrid.MergeSelection();
		}
		#endregion
		#region Table Grid Design
		private void btnTblDgnInsertRowBefore_Click(object sender, EventArgs e)
		{
			MyFlexGrid.InsertRowBefore();
		}

		private void btnTblDgnInsertRowAfter_Click(object sender, EventArgs e)
		{
			MyFlexGrid.InsertRowAfter();
		}

		private void btnTblDgnInsertColumnBefore_Click(object sender, EventArgs e)
		{
			MyFlexGrid.InsertColumnBefore();
		}

		private void btnTblDgnInsertColumnAfter_Click(object sender, EventArgs e)
		{
			MyFlexGrid.InsertColumnAfter();
		}

		private void ToggleTableDesignButtons(bool enable)
		{
			cpTblDgnHighlight.Enabled = enable;
			btnTblDgnAlignText.Enabled = enable;
			btnTblDgnClear.Enabled = enable;
			btnTblDgnCopy.Enabled = enable;
			btnTblDgnDelete.Enabled = enable;
			btnTblDgnGridStyle.Enabled = enable;
			btnTblDgnInsertColumn.Enabled = enable;
			btnTblDgnInsertRow.Enabled = enable;
			btnTblDgnMergeCells.Enabled = enable;
			btnTblDgnPaste.Enabled = enable;
			btnTblDgnSplitCells.Enabled = enable;
			btnTblDgnTableBorder.Enabled = enable;
			btnTblDgnAdjustSize.Checked = !enable;
		}
		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
				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 btnTblDgnDeleteRow_Click_1(object sender, EventArgs e)
		{
			MyFlexGrid.RemoveSelectedRow();
		}

		private void btnTblDgnDeleteColumn_Click_1(object sender, EventArgs e)
		{
			MyFlexGrid.RemoveSelectedColumn();
		}

		private void btnTblDgnDeleteSelected_Click_1(object sender, EventArgs e)
		{
			MyFlexGrid.RemoveSelectedCells();
		}

		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);
		}
	}
	public enum E_FieldToEdit { StepText, Text, Number };
	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);
}