58e58083c2
Fixed Find and Replace logic to keep it from getting into an infinite loop Used new CSLA code to hanndle deletion of procedures with external transitions New Enhanced Document properties
982 lines
34 KiB
C#
982 lines
34 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Data;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Windows.Forms;
|
|
using VEPROMS.CSLA.Library;
|
|
|
|
namespace Volian.Controls.Library
|
|
{
|
|
#region Enums
|
|
public enum ExpandingStatus : int
|
|
{
|
|
No = 0,
|
|
Expanding = 1,
|
|
Colapsing = 2,
|
|
Hiding = 4,
|
|
Showing = 8,
|
|
Done = 16
|
|
}
|
|
public enum EnhancedAddTypes : int
|
|
{
|
|
No = 0,
|
|
Before = 1,
|
|
After = 2,
|
|
Child = 3
|
|
}
|
|
#endregion
|
|
public partial class RTBItem : EditItem
|
|
{
|
|
#region Private Fields
|
|
|
|
public Label MyLabel
|
|
{ get { return lblTab; } }
|
|
/// <summary>
|
|
/// Used to connect the RichTextBox with the menus and toolbars
|
|
/// </summary>
|
|
public override StepRTB MyStepRTB
|
|
{
|
|
get { return _MyStepRTB; }
|
|
}
|
|
public override int TableWidth { get { return (int)GetTableWidth(_MyStepRTB.Font, MyItemInfo.MyContent.Text, true); } }
|
|
|
|
/// <summary>
|
|
/// The left edge of the Tab
|
|
/// </summary>
|
|
public override int ItemLeft
|
|
{
|
|
get { return Left + lblTab.Left; }
|
|
set { Left = value - lblTab.Left; }
|
|
}
|
|
/// <summary>
|
|
/// The Location of the Tab
|
|
/// </summary>
|
|
public override Point ItemLocation
|
|
{
|
|
get { return new Point(Location.X + lblTab.Left, Location.Y); }
|
|
set { Location = new Point(value.X - lblTab.Left, value.Y); }
|
|
}
|
|
/// <summary>
|
|
/// Width of the Tab and RTB
|
|
/// </summary>
|
|
public override int ItemWidth
|
|
{
|
|
get { return Width - lblTab.Left; }
|
|
set
|
|
{
|
|
Width = CheckOffMargin + RTBMargin + value + lblTab.Left;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Width of the RichTextBox
|
|
/// </summary>
|
|
public override int ContentWidth
|
|
{
|
|
get { return _MyStepRTB.Width; }
|
|
set
|
|
{
|
|
// This is wrong for single column (KBR) - RHM Debug:
|
|
//MyStepRTB.Width = value;
|
|
Width = value + lblTab.Left + lblTab.Width + (this.Width - MyStepRTB.Right);
|
|
}
|
|
}
|
|
public override int BorderWidth { get { return (_MyStepRTB.Width - _MyStepRTB.ClientRectangle.Width); } }
|
|
/// <summary>
|
|
/// Location of the RichTextBox
|
|
/// </summary>
|
|
public override Point ContentLocation
|
|
{
|
|
get { return new Point(Location.X + _MyStepRTB.Left, Location.Y); }
|
|
set { Location = new Point(value.X - _MyStepRTB.Left, value.Y); }
|
|
}
|
|
/// <summary>
|
|
/// Left edge of the RichTextBox
|
|
/// </summary>
|
|
public override int ContentLeft
|
|
{
|
|
get { return Left + _MyStepRTB.Left; }
|
|
}
|
|
/// <summary>
|
|
/// Returns the status of the vlnExpander unless it is in the process of expanding or collapsing
|
|
/// If it is colapsing it returns false
|
|
/// If it is expanding it returns true
|
|
/// </summary>
|
|
public override bool Expanded
|
|
{
|
|
get
|
|
{
|
|
return !Colapsing && (MyExpandingStatus != ExpandingStatus.No || _MyvlnExpander.Expanded);
|
|
}
|
|
set
|
|
{
|
|
_MyvlnExpander.Expanded = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
#region IEditItem
|
|
override public void AdjustTableWidthAndLocation()
|
|
{
|
|
_MyStepRTB.Font = MyStepData.Font.WindowsFont;
|
|
ItemWidth = (int)GetTableWidth(_MyStepRTB.Font, MyItemInfo.MyContent.Text, true);
|
|
ItemLocation = new Point(50, _MyParentEditItem.Bottom);
|
|
ItemLocation = TableLocation(_MyParentEditItem, MyStepSectionLayoutData, ItemWidth);
|
|
}
|
|
|
|
override public void SetToolTip(string tip)
|
|
{
|
|
DevComponents.DotNetBar.SuperTooltipInfo tpi = new DevComponents.DotNetBar.SuperTooltipInfo("", "", tip, null, null, DevComponents.DotNetBar.eTooltipColor.Lemon);
|
|
_MyToolTip.MinimumTooltipSize = new Size(0, 24);
|
|
_MyToolTip.TooltipDuration = 3;
|
|
_MyToolTip.SetSuperTooltip(MyStepRTB, tpi);
|
|
}
|
|
public override void RefreshContent()
|
|
{
|
|
MyStepRTB.RefreshDisplay();
|
|
IdentifyMe(false);
|
|
SetExpandAndExpander(MyItemInfo);
|
|
}
|
|
public override void RefreshOrdinal()
|
|
{
|
|
TabFormat = null; // Reset Tab
|
|
}
|
|
/// <summary>
|
|
/// Tab Format used for outputing the Tab
|
|
/// </summary>
|
|
|
|
public override string TabFormat
|
|
{
|
|
get
|
|
{
|
|
if (_TabFormat == null) TabFormat = null; // execute 'set' code.
|
|
return _TabFormat;
|
|
}
|
|
set
|
|
{
|
|
if (MyItemInfo != null)
|
|
{
|
|
ItemInfo.ResetTabString(MyID);
|
|
string tabString = MyItemInfo.IsSection ? MyItemInfo.DisplayNumber.PadRight(MyItemInfo.MyTab.CleanText.Length) : MyItemInfo.MyTab.CleanText;
|
|
//string tabString = /*MyItemInfo.IsSection ? MyItemInfo.DisplayNumber : */ MyItemInfo.MyTab.CleanText;
|
|
|
|
lblTab.Text = tabString;
|
|
// calculate the width based upon characters per inch considering user's DPI
|
|
int cpi = MyItemInfo.IsStep ? (int)MyItemInfo.FormatStepData.TabData.Font.CPI : 12;
|
|
|
|
// if the tab ends with a single digit & has a '.' before it, add space for the possibility
|
|
// that the number can be two digits, for example... 8.1.9 goes to 8.1.10. We want
|
|
// the step windows to line up, so the 8.1.9 has one character more space (lastDigitSingle)
|
|
bool lastDigitSingle = Regex.IsMatch(tabString, "^.*[^0-9][0-9] *$");
|
|
lblTab.Width = ((lastDigitSingle ? 1 : 0) + tabString.Length) * MyStepPanel.DPI / cpi;
|
|
Invalidate();
|
|
if (MyItemInfo.MyTab.Offset == 0)
|
|
{
|
|
// In the following if statement, the last part, 'IsHigh & PageBreakOnStep' (PageBreakOnStep
|
|
// flags background steps and IsHigh is for the HLS - Cautions/Notes were ok), was added
|
|
// for hls in background documents - without this, the tab gets overwritten by the rtb.
|
|
if (MyItemInfo.FormatStepData == null || MyItemInfo.FormatStepData.TabData.IdentEdit.Contains("{Section Prefix}") || !MyItemInfo.IsHigh ||
|
|
(MyItemInfo.IsHigh && MyItemInfo.FormatStepData.PageBreakOnStep))
|
|
_MyStepRTB.Left = lblTab.Left + lblTab.Width;
|
|
_MyStepRTB.Width = Width - _MyStepRTB.Left - RTBMargin - CheckOffMargin;
|
|
}
|
|
_TabFormat = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
#region Properties
|
|
private static int _RTBMargin = 3;
|
|
/// <summary>
|
|
/// Margin between the EditItem and the StepRTB. Appears on the Right.
|
|
/// Will allow space to draw a Change Bar on the right side of the EditItem.
|
|
/// </summary>
|
|
public static int RTBMargin
|
|
{
|
|
get { return _RTBMargin; }
|
|
set { _RTBMargin = value; }
|
|
}
|
|
private int? _CheckOffMargin = null;
|
|
/// <summary>
|
|
/// Margin between the EditItem and the StepRTB. Appears on the Right.
|
|
/// Will allow space to draw a CheckOff on the right side of the EditItem.
|
|
/// </summary>
|
|
public int CheckOffMargin
|
|
{
|
|
get
|
|
{
|
|
if (_CheckOffMargin == null)
|
|
{
|
|
if (MyItemInfo == null) _CheckOffMargin = 0;
|
|
else
|
|
{
|
|
if (!MyItemInfo.IsStep || !MyItemInfo.SectionHasCheckOffs()) _CheckOffMargin = 0;
|
|
else
|
|
{
|
|
Graphics g = CreateGraphics();
|
|
SizeF sz = g.MeasureString("M", MyItemInfo.FormatStepData.Font.WindowsFont);
|
|
_CheckOffMargin = (int)sz.Width;
|
|
}
|
|
}
|
|
}
|
|
return (int)_CheckOffMargin;
|
|
}
|
|
set { _CheckOffMargin = value; }
|
|
}
|
|
private EnhancedAddTypes _EnhAddType = EnhancedAddTypes.No;
|
|
public EnhancedAddTypes EnhAddType
|
|
{
|
|
get { return _EnhAddType; }
|
|
set { _EnhAddType = value; }
|
|
}
|
|
private ItemInfo _EnhAddFromItemInfo = null;
|
|
public ItemInfo EnhAddFromItemInfo
|
|
{
|
|
get { return _EnhAddFromItemInfo; }
|
|
set { _EnhAddFromItemInfo = value; }
|
|
}
|
|
#endregion
|
|
#region Constructors
|
|
public RTBItem(ItemInfo itemInfo, StepPanel myStepPanel, EditItem myParentEditItem, ChildRelation myChildRelation, bool expand)
|
|
{
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB Top");
|
|
InitializeComponent();// TODO: Performance 25%
|
|
SetupEditItem(itemInfo, myStepPanel, myParentEditItem, myChildRelation, expand, null, false);
|
|
MyStepRTB.TextChanged += new EventHandler(MyStepRTB_TextChanged);
|
|
}
|
|
public RTBItem(ItemInfo itemInfo, StepPanel myStepPanel, EditItem myParentEditItem, ChildRelation myChildRelation, bool expand, EditItem nextEditItem)
|
|
{
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB Top");
|
|
InitializeComponent();// TODO: Performance 25%
|
|
SetupEditItem(itemInfo, myStepPanel, myParentEditItem, myChildRelation, expand, nextEditItem, false);
|
|
MyStepRTB.TextChanged += new EventHandler(MyStepRTB_TextChanged);
|
|
}
|
|
public RTBItem(ItemInfo itemInfo, StepPanel myStepPanel, EditItem myParentEditItem, ChildRelation myChildRelation, bool expand, bool addFirstChld)
|
|
{
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB Top");
|
|
InitializeComponent();// TODO: Performance 25%
|
|
SetupEditItem(itemInfo, myStepPanel, myParentEditItem, myChildRelation, expand, null, addFirstChld);
|
|
MyStepRTB.TextChanged += new EventHandler(MyStepRTB_TextChanged);
|
|
}
|
|
//private void SetupRTBItem(ItemInfo itemInfo, StepPanel myStepPanel, EditItem myParentEditItem, ChildRelation myChildRelation, bool expand, EditItem nextEditItem)
|
|
//{
|
|
// //if (itemInfo.ItemID == 225) _MyStepRTB.Resize += new EventHandler(_MyStepRTB_Resize);
|
|
// //_MyStepRTB.MyRTBItem = this;
|
|
// //// TIMING: DisplayItem.TimeIt("CSLARTB InitComp");
|
|
// BackColor = myStepPanel.PanelColor;
|
|
// //_MyStepRTB.BackColor = myStepPanel.InactiveColor;
|
|
// // TODO: Adjust top based upon format
|
|
// // TODO: Remove Label and just output ident on the paint event
|
|
// lblTab.Left = 20;
|
|
// SetupHeader(itemInfo);
|
|
// this.Paint += new PaintEventHandler(RTBItem_Paint);
|
|
// this.BackColorChanged += new EventHandler(RTBItem_BackColorChanged);
|
|
// if (itemInfo != null)
|
|
// {
|
|
// ContentType = (int)itemInfo.MyContent.Type;
|
|
// switch (ContentType / 10000)
|
|
// {
|
|
// case 0: // Procedure
|
|
// _MyStepRTB.Font = myStepPanel.ProcFont;// lblTab.Font = myStepPanel.ProcFont;
|
|
// lblTab.Font = itemInfo.MyTab.MyFont.WindowsFont;
|
|
// break;
|
|
// case 1: // Section
|
|
// _MyStepRTB.Font = myStepPanel.SectFont;// lblTab.Font = myStepPanel.SectFont;
|
|
// lblTab.Font = itemInfo.MyTab.MyFont.WindowsFont;
|
|
// break;
|
|
// case 2: // Steps
|
|
// _MyStepRTB.Font = myStepPanel.StepFont;//lblTab.Font = myStepPanel.StepFont;
|
|
// lblTab.Font = itemInfo.MyTab.MyFont.WindowsFont;
|
|
// MyStepData = itemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList[ContentType % 10000];
|
|
// break;
|
|
// }
|
|
// //this.Move += new EventHandler(DisplayItem_Move);
|
|
// }
|
|
// else
|
|
// {
|
|
// if (myStepPanel.MyFont != null) _MyStepRTB.Font = lblTab.Font = myStepPanel.MyFont;
|
|
// }
|
|
// if (expand) _MyvlnExpander.ShowExpanded();
|
|
// MyStepPanel = myStepPanel;
|
|
// if (itemInfo != null) myStepPanel._LookupEditItems.Add(itemInfo.ItemID, this);
|
|
// _MyChildRelation = myChildRelation;
|
|
// if (myParentEditItem != null) RNOLevel = myParentEditItem.RNOLevel;
|
|
// if (itemInfo != null)
|
|
// {
|
|
// //// TIMING: DisplayItem.TimeIt("CSLARTB before _Layout");
|
|
// MyStepSectionLayoutData = itemInfo.ActiveFormat.MyStepSectionLayoutData;
|
|
// //// TIMING: DisplayItem.TimeIt("CSLARTB _Layout");
|
|
// if (myParentEditItem != null)
|
|
// SeqLevel = myParentEditItem.SeqLevel + ((myChildRelation == ChildRelation.After || myChildRelation == ChildRelation.Before) && itemInfo.IsSequential ? 1 : 0);
|
|
// //// TIMING: DisplayItem.TimeIt("CSLARTB seqLevel");
|
|
// MyItemInfo = itemInfo;
|
|
// MyItemInfo.MyConfig.PropertyChanged += new PropertyChangedEventHandler(MyConfig_PropertyChanged);
|
|
// }
|
|
// //// TIMING: DisplayItem.TimeIt("CSLARTB MyItem");
|
|
// myStepPanel.Controls.Add(this);
|
|
|
|
// switch (myChildRelation)
|
|
// {
|
|
// case ChildRelation.After:
|
|
// AddItem(myParentEditItem, ref myParentEditItem._MyAfterEditItems, nextEditItem);
|
|
// break;
|
|
// case ChildRelation.Before:
|
|
// AddItem(myParentEditItem, ref myParentEditItem._MyBeforeEditItems, nextEditItem);
|
|
// break;
|
|
// case ChildRelation.RNO:
|
|
// RNOLevel = myParentEditItem.RNOLevel + 1;
|
|
// AddItem(myParentEditItem, ref myParentEditItem._MyRNOEditItems, nextEditItem);
|
|
// break;
|
|
// case ChildRelation.None:
|
|
// break;
|
|
// }
|
|
// if (itemInfo != null)
|
|
// {
|
|
// if (myChildRelation == ChildRelation.None)
|
|
// {
|
|
// if (ContentType == 0 && MyStepSectionLayoutData != null)
|
|
// {
|
|
// LastMethodsPush(string.Format("SetupRTBItem {0}", MyID));
|
|
// Width = MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidT);
|
|
// }
|
|
// }
|
|
// }
|
|
// //// TIMING: DisplayItem.TimeIt("CSLARTB Parent");
|
|
// SetText();
|
|
// //// TIMING: DisplayItem.TimeIt("CSLARTB SetText");
|
|
// if (itemInfo != null)
|
|
// {
|
|
// Name = string.Format("Item-{0}", itemInfo.ItemID);
|
|
// SetExpandAndExpander(itemInfo);
|
|
// if (expand && (itemInfo.MyContent.ContentPartCount != 0)) // If it should expand and it can expand
|
|
// Expand(true);
|
|
// else
|
|
// if (myParentEditItem == null)// If it is the top node
|
|
// if (ContentType >= 20000) // and it is a step - fully expand
|
|
// Expand(true);
|
|
// else // otherwise only expand one level
|
|
// Expand(false);
|
|
// }
|
|
// //// TIMING: DisplayItem.TimeIt("CSLARTB before Controls Add");
|
|
// //myStepPanel.Controls.Add(this);
|
|
// int top = FindTop(0);
|
|
// if (Top < top)
|
|
// {
|
|
// LastMethodsPush("SetupRTBItem");
|
|
// MyStepPanel.ItemMoving++;
|
|
// Top = top;
|
|
// MyStepPanel.ItemMoving--;
|
|
// LastMethodsPop();
|
|
// }
|
|
// _Loading = false;
|
|
// //// TIMING: DisplayItem.TimeIt("CSLARTB Controls Add");
|
|
//}
|
|
private void SetupHeader()
|
|
{
|
|
SetupHeader(MyItemInfo);
|
|
LastMethodsPush("SetupHeader");
|
|
Height = _MyStepRTB.Height + _MyStepRTB.Top + 7;
|
|
LastMethodsPop();
|
|
}
|
|
void _MyStepRTB_Resize(object sender, EventArgs e)
|
|
{
|
|
if (MyStepPanel != null && this == MyStepPanel.SelectedEditItem)
|
|
ScrollToCenter();
|
|
//MyStepPanel.ScrollControlIntoView(this);
|
|
}
|
|
void MyStepRTB_TextChanged(object sender, EventArgs e)
|
|
{
|
|
if (MyStepPanel != null && this == MyStepPanel.SelectedEditItem)
|
|
ScrollToCenter();
|
|
//MyStepPanel.ScrollControlIntoView(this);
|
|
}
|
|
private Label lblHeader = null;
|
|
private Label lblFooter = null;
|
|
private void SetupHeaderFooter(ref Label lbl, string name, MetaTag mTag)
|
|
{
|
|
if (lbl == null) lbl = new Label();
|
|
lbl.BackColor = System.Drawing.Color.Transparent;
|
|
lbl.Location = new System.Drawing.Point(0, 0);
|
|
lbl.Name = name;
|
|
lbl.Size = new System.Drawing.Size(this.Width, 23);
|
|
lbl.Visible = true;
|
|
lbl.Font = mTag.MyFont.WindowsFont;
|
|
lbl.Text = mTag.CleanText;
|
|
lbl.TextAlign = mTag.Justify;
|
|
this.Controls.Add(lbl);
|
|
}
|
|
#endregion
|
|
#region EventHandlers
|
|
/// <summary>
|
|
/// When the RichTextBox height changes, change the height of the control to match
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
private void _MyStepRTB_HeightChanged(object sender, EventArgs args)
|
|
{
|
|
if (this.Height != _MyStepRTB.Height + _MyStepRTB.Top + 7) // add in 7 to make it look good // + 10)
|
|
{
|
|
LastMethodsPush(string.Format("_StepRTB_HeightChanged {0}", _MyStepRTB.Height));
|
|
this.Height = _MyStepRTB.Height + _MyStepRTB.Top + 7;
|
|
LastMethodsPop();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// When a RichTextBox is entered, the selected StepRTB is set
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private bool _ProcessingEnter = false;
|
|
private void _StepRTB_Enter(object sender, EventArgs e)
|
|
{
|
|
if (MyStepPanel.DisplayItemChanging) return;
|
|
//vlnStackTrace.ShowStack("_StepRTB_Enter {0}",this.MyID);
|
|
MyStepPanel.SelectedEditItem = this;
|
|
if (MyStepPanel.MyStepTabPanel.MyDisplayTabControl.SyncEnhancedDocuments)
|
|
{
|
|
if (!_ProcessingEnter)
|
|
{
|
|
_ProcessingEnter = true;
|
|
DisplayTabItem dti = null;
|
|
// Syncronize any open Enhanced Documents
|
|
StepConfig sc = new StepConfig(MyItemInfo.MyContent.Config);
|
|
foreach (EnhancedDocument ed in sc.MyEnhancedDocuments)
|
|
{
|
|
ItemInfo ii = ItemInfo.Get(ed.ItemID);
|
|
if (MyStepPanel.MyStepTabPanel.MyDisplayTabControl.IsItemInfoProcedureOpen(ii))
|
|
MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OnOpenEnhancedDocument(new ItemSelectedChangedEventArgs(ii));
|
|
if (dti != null)
|
|
dti.MyStepTabPanel.MyDisplayTabControl.OpenItem(this.MyItemInfo);
|
|
}
|
|
_ProcessingEnter = false;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Pass the AttachmentClick event to the StepPanel control.
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
private void vlnExp_AttachmentClick(object sender, vlnExpanderEventArgs args)
|
|
{
|
|
if (_MyvlnExpander.AutoTOC) return;
|
|
|
|
MyStepPanel.OnAttachmentClicked(sender, new StepPanelAttachmentEventArgs(this));
|
|
}
|
|
/// <summary>
|
|
/// Handle the colape event
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
private void vlnExp_BeforeColapse(object sender, vlnExpanderEventArgs args)
|
|
{
|
|
Cursor tmp = Cursor.Current;
|
|
Cursor.Current = Cursors.WaitCursor;
|
|
int top = TopMostEditItem.Top;// This doesn't work - this is since the last time it was expanded.
|
|
int topOffset = TopMostEditItem.Top + MyStepPanel.VerticalScroll.Value;
|
|
Colapsing = true;
|
|
// Hide Children
|
|
HideChildren();
|
|
// Adjust Positions
|
|
int topOffsetAfter = TopMostEditItem.Top + MyStepPanel.VerticalScroll.Value;
|
|
ExpandPrefix = topOffset - topOffsetAfter;
|
|
//ExpandSuffix = BottomMostEditItem.Bottom - Bottom;
|
|
if (topOffsetAfter != topOffset)
|
|
{
|
|
LastMethodsPush(string.Format("Colapse {0}", MyID));
|
|
MyStepPanel.ItemMoving++;
|
|
Top += (topOffset - topOffsetAfter);
|
|
MyStepPanel.ItemMoving--;
|
|
LastMethodsPop();
|
|
}
|
|
else
|
|
AdjustLocation();
|
|
BottomMostEditItem.AdjustLocation();
|
|
Colapsing = false;
|
|
Cursor.Current = tmp;
|
|
}
|
|
/// <summary>
|
|
/// Handle the expand event
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
private void vlnExp_BeforeExpand(object sender, vlnExpanderEventArgs args)
|
|
{
|
|
Cursor tmp = Cursor.Current;
|
|
Cursor.Current = Cursors.WaitCursor;
|
|
if (!_Loading && MyExpandingStatus == ExpandingStatus.No)
|
|
{
|
|
if (MyStepPanel.AutoExpand)
|
|
Expand((ContentType >= 20000) || MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format);
|
|
else
|
|
Expand(false);
|
|
}
|
|
Cursor.Current = tmp;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises an ItemClick event when the user clicks on the Tab
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void lblTab_MouseDown(object sender, MouseEventArgs e)
|
|
{
|
|
MyStepPanel.OnItemClick(this, new StepPanelEventArgs(this, e));
|
|
}
|
|
/// <summary>
|
|
/// Handle the LinkGoTO event
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
private void _MyStepRTB_LinkGoTo(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
_MyLog.DebugFormat("_DisplayRTB_LinkGoTo " + args.LinkInfoText);
|
|
MyStepPanel.OnLinkClicked(sender, args);
|
|
}
|
|
void _MyStepRTB_RoInsert(object sender, StepRTBRoEventArgs args)
|
|
{
|
|
MyStepRTB.UpdateStepRtb(args.LinkText, args.ValText);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raise a OnLinkModifyTran event, when the user chooses to Modify a transition
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
private void _MyStepRTB_LinkModifyTran(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
MyStepPanel.OnLinkModifyTran(sender, args);
|
|
}
|
|
/// <summary>
|
|
/// Raise a OnLinkModifyRO event, when the user chooses to modify an RO
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
private void _MyStepRTB_LinkModifyRO(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
MyStepPanel.OnLinkModifyRO(sender, args);
|
|
}
|
|
private void _MyStepRTB_CursorKeyPress(object sender, KeyEventArgs args)
|
|
{
|
|
MyStepPanel.StepCursorKeys(this, args);
|
|
}
|
|
private void _MyStepRTB_CursorMovement(object sender, StepRTBCursorMovementEventArgs args)
|
|
{
|
|
MyStepPanel.CursorMovement(this, args.CursorLocation, args.Key);
|
|
}
|
|
//private void _MyStepRTB_ModeChange(object sender, StepRTBModeChangeEventArgs args)
|
|
//{
|
|
// MyStepPanel.OnModeChange(sender as StepRTB, args);
|
|
//}
|
|
void _MyStepRTB_SetMenu(object sender, StepRTBMenuEventArgs args)
|
|
{
|
|
if (args.MenuGroup == null)
|
|
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.ClearContextMenu();
|
|
else if (args.MenuGroup == "OpenContextMenu")
|
|
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.SetContextMenu();
|
|
else
|
|
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.SetShortCutContextMenu(args.MenuGroup);
|
|
}
|
|
void _MyStepRTB_AdjustTableWidth(object sender, StepRTBTableWidthEventArgs args)
|
|
{
|
|
//if ((!_MyItemInfo.IsSection && !_MyItemInfo.IsProcedure) && (_MyItemInfo.IsTable || _MyItemInfo.IsFigure))
|
|
if (MyItemInfo.IsTable || MyItemInfo.IsFigure)
|
|
{
|
|
if (args.EditMode)
|
|
{
|
|
// First get ColR
|
|
int colR = MyStepPanel.ToDisplay(MyStepSectionLayoutData.ColRTable, MyItemInfo.ColumnMode);
|
|
// Second get WidS
|
|
int widS = /* _WidthAdjust + borderWidth + */ MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidSTableEdit, MyItemInfo.ColumnMode);
|
|
//int wNew = MyRTBItem.MyStepPanel.ToDisplay(MyRTBItem.MyStepSectionLayoutData.WidT);
|
|
int wNew = 70 + widS + colR * MyItemInfo.ColumnMode;
|
|
if (wNew > ItemWidth)
|
|
{
|
|
ItemWidth = wNew;
|
|
ItemLocation = TableLocation(MyParentEditItem, MyStepSectionLayoutData, wNew);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int newwidth = (int)GetTableWidth(MyStepRTB.Font, MyStepRTB.Text, false);
|
|
if (ItemWidth != newwidth)
|
|
{
|
|
ItemWidth = newwidth;
|
|
ItemLocation = TableLocation(MyParentEditItem, MyStepSectionLayoutData, newwidth);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Calculate TableWidth based upon the the contents
|
|
/// </summary>
|
|
/// <param name="myFont"></param>
|
|
/// <param name="txt"></param>
|
|
/// <param name="addBorder"></param>
|
|
/// <returns></returns>
|
|
private float GetTableWidth(Font myFont, string txt, bool addBorder)
|
|
{
|
|
string[] lines = txt.Split("\n".ToCharArray());
|
|
float max = 0;
|
|
using (Graphics g = this.CreateGraphics())
|
|
{
|
|
PointF pnt = new PointF(0, 0);
|
|
foreach (string line in lines)
|
|
{
|
|
string lineAdj = Regex.Replace(line, @"\\u....\?", "X"); // Replace Special characters
|
|
//line2 = Regex.Replace(line2, @"\\.*? ", ""); // Remove RTF Commands - Really should not be any
|
|
lineAdj = StepRTB.RemoveLinkComments(lineAdj);
|
|
// MeasureString doesn't work properly if the line include graphics characters.
|
|
// So, Measure a string of the same length with 'M's.
|
|
SizeF siz = g.MeasureString("".PadLeft(lineAdj.Length + (addBorder ? 2 : 0), 'M'), myFont, pnt, StringFormat.GenericTypographic);
|
|
float wid = siz.Width;
|
|
if (wid > max)
|
|
{
|
|
max = wid;
|
|
}
|
|
}
|
|
}
|
|
float widLimit = (float)MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidSTableEdit, MyItemInfo.ColumnMode);
|
|
widLimit += (float)MyStepPanel.ToDisplay(MyStepSectionLayoutData.ColS);
|
|
widLimit += (float)MyStepPanel.ToDisplay(MyStepSectionLayoutData.ColRTable, MyItemInfo.ColumnMode);
|
|
max += MyStepPanel.MyStepPanelSettings.TableWidthAdjust;
|
|
return Math.Min(max, widLimit);
|
|
}
|
|
bool _MyStepRTB_IsNotCurrentSelection(object sender, System.EventArgs args)
|
|
{
|
|
return MyStepPanel.SelectedEditItem != this;
|
|
}
|
|
void _MyStepRTB_OpenAnnotations(object sender, System.EventArgs args)
|
|
{
|
|
OpenAnnotations();
|
|
}
|
|
void _MyStepRTB_InsertPgBrk(object sender, System.EventArgs args)
|
|
{
|
|
InsertPgBrk();
|
|
}
|
|
void _MyStepRTB_EnterKeyPressed(object sender, System.Windows.Forms.KeyEventArgs args)
|
|
{
|
|
if (!MyItemInfo.IsTablePart)
|
|
{
|
|
args.Handled = true;
|
|
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.ProcessEnterKey();
|
|
}
|
|
}
|
|
bool _MyStepRTB_CheckClipboard(object sender, System.EventArgs args)
|
|
{
|
|
return CheckClipboard();
|
|
}
|
|
void _MyStepRTB_CopyStep(object sender, System.EventArgs args)
|
|
{
|
|
CopyStep();
|
|
}
|
|
void _MyStepRTB_OpenContextMenu(object sender, StepRTBLocationEventArgs args)
|
|
{
|
|
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.OpenContextMenu(args.Location);
|
|
}
|
|
void _MyStepRTB_DoMouseWheel(object sender, System.Windows.Forms.MouseEventArgs args)
|
|
{
|
|
DoMouseWheel(args);
|
|
}
|
|
void _MyStepRTB_DoSaveContents(object sender, System.EventArgs args)
|
|
{
|
|
SaveContents();
|
|
}
|
|
#endregion
|
|
#region override methods
|
|
public override void RefreshTab()
|
|
{
|
|
TabFormat = null;
|
|
SetupHeader();
|
|
}
|
|
public override void SetFocus()
|
|
{
|
|
MyStepRTB.Focus();
|
|
}
|
|
public override void SaveContents()
|
|
{
|
|
MyStepRTB.Visible = false;
|
|
while (MyStepRTB.Text.Contains("\\"))
|
|
{
|
|
int loc = MyStepRTB.Text.IndexOf("\\");
|
|
MyStepRTB.SelectionStart = loc;
|
|
MyStepRTB.SelectionLength = 1;
|
|
MyStepRTB.SelectedText = "<BackSlash>";
|
|
}
|
|
SaveText();
|
|
|
|
MyStepRTB.Visible = true;
|
|
SaveConfig(); // This may be redundant
|
|
}
|
|
public void SaveText()
|
|
{
|
|
if (MyStepRTB.ReadOnly) return;
|
|
if (!MyStepRTB.ActiveMode) return;
|
|
if (MyStepRTB.IsExperimenting) return;
|
|
if (MyStepRTB.MyItemInfo.MyContent.Number != null && !MyStepRTB.IsDirty && MyStepRTB.Text.Contains("(Resolved Transition Text)") == false) return;
|
|
bool success = MyStepRTB.OrigDisplayText.Save((RichTextBox)MyStepRTB);
|
|
if (success)
|
|
{
|
|
StepConfig sc = MyStepRTB.MyItemInfo.MyConfig as StepConfig;
|
|
// if the plant has the change id option, the change id was entered when the program started.
|
|
// this should be saved for every piece of edited data. Note that the set of config
|
|
// item Step_MultipleChangeID has the save built in to it.
|
|
if (MyStepRTB.MyItemInfo.IsStep &&
|
|
MyStepRTB.MyItemInfo.ActiveFormat.PlantFormat.FormatData.ProcData.ChangeBarData.ChangeIds
|
|
&& !this.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.EditorialChange)
|
|
{
|
|
//StepConfig sc = MyStepRTB.MyItemInfo.MyConfig as StepConfig;
|
|
if (sc == null) sc = new StepConfig();
|
|
sc.Step_ChangeID = this.MyStepPanel.MyStepTabPanel.MyDisplayTabControl.ChgId;
|
|
//if (MyStepRTB.MyItemInfo.MyConfig == null) itm.MyContent.Config = sc.ToString();
|
|
}
|
|
// We saved changes made to some step text. Reset the change bar override.
|
|
// IF there is a step config remove the change bar override by setting the CBOverride value to null
|
|
// This fixes a problem reported by Farly where if the change bar or overridden to be off, the next
|
|
// time a change was made, the change bar remained turned off.
|
|
if (sc != null)
|
|
sc.Step_CBOverride = null; // clear the change bar override
|
|
MyStepRTB.FindAllLinks();
|
|
MyStepRTB.OrigRTF = MyStepRTB.Rtf;
|
|
MyStepRTB.ClearUndo();
|
|
|
|
// see if enhanced document related steps need to be created: KBR 10/2/15 - NEED to do this when saving RO
|
|
if (EnhAddType != EnhancedAddTypes.No)
|
|
{
|
|
StepConfig sib = EnhAddFromItemInfo.MyConfig as StepConfig;
|
|
foreach (EnhancedDocument ed in sib.MyEnhancedDocuments)
|
|
{
|
|
// create a new enhanced step and link it to this new source step.
|
|
// the new source step's item is passed in to know what type & what to link to.
|
|
// The ed.Type & itemid show what type of enhanced document (use to create new
|
|
// config Type) and itemid is the one to insert after.
|
|
DoAddEnhancedSteps(ed.Type, ed.ItemID);
|
|
}
|
|
EnhAddType = EnhancedAddTypes.No;
|
|
}
|
|
}
|
|
}
|
|
private void DoAddEnhancedSteps(int enhType, int enhItemID)
|
|
{
|
|
// get the item object in the enhanced document so that inserting of the new enhanced item and
|
|
// its children can be done:
|
|
ItemInfo existingEnhancedItemInfo = ItemInfo.Get(enhItemID);
|
|
ItemInfo.EAddpingPart addpart = ItemInfo.EAddpingPart.After;
|
|
if (EnhAddType == EnhancedAddTypes.Before) addpart = ItemInfo.EAddpingPart.Before;
|
|
else if (EnhAddType == EnhancedAddTypes.Child) addpart = ItemInfo.EAddpingPart.Child;
|
|
ItemInfo newEnhancedItemInfo = existingEnhancedItemInfo.InsertEnhancedSteps(MyItemInfo.MyContent.Text, null, addpart, MyItemInfo.MyContent.Type, enhType, MyItemInfo.ItemID);
|
|
StepConfig sc = new StepConfig(MyItemInfo.MyContent.Config);
|
|
sc.AddEnhancedDocument(enhType, newEnhancedItemInfo.ItemID);
|
|
using (Content c = Content.Get(MyItemInfo.ContentID))
|
|
{
|
|
c.Config = sc.ToString();
|
|
c.Save();
|
|
}
|
|
MyItemInfo.RefreshConfig();
|
|
}
|
|
//public override void SetBackgroundColor()
|
|
//{
|
|
// MyStepRTB.SetBackColor();
|
|
//}
|
|
public override void IdentifyMe(bool highlight)
|
|
{
|
|
if (highlight)
|
|
MyStepRTB.BackColor = Color.Gray;
|
|
else
|
|
{
|
|
if (MyStepRTB.Focused) // If active Set BackColor to the active color
|
|
MyStepRTB.BackColor = MyStepPanel.ActiveColor;
|
|
else // Otherwise Set the BackColor to either the InactiveColor or the AnnotationColor
|
|
MyStepRTB.BackColor = MyItemInfo.ItemAnnotationCount == 0 ? MyStepPanel.InactiveColor : MyStepPanel.AnnotationColor;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Gets or Sets the ability to expand
|
|
/// </summary>
|
|
public override bool CanExpand
|
|
{
|
|
get { return _MyvlnExpander.Visible; }
|
|
set { _MyvlnExpander.Visible = value; }
|
|
}
|
|
public override void HandleResize()
|
|
{
|
|
if (lblHeader != null) lblHeader.Width = this.Width;
|
|
}
|
|
public override void MatchExpanded()
|
|
{
|
|
if (!_MyvlnExpander.Expanded)
|
|
_MyvlnExpander.ShowExpanded();
|
|
}
|
|
/// <summary>
|
|
/// Sets the focus to this RTBItem and positions the cursor to the begining of the string
|
|
/// </summary>
|
|
public override void ItemSelect()
|
|
{
|
|
// Was getting an Error that _MyStepRTB was Disposed RHM 20101217
|
|
if (!_MyStepRTB.Disposing && !MyStepRTB.Closed)
|
|
{
|
|
_MyStepRTB.Focus();
|
|
_MyStepRTB.Select(0, 0);
|
|
}
|
|
else
|
|
{
|
|
_MyLog.WarnFormat("Attempt to give Focus to Disposed Object {0}", MyID);
|
|
}
|
|
// if (CanExpand) AutoExpand(); // Expand the item if you can
|
|
ScrollToCenter();
|
|
}
|
|
/// <summary>
|
|
/// Sets the focus to this RTBItem
|
|
/// </summary>
|
|
public override void ItemShow()
|
|
{
|
|
_MyStepRTB.Focus();
|
|
ScrollToCenter();
|
|
}
|
|
public override DialogResult ReplaceText(string rpltxt, string fndstr, bool caseSensitive, bool matchWholeWord, bool reverse, bool prompt, IWin32Window fndrpldlg)
|
|
{
|
|
return MyStepRTB.ReplaceText(rpltxt, fndstr, caseSensitive, matchWholeWord, reverse, prompt, fndrpldlg);
|
|
}
|
|
public override bool FindText(string str, bool caseSensitive, bool matchWholeWord, bool reverse)
|
|
{
|
|
return MyStepRTB.FindText(str, caseSensitive, matchWholeWord, reverse);
|
|
}
|
|
public override void PositionToEnd()
|
|
{
|
|
MyStepRTB.SelectionStart = MyStepRTB.Text.Length;
|
|
}
|
|
public override void PositionToStart()
|
|
{
|
|
return;
|
|
}
|
|
public override string SelectedTextForFind
|
|
{
|
|
get
|
|
{
|
|
StepRTB srtb = MyStepRTB;
|
|
if (srtb.SelectionLength > 0)
|
|
{
|
|
if (srtb.IsSelectionLinked(srtb.SelectionStart, srtb.SelectionLength))
|
|
return srtb.SelectedText.Substring(0, srtb.SelectedText.IndexOf("#Link"));
|
|
else
|
|
return srtb.SelectedText;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
public override bool SpellCheckNext()
|
|
{
|
|
return MyStepRTB.SpellCheckNext();
|
|
}
|
|
public override void SetActive()
|
|
{
|
|
MyStepRTB.BackColor = MyStepPanel.ActiveColor;
|
|
}
|
|
public override bool Empty
|
|
{
|
|
get
|
|
{
|
|
// Console.WriteLine("step rtb is dirty {0} and rtf is {1}", MyStepRTB.IsDirty, MyStepRTB.Rtf);
|
|
// string txt = MyStepRTB.Text;
|
|
// Console.WriteLine("step rtb is dirty {0} and rtf is {1}", MyStepRTB.IsDirty, MyStepRTB.Rtf);
|
|
// return txt == "";
|
|
//return MyStepRTB.IsEmpty;
|
|
return MyStepRTB.Text == "";
|
|
}
|
|
set { MyStepRTB.Text = value ? "" : " "; }
|
|
}
|
|
//public override bool IsEmpty() // this becomes 'Empty' property, i.e. get/set.
|
|
//{ // for the set, emtpy is following line (= not ==).
|
|
// // for not empty - it's code that is in 'MakeNotEmpty'
|
|
// return MyStepRTB.Text == "";
|
|
//}
|
|
//public override void MakeNotEmpty()
|
|
//{
|
|
// MyStepRTB.Text = " ";
|
|
//}
|
|
public override void RefreshDisplay(bool activeMode)
|
|
{
|
|
MyStepRTB.VwMode = MyStepPanel.VwMode;
|
|
MyStepRTB.RefreshDisplay(activeMode);
|
|
//MyStepRTB.ViewRTB = !activeMode;
|
|
}
|
|
public override void ToggleEditView(E_ViewMode vwMode)
|
|
{
|
|
SaveContents();
|
|
MyStepRTB.VwMode = vwMode;
|
|
MyStepRTB.RefreshDisplay();
|
|
MyStepRTB.SelectionStart = 0;
|
|
MyStepRTB.SelectionLength = 0;
|
|
}
|
|
public override int TabLeft { get { return lblTab.Left; } set { lblTab.Left = value; } }
|
|
public override Font TabFont { get { return lblTab.Font; } set { lblTab.Font = value; } }
|
|
public override string TabText { get { return lblTab.Text; } }
|
|
public override Point TabLocation { get { return lblTab.Location; } }
|
|
public override Font ContentFont { get { return MyStepRTB.Font; } set { MyStepRTB.Font = value; } }
|
|
public override float ContentTop { get { return MyStepRTB.Top; } }
|
|
public override void SetupHeader(ItemInfo itemInfo)
|
|
{
|
|
lblTab.Top = 3 + ((itemInfo.HasHeader) ? 23 : 0);
|
|
_MyStepRTB.Top = lblTab.Top; // 3 + ((itemInfo.HasHeader) ? 23 : 0);
|
|
//lblTab.Move += new EventHandler(lblTab_Move);
|
|
if (itemInfo.HasHeader)
|
|
SetupHeaderFooter(ref lblHeader, "Header", itemInfo.MyHeader);
|
|
else
|
|
{
|
|
// remove header from screen if it exists:
|
|
this.Controls.Remove(lblHeader);
|
|
lblHeader = null;
|
|
}
|
|
}
|
|
public override void ShowExpanded()
|
|
{
|
|
_MyvlnExpander.ShowExpanded();
|
|
}
|
|
/// <summary>
|
|
/// Sets the Item and as a result the text for the RichTextBox
|
|
/// </summary>
|
|
public override void SetText()
|
|
{
|
|
LastMethodsPush("SetText");
|
|
if (MyItemInfo != null)
|
|
{
|
|
MyStepRTB.MyItemInfo = MyItemInfo;
|
|
MyStepRTB.RefreshDisplay();
|
|
IdentifyMe(false);
|
|
}
|
|
LastMethodsPop();
|
|
}
|
|
public override void SetExpandAndExpander(ItemInfo itemInfo)
|
|
{
|
|
// Don't allow substeps to expand
|
|
switch (ContentType / 10000)
|
|
{
|
|
case 1: // Section can expand
|
|
CanExpand = true;
|
|
// If a word document set the expander to attachment
|
|
_MyvlnExpander.Attachment = !(itemInfo.IsStepSection);
|
|
_MyvlnExpander.AutoTOC = itemInfo.IsAutoTOCSection;
|
|
//OLD: _MyvlnExpander.Attachment = (itemInfo.MyContent.ContentPartCount == 0);
|
|
break;
|
|
case 2: // High level steps with children can expand
|
|
if(MyStepPanel.AutoExpand)
|
|
CanExpand = itemInfo.IsHigh && !MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format && itemInfo.HasChildren; // TemporaryFormat.IsHigh(item); ;
|
|
else
|
|
CanExpand = itemInfo.HasChildren;
|
|
break;
|
|
default://Procedures cannot expand, because they automatically expand
|
|
CanExpand = false;
|
|
break;
|
|
}
|
|
}
|
|
public override void SaveCurrentAndContents()
|
|
{
|
|
SaveContents();
|
|
}
|
|
#endregion
|
|
}
|
|
}
|